file_path
stringlengths 20
202
| content
stringlengths 9
3.85M
| size
int64 9
3.85M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 8
993
| alphanum_fraction
float64 0.26
0.93
|
|---|---|---|---|---|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/GetPointMapROI.h | #ifndef _ROS_SERVICE_GetPointMapROI_h
#define _ROS_SERVICE_GetPointMapROI_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/PointCloud2.h"
namespace map_msgs
{
static const char GETPOINTMAPROI[] = "map_msgs/GetPointMapROI";
class GetPointMapROIRequest : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
typedef double _r_type;
_r_type r;
typedef double _l_x_type;
_l_x_type l_x;
typedef double _l_y_type;
_l_y_type l_y;
typedef double _l_z_type;
_l_z_type l_z;
GetPointMapROIRequest():
x(0),
y(0),
z(0),
r(0),
l_x(0),
l_y(0),
l_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->z);
union {
double real;
uint64_t base;
} u_r;
u_r.real = this->r;
*(outbuffer + offset + 0) = (u_r.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_r.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_r.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_r.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_r.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_r.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_r.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_r.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->r);
union {
double real;
uint64_t base;
} u_l_x;
u_l_x.real = this->l_x;
*(outbuffer + offset + 0) = (u_l_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_x);
union {
double real;
uint64_t base;
} u_l_y;
u_l_y.real = this->l_y;
*(outbuffer + offset + 0) = (u_l_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_y);
union {
double real;
uint64_t base;
} u_l_z;
u_l_z.real = this->l_z;
*(outbuffer + offset + 0) = (u_l_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->z = u_z.real;
offset += sizeof(this->z);
union {
double real;
uint64_t base;
} u_r;
u_r.base = 0;
u_r.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->r = u_r.real;
offset += sizeof(this->r);
union {
double real;
uint64_t base;
} u_l_x;
u_l_x.base = 0;
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_x = u_l_x.real;
offset += sizeof(this->l_x);
union {
double real;
uint64_t base;
} u_l_y;
u_l_y.base = 0;
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_y = u_l_y.real;
offset += sizeof(this->l_y);
union {
double real;
uint64_t base;
} u_l_z;
u_l_z.base = 0;
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_z = u_l_z.real;
offset += sizeof(this->l_z);
return offset;
}
const char * getType(){ return GETPOINTMAPROI; };
const char * getMD5(){ return "895f7e437a9a6dd225316872b187a303"; };
};
class GetPointMapROIResponse : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud2 _sub_map_type;
_sub_map_type sub_map;
GetPointMapROIResponse():
sub_map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->sub_map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->sub_map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOINTMAPROI; };
const char * getMD5(){ return "313769f8b0e724525c6463336cbccd63"; };
};
class GetPointMapROI {
public:
typedef GetPointMapROIRequest Request;
typedef GetPointMapROIResponse Response;
};
}
#endif
| 11,622 | C | 37.614618 | 72 | 0.462571 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/SetMapProjections.h | #ifndef _ROS_SERVICE_SetMapProjections_h
#define _ROS_SERVICE_SetMapProjections_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "map_msgs/ProjectedMapInfo.h"
namespace map_msgs
{
static const char SETMAPPROJECTIONS[] = "map_msgs/SetMapProjections";
class SetMapProjectionsRequest : public ros::Msg
{
public:
SetMapProjectionsRequest()
{
}
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 SETMAPPROJECTIONS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetMapProjectionsResponse : public ros::Msg
{
public:
uint32_t projected_maps_info_length;
typedef map_msgs::ProjectedMapInfo _projected_maps_info_type;
_projected_maps_info_type st_projected_maps_info;
_projected_maps_info_type * projected_maps_info;
SetMapProjectionsResponse():
projected_maps_info_length(0), projected_maps_info(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->projected_maps_info_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->projected_maps_info_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->projected_maps_info_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->projected_maps_info_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->projected_maps_info_length);
for( uint32_t i = 0; i < projected_maps_info_length; i++){
offset += this->projected_maps_info[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t projected_maps_info_lengthT = ((uint32_t) (*(inbuffer + offset)));
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->projected_maps_info_length);
if(projected_maps_info_lengthT > projected_maps_info_length)
this->projected_maps_info = (map_msgs::ProjectedMapInfo*)realloc(this->projected_maps_info, projected_maps_info_lengthT * sizeof(map_msgs::ProjectedMapInfo));
projected_maps_info_length = projected_maps_info_lengthT;
for( uint32_t i = 0; i < projected_maps_info_length; i++){
offset += this->st_projected_maps_info.deserialize(inbuffer + offset);
memcpy( &(this->projected_maps_info[i]), &(this->st_projected_maps_info), sizeof(map_msgs::ProjectedMapInfo));
}
return offset;
}
const char * getType(){ return SETMAPPROJECTIONS; };
const char * getMD5(){ return "d7980a33202421c8cd74565e57a4d229"; };
};
class SetMapProjections {
public:
typedef SetMapProjectionsRequest Request;
typedef SetMapProjectionsResponse Response;
};
}
#endif
| 3,212 | C | 32.123711 | 166 | 0.647883 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_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"
#include "std_msgs/String.h"
namespace map_msgs
{
static const char SAVEMAP[] = "map_msgs/SaveMap";
class SaveMapRequest : public ros::Msg
{
public:
typedef std_msgs::String _filename_type;
_filename_type filename;
SaveMapRequest():
filename()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->filename.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->filename.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "716e25f9d9dc76ceba197f93cbf05dc7"; };
};
class SaveMapResponse : public ros::Msg
{
public:
SaveMapResponse()
{
}
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 SAVEMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SaveMap {
public:
typedef SaveMapRequest Request;
typedef SaveMapResponse Response;
};
}
#endif
| 1,470 | C | 18.103896 | 72 | 0.633333 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/ProjectedMapInfo.h | #ifndef _ROS_map_msgs_ProjectedMapInfo_h
#define _ROS_map_msgs_ProjectedMapInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace map_msgs
{
class ProjectedMapInfo : public ros::Msg
{
public:
typedef const char* _frame_id_type;
_frame_id_type frame_id;
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _width_type;
_width_type width;
typedef double _height_type;
_height_type height;
typedef double _min_z_type;
_min_z_type min_z;
typedef double _max_z_type;
_max_z_type max_z;
ProjectedMapInfo():
frame_id(""),
x(0),
y(0),
width(0),
height(0),
min_z(0),
max_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_frame_id = strlen(this->frame_id);
varToArr(outbuffer + offset, length_frame_id);
offset += 4;
memcpy(outbuffer + offset, this->frame_id, length_frame_id);
offset += length_frame_id;
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_width;
u_width.real = this->width;
*(outbuffer + offset + 0) = (u_width.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_width.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_width.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_width.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_width.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_width.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_width.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_width.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->width);
union {
double real;
uint64_t base;
} u_height;
u_height.real = this->height;
*(outbuffer + offset + 0) = (u_height.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_height.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_height.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_height.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_height.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_height.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_height.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_height.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->height);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.real = this->min_z;
*(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.real = this->max_z;
*(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_frame_id;
arrToVar(length_frame_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_frame_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_frame_id-1]=0;
this->frame_id = (char *)(inbuffer + offset-1);
offset += length_frame_id;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_width;
u_width.base = 0;
u_width.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->width = u_width.real;
offset += sizeof(this->width);
union {
double real;
uint64_t base;
} u_height;
u_height.base = 0;
u_height.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->height = u_height.real;
offset += sizeof(this->height);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.base = 0;
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_z = u_min_z.real;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.base = 0;
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_z = u_max_z.real;
offset += sizeof(this->max_z);
return offset;
}
const char * getType(){ return "map_msgs/ProjectedMapInfo"; };
const char * getMD5(){ return "2dc10595ae94de23f22f8a6d2a0eef7a"; };
};
}
#endif
| 10,290 | C | 40.495968 | 74 | 0.477357 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/PointCloud2Update.h | #ifndef _ROS_map_msgs_PointCloud2Update_h
#define _ROS_map_msgs_PointCloud2Update_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/PointCloud2.h"
namespace map_msgs
{
class PointCloud2Update : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _type_type;
_type_type type;
typedef sensor_msgs::PointCloud2 _points_type;
_points_type points;
enum { ADD = 0 };
enum { DELETE = 1 };
PointCloud2Update():
header(),
type(0),
points()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->type >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->type >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->type >> (8 * 3)) & 0xFF;
offset += sizeof(this->type);
offset += this->points.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->type = ((uint32_t) (*(inbuffer + offset)));
this->type |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->type |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->type |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->type);
offset += this->points.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "map_msgs/PointCloud2Update"; };
const char * getMD5(){ return "6c58e4f249ae9cd2b24fb1ee0f99195e"; };
};
}
#endif
| 1,891 | C | 27.666666 | 72 | 0.580645 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/ProjectedMap.h | #ifndef _ROS_map_msgs_ProjectedMap_h
#define _ROS_map_msgs_ProjectedMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace map_msgs
{
class ProjectedMap : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
typedef double _min_z_type;
_min_z_type min_z;
typedef double _max_z_type;
_max_z_type max_z;
ProjectedMap():
map(),
min_z(0),
max_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.real = this->min_z;
*(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.real = this->max_z;
*(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.base = 0;
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_z = u_min_z.real;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.base = 0;
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_z = u_max_z.real;
offset += sizeof(this->max_z);
return offset;
}
const char * getType(){ return "map_msgs/ProjectedMap"; };
const char * getMD5(){ return "7bbe8f96e45089681dc1ea7d023cbfca"; };
};
}
#endif
| 3,929 | C | 35.055046 | 73 | 0.4958 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/KeyValue.h | #ifndef _ROS_diagnostic_msgs_KeyValue_h
#define _ROS_diagnostic_msgs_KeyValue_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace diagnostic_msgs
{
class KeyValue : public ros::Msg
{
public:
typedef const char* _key_type;
_key_type key;
typedef const char* _value_type;
_value_type value;
KeyValue():
key(""),
value("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_key = strlen(this->key);
varToArr(outbuffer + offset, length_key);
offset += 4;
memcpy(outbuffer + offset, this->key, length_key);
offset += length_key;
uint32_t length_value = strlen(this->value);
varToArr(outbuffer + offset, length_value);
offset += 4;
memcpy(outbuffer + offset, this->value, length_value);
offset += length_value;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_key;
arrToVar(length_key, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_key; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_key-1]=0;
this->key = (char *)(inbuffer + offset-1);
offset += length_key;
uint32_t length_value;
arrToVar(length_value, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_value; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_value-1]=0;
this->value = (char *)(inbuffer + offset-1);
offset += length_value;
return offset;
}
const char * getType(){ return "diagnostic_msgs/KeyValue"; };
const char * getMD5(){ return "cf57fdc6617a881a88c16e768132149c"; };
};
}
#endif
| 1,861 | C | 24.506849 | 72 | 0.597528 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/DiagnosticArray.h | #ifndef _ROS_diagnostic_msgs_DiagnosticArray_h
#define _ROS_diagnostic_msgs_DiagnosticArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "diagnostic_msgs/DiagnosticStatus.h"
namespace diagnostic_msgs
{
class DiagnosticArray : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t status_length;
typedef diagnostic_msgs::DiagnosticStatus _status_type;
_status_type st_status;
_status_type * status;
DiagnosticArray():
header(),
status_length(0), status(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->status_length);
for( uint32_t i = 0; i < status_length; i++){
offset += this->status[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->status_length);
if(status_lengthT > status_length)
this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
status_length = status_lengthT;
for( uint32_t i = 0; i < status_length; i++){
offset += this->st_status.deserialize(inbuffer + offset);
memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
}
return offset;
}
const char * getType(){ return "diagnostic_msgs/DiagnosticArray"; };
const char * getMD5(){ return "60810da900de1dd6ddd437c3503511da"; };
};
}
#endif
| 2,416 | C | 33.042253 | 141 | 0.613825 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/DiagnosticStatus.h | #ifndef _ROS_diagnostic_msgs_DiagnosticStatus_h
#define _ROS_diagnostic_msgs_DiagnosticStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "diagnostic_msgs/KeyValue.h"
namespace diagnostic_msgs
{
class DiagnosticStatus : public ros::Msg
{
public:
typedef int8_t _level_type;
_level_type level;
typedef const char* _name_type;
_name_type name;
typedef const char* _message_type;
_message_type message;
typedef const char* _hardware_id_type;
_hardware_id_type hardware_id;
uint32_t values_length;
typedef diagnostic_msgs::KeyValue _values_type;
_values_type st_values;
_values_type * values;
enum { OK = 0 };
enum { WARN = 1 };
enum { ERROR = 2 };
enum { STALE = 3 };
DiagnosticStatus():
level(0),
name(""),
message(""),
hardware_id(""),
values_length(0), values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_level;
u_level.real = this->level;
*(outbuffer + offset + 0) = (u_level.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->level);
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_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
uint32_t length_hardware_id = strlen(this->hardware_id);
varToArr(outbuffer + offset, length_hardware_id);
offset += 4;
memcpy(outbuffer + offset, this->hardware_id, length_hardware_id);
offset += length_hardware_id;
*(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->values_length);
for( uint32_t i = 0; i < values_length; i++){
offset += this->values[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_level;
u_level.base = 0;
u_level.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->level = u_level.real;
offset += sizeof(this->level);
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_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
uint32_t length_hardware_id;
arrToVar(length_hardware_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_hardware_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_hardware_id-1]=0;
this->hardware_id = (char *)(inbuffer + offset-1);
offset += length_hardware_id;
uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->values_length);
if(values_lengthT > values_length)
this->values = (diagnostic_msgs::KeyValue*)realloc(this->values, values_lengthT * sizeof(diagnostic_msgs::KeyValue));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
offset += this->st_values.deserialize(inbuffer + offset);
memcpy( &(this->values[i]), &(this->st_values), sizeof(diagnostic_msgs::KeyValue));
}
return offset;
}
const char * getType(){ return "diagnostic_msgs/DiagnosticStatus"; };
const char * getMD5(){ return "d0ce08bc6e5ba34c7754f563a9cabaf1"; };
};
}
#endif
| 4,751 | C | 33.434782 | 125 | 0.584719 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/AddDiagnostics.h | #ifndef _ROS_SERVICE_AddDiagnostics_h
#define _ROS_SERVICE_AddDiagnostics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace diagnostic_msgs
{
static const char ADDDIAGNOSTICS[] = "diagnostic_msgs/AddDiagnostics";
class AddDiagnosticsRequest : public ros::Msg
{
public:
typedef const char* _load_namespace_type;
_load_namespace_type load_namespace;
AddDiagnosticsRequest():
load_namespace("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_load_namespace = strlen(this->load_namespace);
varToArr(outbuffer + offset, length_load_namespace);
offset += 4;
memcpy(outbuffer + offset, this->load_namespace, length_load_namespace);
offset += length_load_namespace;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_load_namespace;
arrToVar(length_load_namespace, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_load_namespace; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_load_namespace-1]=0;
this->load_namespace = (char *)(inbuffer + offset-1);
offset += length_load_namespace;
return offset;
}
const char * getType(){ return ADDDIAGNOSTICS; };
const char * getMD5(){ return "c26cf6e164288fbc6050d74f838bcdf0"; };
};
class AddDiagnosticsResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _message_type;
_message_type message;
AddDiagnosticsResponse():
success(0),
message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
return offset;
}
const char * getType(){ return ADDDIAGNOSTICS; };
const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
};
class AddDiagnostics {
public:
typedef AddDiagnosticsRequest Request;
typedef AddDiagnosticsResponse Response;
};
}
#endif
| 3,299 | C | 25.829268 | 78 | 0.619582 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/SelfTest.h | #ifndef _ROS_SERVICE_SelfTest_h
#define _ROS_SERVICE_SelfTest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "diagnostic_msgs/DiagnosticStatus.h"
namespace diagnostic_msgs
{
static const char SELFTEST[] = "diagnostic_msgs/SelfTest";
class SelfTestRequest : public ros::Msg
{
public:
SelfTestRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return SELFTEST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SelfTestResponse : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef int8_t _passed_type;
_passed_type passed;
uint32_t status_length;
typedef diagnostic_msgs::DiagnosticStatus _status_type;
_status_type st_status;
_status_type * status;
SelfTestResponse():
id(""),
passed(0),
status_length(0), status(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
union {
int8_t real;
uint8_t base;
} u_passed;
u_passed.real = this->passed;
*(outbuffer + offset + 0) = (u_passed.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->passed);
*(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->status_length);
for( uint32_t i = 0; i < status_length; i++){
offset += this->status[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
union {
int8_t real;
uint8_t base;
} u_passed;
u_passed.base = 0;
u_passed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->passed = u_passed.real;
offset += sizeof(this->passed);
uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->status_length);
if(status_lengthT > status_length)
this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
status_length = status_lengthT;
for( uint32_t i = 0; i < status_length; i++){
offset += this->st_status.deserialize(inbuffer + offset);
memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
}
return offset;
}
const char * getType(){ return SELFTEST; };
const char * getMD5(){ return "ac21b1bab7ab17546986536c22eb34e9"; };
};
class SelfTest {
public:
typedef SelfTestRequest Request;
typedef SelfTestResponse Response;
};
}
#endif
| 3,860 | C | 28.25 | 141 | 0.585751 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestMessageInfo.h | #ifndef _ROS_SERVICE_RequestMessageInfo_h
#define _ROS_SERVICE_RequestMessageInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTMESSAGEINFO[] = "rosserial_msgs/RequestMessageInfo";
class RequestMessageInfoRequest : public ros::Msg
{
public:
typedef const char* _type_type;
_type_type type;
RequestMessageInfoRequest():
type("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
return offset;
}
const char * getType(){ return REQUESTMESSAGEINFO; };
const char * getMD5(){ return "dc67331de85cf97091b7d45e5c64ab75"; };
};
class RequestMessageInfoResponse : public ros::Msg
{
public:
typedef const char* _md5_type;
_md5_type md5;
typedef const char* _definition_type;
_definition_type definition;
RequestMessageInfoResponse():
md5(""),
definition("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_md5 = strlen(this->md5);
varToArr(outbuffer + offset, length_md5);
offset += 4;
memcpy(outbuffer + offset, this->md5, length_md5);
offset += length_md5;
uint32_t length_definition = strlen(this->definition);
varToArr(outbuffer + offset, length_definition);
offset += 4;
memcpy(outbuffer + offset, this->definition, length_definition);
offset += length_definition;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_md5;
arrToVar(length_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_md5-1]=0;
this->md5 = (char *)(inbuffer + offset-1);
offset += length_md5;
uint32_t length_definition;
arrToVar(length_definition, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_definition; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_definition-1]=0;
this->definition = (char *)(inbuffer + offset-1);
offset += length_definition;
return offset;
}
const char * getType(){ return REQUESTMESSAGEINFO; };
const char * getMD5(){ return "fe452186a069bed40f09b8628fe5eac8"; };
};
class RequestMessageInfo {
public:
typedef RequestMessageInfoRequest Request;
typedef RequestMessageInfoResponse Response;
};
}
#endif
| 3,273 | C | 25.836065 | 77 | 0.62542 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/TopicInfo.h | #ifndef _ROS_rosserial_msgs_TopicInfo_h
#define _ROS_rosserial_msgs_TopicInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
class TopicInfo : public ros::Msg
{
public:
typedef uint16_t _topic_id_type;
_topic_id_type topic_id;
typedef const char* _topic_name_type;
_topic_name_type topic_name;
typedef const char* _message_type_type;
_message_type_type message_type;
typedef const char* _md5sum_type;
_md5sum_type md5sum;
typedef int32_t _buffer_size_type;
_buffer_size_type buffer_size;
enum { ID_PUBLISHER = 0 };
enum { ID_SUBSCRIBER = 1 };
enum { ID_SERVICE_SERVER = 2 };
enum { ID_SERVICE_CLIENT = 4 };
enum { ID_PARAMETER_REQUEST = 6 };
enum { ID_LOG = 7 };
enum { ID_TIME = 10 };
enum { ID_TX_STOP = 11 };
TopicInfo():
topic_id(0),
topic_name(""),
message_type(""),
md5sum(""),
buffer_size(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->topic_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topic_id >> (8 * 1)) & 0xFF;
offset += sizeof(this->topic_id);
uint32_t length_topic_name = strlen(this->topic_name);
varToArr(outbuffer + offset, length_topic_name);
offset += 4;
memcpy(outbuffer + offset, this->topic_name, length_topic_name);
offset += length_topic_name;
uint32_t length_message_type = strlen(this->message_type);
varToArr(outbuffer + offset, length_message_type);
offset += 4;
memcpy(outbuffer + offset, this->message_type, length_message_type);
offset += length_message_type;
uint32_t length_md5sum = strlen(this->md5sum);
varToArr(outbuffer + offset, length_md5sum);
offset += 4;
memcpy(outbuffer + offset, this->md5sum, length_md5sum);
offset += length_md5sum;
union {
int32_t real;
uint32_t base;
} u_buffer_size;
u_buffer_size.real = this->buffer_size;
*(outbuffer + offset + 0) = (u_buffer_size.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_buffer_size.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_buffer_size.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_buffer_size.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->buffer_size);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->topic_id = ((uint16_t) (*(inbuffer + offset)));
this->topic_id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->topic_id);
uint32_t length_topic_name;
arrToVar(length_topic_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic_name-1]=0;
this->topic_name = (char *)(inbuffer + offset-1);
offset += length_topic_name;
uint32_t length_message_type;
arrToVar(length_message_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message_type-1]=0;
this->message_type = (char *)(inbuffer + offset-1);
offset += length_message_type;
uint32_t length_md5sum;
arrToVar(length_md5sum, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_md5sum; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_md5sum-1]=0;
this->md5sum = (char *)(inbuffer + offset-1);
offset += length_md5sum;
union {
int32_t real;
uint32_t base;
} u_buffer_size;
u_buffer_size.base = 0;
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->buffer_size = u_buffer_size.real;
offset += sizeof(this->buffer_size);
return offset;
}
const char * getType(){ return "rosserial_msgs/TopicInfo"; };
const char * getMD5(){ return "0ad51f88fc44892f8c10684077646005"; };
};
}
#endif
| 4,530 | C | 33.587786 | 79 | 0.577042 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestParam.h | #ifndef _ROS_SERVICE_RequestParam_h
#define _ROS_SERVICE_RequestParam_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTPARAM[] = "rosserial_msgs/RequestParam";
class RequestParamRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
RequestParamRequest():
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
return offset;
}
const char * getType(){ return REQUESTPARAM; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class RequestParamResponse : public ros::Msg
{
public:
uint32_t ints_length;
typedef int32_t _ints_type;
_ints_type st_ints;
_ints_type * ints;
uint32_t floats_length;
typedef float _floats_type;
_floats_type st_floats;
_floats_type * floats;
uint32_t strings_length;
typedef char* _strings_type;
_strings_type st_strings;
_strings_type * strings;
RequestParamResponse():
ints_length(0), ints(NULL),
floats_length(0), floats(NULL),
strings_length(0), strings(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->ints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints_length);
for( uint32_t i = 0; i < ints_length; i++){
union {
int32_t real;
uint32_t base;
} u_intsi;
u_intsi.real = this->ints[i];
*(outbuffer + offset + 0) = (u_intsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_intsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_intsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_intsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints[i]);
}
*(outbuffer + offset + 0) = (this->floats_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->floats_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->floats_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->floats_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->floats_length);
for( uint32_t i = 0; i < floats_length; i++){
union {
float real;
uint32_t base;
} u_floatsi;
u_floatsi.real = this->floats[i];
*(outbuffer + offset + 0) = (u_floatsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_floatsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_floatsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_floatsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->floats[i]);
}
*(outbuffer + offset + 0) = (this->strings_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->strings_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->strings_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->strings_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->strings_length);
for( uint32_t i = 0; i < strings_length; i++){
uint32_t length_stringsi = strlen(this->strings[i]);
varToArr(outbuffer + offset, length_stringsi);
offset += 4;
memcpy(outbuffer + offset, this->strings[i], length_stringsi);
offset += length_stringsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t ints_lengthT = ((uint32_t) (*(inbuffer + offset)));
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ints_length);
if(ints_lengthT > ints_length)
this->ints = (int32_t*)realloc(this->ints, ints_lengthT * sizeof(int32_t));
ints_length = ints_lengthT;
for( uint32_t i = 0; i < ints_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_ints;
u_st_ints.base = 0;
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_ints = u_st_ints.real;
offset += sizeof(this->st_ints);
memcpy( &(this->ints[i]), &(this->st_ints), sizeof(int32_t));
}
uint32_t floats_lengthT = ((uint32_t) (*(inbuffer + offset)));
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->floats_length);
if(floats_lengthT > floats_length)
this->floats = (float*)realloc(this->floats, floats_lengthT * sizeof(float));
floats_length = floats_lengthT;
for( uint32_t i = 0; i < floats_length; i++){
union {
float real;
uint32_t base;
} u_st_floats;
u_st_floats.base = 0;
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_floats = u_st_floats.real;
offset += sizeof(this->st_floats);
memcpy( &(this->floats[i]), &(this->st_floats), sizeof(float));
}
uint32_t strings_lengthT = ((uint32_t) (*(inbuffer + offset)));
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->strings_length);
if(strings_lengthT > strings_length)
this->strings = (char**)realloc(this->strings, strings_lengthT * sizeof(char*));
strings_length = strings_lengthT;
for( uint32_t i = 0; i < strings_length; i++){
uint32_t length_st_strings;
arrToVar(length_st_strings, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_strings; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_strings-1]=0;
this->st_strings = (char *)(inbuffer + offset-1);
offset += length_st_strings;
memcpy( &(this->strings[i]), &(this->st_strings), sizeof(char*));
}
return offset;
}
const char * getType(){ return REQUESTPARAM; };
const char * getMD5(){ return "9f0e98bda65981986ddf53afa7a40e49"; };
};
class RequestParam {
public:
typedef RequestParamRequest Request;
typedef RequestParamResponse Response;
};
}
#endif
| 7,948 | C | 36.319249 | 88 | 0.551963 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/Log.h | #ifndef _ROS_rosserial_msgs_Log_h
#define _ROS_rosserial_msgs_Log_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
class Log : public ros::Msg
{
public:
typedef uint8_t _level_type;
_level_type level;
typedef const char* _msg_type;
_msg_type msg;
enum { ROSDEBUG = 0 };
enum { INFO = 1 };
enum { WARN = 2 };
enum { ERROR = 3 };
enum { FATAL = 4 };
Log():
level(0),
msg("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->level >> (8 * 0)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->level);
uint32_t length_msg;
arrToVar(length_msg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_msg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_msg-1]=0;
this->msg = (char *)(inbuffer + offset-1);
offset += length_msg;
return offset;
}
const char * getType(){ return "rosserial_msgs/Log"; };
const char * getMD5(){ return "11abd731c25933261cd6183bd12d6295"; };
};
}
#endif
| 1,615 | C | 22.764706 | 72 | 0.565325 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestServiceInfo.h | #ifndef _ROS_SERVICE_RequestServiceInfo_h
#define _ROS_SERVICE_RequestServiceInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTSERVICEINFO[] = "rosserial_msgs/RequestServiceInfo";
class RequestServiceInfoRequest : public ros::Msg
{
public:
typedef const char* _service_type;
_service_type service;
RequestServiceInfoRequest():
service("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_service = strlen(this->service);
varToArr(outbuffer + offset, length_service);
offset += 4;
memcpy(outbuffer + offset, this->service, length_service);
offset += length_service;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_service;
arrToVar(length_service, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_service; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_service-1]=0;
this->service = (char *)(inbuffer + offset-1);
offset += length_service;
return offset;
}
const char * getType(){ return REQUESTSERVICEINFO; };
const char * getMD5(){ return "1cbcfa13b08f6d36710b9af8741e6112"; };
};
class RequestServiceInfoResponse : public ros::Msg
{
public:
typedef const char* _service_md5_type;
_service_md5_type service_md5;
typedef const char* _request_md5_type;
_request_md5_type request_md5;
typedef const char* _response_md5_type;
_response_md5_type response_md5;
RequestServiceInfoResponse():
service_md5(""),
request_md5(""),
response_md5("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_service_md5 = strlen(this->service_md5);
varToArr(outbuffer + offset, length_service_md5);
offset += 4;
memcpy(outbuffer + offset, this->service_md5, length_service_md5);
offset += length_service_md5;
uint32_t length_request_md5 = strlen(this->request_md5);
varToArr(outbuffer + offset, length_request_md5);
offset += 4;
memcpy(outbuffer + offset, this->request_md5, length_request_md5);
offset += length_request_md5;
uint32_t length_response_md5 = strlen(this->response_md5);
varToArr(outbuffer + offset, length_response_md5);
offset += 4;
memcpy(outbuffer + offset, this->response_md5, length_response_md5);
offset += length_response_md5;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_service_md5;
arrToVar(length_service_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_service_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_service_md5-1]=0;
this->service_md5 = (char *)(inbuffer + offset-1);
offset += length_service_md5;
uint32_t length_request_md5;
arrToVar(length_request_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_request_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_request_md5-1]=0;
this->request_md5 = (char *)(inbuffer + offset-1);
offset += length_request_md5;
uint32_t length_response_md5;
arrToVar(length_response_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_response_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_response_md5-1]=0;
this->response_md5 = (char *)(inbuffer + offset-1);
offset += length_response_md5;
return offset;
}
const char * getType(){ return REQUESTSERVICEINFO; };
const char * getMD5(){ return "c3d6dd25b909596479fbbc6559fa6874"; };
};
class RequestServiceInfo {
public:
typedef RequestServiceInfoRequest Request;
typedef RequestServiceInfoResponse Response;
};
}
#endif
| 4,199 | C | 29.215827 | 77 | 0.635389 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisGoal_h
#define _ROS_flexbe_msgs_BehaviorSynthesisGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/SynthesisRequest.h"
namespace flexbe_msgs
{
class BehaviorSynthesisGoal : public ros::Msg
{
public:
typedef flexbe_msgs::SynthesisRequest _request_type;
_request_type request;
BehaviorSynthesisGoal():
request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisGoal"; };
const char * getMD5(){ return "64ccf8fdad6091a950ca099bc67e6595"; };
};
}
#endif
| 968 | C | 20.533333 | 74 | 0.670455 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisFeedback_h
#define _ROS_flexbe_msgs_BehaviorSynthesisFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorSynthesisFeedback : public ros::Msg
{
public:
typedef const char* _status_type;
_status_type status;
typedef float _progress_type;
_progress_type progress;
BehaviorSynthesisFeedback():
status(""),
progress(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_status = strlen(this->status);
varToArr(outbuffer + offset, length_status);
offset += 4;
memcpy(outbuffer + offset, this->status, length_status);
offset += length_status;
union {
float real;
uint32_t base;
} u_progress;
u_progress.real = this->progress;
*(outbuffer + offset + 0) = (u_progress.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_progress.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_progress.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_progress.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->progress);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_status;
arrToVar(length_status, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status-1]=0;
this->status = (char *)(inbuffer + offset-1);
offset += length_status;
union {
float real;
uint32_t base;
} u_progress;
u_progress.base = 0;
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->progress = u_progress.real;
offset += sizeof(this->progress);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisFeedback"; };
const char * getMD5(){ return "ce404b6cabcba81b67a4c8bac81c05d3"; };
};
}
#endif
| 2,375 | C | 28.7 | 78 | 0.583158 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionGoal_h
#define _ROS_flexbe_msgs_BehaviorExecutionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionGoal : public ros::Msg
{
public:
typedef const char* _behavior_name_type;
_behavior_name_type behavior_name;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t input_values_length;
typedef char* _input_values_type;
_input_values_type st_input_values;
_input_values_type * input_values;
BehaviorExecutionGoal():
behavior_name(""),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
input_keys_length(0), input_keys(NULL),
input_values_length(0), input_values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_behavior_name = strlen(this->behavior_name);
varToArr(outbuffer + offset, length_behavior_name);
offset += 4;
memcpy(outbuffer + offset, this->behavior_name, length_behavior_name);
offset += length_behavior_name;
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->input_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_values_length);
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_input_valuesi = strlen(this->input_values[i]);
varToArr(outbuffer + offset, length_input_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->input_values[i], length_input_valuesi);
offset += length_input_valuesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_behavior_name;
arrToVar(length_behavior_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_name-1]=0;
this->behavior_name = (char *)(inbuffer + offset-1);
offset += length_behavior_name;
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t input_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_values_length);
if(input_values_lengthT > input_values_length)
this->input_values = (char**)realloc(this->input_values, input_values_lengthT * sizeof(char*));
input_values_length = input_values_lengthT;
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_st_input_values;
arrToVar(length_st_input_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_values-1]=0;
this->st_input_values = (char *)(inbuffer + offset-1);
offset += length_st_input_values;
memcpy( &(this->input_values[i]), &(this->st_input_values), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionGoal"; };
const char * getMD5(){ return "448c2298fe3c13b6fd73cfc07e865a14"; };
};
}
#endif
| 9,264 | C | 44.416666 | 103 | 0.588515 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/SynthesisRequest.h | #ifndef _ROS_flexbe_msgs_SynthesisRequest_h
#define _ROS_flexbe_msgs_SynthesisRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class SynthesisRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _system_type;
_system_type system;
typedef const char* _goal_type;
_goal_type goal;
typedef const char* _initial_condition_type;
_initial_condition_type initial_condition;
uint32_t sm_outcomes_length;
typedef char* _sm_outcomes_type;
_sm_outcomes_type st_sm_outcomes;
_sm_outcomes_type * sm_outcomes;
SynthesisRequest():
name(""),
system(""),
goal(""),
initial_condition(""),
sm_outcomes_length(0), sm_outcomes(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_system = strlen(this->system);
varToArr(outbuffer + offset, length_system);
offset += 4;
memcpy(outbuffer + offset, this->system, length_system);
offset += length_system;
uint32_t length_goal = strlen(this->goal);
varToArr(outbuffer + offset, length_goal);
offset += 4;
memcpy(outbuffer + offset, this->goal, length_goal);
offset += length_goal;
uint32_t length_initial_condition = strlen(this->initial_condition);
varToArr(outbuffer + offset, length_initial_condition);
offset += 4;
memcpy(outbuffer + offset, this->initial_condition, length_initial_condition);
offset += length_initial_condition;
*(outbuffer + offset + 0) = (this->sm_outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sm_outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sm_outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sm_outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sm_outcomes_length);
for( uint32_t i = 0; i < sm_outcomes_length; i++){
uint32_t length_sm_outcomesi = strlen(this->sm_outcomes[i]);
varToArr(outbuffer + offset, length_sm_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->sm_outcomes[i], length_sm_outcomesi);
offset += length_sm_outcomesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_system;
arrToVar(length_system, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_system; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_system-1]=0;
this->system = (char *)(inbuffer + offset-1);
offset += length_system;
uint32_t length_goal;
arrToVar(length_goal, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_goal; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_goal-1]=0;
this->goal = (char *)(inbuffer + offset-1);
offset += length_goal;
uint32_t length_initial_condition;
arrToVar(length_initial_condition, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_initial_condition; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_initial_condition-1]=0;
this->initial_condition = (char *)(inbuffer + offset-1);
offset += length_initial_condition;
uint32_t sm_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sm_outcomes_length);
if(sm_outcomes_lengthT > sm_outcomes_length)
this->sm_outcomes = (char**)realloc(this->sm_outcomes, sm_outcomes_lengthT * sizeof(char*));
sm_outcomes_length = sm_outcomes_lengthT;
for( uint32_t i = 0; i < sm_outcomes_length; i++){
uint32_t length_st_sm_outcomes;
arrToVar(length_st_sm_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_sm_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_sm_outcomes-1]=0;
this->st_sm_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_sm_outcomes;
memcpy( &(this->sm_outcomes[i]), &(this->st_sm_outcomes), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/SynthesisRequest"; };
const char * getMD5(){ return "99257dbfe8a196d006a75837dcabf3f6"; };
};
}
#endif
| 5,332 | C | 36.034722 | 100 | 0.605214 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/SynthesisErrorCodes.h | #ifndef _ROS_flexbe_msgs_SynthesisErrorCodes_h
#define _ROS_flexbe_msgs_SynthesisErrorCodes_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class SynthesisErrorCodes : public ros::Msg
{
public:
typedef int32_t _value_type;
_value_type value;
enum { SUCCESS = 1 };
SynthesisErrorCodes():
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "flexbe_msgs/SynthesisErrorCodes"; };
const char * getMD5(){ return "64e05da1f86a12ce44b1cca74395bd4e"; };
};
}
#endif
| 1,679 | C | 25.25 | 73 | 0.551519 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorInputGoal_h
#define _ROS_flexbe_msgs_BehaviorInputGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputGoal : public ros::Msg
{
public:
typedef uint8_t _request_type_type;
_request_type_type request_type;
typedef const char* _msg_type;
_msg_type msg;
BehaviorInputGoal():
request_type(0),
msg("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->request_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->request_type);
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->request_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->request_type);
uint32_t length_msg;
arrToVar(length_msg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_msg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_msg-1]=0;
this->msg = (char *)(inbuffer + offset-1);
offset += length_msg;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputGoal"; };
const char * getMD5(){ return "724150348fd57a5ebc07765871d3f316"; };
};
}
#endif
| 1,598 | C | 24.380952 | 73 | 0.605757 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorModification.h | #ifndef _ROS_flexbe_msgs_BehaviorModification_h
#define _ROS_flexbe_msgs_BehaviorModification_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorModification : public ros::Msg
{
public:
typedef int32_t _index_begin_type;
_index_begin_type index_begin;
typedef int32_t _index_end_type;
_index_end_type index_end;
typedef const char* _new_content_type;
_new_content_type new_content;
BehaviorModification():
index_begin(0),
index_end(0),
new_content("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_index_begin;
u_index_begin.real = this->index_begin;
*(outbuffer + offset + 0) = (u_index_begin.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_index_begin.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_index_begin.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_index_begin.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->index_begin);
union {
int32_t real;
uint32_t base;
} u_index_end;
u_index_end.real = this->index_end;
*(outbuffer + offset + 0) = (u_index_end.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_index_end.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_index_end.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_index_end.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->index_end);
uint32_t length_new_content = strlen(this->new_content);
varToArr(outbuffer + offset, length_new_content);
offset += 4;
memcpy(outbuffer + offset, this->new_content, length_new_content);
offset += length_new_content;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_index_begin;
u_index_begin.base = 0;
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->index_begin = u_index_begin.real;
offset += sizeof(this->index_begin);
union {
int32_t real;
uint32_t base;
} u_index_end;
u_index_end.base = 0;
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->index_end = u_index_end.real;
offset += sizeof(this->index_end);
uint32_t length_new_content;
arrToVar(length_new_content, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_new_content; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_new_content-1]=0;
this->new_content = (char *)(inbuffer + offset-1);
offset += length_new_content;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorModification"; };
const char * getMD5(){ return "ac997193d826b145a432b8e3e528f6b4"; };
};
}
#endif
| 3,545 | C | 33.096154 | 79 | 0.5622 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/StateInstantiation.h | #ifndef _ROS_flexbe_msgs_StateInstantiation_h
#define _ROS_flexbe_msgs_StateInstantiation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/OutcomeCondition.h"
namespace flexbe_msgs
{
class StateInstantiation : public ros::Msg
{
public:
typedef const char* _state_path_type;
_state_path_type state_path;
typedef const char* _state_class_type;
_state_class_type state_class;
typedef const char* _initial_state_name_type;
_initial_state_name_type initial_state_name;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t output_keys_length;
typedef char* _output_keys_type;
_output_keys_type st_output_keys;
_output_keys_type * output_keys;
uint32_t cond_outcome_length;
typedef char* _cond_outcome_type;
_cond_outcome_type st_cond_outcome;
_cond_outcome_type * cond_outcome;
uint32_t cond_transition_length;
typedef flexbe_msgs::OutcomeCondition _cond_transition_type;
_cond_transition_type st_cond_transition;
_cond_transition_type * cond_transition;
typedef const char* _behavior_class_type;
_behavior_class_type behavior_class;
uint32_t parameter_names_length;
typedef char* _parameter_names_type;
_parameter_names_type st_parameter_names;
_parameter_names_type * parameter_names;
uint32_t parameter_values_length;
typedef char* _parameter_values_type;
_parameter_values_type st_parameter_values;
_parameter_values_type * parameter_values;
float position[2];
uint32_t outcomes_length;
typedef char* _outcomes_type;
_outcomes_type st_outcomes;
_outcomes_type * outcomes;
uint32_t transitions_length;
typedef char* _transitions_type;
_transitions_type st_transitions;
_transitions_type * transitions;
uint32_t autonomy_length;
typedef int8_t _autonomy_type;
_autonomy_type st_autonomy;
_autonomy_type * autonomy;
uint32_t userdata_keys_length;
typedef char* _userdata_keys_type;
_userdata_keys_type st_userdata_keys;
_userdata_keys_type * userdata_keys;
uint32_t userdata_remapping_length;
typedef char* _userdata_remapping_type;
_userdata_remapping_type st_userdata_remapping;
_userdata_remapping_type * userdata_remapping;
enum { CLASS_STATEMACHINE = :STATEMACHINE };
enum { CLASS_CONCURRENCY = :CONCURRENCY };
enum { CLASS_PRIORITY = :PRIORITY };
enum { CLASS_BEHAVIOR = :BEHAVIOR };
StateInstantiation():
state_path(""),
state_class(""),
initial_state_name(""),
input_keys_length(0), input_keys(NULL),
output_keys_length(0), output_keys(NULL),
cond_outcome_length(0), cond_outcome(NULL),
cond_transition_length(0), cond_transition(NULL),
behavior_class(""),
parameter_names_length(0), parameter_names(NULL),
parameter_values_length(0), parameter_values(NULL),
position(),
outcomes_length(0), outcomes(NULL),
transitions_length(0), transitions(NULL),
autonomy_length(0), autonomy(NULL),
userdata_keys_length(0), userdata_keys(NULL),
userdata_remapping_length(0), userdata_remapping(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state_path = strlen(this->state_path);
varToArr(outbuffer + offset, length_state_path);
offset += 4;
memcpy(outbuffer + offset, this->state_path, length_state_path);
offset += length_state_path;
uint32_t length_state_class = strlen(this->state_class);
varToArr(outbuffer + offset, length_state_class);
offset += 4;
memcpy(outbuffer + offset, this->state_class, length_state_class);
offset += length_state_class;
uint32_t length_initial_state_name = strlen(this->initial_state_name);
varToArr(outbuffer + offset, length_initial_state_name);
offset += 4;
memcpy(outbuffer + offset, this->initial_state_name, length_initial_state_name);
offset += length_initial_state_name;
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->output_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->output_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->output_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->output_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->output_keys_length);
for( uint32_t i = 0; i < output_keys_length; i++){
uint32_t length_output_keysi = strlen(this->output_keys[i]);
varToArr(outbuffer + offset, length_output_keysi);
offset += 4;
memcpy(outbuffer + offset, this->output_keys[i], length_output_keysi);
offset += length_output_keysi;
}
*(outbuffer + offset + 0) = (this->cond_outcome_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cond_outcome_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cond_outcome_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cond_outcome_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cond_outcome_length);
for( uint32_t i = 0; i < cond_outcome_length; i++){
uint32_t length_cond_outcomei = strlen(this->cond_outcome[i]);
varToArr(outbuffer + offset, length_cond_outcomei);
offset += 4;
memcpy(outbuffer + offset, this->cond_outcome[i], length_cond_outcomei);
offset += length_cond_outcomei;
}
*(outbuffer + offset + 0) = (this->cond_transition_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cond_transition_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cond_transition_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cond_transition_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cond_transition_length);
for( uint32_t i = 0; i < cond_transition_length; i++){
offset += this->cond_transition[i].serialize(outbuffer + offset);
}
uint32_t length_behavior_class = strlen(this->behavior_class);
varToArr(outbuffer + offset, length_behavior_class);
offset += 4;
memcpy(outbuffer + offset, this->behavior_class, length_behavior_class);
offset += length_behavior_class;
*(outbuffer + offset + 0) = (this->parameter_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameter_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameter_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameter_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameter_names_length);
for( uint32_t i = 0; i < parameter_names_length; i++){
uint32_t length_parameter_namesi = strlen(this->parameter_names[i]);
varToArr(outbuffer + offset, length_parameter_namesi);
offset += 4;
memcpy(outbuffer + offset, this->parameter_names[i], length_parameter_namesi);
offset += length_parameter_namesi;
}
*(outbuffer + offset + 0) = (this->parameter_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameter_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameter_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameter_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameter_values_length);
for( uint32_t i = 0; i < parameter_values_length; i++){
uint32_t length_parameter_valuesi = strlen(this->parameter_values[i]);
varToArr(outbuffer + offset, length_parameter_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->parameter_values[i], length_parameter_valuesi);
offset += length_parameter_valuesi;
}
for( uint32_t i = 0; i < 2; i++){
union {
float real;
uint32_t base;
} u_positioni;
u_positioni.real = this->position[i];
*(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_length);
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_outcomesi = strlen(this->outcomes[i]);
varToArr(outbuffer + offset, length_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes[i], length_outcomesi);
offset += length_outcomesi;
}
*(outbuffer + offset + 0) = (this->transitions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transitions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transitions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transitions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transitions_length);
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_transitionsi = strlen(this->transitions[i]);
varToArr(outbuffer + offset, length_transitionsi);
offset += 4;
memcpy(outbuffer + offset, this->transitions[i], length_transitionsi);
offset += length_transitionsi;
}
*(outbuffer + offset + 0) = (this->autonomy_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->autonomy_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->autonomy_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->autonomy_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->autonomy_length);
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_autonomyi;
u_autonomyi.real = this->autonomy[i];
*(outbuffer + offset + 0) = (u_autonomyi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy[i]);
}
*(outbuffer + offset + 0) = (this->userdata_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->userdata_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->userdata_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->userdata_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->userdata_keys_length);
for( uint32_t i = 0; i < userdata_keys_length; i++){
uint32_t length_userdata_keysi = strlen(this->userdata_keys[i]);
varToArr(outbuffer + offset, length_userdata_keysi);
offset += 4;
memcpy(outbuffer + offset, this->userdata_keys[i], length_userdata_keysi);
offset += length_userdata_keysi;
}
*(outbuffer + offset + 0) = (this->userdata_remapping_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->userdata_remapping_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->userdata_remapping_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->userdata_remapping_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->userdata_remapping_length);
for( uint32_t i = 0; i < userdata_remapping_length; i++){
uint32_t length_userdata_remappingi = strlen(this->userdata_remapping[i]);
varToArr(outbuffer + offset, length_userdata_remappingi);
offset += 4;
memcpy(outbuffer + offset, this->userdata_remapping[i], length_userdata_remappingi);
offset += length_userdata_remappingi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state_path;
arrToVar(length_state_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state_path-1]=0;
this->state_path = (char *)(inbuffer + offset-1);
offset += length_state_path;
uint32_t length_state_class;
arrToVar(length_state_class, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state_class; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state_class-1]=0;
this->state_class = (char *)(inbuffer + offset-1);
offset += length_state_class;
uint32_t length_initial_state_name;
arrToVar(length_initial_state_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_initial_state_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_initial_state_name-1]=0;
this->initial_state_name = (char *)(inbuffer + offset-1);
offset += length_initial_state_name;
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t output_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->output_keys_length);
if(output_keys_lengthT > output_keys_length)
this->output_keys = (char**)realloc(this->output_keys, output_keys_lengthT * sizeof(char*));
output_keys_length = output_keys_lengthT;
for( uint32_t i = 0; i < output_keys_length; i++){
uint32_t length_st_output_keys;
arrToVar(length_st_output_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_output_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_output_keys-1]=0;
this->st_output_keys = (char *)(inbuffer + offset-1);
offset += length_st_output_keys;
memcpy( &(this->output_keys[i]), &(this->st_output_keys), sizeof(char*));
}
uint32_t cond_outcome_lengthT = ((uint32_t) (*(inbuffer + offset)));
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cond_outcome_length);
if(cond_outcome_lengthT > cond_outcome_length)
this->cond_outcome = (char**)realloc(this->cond_outcome, cond_outcome_lengthT * sizeof(char*));
cond_outcome_length = cond_outcome_lengthT;
for( uint32_t i = 0; i < cond_outcome_length; i++){
uint32_t length_st_cond_outcome;
arrToVar(length_st_cond_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_cond_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_cond_outcome-1]=0;
this->st_cond_outcome = (char *)(inbuffer + offset-1);
offset += length_st_cond_outcome;
memcpy( &(this->cond_outcome[i]), &(this->st_cond_outcome), sizeof(char*));
}
uint32_t cond_transition_lengthT = ((uint32_t) (*(inbuffer + offset)));
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cond_transition_length);
if(cond_transition_lengthT > cond_transition_length)
this->cond_transition = (flexbe_msgs::OutcomeCondition*)realloc(this->cond_transition, cond_transition_lengthT * sizeof(flexbe_msgs::OutcomeCondition));
cond_transition_length = cond_transition_lengthT;
for( uint32_t i = 0; i < cond_transition_length; i++){
offset += this->st_cond_transition.deserialize(inbuffer + offset);
memcpy( &(this->cond_transition[i]), &(this->st_cond_transition), sizeof(flexbe_msgs::OutcomeCondition));
}
uint32_t length_behavior_class;
arrToVar(length_behavior_class, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_class; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_class-1]=0;
this->behavior_class = (char *)(inbuffer + offset-1);
offset += length_behavior_class;
uint32_t parameter_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameter_names_length);
if(parameter_names_lengthT > parameter_names_length)
this->parameter_names = (char**)realloc(this->parameter_names, parameter_names_lengthT * sizeof(char*));
parameter_names_length = parameter_names_lengthT;
for( uint32_t i = 0; i < parameter_names_length; i++){
uint32_t length_st_parameter_names;
arrToVar(length_st_parameter_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_parameter_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_parameter_names-1]=0;
this->st_parameter_names = (char *)(inbuffer + offset-1);
offset += length_st_parameter_names;
memcpy( &(this->parameter_names[i]), &(this->st_parameter_names), sizeof(char*));
}
uint32_t parameter_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameter_values_length);
if(parameter_values_lengthT > parameter_values_length)
this->parameter_values = (char**)realloc(this->parameter_values, parameter_values_lengthT * sizeof(char*));
parameter_values_length = parameter_values_lengthT;
for( uint32_t i = 0; i < parameter_values_length; i++){
uint32_t length_st_parameter_values;
arrToVar(length_st_parameter_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_parameter_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_parameter_values-1]=0;
this->st_parameter_values = (char *)(inbuffer + offset-1);
offset += length_st_parameter_values;
memcpy( &(this->parameter_values[i]), &(this->st_parameter_values), sizeof(char*));
}
for( uint32_t i = 0; i < 2; i++){
union {
float real;
uint32_t base;
} u_positioni;
u_positioni.base = 0;
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->position[i] = u_positioni.real;
offset += sizeof(this->position[i]);
}
uint32_t outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_length);
if(outcomes_lengthT > outcomes_length)
this->outcomes = (char**)realloc(this->outcomes, outcomes_lengthT * sizeof(char*));
outcomes_length = outcomes_lengthT;
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_st_outcomes;
arrToVar(length_st_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes-1]=0;
this->st_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_outcomes;
memcpy( &(this->outcomes[i]), &(this->st_outcomes), sizeof(char*));
}
uint32_t transitions_lengthT = ((uint32_t) (*(inbuffer + offset)));
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transitions_length);
if(transitions_lengthT > transitions_length)
this->transitions = (char**)realloc(this->transitions, transitions_lengthT * sizeof(char*));
transitions_length = transitions_lengthT;
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_st_transitions;
arrToVar(length_st_transitions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_transitions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_transitions-1]=0;
this->st_transitions = (char *)(inbuffer + offset-1);
offset += length_st_transitions;
memcpy( &(this->transitions[i]), &(this->st_transitions), sizeof(char*));
}
uint32_t autonomy_lengthT = ((uint32_t) (*(inbuffer + offset)));
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->autonomy_length);
if(autonomy_lengthT > autonomy_length)
this->autonomy = (int8_t*)realloc(this->autonomy, autonomy_lengthT * sizeof(int8_t));
autonomy_length = autonomy_lengthT;
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_autonomy;
u_st_autonomy.base = 0;
u_st_autonomy.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_autonomy = u_st_autonomy.real;
offset += sizeof(this->st_autonomy);
memcpy( &(this->autonomy[i]), &(this->st_autonomy), sizeof(int8_t));
}
uint32_t userdata_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->userdata_keys_length);
if(userdata_keys_lengthT > userdata_keys_length)
this->userdata_keys = (char**)realloc(this->userdata_keys, userdata_keys_lengthT * sizeof(char*));
userdata_keys_length = userdata_keys_lengthT;
for( uint32_t i = 0; i < userdata_keys_length; i++){
uint32_t length_st_userdata_keys;
arrToVar(length_st_userdata_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_userdata_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_userdata_keys-1]=0;
this->st_userdata_keys = (char *)(inbuffer + offset-1);
offset += length_st_userdata_keys;
memcpy( &(this->userdata_keys[i]), &(this->st_userdata_keys), sizeof(char*));
}
uint32_t userdata_remapping_lengthT = ((uint32_t) (*(inbuffer + offset)));
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->userdata_remapping_length);
if(userdata_remapping_lengthT > userdata_remapping_length)
this->userdata_remapping = (char**)realloc(this->userdata_remapping, userdata_remapping_lengthT * sizeof(char*));
userdata_remapping_length = userdata_remapping_lengthT;
for( uint32_t i = 0; i < userdata_remapping_length; i++){
uint32_t length_st_userdata_remapping;
arrToVar(length_st_userdata_remapping, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_userdata_remapping; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_userdata_remapping-1]=0;
this->st_userdata_remapping = (char *)(inbuffer + offset-1);
offset += length_st_userdata_remapping;
memcpy( &(this->userdata_remapping[i]), &(this->st_userdata_remapping), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/StateInstantiation"; };
const char * getMD5(){ return "1c6026e288cfff7ab6c8308ee1db66f1"; };
};
}
#endif
| 27,095 | C | 49.646729 | 160 | 0.602141 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputResult.h | #ifndef _ROS_flexbe_msgs_BehaviorInputResult_h
#define _ROS_flexbe_msgs_BehaviorInputResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputResult : public ros::Msg
{
public:
typedef uint8_t _result_code_type;
_result_code_type result_code;
typedef const char* _data_type;
_data_type data;
enum { RESULT_OK = 0 };
enum { RESULT_FAILED = 1 };
enum { RESULT_ABORTED = 2 };
BehaviorInputResult():
result_code(0),
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->result_code >> (8 * 0)) & 0xFF;
offset += sizeof(this->result_code);
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->result_code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->result_code);
uint32_t length_data;
arrToVar(length_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_data-1]=0;
this->data = (char *)(inbuffer + offset-1);
offset += length_data;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputResult"; };
const char * getMD5(){ return "e0509f159e7c7bb2268efbc625f63b3f"; };
};
}
#endif
| 1,718 | C | 25.045454 | 72 | 0.601863 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionFeedback_h
#define _ROS_flexbe_msgs_BehaviorExecutionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionFeedback : public ros::Msg
{
public:
typedef const char* _current_state_type;
_current_state_type current_state;
BehaviorExecutionFeedback():
current_state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_current_state = strlen(this->current_state);
varToArr(outbuffer + offset, length_current_state);
offset += 4;
memcpy(outbuffer + offset, this->current_state, length_current_state);
offset += length_current_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_current_state;
arrToVar(length_current_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_current_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_current_state-1]=0;
this->current_state = (char *)(inbuffer + offset-1);
offset += length_current_state;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionFeedback"; };
const char * getMD5(){ return "6b3c1b68b57cc9263bf79fc4ad6ec8c7"; };
};
}
#endif
| 1,468 | C | 25.232142 | 78 | 0.653951 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/Container.h | #ifndef _ROS_flexbe_msgs_Container_h
#define _ROS_flexbe_msgs_Container_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class Container : public ros::Msg
{
public:
typedef const char* _path_type;
_path_type path;
uint32_t children_length;
typedef char* _children_type;
_children_type st_children;
_children_type * children;
uint32_t outcomes_length;
typedef char* _outcomes_type;
_outcomes_type st_outcomes;
_outcomes_type * outcomes;
uint32_t transitions_length;
typedef char* _transitions_type;
_transitions_type st_transitions;
_transitions_type * transitions;
uint32_t autonomy_length;
typedef int8_t _autonomy_type;
_autonomy_type st_autonomy;
_autonomy_type * autonomy;
Container():
path(""),
children_length(0), children(NULL),
outcomes_length(0), outcomes(NULL),
transitions_length(0), transitions(NULL),
autonomy_length(0), autonomy(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->children_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->children_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->children_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->children_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->children_length);
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_childreni = strlen(this->children[i]);
varToArr(outbuffer + offset, length_childreni);
offset += 4;
memcpy(outbuffer + offset, this->children[i], length_childreni);
offset += length_childreni;
}
*(outbuffer + offset + 0) = (this->outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_length);
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_outcomesi = strlen(this->outcomes[i]);
varToArr(outbuffer + offset, length_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes[i], length_outcomesi);
offset += length_outcomesi;
}
*(outbuffer + offset + 0) = (this->transitions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transitions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transitions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transitions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transitions_length);
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_transitionsi = strlen(this->transitions[i]);
varToArr(outbuffer + offset, length_transitionsi);
offset += 4;
memcpy(outbuffer + offset, this->transitions[i], length_transitionsi);
offset += length_transitionsi;
}
*(outbuffer + offset + 0) = (this->autonomy_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->autonomy_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->autonomy_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->autonomy_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->autonomy_length);
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_autonomyi;
u_autonomyi.real = this->autonomy[i];
*(outbuffer + offset + 0) = (u_autonomyi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t children_lengthT = ((uint32_t) (*(inbuffer + offset)));
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->children_length);
if(children_lengthT > children_length)
this->children = (char**)realloc(this->children, children_lengthT * sizeof(char*));
children_length = children_lengthT;
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_st_children;
arrToVar(length_st_children, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_children; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_children-1]=0;
this->st_children = (char *)(inbuffer + offset-1);
offset += length_st_children;
memcpy( &(this->children[i]), &(this->st_children), sizeof(char*));
}
uint32_t outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_length);
if(outcomes_lengthT > outcomes_length)
this->outcomes = (char**)realloc(this->outcomes, outcomes_lengthT * sizeof(char*));
outcomes_length = outcomes_lengthT;
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_st_outcomes;
arrToVar(length_st_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes-1]=0;
this->st_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_outcomes;
memcpy( &(this->outcomes[i]), &(this->st_outcomes), sizeof(char*));
}
uint32_t transitions_lengthT = ((uint32_t) (*(inbuffer + offset)));
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transitions_length);
if(transitions_lengthT > transitions_length)
this->transitions = (char**)realloc(this->transitions, transitions_lengthT * sizeof(char*));
transitions_length = transitions_lengthT;
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_st_transitions;
arrToVar(length_st_transitions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_transitions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_transitions-1]=0;
this->st_transitions = (char *)(inbuffer + offset-1);
offset += length_st_transitions;
memcpy( &(this->transitions[i]), &(this->st_transitions), sizeof(char*));
}
uint32_t autonomy_lengthT = ((uint32_t) (*(inbuffer + offset)));
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->autonomy_length);
if(autonomy_lengthT > autonomy_length)
this->autonomy = (int8_t*)realloc(this->autonomy, autonomy_lengthT * sizeof(int8_t));
autonomy_length = autonomy_lengthT;
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_autonomy;
u_st_autonomy.base = 0;
u_st_autonomy.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_autonomy = u_st_autonomy.real;
offset += sizeof(this->st_autonomy);
memcpy( &(this->autonomy[i]), &(this->st_autonomy), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/Container"; };
const char * getMD5(){ return "627eacc0f462c8ee83d7105e17cf4119"; };
};
}
#endif
| 8,769 | C | 41.780488 | 100 | 0.583647 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/OutcomeRequest.h | #ifndef _ROS_flexbe_msgs_OutcomeRequest_h
#define _ROS_flexbe_msgs_OutcomeRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class OutcomeRequest : public ros::Msg
{
public:
typedef uint8_t _outcome_type;
_outcome_type outcome;
typedef const char* _target_type;
_target_type target;
OutcomeRequest():
outcome(0),
target("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->outcome >> (8 * 0)) & 0xFF;
offset += sizeof(this->outcome);
uint32_t length_target = strlen(this->target);
varToArr(outbuffer + offset, length_target);
offset += 4;
memcpy(outbuffer + offset, this->target, length_target);
offset += length_target;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->outcome = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->outcome);
uint32_t length_target;
arrToVar(length_target, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target-1]=0;
this->target = (char *)(inbuffer + offset-1);
offset += length_target;
return offset;
}
const char * getType(){ return "flexbe_msgs/OutcomeRequest"; };
const char * getMD5(){ return "b057cf075cb943bf0dbb3443419a61ed"; };
};
}
#endif
| 1,591 | C | 24.269841 | 72 | 0.609051 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorRequest.h | #ifndef _ROS_flexbe_msgs_BehaviorRequest_h
#define _ROS_flexbe_msgs_BehaviorRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/Container.h"
namespace flexbe_msgs
{
class BehaviorRequest : public ros::Msg
{
public:
typedef const char* _behavior_name_type;
_behavior_name_type behavior_name;
typedef uint8_t _autonomy_level_type;
_autonomy_level_type autonomy_level;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t structure_length;
typedef flexbe_msgs::Container _structure_type;
_structure_type st_structure;
_structure_type * structure;
BehaviorRequest():
behavior_name(""),
autonomy_level(0),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
structure_length(0), structure(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_behavior_name = strlen(this->behavior_name);
varToArr(outbuffer + offset, length_behavior_name);
offset += 4;
memcpy(outbuffer + offset, this->behavior_name, length_behavior_name);
offset += length_behavior_name;
*(outbuffer + offset + 0) = (this->autonomy_level >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy_level);
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->structure_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->structure_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->structure_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->structure_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->structure_length);
for( uint32_t i = 0; i < structure_length; i++){
offset += this->structure[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_behavior_name;
arrToVar(length_behavior_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_name-1]=0;
this->behavior_name = (char *)(inbuffer + offset-1);
offset += length_behavior_name;
this->autonomy_level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->autonomy_level);
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t structure_lengthT = ((uint32_t) (*(inbuffer + offset)));
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->structure_length);
if(structure_lengthT > structure_length)
this->structure = (flexbe_msgs::Container*)realloc(this->structure, structure_lengthT * sizeof(flexbe_msgs::Container));
structure_length = structure_lengthT;
for( uint32_t i = 0; i < structure_length; i++){
offset += this->st_structure.deserialize(inbuffer + offset);
memcpy( &(this->structure[i]), &(this->st_structure), sizeof(flexbe_msgs::Container));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorRequest"; };
const char * getMD5(){ return "0b55949502d4c602376ee00a64d0d294"; };
};
}
#endif
| 7,122 | C | 42.699386 | 128 | 0.591126 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionResult_h
#define _ROS_flexbe_msgs_BehaviorExecutionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionResult : public ros::Msg
{
public:
typedef const char* _outcome_type;
_outcome_type outcome;
BehaviorExecutionResult():
outcome("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_outcome = strlen(this->outcome);
varToArr(outbuffer + offset, length_outcome);
offset += 4;
memcpy(outbuffer + offset, this->outcome, length_outcome);
offset += length_outcome;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_outcome;
arrToVar(length_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_outcome-1]=0;
this->outcome = (char *)(inbuffer + offset-1);
offset += length_outcome;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionResult"; };
const char * getMD5(){ return "2b95071cca675b3d5b80ad0bdaf20389"; };
};
}
#endif
| 1,362 | C | 23.339285 | 76 | 0.638767 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisResult.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisResult_h
#define _ROS_flexbe_msgs_BehaviorSynthesisResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/SynthesisErrorCodes.h"
#include "flexbe_msgs/StateInstantiation.h"
namespace flexbe_msgs
{
class BehaviorSynthesisResult : public ros::Msg
{
public:
typedef flexbe_msgs::SynthesisErrorCodes _error_code_type;
_error_code_type error_code;
uint32_t states_length;
typedef flexbe_msgs::StateInstantiation _states_type;
_states_type st_states;
_states_type * states;
BehaviorSynthesisResult():
error_code(),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (flexbe_msgs::StateInstantiation*)realloc(this->states, states_lengthT * sizeof(flexbe_msgs::StateInstantiation));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(flexbe_msgs::StateInstantiation));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisResult"; };
const char * getMD5(){ return "088bd6aee1c7ee2902db2babfd6af1c2"; };
};
}
#endif
| 2,486 | C | 34.028169 | 137 | 0.622285 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/ContainerStructure.h | #ifndef _ROS_flexbe_msgs_ContainerStructure_h
#define _ROS_flexbe_msgs_ContainerStructure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/Container.h"
namespace flexbe_msgs
{
class ContainerStructure : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
uint32_t containers_length;
typedef flexbe_msgs::Container _containers_type;
_containers_type st_containers;
_containers_type * containers;
ContainerStructure():
behavior_id(0),
containers_length(0), containers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
*(outbuffer + offset + 0) = (this->containers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->containers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->containers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->containers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->containers_length);
for( uint32_t i = 0; i < containers_length; i++){
offset += this->containers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
uint32_t containers_lengthT = ((uint32_t) (*(inbuffer + offset)));
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->containers_length);
if(containers_lengthT > containers_length)
this->containers = (flexbe_msgs::Container*)realloc(this->containers, containers_lengthT * sizeof(flexbe_msgs::Container));
containers_length = containers_lengthT;
for( uint32_t i = 0; i < containers_length; i++){
offset += this->st_containers.deserialize(inbuffer + offset);
memcpy( &(this->containers[i]), &(this->st_containers), sizeof(flexbe_msgs::Container));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/ContainerStructure"; };
const char * getMD5(){ return "9cd26d15621063b90279d87117694328"; };
};
}
#endif
| 3,334 | C | 36.47191 | 131 | 0.588782 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputAction.h | #ifndef _ROS_flexbe_msgs_BehaviorInputAction_h
#define _ROS_flexbe_msgs_BehaviorInputAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorInputActionGoal.h"
#include "flexbe_msgs/BehaviorInputActionResult.h"
#include "flexbe_msgs/BehaviorInputActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorInputAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorInputActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorInputActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorInputActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorInputAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputAction"; };
const char * getMD5(){ return "409aeef36c5fba868c3b1f845c52f119"; };
};
}
#endif
| 1,660 | C | 28.14035 | 77 | 0.695783 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionAction.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionAction_h
#define _ROS_flexbe_msgs_BehaviorExecutionAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorExecutionActionGoal.h"
#include "flexbe_msgs/BehaviorExecutionActionResult.h"
#include "flexbe_msgs/BehaviorExecutionActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorExecutionAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorExecutionActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorExecutionActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorExecutionActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorExecutionAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionAction"; };
const char * getMD5(){ return "5137e5877c4ee9dbe6ca4796ad090f1a"; };
};
}
#endif
| 1,704 | C | 28.91228 | 81 | 0.703638 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSync.h | #ifndef _ROS_flexbe_msgs_BehaviorSync_h
#define _ROS_flexbe_msgs_BehaviorSync_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorSync : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef int32_t _current_state_checksum_type;
_current_state_checksum_type current_state_checksum;
BehaviorSync():
behavior_id(0),
current_state_checksum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_current_state_checksum;
u_current_state_checksum.real = this->current_state_checksum;
*(outbuffer + offset + 0) = (u_current_state_checksum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_current_state_checksum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_current_state_checksum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_current_state_checksum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->current_state_checksum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_current_state_checksum;
u_current_state_checksum.base = 0;
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->current_state_checksum = u_current_state_checksum.real;
offset += sizeof(this->current_state_checksum);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSync"; };
const char * getMD5(){ return "118d64f48696509906c4cf4a228608b1"; };
};
}
#endif
| 3,060 | C | 34.183908 | 90 | 0.575163 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorLog.h | #ifndef _ROS_flexbe_msgs_BehaviorLog_h
#define _ROS_flexbe_msgs_BehaviorLog_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorLog : public ros::Msg
{
public:
typedef const char* _text_type;
_text_type text;
typedef uint8_t _status_code_type;
_status_code_type status_code;
enum { INFO = 0 };
enum { WARN = 1 };
enum { HINT = 2 };
enum { ERROR = 3 };
enum { DEBUG = 10 };
BehaviorLog():
text(""),
status_code(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_text = strlen(this->text);
varToArr(outbuffer + offset, length_text);
offset += 4;
memcpy(outbuffer + offset, this->text, length_text);
offset += length_text;
*(outbuffer + offset + 0) = (this->status_code >> (8 * 0)) & 0xFF;
offset += sizeof(this->status_code);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_text;
arrToVar(length_text, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_text; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_text-1]=0;
this->text = (char *)(inbuffer + offset-1);
offset += length_text;
this->status_code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->status_code);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorLog"; };
const char * getMD5(){ return "03d7689372c7e2617b8d61fbf552e694"; };
};
}
#endif
| 1,709 | C | 24.147058 | 72 | 0.581627 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/OutcomeCondition.h | #ifndef _ROS_flexbe_msgs_OutcomeCondition_h
#define _ROS_flexbe_msgs_OutcomeCondition_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class OutcomeCondition : public ros::Msg
{
public:
uint32_t state_name_length;
typedef char* _state_name_type;
_state_name_type st_state_name;
_state_name_type * state_name;
uint32_t state_outcome_length;
typedef char* _state_outcome_type;
_state_outcome_type st_state_outcome;
_state_outcome_type * state_outcome;
OutcomeCondition():
state_name_length(0), state_name(NULL),
state_outcome_length(0), state_outcome(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->state_name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->state_name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->state_name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->state_name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->state_name_length);
for( uint32_t i = 0; i < state_name_length; i++){
uint32_t length_state_namei = strlen(this->state_name[i]);
varToArr(outbuffer + offset, length_state_namei);
offset += 4;
memcpy(outbuffer + offset, this->state_name[i], length_state_namei);
offset += length_state_namei;
}
*(outbuffer + offset + 0) = (this->state_outcome_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->state_outcome_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->state_outcome_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->state_outcome_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->state_outcome_length);
for( uint32_t i = 0; i < state_outcome_length; i++){
uint32_t length_state_outcomei = strlen(this->state_outcome[i]);
varToArr(outbuffer + offset, length_state_outcomei);
offset += 4;
memcpy(outbuffer + offset, this->state_outcome[i], length_state_outcomei);
offset += length_state_outcomei;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t state_name_lengthT = ((uint32_t) (*(inbuffer + offset)));
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->state_name_length);
if(state_name_lengthT > state_name_length)
this->state_name = (char**)realloc(this->state_name, state_name_lengthT * sizeof(char*));
state_name_length = state_name_lengthT;
for( uint32_t i = 0; i < state_name_length; i++){
uint32_t length_st_state_name;
arrToVar(length_st_state_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_state_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_state_name-1]=0;
this->st_state_name = (char *)(inbuffer + offset-1);
offset += length_st_state_name;
memcpy( &(this->state_name[i]), &(this->st_state_name), sizeof(char*));
}
uint32_t state_outcome_lengthT = ((uint32_t) (*(inbuffer + offset)));
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->state_outcome_length);
if(state_outcome_lengthT > state_outcome_length)
this->state_outcome = (char**)realloc(this->state_outcome, state_outcome_lengthT * sizeof(char*));
state_outcome_length = state_outcome_lengthT;
for( uint32_t i = 0; i < state_outcome_length; i++){
uint32_t length_st_state_outcome;
arrToVar(length_st_state_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_state_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_state_outcome-1]=0;
this->st_state_outcome = (char *)(inbuffer + offset-1);
offset += length_st_state_outcome;
memcpy( &(this->state_outcome[i]), &(this->st_state_outcome), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/OutcomeCondition"; };
const char * getMD5(){ return "3f00d7f2d34167712ca29ef288547863"; };
};
}
#endif
| 4,704 | C | 40.637168 | 106 | 0.598852 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSelection.h | #ifndef _ROS_flexbe_msgs_BehaviorSelection_h
#define _ROS_flexbe_msgs_BehaviorSelection_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorModification.h"
namespace flexbe_msgs
{
class BehaviorSelection : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef int32_t _behavior_checksum_type;
_behavior_checksum_type behavior_checksum;
typedef uint8_t _autonomy_level_type;
_autonomy_level_type autonomy_level;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t input_values_length;
typedef char* _input_values_type;
_input_values_type st_input_values;
_input_values_type * input_values;
uint32_t modifications_length;
typedef flexbe_msgs::BehaviorModification _modifications_type;
_modifications_type st_modifications;
_modifications_type * modifications;
BehaviorSelection():
behavior_id(0),
behavior_checksum(0),
autonomy_level(0),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
input_keys_length(0), input_keys(NULL),
input_values_length(0), input_values(NULL),
modifications_length(0), modifications(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_behavior_checksum;
u_behavior_checksum.real = this->behavior_checksum;
*(outbuffer + offset + 0) = (u_behavior_checksum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_checksum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_checksum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_checksum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_checksum);
*(outbuffer + offset + 0) = (this->autonomy_level >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy_level);
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->input_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_values_length);
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_input_valuesi = strlen(this->input_values[i]);
varToArr(outbuffer + offset, length_input_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->input_values[i], length_input_valuesi);
offset += length_input_valuesi;
}
*(outbuffer + offset + 0) = (this->modifications_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->modifications_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->modifications_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->modifications_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->modifications_length);
for( uint32_t i = 0; i < modifications_length; i++){
offset += this->modifications[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_behavior_checksum;
u_behavior_checksum.base = 0;
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_checksum = u_behavior_checksum.real;
offset += sizeof(this->behavior_checksum);
this->autonomy_level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->autonomy_level);
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t input_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_values_length);
if(input_values_lengthT > input_values_length)
this->input_values = (char**)realloc(this->input_values, input_values_lengthT * sizeof(char*));
input_values_length = input_values_lengthT;
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_st_input_values;
arrToVar(length_st_input_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_values-1]=0;
this->st_input_values = (char *)(inbuffer + offset-1);
offset += length_st_input_values;
memcpy( &(this->input_values[i]), &(this->st_input_values), sizeof(char*));
}
uint32_t modifications_lengthT = ((uint32_t) (*(inbuffer + offset)));
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->modifications_length);
if(modifications_lengthT > modifications_length)
this->modifications = (flexbe_msgs::BehaviorModification*)realloc(this->modifications, modifications_lengthT * sizeof(flexbe_msgs::BehaviorModification));
modifications_length = modifications_lengthT;
for( uint32_t i = 0; i < modifications_length; i++){
offset += this->st_modifications.deserialize(inbuffer + offset);
memcpy( &(this->modifications[i]), &(this->st_modifications), sizeof(flexbe_msgs::BehaviorModification));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSelection"; };
const char * getMD5(){ return "514f1b101295bdbd417ee6cc46e3823c"; };
};
}
#endif
| 12,853 | C | 46.962686 | 162 | 0.584922 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BEStatus.h | #ifndef _ROS_flexbe_msgs_BEStatus_h
#define _ROS_flexbe_msgs_BEStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace flexbe_msgs
{
class BEStatus : public ros::Msg
{
public:
typedef ros::Time _stamp_type;
_stamp_type stamp;
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef uint8_t _code_type;
_code_type code;
uint32_t args_length;
typedef char* _args_type;
_args_type st_args;
_args_type * args;
enum { STARTED = 0 };
enum { FINISHED = 1 };
enum { FAILED = 2 };
enum { LOCKED = 4 };
enum { WAITING = 5 };
enum { SWITCHING = 6 };
enum { WARNING = 10 };
enum { ERROR = 11 };
enum { READY = 20 };
BEStatus():
stamp(),
behavior_id(0),
code(0),
args_length(0), args(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.sec);
*(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.nsec);
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
*(outbuffer + offset + 0) = (this->code >> (8 * 0)) & 0xFF;
offset += sizeof(this->code);
*(outbuffer + offset + 0) = (this->args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->args_length);
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_argsi = strlen(this->args[i]);
varToArr(outbuffer + offset, length_argsi);
offset += 4;
memcpy(outbuffer + offset, this->args[i], length_argsi);
offset += length_argsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->stamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.sec);
this->stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.nsec);
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
this->code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->code);
uint32_t args_lengthT = ((uint32_t) (*(inbuffer + offset)));
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->args_length);
if(args_lengthT > args_length)
this->args = (char**)realloc(this->args, args_lengthT * sizeof(char*));
args_length = args_lengthT;
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_st_args;
arrToVar(length_st_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_args-1]=0;
this->st_args = (char *)(inbuffer + offset-1);
offset += length_st_args;
memcpy( &(this->args[i]), &(this->st_args), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BEStatus"; };
const char * getMD5(){ return "467355de4ad406f864268f41621cb885"; };
};
}
#endif
| 5,383 | C | 37.457143 | 79 | 0.529073 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/CommandFeedback.h | #ifndef _ROS_flexbe_msgs_CommandFeedback_h
#define _ROS_flexbe_msgs_CommandFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class CommandFeedback : public ros::Msg
{
public:
typedef const char* _command_type;
_command_type command;
uint32_t args_length;
typedef char* _args_type;
_args_type st_args;
_args_type * args;
CommandFeedback():
command(""),
args_length(0), args(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
*(outbuffer + offset + 0) = (this->args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->args_length);
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_argsi = strlen(this->args[i]);
varToArr(outbuffer + offset, length_argsi);
offset += 4;
memcpy(outbuffer + offset, this->args[i], length_argsi);
offset += length_argsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_command;
arrToVar(length_command, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command-1]=0;
this->command = (char *)(inbuffer + offset-1);
offset += length_command;
uint32_t args_lengthT = ((uint32_t) (*(inbuffer + offset)));
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->args_length);
if(args_lengthT > args_length)
this->args = (char**)realloc(this->args, args_lengthT * sizeof(char*));
args_length = args_lengthT;
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_st_args;
arrToVar(length_st_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_args-1]=0;
this->st_args = (char *)(inbuffer + offset-1);
offset += length_st_args;
memcpy( &(this->args[i]), &(this->st_args), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/CommandFeedback"; };
const char * getMD5(){ return "0c984ea7f8fc562a9c04a778877e1a03"; };
};
}
#endif
| 3,030 | C | 31.591398 | 79 | 0.578548 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/HeaderString.h | #ifndef _ROS_rospy_tutorials_HeaderString_h
#define _ROS_rospy_tutorials_HeaderString_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace rospy_tutorials
{
class HeaderString : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _data_type;
_data_type data;
HeaderString():
header(),
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_data;
arrToVar(length_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_data-1]=0;
this->data = (char *)(inbuffer + offset-1);
offset += length_data;
return offset;
}
const char * getType(){ return "rospy_tutorials/HeaderString"; };
const char * getMD5(){ return "c99a9440709e4d4a9716d55b8270d5e7"; };
};
}
#endif
| 1,513 | C | 23.419354 | 72 | 0.619299 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformGoal.h | #ifndef _ROS_tf2_msgs_LookupTransformGoal_h
#define _ROS_tf2_msgs_LookupTransformGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "ros/duration.h"
namespace tf2_msgs
{
class LookupTransformGoal : public ros::Msg
{
public:
typedef const char* _target_frame_type;
_target_frame_type target_frame;
typedef const char* _source_frame_type;
_source_frame_type source_frame;
typedef ros::Time _source_time_type;
_source_time_type source_time;
typedef ros::Duration _timeout_type;
_timeout_type timeout;
typedef ros::Time _target_time_type;
_target_time_type target_time;
typedef const char* _fixed_frame_type;
_fixed_frame_type fixed_frame;
typedef bool _advanced_type;
_advanced_type advanced;
LookupTransformGoal():
target_frame(""),
source_frame(""),
source_time(),
timeout(),
target_time(),
fixed_frame(""),
advanced(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_target_frame = strlen(this->target_frame);
varToArr(outbuffer + offset, length_target_frame);
offset += 4;
memcpy(outbuffer + offset, this->target_frame, length_target_frame);
offset += length_target_frame;
uint32_t length_source_frame = strlen(this->source_frame);
varToArr(outbuffer + offset, length_source_frame);
offset += 4;
memcpy(outbuffer + offset, this->source_frame, length_source_frame);
offset += length_source_frame;
*(outbuffer + offset + 0) = (this->source_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->source_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->source_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->source_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->source_time.sec);
*(outbuffer + offset + 0) = (this->source_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->source_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->source_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->source_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->source_time.nsec);
*(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.sec);
*(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.nsec);
*(outbuffer + offset + 0) = (this->target_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->target_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->target_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->target_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->target_time.sec);
*(outbuffer + offset + 0) = (this->target_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->target_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->target_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->target_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->target_time.nsec);
uint32_t length_fixed_frame = strlen(this->fixed_frame);
varToArr(outbuffer + offset, length_fixed_frame);
offset += 4;
memcpy(outbuffer + offset, this->fixed_frame, length_fixed_frame);
offset += length_fixed_frame;
union {
bool real;
uint8_t base;
} u_advanced;
u_advanced.real = this->advanced;
*(outbuffer + offset + 0) = (u_advanced.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->advanced);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_target_frame;
arrToVar(length_target_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target_frame-1]=0;
this->target_frame = (char *)(inbuffer + offset-1);
offset += length_target_frame;
uint32_t length_source_frame;
arrToVar(length_source_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_source_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_source_frame-1]=0;
this->source_frame = (char *)(inbuffer + offset-1);
offset += length_source_frame;
this->source_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->source_time.sec);
this->source_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->source_time.nsec);
this->timeout.sec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.sec);
this->timeout.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.nsec);
this->target_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->target_time.sec);
this->target_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->target_time.nsec);
uint32_t length_fixed_frame;
arrToVar(length_fixed_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_fixed_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_fixed_frame-1]=0;
this->fixed_frame = (char *)(inbuffer + offset-1);
offset += length_fixed_frame;
union {
bool real;
uint8_t base;
} u_advanced;
u_advanced.base = 0;
u_advanced.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->advanced = u_advanced.real;
offset += sizeof(this->advanced);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformGoal"; };
const char * getMD5(){ return "35e3720468131d675a18bb6f3e5f22f8"; };
};
}
#endif
| 8,034 | C | 43.888268 | 83 | 0.564974 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/FrameGraph.h | #ifndef _ROS_SERVICE_FrameGraph_h
#define _ROS_SERVICE_FrameGraph_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
static const char FRAMEGRAPH[] = "tf2_msgs/FrameGraph";
class FrameGraphRequest : public ros::Msg
{
public:
FrameGraphRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return FRAMEGRAPH; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class FrameGraphResponse : public ros::Msg
{
public:
typedef const char* _frame_yaml_type;
_frame_yaml_type frame_yaml;
FrameGraphResponse():
frame_yaml("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_frame_yaml = strlen(this->frame_yaml);
varToArr(outbuffer + offset, length_frame_yaml);
offset += 4;
memcpy(outbuffer + offset, this->frame_yaml, length_frame_yaml);
offset += length_frame_yaml;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_frame_yaml;
arrToVar(length_frame_yaml, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_frame_yaml; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_frame_yaml-1]=0;
this->frame_yaml = (char *)(inbuffer + offset-1);
offset += length_frame_yaml;
return offset;
}
const char * getType(){ return FRAMEGRAPH; };
const char * getMD5(){ return "437ea58e9463815a0d511c7326b686b0"; };
};
class FrameGraph {
public:
typedef FrameGraphRequest Request;
typedef FrameGraphResponse Response;
};
}
#endif
| 1,961 | C | 21.295454 | 72 | 0.628761 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformResult.h | #ifndef _ROS_tf2_msgs_LookupTransformResult_h
#define _ROS_tf2_msgs_LookupTransformResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
#include "tf2_msgs/TF2Error.h"
namespace tf2_msgs
{
class LookupTransformResult : public ros::Msg
{
public:
typedef geometry_msgs::TransformStamped _transform_type;
_transform_type transform;
typedef tf2_msgs::TF2Error _error_type;
_error_type error;
LookupTransformResult():
transform(),
error()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->transform.serialize(outbuffer + offset);
offset += this->error.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->transform.deserialize(inbuffer + offset);
offset += this->error.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformResult"; };
const char * getMD5(){ return "3fe5db6a19ca9cfb675418c5ad875c36"; };
};
}
#endif
| 1,208 | C | 22.705882 | 72 | 0.666391 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/TF2Error.h | #ifndef _ROS_tf2_msgs_TF2Error_h
#define _ROS_tf2_msgs_TF2Error_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
class TF2Error : public ros::Msg
{
public:
typedef uint8_t _error_type;
_error_type error;
typedef const char* _error_string_type;
_error_string_type error_string;
enum { NO_ERROR = 0 };
enum { LOOKUP_ERROR = 1 };
enum { CONNECTIVITY_ERROR = 2 };
enum { EXTRAPOLATION_ERROR = 3 };
enum { INVALID_ARGUMENT_ERROR = 4 };
enum { TIMEOUT_ERROR = 5 };
enum { TRANSFORM_ERROR = 6 };
TF2Error():
error(0),
error_string("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->error >> (8 * 0)) & 0xFF;
offset += sizeof(this->error);
uint32_t length_error_string = strlen(this->error_string);
varToArr(outbuffer + offset, length_error_string);
offset += 4;
memcpy(outbuffer + offset, this->error_string, length_error_string);
offset += length_error_string;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->error = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->error);
uint32_t length_error_string;
arrToVar(length_error_string, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_error_string; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_error_string-1]=0;
this->error_string = (char *)(inbuffer + offset-1);
offset += length_error_string;
return offset;
}
const char * getType(){ return "tf2_msgs/TF2Error"; };
const char * getMD5(){ return "bc6848fd6fd750c92e38575618a4917d"; };
};
}
#endif
| 1,890 | C | 26.014285 | 74 | 0.595238 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformAction.h | #ifndef _ROS_tf2_msgs_LookupTransformAction_h
#define _ROS_tf2_msgs_LookupTransformAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "tf2_msgs/LookupTransformActionGoal.h"
#include "tf2_msgs/LookupTransformActionResult.h"
#include "tf2_msgs/LookupTransformActionFeedback.h"
namespace tf2_msgs
{
class LookupTransformAction : public ros::Msg
{
public:
typedef tf2_msgs::LookupTransformActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef tf2_msgs::LookupTransformActionResult _action_result_type;
_action_result_type action_result;
typedef tf2_msgs::LookupTransformActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
LookupTransformAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformAction"; };
const char * getMD5(){ return "7ee01ba91a56c2245c610992dbaa3c37"; };
};
}
#endif
| 1,652 | C | 28 | 76 | 0.69431 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/TFMessage.h | #ifndef _ROS_tf2_msgs_TFMessage_h
#define _ROS_tf2_msgs_TFMessage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
namespace tf2_msgs
{
class TFMessage : public ros::Msg
{
public:
uint32_t transforms_length;
typedef geometry_msgs::TransformStamped _transforms_type;
_transforms_type st_transforms;
_transforms_type * transforms;
TFMessage():
transforms_length(0), transforms(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transforms_length);
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->transforms[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transforms_length);
if(transforms_lengthT > transforms_length)
this->transforms = (geometry_msgs::TransformStamped*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
transforms_length = transforms_lengthT;
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->st_transforms.deserialize(inbuffer + offset);
memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::TransformStamped));
}
return offset;
}
const char * getType(){ return "tf2_msgs/TFMessage"; };
const char * getMD5(){ return "94810edda583a504dfda3829e70d7eec"; };
};
}
#endif
| 2,234 | C | 33.384615 | 149 | 0.619964 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ar_track_alvar_msgs/AlvarMarker.h | #ifndef _ROS_ar_track_alvar_msgs_AlvarMarker_h
#define _ROS_ar_track_alvar_msgs_AlvarMarker_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/PoseStamped.h"
namespace ar_track_alvar_msgs
{
class AlvarMarker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _id_type;
_id_type id;
typedef uint32_t _confidence_type;
_confidence_type confidence;
typedef geometry_msgs::PoseStamped _pose_type;
_pose_type pose;
AlvarMarker():
header(),
id(0),
confidence(0),
pose()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
*(outbuffer + offset + 0) = (this->confidence >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->confidence >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->confidence >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->confidence >> (8 * 3)) & 0xFF;
offset += sizeof(this->confidence);
offset += this->pose.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
this->confidence = ((uint32_t) (*(inbuffer + offset)));
this->confidence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->confidence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->confidence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->confidence);
offset += this->pose.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "ar_track_alvar_msgs/AlvarMarker"; };
const char * getMD5(){ return "ef2b6ad42bcb18e16b22fefb5c0fb85f"; };
};
}
#endif
| 2,584 | C | 32.571428 | 77 | 0.563854 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ar_track_alvar_msgs/AlvarMarkers.h | #ifndef _ROS_ar_track_alvar_msgs_AlvarMarkers_h
#define _ROS_ar_track_alvar_msgs_AlvarMarkers_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "ar_track_alvar_msgs/AlvarMarker.h"
namespace ar_track_alvar_msgs
{
class AlvarMarkers : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t markers_length;
typedef ar_track_alvar_msgs::AlvarMarker _markers_type;
_markers_type st_markers;
_markers_type * markers;
AlvarMarkers():
header(),
markers_length(0), markers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (ar_track_alvar_msgs::AlvarMarker*)realloc(this->markers, markers_lengthT * sizeof(ar_track_alvar_msgs::AlvarMarker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(ar_track_alvar_msgs::AlvarMarker));
}
return offset;
}
const char * getType(){ return "ar_track_alvar_msgs/AlvarMarkers"; };
const char * getMD5(){ return "943fe17bfb0b4ea7890368d0b25ad0ad"; };
};
}
#endif
| 2,443 | C | 33.422535 | 142 | 0.610725 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PidState.h | #ifndef _ROS_control_msgs_PidState_h
#define _ROS_control_msgs_PidState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "ros/duration.h"
namespace control_msgs
{
class PidState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef ros::Duration _timestep_type;
_timestep_type timestep;
typedef double _error_type;
_error_type error;
typedef double _error_dot_type;
_error_dot_type error_dot;
typedef double _p_error_type;
_p_error_type p_error;
typedef double _i_error_type;
_i_error_type i_error;
typedef double _d_error_type;
_d_error_type d_error;
typedef double _p_term_type;
_p_term_type p_term;
typedef double _i_term_type;
_i_term_type i_term;
typedef double _d_term_type;
_d_term_type d_term;
typedef double _i_max_type;
_i_max_type i_max;
typedef double _i_min_type;
_i_min_type i_min;
typedef double _output_type;
_output_type output;
PidState():
header(),
timestep(),
error(0),
error_dot(0),
p_error(0),
i_error(0),
d_error(0),
p_term(0),
i_term(0),
d_term(0),
i_max(0),
i_min(0),
output(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->timestep.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestep.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestep.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestep.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestep.sec);
*(outbuffer + offset + 0) = (this->timestep.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestep.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestep.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestep.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestep.nsec);
union {
double real;
uint64_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_error_dot;
u_error_dot.real = this->error_dot;
*(outbuffer + offset + 0) = (u_error_dot.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error_dot.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error_dot.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error_dot.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error_dot.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error_dot.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error_dot.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error_dot.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error_dot);
union {
double real;
uint64_t base;
} u_p_error;
u_p_error.real = this->p_error;
*(outbuffer + offset + 0) = (u_p_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_p_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_p_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_p_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_p_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_p_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_p_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_p_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->p_error);
union {
double real;
uint64_t base;
} u_i_error;
u_i_error.real = this->i_error;
*(outbuffer + offset + 0) = (u_i_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_error);
union {
double real;
uint64_t base;
} u_d_error;
u_d_error.real = this->d_error;
*(outbuffer + offset + 0) = (u_d_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_d_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_d_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_d_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_d_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_d_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_d_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_d_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->d_error);
union {
double real;
uint64_t base;
} u_p_term;
u_p_term.real = this->p_term;
*(outbuffer + offset + 0) = (u_p_term.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_p_term.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_p_term.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_p_term.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_p_term.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_p_term.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_p_term.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_p_term.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->p_term);
union {
double real;
uint64_t base;
} u_i_term;
u_i_term.real = this->i_term;
*(outbuffer + offset + 0) = (u_i_term.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_term.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_term.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_term.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_term.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_term.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_term.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_term.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_term);
union {
double real;
uint64_t base;
} u_d_term;
u_d_term.real = this->d_term;
*(outbuffer + offset + 0) = (u_d_term.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_d_term.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_d_term.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_d_term.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_d_term.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_d_term.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_d_term.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_d_term.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->d_term);
union {
double real;
uint64_t base;
} u_i_max;
u_i_max.real = this->i_max;
*(outbuffer + offset + 0) = (u_i_max.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_max.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_max.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_max.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_max.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_max.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_max.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_max.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_max);
union {
double real;
uint64_t base;
} u_i_min;
u_i_min.real = this->i_min;
*(outbuffer + offset + 0) = (u_i_min.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_min.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_min.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_min.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_min.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_min.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_min.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_min.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_min);
union {
double real;
uint64_t base;
} u_output;
u_output.real = this->output;
*(outbuffer + offset + 0) = (u_output.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_output.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_output.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_output.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_output.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_output.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_output.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_output.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->output);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->timestep.sec = ((uint32_t) (*(inbuffer + offset)));
this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestep.sec);
this->timestep.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestep.nsec);
union {
double real;
uint64_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error = u_error.real;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_error_dot;
u_error_dot.base = 0;
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error_dot = u_error_dot.real;
offset += sizeof(this->error_dot);
union {
double real;
uint64_t base;
} u_p_error;
u_p_error.base = 0;
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->p_error = u_p_error.real;
offset += sizeof(this->p_error);
union {
double real;
uint64_t base;
} u_i_error;
u_i_error.base = 0;
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_error = u_i_error.real;
offset += sizeof(this->i_error);
union {
double real;
uint64_t base;
} u_d_error;
u_d_error.base = 0;
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->d_error = u_d_error.real;
offset += sizeof(this->d_error);
union {
double real;
uint64_t base;
} u_p_term;
u_p_term.base = 0;
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->p_term = u_p_term.real;
offset += sizeof(this->p_term);
union {
double real;
uint64_t base;
} u_i_term;
u_i_term.base = 0;
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_term = u_i_term.real;
offset += sizeof(this->i_term);
union {
double real;
uint64_t base;
} u_d_term;
u_d_term.base = 0;
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->d_term = u_d_term.real;
offset += sizeof(this->d_term);
union {
double real;
uint64_t base;
} u_i_max;
u_i_max.base = 0;
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_max = u_i_max.real;
offset += sizeof(this->i_max);
union {
double real;
uint64_t base;
} u_i_min;
u_i_min.base = 0;
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_min = u_i_min.real;
offset += sizeof(this->i_min);
union {
double real;
uint64_t base;
} u_output;
u_output.base = 0;
u_output.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->output = u_output.real;
offset += sizeof(this->output);
return offset;
}
const char * getType(){ return "control_msgs/PidState"; };
const char * getMD5(){ return "b138ec00e886c10e73f27e8712252ea6"; };
};
}
#endif
| 19,585 | C | 45.522565 | 80 | 0.483686 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionFeedback.h | #ifndef _ROS_control_msgs_SingleJointPositionFeedback_h
#define _ROS_control_msgs_SingleJointPositionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace control_msgs
{
class SingleJointPositionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _position_type;
_position_type position;
typedef double _velocity_type;
_velocity_type velocity;
typedef double _error_type;
_error_type error;
SingleJointPositionFeedback():
header(),
position(0),
velocity(0),
error(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.real = this->velocity;
*(outbuffer + offset + 0) = (u_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.base = 0;
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->velocity = u_velocity.real;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error = u_error.real;
offset += sizeof(this->error);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionFeedback"; };
const char * getMD5(){ return "8cee65610a3d08e0a1bded82f146f1fd"; };
};
}
#endif
| 5,725 | C | 39.609929 | 81 | 0.524017 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTolerance.h | #ifndef _ROS_control_msgs_JointTolerance_h
#define _ROS_control_msgs_JointTolerance_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class JointTolerance : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef double _position_type;
_position_type position;
typedef double _velocity_type;
_velocity_type velocity;
typedef double _acceleration_type;
_acceleration_type acceleration;
JointTolerance():
name(""),
position(0),
velocity(0),
acceleration(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.real = this->velocity;
*(outbuffer + offset + 0) = (u_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_acceleration;
u_acceleration.real = this->acceleration;
*(outbuffer + offset + 0) = (u_acceleration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acceleration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acceleration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acceleration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_acceleration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_acceleration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_acceleration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_acceleration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->acceleration);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.base = 0;
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->velocity = u_velocity.real;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_acceleration;
u_acceleration.base = 0;
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->acceleration = u_acceleration.real;
offset += sizeof(this->acceleration);
return offset;
}
const char * getType(){ return "control_msgs/JointTolerance"; };
const char * getMD5(){ return "f544fe9c16cf04547e135dd6063ff5be"; };
};
}
#endif
| 6,231 | C | 40 | 80 | 0.534906 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionAction.h | #ifndef _ROS_control_msgs_SingleJointPositionAction_h
#define _ROS_control_msgs_SingleJointPositionAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/SingleJointPositionActionGoal.h"
#include "control_msgs/SingleJointPositionActionResult.h"
#include "control_msgs/SingleJointPositionActionFeedback.h"
namespace control_msgs
{
class SingleJointPositionAction : public ros::Msg
{
public:
typedef control_msgs::SingleJointPositionActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::SingleJointPositionActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::SingleJointPositionActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
SingleJointPositionAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionAction"; };
const char * getMD5(){ return "c4a786b7d53e5d0983decf967a5a779e"; };
};
}
#endif
| 1,736 | C | 29.473684 | 84 | 0.709101 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryControllerState.h | #ifndef _ROS_control_msgs_JointTrajectoryControllerState_h
#define _ROS_control_msgs_JointTrajectoryControllerState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "trajectory_msgs/JointTrajectoryPoint.h"
namespace control_msgs
{
class JointTrajectoryControllerState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
typedef trajectory_msgs::JointTrajectoryPoint _desired_type;
_desired_type desired;
typedef trajectory_msgs::JointTrajectoryPoint _actual_type;
_actual_type actual;
typedef trajectory_msgs::JointTrajectoryPoint _error_type;
_error_type error;
JointTrajectoryControllerState():
header(),
joint_names_length(0), joint_names(NULL),
desired(),
actual(),
error()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
offset += this->desired.serialize(outbuffer + offset);
offset += this->actual.serialize(outbuffer + offset);
offset += this->error.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
offset += this->desired.deserialize(inbuffer + offset);
offset += this->actual.deserialize(inbuffer + offset);
offset += this->error.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryControllerState"; };
const char * getMD5(){ return "10817c60c2486ef6b33e97dcd87f4474"; };
};
}
#endif
| 3,720 | C | 36.969387 | 100 | 0.628763 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/QueryTrajectoryState.h | #ifndef _ROS_SERVICE_QueryTrajectoryState_h
#define _ROS_SERVICE_QueryTrajectoryState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace control_msgs
{
static const char QUERYTRAJECTORYSTATE[] = "control_msgs/QueryTrajectoryState";
class QueryTrajectoryStateRequest : public ros::Msg
{
public:
typedef ros::Time _time_type;
_time_type time;
QueryTrajectoryStateRequest():
time()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time.sec);
*(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->time.sec = ((uint32_t) (*(inbuffer + offset)));
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time.sec);
this->time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time.nsec);
return offset;
}
const char * getType(){ return QUERYTRAJECTORYSTATE; };
const char * getMD5(){ return "556a4fb76023a469987922359d08a844"; };
};
class QueryTrajectoryStateResponse : public ros::Msg
{
public:
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t position_length;
typedef double _position_type;
_position_type st_position;
_position_type * position;
uint32_t velocity_length;
typedef double _velocity_type;
_velocity_type st_velocity;
_velocity_type * velocity;
uint32_t acceleration_length;
typedef double _acceleration_type;
_acceleration_type st_acceleration;
_acceleration_type * acceleration;
QueryTrajectoryStateResponse():
name_length(0), name(NULL),
position_length(0), position(NULL),
velocity_length(0), velocity(NULL),
acceleration_length(0), acceleration(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_length);
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_positioni;
u_positioni.real = this->position[i];
*(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocity_length);
for( uint32_t i = 0; i < velocity_length; i++){
union {
double real;
uint64_t base;
} u_velocityi;
u_velocityi.real = this->velocity[i];
*(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity[i]);
}
*(outbuffer + offset + 0) = (this->acceleration_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->acceleration_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->acceleration_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->acceleration_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->acceleration_length);
for( uint32_t i = 0; i < acceleration_length; i++){
union {
double real;
uint64_t base;
} u_accelerationi;
u_accelerationi.real = this->acceleration[i];
*(outbuffer + offset + 0) = (u_accelerationi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_accelerationi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_accelerationi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_accelerationi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_accelerationi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_accelerationi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_accelerationi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_accelerationi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->acceleration[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_length);
if(position_lengthT > position_length)
this->position = (double*)realloc(this->position, position_lengthT * sizeof(double));
position_length = position_lengthT;
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_st_position;
u_st_position.base = 0;
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position = u_st_position.real;
offset += sizeof(this->st_position);
memcpy( &(this->position[i]), &(this->st_position), sizeof(double));
}
uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocity_length);
if(velocity_lengthT > velocity_length)
this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double));
velocity_length = velocity_lengthT;
for( uint32_t i = 0; i < velocity_length; i++){
union {
double real;
uint64_t base;
} u_st_velocity;
u_st_velocity.base = 0;
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocity = u_st_velocity.real;
offset += sizeof(this->st_velocity);
memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double));
}
uint32_t acceleration_lengthT = ((uint32_t) (*(inbuffer + offset)));
acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->acceleration_length);
if(acceleration_lengthT > acceleration_length)
this->acceleration = (double*)realloc(this->acceleration, acceleration_lengthT * sizeof(double));
acceleration_length = acceleration_lengthT;
for( uint32_t i = 0; i < acceleration_length; i++){
union {
double real;
uint64_t base;
} u_st_acceleration;
u_st_acceleration.base = 0;
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_acceleration = u_st_acceleration.real;
offset += sizeof(this->st_acceleration);
memcpy( &(this->acceleration[i]), &(this->st_acceleration), sizeof(double));
}
return offset;
}
const char * getType(){ return QUERYTRAJECTORYSTATE; };
const char * getMD5(){ return "1f1a6554ad060f44d013e71868403c1a"; };
};
class QueryTrajectoryState {
public:
typedef QueryTrajectoryStateRequest Request;
typedef QueryTrajectoryStateResponse Response;
};
}
#endif
| 13,283 | C | 45.125 | 105 | 0.551231 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/QueryCalibrationState.h | #ifndef _ROS_SERVICE_QueryCalibrationState_h
#define _ROS_SERVICE_QueryCalibrationState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
static const char QUERYCALIBRATIONSTATE[] = "control_msgs/QueryCalibrationState";
class QueryCalibrationStateRequest : public ros::Msg
{
public:
QueryCalibrationStateRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return QUERYCALIBRATIONSTATE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class QueryCalibrationStateResponse : public ros::Msg
{
public:
typedef bool _is_calibrated_type;
_is_calibrated_type is_calibrated;
QueryCalibrationStateResponse():
is_calibrated(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_is_calibrated;
u_is_calibrated.real = this->is_calibrated;
*(outbuffer + offset + 0) = (u_is_calibrated.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_calibrated);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_is_calibrated;
u_is_calibrated.base = 0;
u_is_calibrated.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_calibrated = u_is_calibrated.real;
offset += sizeof(this->is_calibrated);
return offset;
}
const char * getType(){ return QUERYCALIBRATIONSTATE; };
const char * getMD5(){ return "28af3beedcb84986b8e470dc5470507d"; };
};
class QueryCalibrationState {
public:
typedef QueryCalibrationStateRequest Request;
typedef QueryCalibrationStateResponse Response;
};
}
#endif
| 2,054 | C | 22.089887 | 81 | 0.639727 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandFeedback.h | #ifndef _ROS_control_msgs_GripperCommandFeedback_h
#define _ROS_control_msgs_GripperCommandFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class GripperCommandFeedback : public ros::Msg
{
public:
typedef double _position_type;
_position_type position;
typedef double _effort_type;
_effort_type effort;
typedef bool _stalled_type;
_stalled_type stalled;
typedef bool _reached_goal_type;
_reached_goal_type reached_goal;
GripperCommandFeedback():
position(0),
effort(0),
stalled(0),
reached_goal(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_effort;
u_effort.real = this->effort;
*(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->effort);
union {
bool real;
uint8_t base;
} u_stalled;
u_stalled.real = this->stalled;
*(outbuffer + offset + 0) = (u_stalled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->stalled);
union {
bool real;
uint8_t base;
} u_reached_goal;
u_reached_goal.real = this->reached_goal;
*(outbuffer + offset + 0) = (u_reached_goal.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->reached_goal);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_effort;
u_effort.base = 0;
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->effort = u_effort.real;
offset += sizeof(this->effort);
union {
bool real;
uint8_t base;
} u_stalled;
u_stalled.base = 0;
u_stalled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->stalled = u_stalled.real;
offset += sizeof(this->stalled);
union {
bool real;
uint8_t base;
} u_reached_goal;
u_reached_goal.base = 0;
u_reached_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->reached_goal = u_reached_goal.real;
offset += sizeof(this->reached_goal);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandFeedback"; };
const char * getMD5(){ return "e4cbff56d3562bcf113da5a5adeef91f"; };
};
}
#endif
| 5,060 | C | 35.410072 | 79 | 0.526877 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadFeedback.h | #ifndef _ROS_control_msgs_PointHeadFeedback_h
#define _ROS_control_msgs_PointHeadFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class PointHeadFeedback : public ros::Msg
{
public:
typedef double _pointing_angle_error_type;
_pointing_angle_error_type pointing_angle_error;
PointHeadFeedback():
pointing_angle_error(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_pointing_angle_error;
u_pointing_angle_error.real = this->pointing_angle_error;
*(outbuffer + offset + 0) = (u_pointing_angle_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pointing_angle_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pointing_angle_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pointing_angle_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_pointing_angle_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_pointing_angle_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_pointing_angle_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_pointing_angle_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->pointing_angle_error);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_pointing_angle_error;
u_pointing_angle_error.base = 0;
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->pointing_angle_error = u_pointing_angle_error.real;
offset += sizeof(this->pointing_angle_error);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadFeedback"; };
const char * getMD5(){ return "cce80d27fd763682da8805a73316cab4"; };
};
}
#endif
| 2,644 | C | 36.253521 | 88 | 0.585855 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryGoal.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryGoal_h
#define _ROS_control_msgs_FollowJointTrajectoryGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "control_msgs/JointTolerance.h"
#include "ros/duration.h"
namespace control_msgs
{
class FollowJointTrajectoryGoal : public ros::Msg
{
public:
typedef trajectory_msgs::JointTrajectory _trajectory_type;
_trajectory_type trajectory;
uint32_t path_tolerance_length;
typedef control_msgs::JointTolerance _path_tolerance_type;
_path_tolerance_type st_path_tolerance;
_path_tolerance_type * path_tolerance;
uint32_t goal_tolerance_length;
typedef control_msgs::JointTolerance _goal_tolerance_type;
_goal_tolerance_type st_goal_tolerance;
_goal_tolerance_type * goal_tolerance;
typedef ros::Duration _goal_time_tolerance_type;
_goal_time_tolerance_type goal_time_tolerance;
FollowJointTrajectoryGoal():
trajectory(),
path_tolerance_length(0), path_tolerance(NULL),
goal_tolerance_length(0), goal_tolerance(NULL),
goal_time_tolerance()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->path_tolerance_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->path_tolerance_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->path_tolerance_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->path_tolerance_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->path_tolerance_length);
for( uint32_t i = 0; i < path_tolerance_length; i++){
offset += this->path_tolerance[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->goal_tolerance_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_tolerance_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_tolerance_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_tolerance_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_tolerance_length);
for( uint32_t i = 0; i < goal_tolerance_length; i++){
offset += this->goal_tolerance[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->goal_time_tolerance.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_time_tolerance.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_time_tolerance.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_time_tolerance.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_time_tolerance.sec);
*(outbuffer + offset + 0) = (this->goal_time_tolerance.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_time_tolerance.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_time_tolerance.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_time_tolerance.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_time_tolerance.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory.deserialize(inbuffer + offset);
uint32_t path_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->path_tolerance_length);
if(path_tolerance_lengthT > path_tolerance_length)
this->path_tolerance = (control_msgs::JointTolerance*)realloc(this->path_tolerance, path_tolerance_lengthT * sizeof(control_msgs::JointTolerance));
path_tolerance_length = path_tolerance_lengthT;
for( uint32_t i = 0; i < path_tolerance_length; i++){
offset += this->st_path_tolerance.deserialize(inbuffer + offset);
memcpy( &(this->path_tolerance[i]), &(this->st_path_tolerance), sizeof(control_msgs::JointTolerance));
}
uint32_t goal_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_tolerance_length);
if(goal_tolerance_lengthT > goal_tolerance_length)
this->goal_tolerance = (control_msgs::JointTolerance*)realloc(this->goal_tolerance, goal_tolerance_lengthT * sizeof(control_msgs::JointTolerance));
goal_tolerance_length = goal_tolerance_lengthT;
for( uint32_t i = 0; i < goal_tolerance_length; i++){
offset += this->st_goal_tolerance.deserialize(inbuffer + offset);
memcpy( &(this->goal_tolerance[i]), &(this->st_goal_tolerance), sizeof(control_msgs::JointTolerance));
}
this->goal_time_tolerance.sec = ((uint32_t) (*(inbuffer + offset)));
this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_time_tolerance.sec);
this->goal_time_tolerance.nsec = ((uint32_t) (*(inbuffer + offset)));
this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_time_tolerance.nsec);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryGoal"; };
const char * getMD5(){ return "69636787b6ecbde4d61d711979bc7ecb"; };
};
}
#endif
| 6,180 | C | 50.508333 | 155 | 0.618285 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointJog.h | #ifndef _ROS_control_msgs_JointJog_h
#define _ROS_control_msgs_JointJog_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace control_msgs
{
class JointJog : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t displacements_length;
typedef double _displacements_type;
_displacements_type st_displacements;
_displacements_type * displacements;
uint32_t velocities_length;
typedef double _velocities_type;
_velocities_type st_velocities;
_velocities_type * velocities;
typedef double _duration_type;
_duration_type duration;
JointJog():
header(),
joint_names_length(0), joint_names(NULL),
displacements_length(0), displacements(NULL),
velocities_length(0), velocities(NULL),
duration(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->displacements_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->displacements_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->displacements_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->displacements_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->displacements_length);
for( uint32_t i = 0; i < displacements_length; i++){
union {
double real;
uint64_t base;
} u_displacementsi;
u_displacementsi.real = this->displacements[i];
*(outbuffer + offset + 0) = (u_displacementsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_displacementsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_displacementsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_displacementsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_displacementsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_displacementsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_displacementsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_displacementsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->displacements[i]);
}
*(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocities_length);
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_velocitiesi;
u_velocitiesi.real = this->velocities[i];
*(outbuffer + offset + 0) = (u_velocitiesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocitiesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocitiesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocitiesi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocitiesi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocitiesi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocitiesi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocitiesi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocities[i]);
}
union {
double real;
uint64_t base;
} u_duration;
u_duration.real = this->duration;
*(outbuffer + offset + 0) = (u_duration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_duration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_duration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_duration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_duration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_duration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_duration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_duration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->duration);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t displacements_lengthT = ((uint32_t) (*(inbuffer + offset)));
displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->displacements_length);
if(displacements_lengthT > displacements_length)
this->displacements = (double*)realloc(this->displacements, displacements_lengthT * sizeof(double));
displacements_length = displacements_lengthT;
for( uint32_t i = 0; i < displacements_length; i++){
union {
double real;
uint64_t base;
} u_st_displacements;
u_st_displacements.base = 0;
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_displacements = u_st_displacements.real;
offset += sizeof(this->st_displacements);
memcpy( &(this->displacements[i]), &(this->st_displacements), sizeof(double));
}
uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocities_length);
if(velocities_lengthT > velocities_length)
this->velocities = (double*)realloc(this->velocities, velocities_lengthT * sizeof(double));
velocities_length = velocities_lengthT;
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_st_velocities;
u_st_velocities.base = 0;
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocities = u_st_velocities.real;
offset += sizeof(this->st_velocities);
memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(double));
}
union {
double real;
uint64_t base;
} u_duration;
u_duration.base = 0;
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->duration = u_duration.real;
offset += sizeof(this->duration);
return offset;
}
const char * getType(){ return "control_msgs/JointJog"; };
const char * getMD5(){ return "1685da700c8c2e1254afc92a5fb89c96"; };
};
}
#endif
| 10,568 | C | 47.481651 | 108 | 0.562737 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryAction.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryAction_h
#define _ROS_control_msgs_FollowJointTrajectoryAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/FollowJointTrajectoryActionGoal.h"
#include "control_msgs/FollowJointTrajectoryActionResult.h"
#include "control_msgs/FollowJointTrajectoryActionFeedback.h"
namespace control_msgs
{
class FollowJointTrajectoryAction : public ros::Msg
{
public:
typedef control_msgs::FollowJointTrajectoryActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::FollowJointTrajectoryActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::FollowJointTrajectoryActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
FollowJointTrajectoryAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryAction"; };
const char * getMD5(){ return "bc4f9b743838566551c0390c65f1a248"; };
};
}
#endif
| 1,758 | C | 29.859649 | 86 | 0.712742 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionGoal.h | #ifndef _ROS_control_msgs_SingleJointPositionGoal_h
#define _ROS_control_msgs_SingleJointPositionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
namespace control_msgs
{
class SingleJointPositionGoal : public ros::Msg
{
public:
typedef double _position_type;
_position_type position;
typedef ros::Duration _min_duration_type;
_min_duration_type min_duration;
typedef double _max_velocity_type;
_max_velocity_type max_velocity;
SingleJointPositionGoal():
position(0),
min_duration(),
max_velocity(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
*(outbuffer + offset + 0) = (this->min_duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.sec);
*(outbuffer + offset + 0) = (this->min_duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.real = this->max_velocity;
*(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
this->min_duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.sec);
this->min_duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.base = 0;
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_velocity = u_max_velocity.real;
offset += sizeof(this->max_velocity);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionGoal"; };
const char * getMD5(){ return "fbaaa562a23a013fd5053e5f72cbb35c"; };
};
}
#endif
| 5,659 | C | 43.566929 | 84 | 0.540201 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryResult.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryResult_h
#define _ROS_control_msgs_FollowJointTrajectoryResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class FollowJointTrajectoryResult : public ros::Msg
{
public:
typedef int32_t _error_code_type;
_error_code_type error_code;
typedef const char* _error_string_type;
_error_string_type error_string;
enum { SUCCESSFUL = 0 };
enum { INVALID_GOAL = -1 };
enum { INVALID_JOINTS = -2 };
enum { OLD_HEADER_TIMESTAMP = -3 };
enum { PATH_TOLERANCE_VIOLATED = -4 };
enum { GOAL_TOLERANCE_VIOLATED = -5 };
FollowJointTrajectoryResult():
error_code(0),
error_string("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_error_code;
u_error_code.real = this->error_code;
*(outbuffer + offset + 0) = (u_error_code.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error_code.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error_code.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error_code.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->error_code);
uint32_t length_error_string = strlen(this->error_string);
varToArr(outbuffer + offset, length_error_string);
offset += 4;
memcpy(outbuffer + offset, this->error_string, length_error_string);
offset += length_error_string;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_error_code;
u_error_code.base = 0;
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->error_code = u_error_code.real;
offset += sizeof(this->error_code);
uint32_t length_error_string;
arrToVar(length_error_string, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_error_string; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_error_string-1]=0;
this->error_string = (char *)(inbuffer + offset-1);
offset += length_error_string;
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryResult"; };
const char * getMD5(){ return "493383b18409bfb604b4e26c676401d2"; };
};
}
#endif
| 2,772 | C | 31.244186 | 81 | 0.586941 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointControllerState.h | #ifndef _ROS_control_msgs_JointControllerState_h
#define _ROS_control_msgs_JointControllerState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace control_msgs
{
class JointControllerState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _set_point_type;
_set_point_type set_point;
typedef double _process_value_type;
_process_value_type process_value;
typedef double _process_value_dot_type;
_process_value_dot_type process_value_dot;
typedef double _error_type;
_error_type error;
typedef double _time_step_type;
_time_step_type time_step;
typedef double _command_type;
_command_type command;
typedef double _p_type;
_p_type p;
typedef double _i_type;
_i_type i;
typedef double _d_type;
_d_type d;
typedef double _i_clamp_type;
_i_clamp_type i_clamp;
typedef bool _antiwindup_type;
_antiwindup_type antiwindup;
JointControllerState():
header(),
set_point(0),
process_value(0),
process_value_dot(0),
error(0),
time_step(0),
command(0),
p(0),
i(0),
d(0),
i_clamp(0),
antiwindup(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_set_point;
u_set_point.real = this->set_point;
*(outbuffer + offset + 0) = (u_set_point.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_set_point.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_set_point.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_set_point.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_set_point.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_set_point.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_set_point.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_set_point.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->set_point);
union {
double real;
uint64_t base;
} u_process_value;
u_process_value.real = this->process_value;
*(outbuffer + offset + 0) = (u_process_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_process_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_process_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_process_value.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_process_value.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_process_value.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_process_value.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_process_value.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->process_value);
union {
double real;
uint64_t base;
} u_process_value_dot;
u_process_value_dot.real = this->process_value_dot;
*(outbuffer + offset + 0) = (u_process_value_dot.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_process_value_dot.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_process_value_dot.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_process_value_dot.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_process_value_dot.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_process_value_dot.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_process_value_dot.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_process_value_dot.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->process_value_dot);
union {
double real;
uint64_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.real = this->time_step;
*(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_command;
u_command.real = this->command;
*(outbuffer + offset + 0) = (u_command.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_command.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_command.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_command.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_command.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_command.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_command.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_command.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->command);
union {
double real;
uint64_t base;
} u_p;
u_p.real = this->p;
*(outbuffer + offset + 0) = (u_p.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_p.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_p.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_p.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_p.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_p.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_p.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_p.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->p);
union {
double real;
uint64_t base;
} u_i;
u_i.real = this->i;
*(outbuffer + offset + 0) = (u_i.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i);
union {
double real;
uint64_t base;
} u_d;
u_d.real = this->d;
*(outbuffer + offset + 0) = (u_d.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_d.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_d.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_d.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_d.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_d.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_d.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_d.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->d);
union {
double real;
uint64_t base;
} u_i_clamp;
u_i_clamp.real = this->i_clamp;
*(outbuffer + offset + 0) = (u_i_clamp.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_clamp.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_clamp.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_clamp.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_clamp.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_clamp.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_clamp.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_clamp.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_clamp);
union {
bool real;
uint8_t base;
} u_antiwindup;
u_antiwindup.real = this->antiwindup;
*(outbuffer + offset + 0) = (u_antiwindup.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->antiwindup);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_set_point;
u_set_point.base = 0;
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->set_point = u_set_point.real;
offset += sizeof(this->set_point);
union {
double real;
uint64_t base;
} u_process_value;
u_process_value.base = 0;
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->process_value = u_process_value.real;
offset += sizeof(this->process_value);
union {
double real;
uint64_t base;
} u_process_value_dot;
u_process_value_dot.base = 0;
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->process_value_dot = u_process_value_dot.real;
offset += sizeof(this->process_value_dot);
union {
double real;
uint64_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error = u_error.real;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.base = 0;
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time_step = u_time_step.real;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_command;
u_command.base = 0;
u_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->command = u_command.real;
offset += sizeof(this->command);
union {
double real;
uint64_t base;
} u_p;
u_p.base = 0;
u_p.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->p = u_p.real;
offset += sizeof(this->p);
union {
double real;
uint64_t base;
} u_i;
u_i.base = 0;
u_i.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i = u_i.real;
offset += sizeof(this->i);
union {
double real;
uint64_t base;
} u_d;
u_d.base = 0;
u_d.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->d = u_d.real;
offset += sizeof(this->d);
union {
double real;
uint64_t base;
} u_i_clamp;
u_i_clamp.base = 0;
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_clamp = u_i_clamp.real;
offset += sizeof(this->i_clamp);
union {
bool real;
uint8_t base;
} u_antiwindup;
u_antiwindup.base = 0;
u_antiwindup.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->antiwindup = u_antiwindup.real;
offset += sizeof(this->antiwindup);
return offset;
}
const char * getType(){ return "control_msgs/JointControllerState"; };
const char * getMD5(){ return "987ad85e4756f3aef7f1e5e7fe0595d1"; };
};
}
#endif
| 17,384 | C | 44.391645 | 85 | 0.494765 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadAction.h | #ifndef _ROS_control_msgs_PointHeadAction_h
#define _ROS_control_msgs_PointHeadAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/PointHeadActionGoal.h"
#include "control_msgs/PointHeadActionResult.h"
#include "control_msgs/PointHeadActionFeedback.h"
namespace control_msgs
{
class PointHeadAction : public ros::Msg
{
public:
typedef control_msgs::PointHeadActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::PointHeadActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::PointHeadActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
PointHeadAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadAction"; };
const char * getMD5(){ return "7252920f1243de1b741f14f214125371"; };
};
}
#endif
| 1,626 | C | 27.543859 | 74 | 0.689422 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandGoal.h | #ifndef _ROS_control_msgs_GripperCommandGoal_h
#define _ROS_control_msgs_GripperCommandGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/GripperCommand.h"
namespace control_msgs
{
class GripperCommandGoal : public ros::Msg
{
public:
typedef control_msgs::GripperCommand _command_type;
_command_type command;
GripperCommandGoal():
command()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->command.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->command.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandGoal"; };
const char * getMD5(){ return "86fd82f4ddc48a4cb6856cfa69217e43"; };
};
}
#endif
| 955 | C | 20.244444 | 72 | 0.665969 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryAction.h | #ifndef _ROS_control_msgs_JointTrajectoryAction_h
#define _ROS_control_msgs_JointTrajectoryAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/JointTrajectoryActionGoal.h"
#include "control_msgs/JointTrajectoryActionResult.h"
#include "control_msgs/JointTrajectoryActionFeedback.h"
namespace control_msgs
{
class JointTrajectoryAction : public ros::Msg
{
public:
typedef control_msgs::JointTrajectoryActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::JointTrajectoryActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::JointTrajectoryActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
JointTrajectoryAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryAction"; };
const char * getMD5(){ return "a04ba3ee8f6a2d0985a6aeaf23d9d7ad"; };
};
}
#endif
| 1,692 | C | 28.701754 | 80 | 0.701537 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadGoal.h | #ifndef _ROS_control_msgs_PointHeadGoal_h
#define _ROS_control_msgs_PointHeadGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PointStamped.h"
#include "geometry_msgs/Vector3.h"
#include "ros/duration.h"
namespace control_msgs
{
class PointHeadGoal : public ros::Msg
{
public:
typedef geometry_msgs::PointStamped _target_type;
_target_type target;
typedef geometry_msgs::Vector3 _pointing_axis_type;
_pointing_axis_type pointing_axis;
typedef const char* _pointing_frame_type;
_pointing_frame_type pointing_frame;
typedef ros::Duration _min_duration_type;
_min_duration_type min_duration;
typedef double _max_velocity_type;
_max_velocity_type max_velocity;
PointHeadGoal():
target(),
pointing_axis(),
pointing_frame(""),
min_duration(),
max_velocity(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->target.serialize(outbuffer + offset);
offset += this->pointing_axis.serialize(outbuffer + offset);
uint32_t length_pointing_frame = strlen(this->pointing_frame);
varToArr(outbuffer + offset, length_pointing_frame);
offset += 4;
memcpy(outbuffer + offset, this->pointing_frame, length_pointing_frame);
offset += length_pointing_frame;
*(outbuffer + offset + 0) = (this->min_duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.sec);
*(outbuffer + offset + 0) = (this->min_duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.real = this->max_velocity;
*(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->target.deserialize(inbuffer + offset);
offset += this->pointing_axis.deserialize(inbuffer + offset);
uint32_t length_pointing_frame;
arrToVar(length_pointing_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_pointing_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_pointing_frame-1]=0;
this->pointing_frame = (char *)(inbuffer + offset-1);
offset += length_pointing_frame;
this->min_duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.sec);
this->min_duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.base = 0;
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_velocity = u_max_velocity.real;
offset += sizeof(this->max_velocity);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadGoal"; };
const char * getMD5(){ return "8b92b1cd5e06c8a94c917dc3209a4c1d"; };
};
}
#endif
| 5,313 | C | 41.854838 | 84 | 0.577075 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandAction.h | #ifndef _ROS_control_msgs_GripperCommandAction_h
#define _ROS_control_msgs_GripperCommandAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/GripperCommandActionGoal.h"
#include "control_msgs/GripperCommandActionResult.h"
#include "control_msgs/GripperCommandActionFeedback.h"
namespace control_msgs
{
class GripperCommandAction : public ros::Msg
{
public:
typedef control_msgs::GripperCommandActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::GripperCommandActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::GripperCommandActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
GripperCommandAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandAction"; };
const char * getMD5(){ return "950b2a6ebe831f5d4f4ceaba3d8be01e"; };
};
}
#endif
| 1,681 | C | 28.508771 | 79 | 0.699584 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommand.h | #ifndef _ROS_control_msgs_GripperCommand_h
#define _ROS_control_msgs_GripperCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class GripperCommand : public ros::Msg
{
public:
typedef double _position_type;
_position_type position;
typedef double _max_effort_type;
_max_effort_type max_effort;
GripperCommand():
position(0),
max_effort(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_max_effort;
u_max_effort.real = this->max_effort;
*(outbuffer + offset + 0) = (u_max_effort.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_effort.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_effort.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_effort.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_effort.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_effort.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_effort.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_effort.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_effort);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_max_effort;
u_max_effort.base = 0;
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_effort = u_max_effort.real;
offset += sizeof(this->max_effort);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommand"; };
const char * getMD5(){ return "680acaff79486f017132a7f198d40f08"; };
};
}
#endif
| 3,953 | C | 37.388349 | 78 | 0.527448 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/Velocity.h | #ifndef _ROS_turtle_actionlib_Velocity_h
#define _ROS_turtle_actionlib_Velocity_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class Velocity : public ros::Msg
{
public:
typedef float _linear_type;
_linear_type linear;
typedef float _angular_type;
_angular_type angular;
Velocity():
linear(0),
angular(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.real = this->linear;
*(outbuffer + offset + 0) = (u_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_linear.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.real = this->angular;
*(outbuffer + offset + 0) = (u_angular.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angular.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angular.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angular.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angular);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.base = 0;
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->linear = u_linear.real;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.base = 0;
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angular = u_angular.real;
offset += sizeof(this->angular);
return offset;
}
const char * getType(){ return "turtle_actionlib/Velocity"; };
const char * getMD5(){ return "9d5c2dcd348ac8f76ce2a4307bd63a13"; };
};
}
#endif
| 2,628 | C | 29.21839 | 75 | 0.531583 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeAction.h | #ifndef _ROS_turtle_actionlib_ShapeAction_h
#define _ROS_turtle_actionlib_ShapeAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "turtle_actionlib/ShapeActionGoal.h"
#include "turtle_actionlib/ShapeActionResult.h"
#include "turtle_actionlib/ShapeActionFeedback.h"
namespace turtle_actionlib
{
class ShapeAction : public ros::Msg
{
public:
typedef turtle_actionlib::ShapeActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef turtle_actionlib::ShapeActionResult _action_result_type;
_action_result_type action_result;
typedef turtle_actionlib::ShapeActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
ShapeAction():
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 "turtle_actionlib/ShapeAction"; };
const char * getMD5(){ return "d73b17d6237a925511f5d7727a1dc903"; };
};
}
#endif
| 1,622 | C | 27.473684 | 74 | 0.688656 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeGoal.h | #ifndef _ROS_turtle_actionlib_ShapeGoal_h
#define _ROS_turtle_actionlib_ShapeGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class ShapeGoal : public ros::Msg
{
public:
typedef int32_t _edges_type;
_edges_type edges;
typedef float _radius_type;
_radius_type radius;
ShapeGoal():
edges(0),
radius(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_edges;
u_edges.real = this->edges;
*(outbuffer + offset + 0) = (u_edges.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_edges.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_edges.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_edges.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->edges);
union {
float real;
uint32_t base;
} u_radius;
u_radius.real = this->radius;
*(outbuffer + offset + 0) = (u_radius.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_radius.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_radius.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_radius.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->radius);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_edges;
u_edges.base = 0;
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->edges = u_edges.real;
offset += sizeof(this->edges);
union {
float real;
uint32_t base;
} u_radius;
u_radius.base = 0;
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->radius = u_radius.real;
offset += sizeof(this->radius);
return offset;
}
const char * getType(){ return "turtle_actionlib/ShapeGoal"; };
const char * getMD5(){ return "3b9202ab7292cebe5a95ab2bf6b9c091"; };
};
}
#endif
| 2,597 | C | 28.862069 | 74 | 0.524836 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeResult.h | #ifndef _ROS_turtle_actionlib_ShapeResult_h
#define _ROS_turtle_actionlib_ShapeResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class ShapeResult : public ros::Msg
{
public:
typedef float _interior_angle_type;
_interior_angle_type interior_angle;
typedef float _apothem_type;
_apothem_type apothem;
ShapeResult():
interior_angle(0),
apothem(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_interior_angle;
u_interior_angle.real = this->interior_angle;
*(outbuffer + offset + 0) = (u_interior_angle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_interior_angle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_interior_angle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_interior_angle.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->interior_angle);
union {
float real;
uint32_t base;
} u_apothem;
u_apothem.real = this->apothem;
*(outbuffer + offset + 0) = (u_apothem.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_apothem.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_apothem.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_apothem.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->apothem);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_interior_angle;
u_interior_angle.base = 0;
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->interior_angle = u_interior_angle.real;
offset += sizeof(this->interior_angle);
union {
float real;
uint32_t base;
} u_apothem;
u_apothem.base = 0;
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->apothem = u_apothem.real;
offset += sizeof(this->apothem);
return offset;
}
const char * getType(){ return "turtle_actionlib/ShapeResult"; };
const char * getMD5(){ return "b06c6e2225f820dbc644270387cd1a7c"; };
};
}
#endif
| 2,811 | C | 31.321839 | 82 | 0.554607 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/trajectory_msgs/JointTrajectoryPoint.h | #ifndef _ROS_trajectory_msgs_JointTrajectoryPoint_h
#define _ROS_trajectory_msgs_JointTrajectoryPoint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
namespace trajectory_msgs
{
class JointTrajectoryPoint : public ros::Msg
{
public:
uint32_t positions_length;
typedef double _positions_type;
_positions_type st_positions;
_positions_type * positions;
uint32_t velocities_length;
typedef double _velocities_type;
_velocities_type st_velocities;
_velocities_type * velocities;
uint32_t accelerations_length;
typedef double _accelerations_type;
_accelerations_type st_accelerations;
_accelerations_type * accelerations;
uint32_t effort_length;
typedef double _effort_type;
_effort_type st_effort;
_effort_type * effort;
typedef ros::Duration _time_from_start_type;
_time_from_start_type time_from_start;
JointTrajectoryPoint():
positions_length(0), positions(NULL),
velocities_length(0), velocities(NULL),
accelerations_length(0), accelerations(NULL),
effort_length(0), effort(NULL),
time_from_start()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->positions_length);
for( uint32_t i = 0; i < positions_length; i++){
union {
double real;
uint64_t base;
} u_positionsi;
u_positionsi.real = this->positions[i];
*(outbuffer + offset + 0) = (u_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->positions[i]);
}
*(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocities_length);
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_velocitiesi;
u_velocitiesi.real = this->velocities[i];
*(outbuffer + offset + 0) = (u_velocitiesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocitiesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocitiesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocitiesi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocitiesi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocitiesi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocitiesi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocitiesi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocities[i]);
}
*(outbuffer + offset + 0) = (this->accelerations_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->accelerations_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->accelerations_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->accelerations_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->accelerations_length);
for( uint32_t i = 0; i < accelerations_length; i++){
union {
double real;
uint64_t base;
} u_accelerationsi;
u_accelerationsi.real = this->accelerations[i];
*(outbuffer + offset + 0) = (u_accelerationsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_accelerationsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_accelerationsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_accelerationsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_accelerationsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_accelerationsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_accelerationsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_accelerationsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->accelerations[i]);
}
*(outbuffer + offset + 0) = (this->effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->effort_length);
for( uint32_t i = 0; i < effort_length; i++){
union {
double real;
uint64_t base;
} u_efforti;
u_efforti.real = this->effort[i];
*(outbuffer + offset + 0) = (u_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->effort[i]);
}
*(outbuffer + offset + 0) = (this->time_from_start.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.sec);
*(outbuffer + offset + 0) = (this->time_from_start.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->positions_length);
if(positions_lengthT > positions_length)
this->positions = (double*)realloc(this->positions, positions_lengthT * sizeof(double));
positions_length = positions_lengthT;
for( uint32_t i = 0; i < positions_length; i++){
union {
double real;
uint64_t base;
} u_st_positions;
u_st_positions.base = 0;
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_positions = u_st_positions.real;
offset += sizeof(this->st_positions);
memcpy( &(this->positions[i]), &(this->st_positions), sizeof(double));
}
uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocities_length);
if(velocities_lengthT > velocities_length)
this->velocities = (double*)realloc(this->velocities, velocities_lengthT * sizeof(double));
velocities_length = velocities_lengthT;
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_st_velocities;
u_st_velocities.base = 0;
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocities = u_st_velocities.real;
offset += sizeof(this->st_velocities);
memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(double));
}
uint32_t accelerations_lengthT = ((uint32_t) (*(inbuffer + offset)));
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->accelerations_length);
if(accelerations_lengthT > accelerations_length)
this->accelerations = (double*)realloc(this->accelerations, accelerations_lengthT * sizeof(double));
accelerations_length = accelerations_lengthT;
for( uint32_t i = 0; i < accelerations_length; i++){
union {
double real;
uint64_t base;
} u_st_accelerations;
u_st_accelerations.base = 0;
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_accelerations = u_st_accelerations.real;
offset += sizeof(this->st_accelerations);
memcpy( &(this->accelerations[i]), &(this->st_accelerations), sizeof(double));
}
uint32_t effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->effort_length);
if(effort_lengthT > effort_length)
this->effort = (double*)realloc(this->effort, effort_lengthT * sizeof(double));
effort_length = effort_lengthT;
for( uint32_t i = 0; i < effort_length; i++){
union {
double real;
uint64_t base;
} u_st_effort;
u_st_effort.base = 0;
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_effort = u_st_effort.real;
offset += sizeof(this->st_effort);
memcpy( &(this->effort[i]), &(this->st_effort), sizeof(double));
}
this->time_from_start.sec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.sec);
this->time_from_start.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.nsec);
return offset;
}
const char * getType(){ return "trajectory_msgs/JointTrajectoryPoint"; };
const char * getMD5(){ return "f3cd1e1c4d320c79d6985c904ae5dcd3"; };
};
}
#endif
| 14,120 | C | 51.107011 | 108 | 0.550921 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/trajectory_msgs/MultiDOFJointTrajectoryPoint.h | #ifndef _ROS_trajectory_msgs_MultiDOFJointTrajectoryPoint_h
#define _ROS_trajectory_msgs_MultiDOFJointTrajectoryPoint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Transform.h"
#include "geometry_msgs/Twist.h"
#include "ros/duration.h"
namespace trajectory_msgs
{
class MultiDOFJointTrajectoryPoint : public ros::Msg
{
public:
uint32_t transforms_length;
typedef geometry_msgs::Transform _transforms_type;
_transforms_type st_transforms;
_transforms_type * transforms;
uint32_t velocities_length;
typedef geometry_msgs::Twist _velocities_type;
_velocities_type st_velocities;
_velocities_type * velocities;
uint32_t accelerations_length;
typedef geometry_msgs::Twist _accelerations_type;
_accelerations_type st_accelerations;
_accelerations_type * accelerations;
typedef ros::Duration _time_from_start_type;
_time_from_start_type time_from_start;
MultiDOFJointTrajectoryPoint():
transforms_length(0), transforms(NULL),
velocities_length(0), velocities(NULL),
accelerations_length(0), accelerations(NULL),
time_from_start()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transforms_length);
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->transforms[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocities_length);
for( uint32_t i = 0; i < velocities_length; i++){
offset += this->velocities[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->accelerations_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->accelerations_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->accelerations_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->accelerations_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->accelerations_length);
for( uint32_t i = 0; i < accelerations_length; i++){
offset += this->accelerations[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->time_from_start.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.sec);
*(outbuffer + offset + 0) = (this->time_from_start.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transforms_length);
if(transforms_lengthT > transforms_length)
this->transforms = (geometry_msgs::Transform*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::Transform));
transforms_length = transforms_lengthT;
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->st_transforms.deserialize(inbuffer + offset);
memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::Transform));
}
uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocities_length);
if(velocities_lengthT > velocities_length)
this->velocities = (geometry_msgs::Twist*)realloc(this->velocities, velocities_lengthT * sizeof(geometry_msgs::Twist));
velocities_length = velocities_lengthT;
for( uint32_t i = 0; i < velocities_length; i++){
offset += this->st_velocities.deserialize(inbuffer + offset);
memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(geometry_msgs::Twist));
}
uint32_t accelerations_lengthT = ((uint32_t) (*(inbuffer + offset)));
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->accelerations_length);
if(accelerations_lengthT > accelerations_length)
this->accelerations = (geometry_msgs::Twist*)realloc(this->accelerations, accelerations_lengthT * sizeof(geometry_msgs::Twist));
accelerations_length = accelerations_lengthT;
for( uint32_t i = 0; i < accelerations_length; i++){
offset += this->st_accelerations.deserialize(inbuffer + offset);
memcpy( &(this->accelerations[i]), &(this->st_accelerations), sizeof(geometry_msgs::Twist));
}
this->time_from_start.sec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.sec);
this->time_from_start.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.nsec);
return offset;
}
const char * getType(){ return "trajectory_msgs/MultiDOFJointTrajectoryPoint"; };
const char * getMD5(){ return "3ebe08d1abd5b65862d50e09430db776"; };
};
}
#endif
| 7,163 | C | 50.171428 | 136 | 0.605333 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/trajectory_msgs/MultiDOFJointTrajectory.h | #ifndef _ROS_trajectory_msgs_MultiDOFJointTrajectory_h
#define _ROS_trajectory_msgs_MultiDOFJointTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "trajectory_msgs/MultiDOFJointTrajectoryPoint.h"
namespace trajectory_msgs
{
class MultiDOFJointTrajectory : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t points_length;
typedef trajectory_msgs::MultiDOFJointTrajectoryPoint _points_type;
_points_type st_points;
_points_type * points;
MultiDOFJointTrajectory():
header(),
joint_names_length(0), joint_names(NULL),
points_length(0), points(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->points_length);
for( uint32_t i = 0; i < points_length; i++){
offset += this->points[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->points_length);
if(points_lengthT > points_length)
this->points = (trajectory_msgs::MultiDOFJointTrajectoryPoint*)realloc(this->points, points_lengthT * sizeof(trajectory_msgs::MultiDOFJointTrajectoryPoint));
points_length = points_lengthT;
for( uint32_t i = 0; i < points_length; i++){
offset += this->st_points.deserialize(inbuffer + offset);
memcpy( &(this->points[i]), &(this->st_points), sizeof(trajectory_msgs::MultiDOFJointTrajectoryPoint));
}
return offset;
}
const char * getType(){ return "trajectory_msgs/MultiDOFJointTrajectory"; };
const char * getMD5(){ return "ef145a45a5f47b77b7f5cdde4b16c942"; };
};
}
#endif
| 4,511 | C | 40.777777 | 165 | 0.610064 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/TrajectoryOptions.h | #ifndef _ROS_intera_motion_msgs_TrajectoryOptions_h
#define _ROS_intera_motion_msgs_TrajectoryOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "intera_core_msgs/InteractionControlCommand.h"
#include "intera_motion_msgs/TrackingOptions.h"
#include "ros/time.h"
namespace intera_motion_msgs
{
class TrajectoryOptions : public ros::Msg
{
public:
typedef const char* _interpolation_type_type;
_interpolation_type_type interpolation_type;
typedef bool _interaction_control_type;
_interaction_control_type interaction_control;
typedef intera_core_msgs::InteractionControlCommand _interaction_params_type;
_interaction_params_type interaction_params;
typedef bool _nso_start_offset_allowed_type;
_nso_start_offset_allowed_type nso_start_offset_allowed;
typedef bool _nso_check_end_offset_type;
_nso_check_end_offset_type nso_check_end_offset;
typedef intera_motion_msgs::TrackingOptions _tracking_options_type;
_tracking_options_type tracking_options;
typedef ros::Time _end_time_type;
_end_time_type end_time;
typedef double _path_interpolation_step_type;
_path_interpolation_step_type path_interpolation_step;
enum { CARTESIAN = CARTESIAN };
enum { JOINT = JOINT };
TrajectoryOptions():
interpolation_type(""),
interaction_control(0),
interaction_params(),
nso_start_offset_allowed(0),
nso_check_end_offset(0),
tracking_options(),
end_time(),
path_interpolation_step(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_interpolation_type = strlen(this->interpolation_type);
varToArr(outbuffer + offset, length_interpolation_type);
offset += 4;
memcpy(outbuffer + offset, this->interpolation_type, length_interpolation_type);
offset += length_interpolation_type;
union {
bool real;
uint8_t base;
} u_interaction_control;
u_interaction_control.real = this->interaction_control;
*(outbuffer + offset + 0) = (u_interaction_control.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->interaction_control);
offset += this->interaction_params.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_nso_start_offset_allowed;
u_nso_start_offset_allowed.real = this->nso_start_offset_allowed;
*(outbuffer + offset + 0) = (u_nso_start_offset_allowed.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->nso_start_offset_allowed);
union {
bool real;
uint8_t base;
} u_nso_check_end_offset;
u_nso_check_end_offset.real = this->nso_check_end_offset;
*(outbuffer + offset + 0) = (u_nso_check_end_offset.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->nso_check_end_offset);
offset += this->tracking_options.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->end_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end_time.sec);
*(outbuffer + offset + 0) = (this->end_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end_time.nsec);
union {
double real;
uint64_t base;
} u_path_interpolation_step;
u_path_interpolation_step.real = this->path_interpolation_step;
*(outbuffer + offset + 0) = (u_path_interpolation_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_path_interpolation_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_path_interpolation_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_path_interpolation_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_path_interpolation_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_path_interpolation_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_path_interpolation_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_path_interpolation_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->path_interpolation_step);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_interpolation_type;
arrToVar(length_interpolation_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_interpolation_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_interpolation_type-1]=0;
this->interpolation_type = (char *)(inbuffer + offset-1);
offset += length_interpolation_type;
union {
bool real;
uint8_t base;
} u_interaction_control;
u_interaction_control.base = 0;
u_interaction_control.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->interaction_control = u_interaction_control.real;
offset += sizeof(this->interaction_control);
offset += this->interaction_params.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_nso_start_offset_allowed;
u_nso_start_offset_allowed.base = 0;
u_nso_start_offset_allowed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->nso_start_offset_allowed = u_nso_start_offset_allowed.real;
offset += sizeof(this->nso_start_offset_allowed);
union {
bool real;
uint8_t base;
} u_nso_check_end_offset;
u_nso_check_end_offset.base = 0;
u_nso_check_end_offset.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->nso_check_end_offset = u_nso_check_end_offset.real;
offset += sizeof(this->nso_check_end_offset);
offset += this->tracking_options.deserialize(inbuffer + offset);
this->end_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->end_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end_time.sec);
this->end_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->end_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end_time.nsec);
union {
double real;
uint64_t base;
} u_path_interpolation_step;
u_path_interpolation_step.base = 0;
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->path_interpolation_step = u_path_interpolation_step.real;
offset += sizeof(this->path_interpolation_step);
return offset;
}
const char * getType(){ return "intera_motion_msgs/TrajectoryOptions"; };
const char * getMD5(){ return "d6c6806743ac9695334265046d57235e"; };
};
}
#endif
| 8,144 | C | 44.25 | 91 | 0.602529 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/TrackingOptions.h | #ifndef _ROS_intera_motion_msgs_TrackingOptions_h
#define _ROS_intera_motion_msgs_TrackingOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace intera_motion_msgs
{
class TrackingOptions : public ros::Msg
{
public:
typedef bool _use_min_time_rate_type;
_use_min_time_rate_type use_min_time_rate;
typedef double _min_time_rate_type;
_min_time_rate_type min_time_rate;
typedef bool _use_max_time_rate_type;
_use_max_time_rate_type use_max_time_rate;
typedef double _max_time_rate_type;
_max_time_rate_type max_time_rate;
uint32_t goal_joint_tolerance_length;
typedef double _goal_joint_tolerance_type;
_goal_joint_tolerance_type st_goal_joint_tolerance;
_goal_joint_tolerance_type * goal_joint_tolerance;
typedef bool _use_settling_time_at_goal_type;
_use_settling_time_at_goal_type use_settling_time_at_goal;
typedef double _settling_time_at_goal_type;
_settling_time_at_goal_type settling_time_at_goal;
TrackingOptions():
use_min_time_rate(0),
min_time_rate(0),
use_max_time_rate(0),
max_time_rate(0),
goal_joint_tolerance_length(0), goal_joint_tolerance(NULL),
use_settling_time_at_goal(0),
settling_time_at_goal(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_use_min_time_rate;
u_use_min_time_rate.real = this->use_min_time_rate;
*(outbuffer + offset + 0) = (u_use_min_time_rate.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->use_min_time_rate);
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.real = this->min_time_rate;
*(outbuffer + offset + 0) = (u_min_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_time_rate);
union {
bool real;
uint8_t base;
} u_use_max_time_rate;
u_use_max_time_rate.real = this->use_max_time_rate;
*(outbuffer + offset + 0) = (u_use_max_time_rate.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->use_max_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.real = this->max_time_rate;
*(outbuffer + offset + 0) = (u_max_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_time_rate);
*(outbuffer + offset + 0) = (this->goal_joint_tolerance_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_joint_tolerance_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_joint_tolerance_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_joint_tolerance_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_joint_tolerance_length);
for( uint32_t i = 0; i < goal_joint_tolerance_length; i++){
union {
double real;
uint64_t base;
} u_goal_joint_tolerancei;
u_goal_joint_tolerancei.real = this->goal_joint_tolerance[i];
*(outbuffer + offset + 0) = (u_goal_joint_tolerancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_goal_joint_tolerancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_goal_joint_tolerancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_goal_joint_tolerancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_goal_joint_tolerancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_goal_joint_tolerancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_goal_joint_tolerancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_goal_joint_tolerancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->goal_joint_tolerance[i]);
}
union {
bool real;
uint8_t base;
} u_use_settling_time_at_goal;
u_use_settling_time_at_goal.real = this->use_settling_time_at_goal;
*(outbuffer + offset + 0) = (u_use_settling_time_at_goal.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->use_settling_time_at_goal);
union {
double real;
uint64_t base;
} u_settling_time_at_goal;
u_settling_time_at_goal.real = this->settling_time_at_goal;
*(outbuffer + offset + 0) = (u_settling_time_at_goal.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_settling_time_at_goal.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_settling_time_at_goal.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_settling_time_at_goal.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_settling_time_at_goal.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_settling_time_at_goal.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_settling_time_at_goal.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_settling_time_at_goal.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->settling_time_at_goal);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_use_min_time_rate;
u_use_min_time_rate.base = 0;
u_use_min_time_rate.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->use_min_time_rate = u_use_min_time_rate.real;
offset += sizeof(this->use_min_time_rate);
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.base = 0;
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_time_rate = u_min_time_rate.real;
offset += sizeof(this->min_time_rate);
union {
bool real;
uint8_t base;
} u_use_max_time_rate;
u_use_max_time_rate.base = 0;
u_use_max_time_rate.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->use_max_time_rate = u_use_max_time_rate.real;
offset += sizeof(this->use_max_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.base = 0;
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_time_rate = u_max_time_rate.real;
offset += sizeof(this->max_time_rate);
uint32_t goal_joint_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
goal_joint_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
goal_joint_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
goal_joint_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_joint_tolerance_length);
if(goal_joint_tolerance_lengthT > goal_joint_tolerance_length)
this->goal_joint_tolerance = (double*)realloc(this->goal_joint_tolerance, goal_joint_tolerance_lengthT * sizeof(double));
goal_joint_tolerance_length = goal_joint_tolerance_lengthT;
for( uint32_t i = 0; i < goal_joint_tolerance_length; i++){
union {
double real;
uint64_t base;
} u_st_goal_joint_tolerance;
u_st_goal_joint_tolerance.base = 0;
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_goal_joint_tolerance = u_st_goal_joint_tolerance.real;
offset += sizeof(this->st_goal_joint_tolerance);
memcpy( &(this->goal_joint_tolerance[i]), &(this->st_goal_joint_tolerance), sizeof(double));
}
union {
bool real;
uint8_t base;
} u_use_settling_time_at_goal;
u_use_settling_time_at_goal.base = 0;
u_use_settling_time_at_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->use_settling_time_at_goal = u_use_settling_time_at_goal.real;
offset += sizeof(this->use_settling_time_at_goal);
union {
double real;
uint64_t base;
} u_settling_time_at_goal;
u_settling_time_at_goal.base = 0;
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->settling_time_at_goal = u_settling_time_at_goal.real;
offset += sizeof(this->settling_time_at_goal);
return offset;
}
const char * getType(){ return "intera_motion_msgs/TrackingOptions"; };
const char * getMD5(){ return "e848e8a266b514c3bde707d0e1859055"; };
};
}
#endif
| 11,938 | C | 48.539419 | 129 | 0.559977 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/JointTrackingError.h | #ifndef _ROS_intera_motion_msgs_JointTrackingError_h
#define _ROS_intera_motion_msgs_JointTrackingError_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace intera_motion_msgs
{
class JointTrackingError : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _trajectory_id_type;
_trajectory_id_type trajectory_id;
typedef double _trajectory_time_type;
_trajectory_time_type trajectory_time;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t position_error_length;
typedef double _position_error_type;
_position_error_type st_position_error;
_position_error_type * position_error;
uint32_t velocity_error_length;
typedef double _velocity_error_type;
_velocity_error_type st_velocity_error;
_velocity_error_type * velocity_error;
uint32_t position_command_length;
typedef double _position_command_type;
_position_command_type st_position_command;
_position_command_type * position_command;
uint32_t velocity_command_length;
typedef double _velocity_command_type;
_velocity_command_type st_velocity_command;
_velocity_command_type * velocity_command;
JointTrackingError():
header(),
trajectory_id(0),
trajectory_time(0),
joint_names_length(0), joint_names(NULL),
position_error_length(0), position_error(NULL),
velocity_error_length(0), velocity_error(NULL),
position_command_length(0), position_command(NULL),
velocity_command_length(0), velocity_command(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.real = this->trajectory_time;
*(outbuffer + offset + 0) = (u_trajectory_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_trajectory_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_trajectory_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_trajectory_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_trajectory_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_trajectory_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_trajectory_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_trajectory_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->trajectory_time);
*(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->position_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_error_length);
for( uint32_t i = 0; i < position_error_length; i++){
union {
double real;
uint64_t base;
} u_position_errori;
u_position_errori.real = this->position_error[i];
*(outbuffer + offset + 0) = (u_position_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position_error[i]);
}
*(outbuffer + offset + 0) = (this->velocity_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocity_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocity_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocity_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocity_error_length);
for( uint32_t i = 0; i < velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_velocity_errori;
u_velocity_errori.real = this->velocity_error[i];
*(outbuffer + offset + 0) = (u_velocity_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity_error[i]);
}
*(outbuffer + offset + 0) = (this->position_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_command_length);
for( uint32_t i = 0; i < position_command_length; i++){
union {
double real;
uint64_t base;
} u_position_commandi;
u_position_commandi.real = this->position_command[i];
*(outbuffer + offset + 0) = (u_position_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position_command[i]);
}
*(outbuffer + offset + 0) = (this->velocity_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocity_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocity_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocity_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocity_command_length);
for( uint32_t i = 0; i < velocity_command_length; i++){
union {
double real;
uint64_t base;
} u_velocity_commandi;
u_velocity_commandi.real = this->velocity_command[i];
*(outbuffer + offset + 0) = (u_velocity_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity_command[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->trajectory_id = ((uint32_t) (*(inbuffer + offset)));
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.base = 0;
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->trajectory_time = u_trajectory_time.real;
offset += sizeof(this->trajectory_time);
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 position_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_error_length);
if(position_error_lengthT > position_error_length)
this->position_error = (double*)realloc(this->position_error, position_error_lengthT * sizeof(double));
position_error_length = position_error_lengthT;
for( uint32_t i = 0; i < position_error_length; i++){
union {
double real;
uint64_t base;
} u_st_position_error;
u_st_position_error.base = 0;
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position_error = u_st_position_error.real;
offset += sizeof(this->st_position_error);
memcpy( &(this->position_error[i]), &(this->st_position_error), sizeof(double));
}
uint32_t velocity_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocity_error_length);
if(velocity_error_lengthT > velocity_error_length)
this->velocity_error = (double*)realloc(this->velocity_error, velocity_error_lengthT * sizeof(double));
velocity_error_length = velocity_error_lengthT;
for( uint32_t i = 0; i < velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_st_velocity_error;
u_st_velocity_error.base = 0;
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocity_error = u_st_velocity_error.real;
offset += sizeof(this->st_velocity_error);
memcpy( &(this->velocity_error[i]), &(this->st_velocity_error), sizeof(double));
}
uint32_t position_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_command_length);
if(position_command_lengthT > position_command_length)
this->position_command = (double*)realloc(this->position_command, position_command_lengthT * sizeof(double));
position_command_length = position_command_lengthT;
for( uint32_t i = 0; i < position_command_length; i++){
union {
double real;
uint64_t base;
} u_st_position_command;
u_st_position_command.base = 0;
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position_command = u_st_position_command.real;
offset += sizeof(this->st_position_command);
memcpy( &(this->position_command[i]), &(this->st_position_command), sizeof(double));
}
uint32_t velocity_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocity_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocity_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocity_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocity_command_length);
if(velocity_command_lengthT > velocity_command_length)
this->velocity_command = (double*)realloc(this->velocity_command, velocity_command_lengthT * sizeof(double));
velocity_command_length = velocity_command_lengthT;
for( uint32_t i = 0; i < velocity_command_length; i++){
union {
double real;
uint64_t base;
} u_st_velocity_command;
u_st_velocity_command.base = 0;
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocity_command = u_st_velocity_command.real;
offset += sizeof(this->st_velocity_command);
memcpy( &(this->velocity_command[i]), &(this->st_velocity_command), sizeof(double));
}
return offset;
}
const char * getType(){ return "intera_motion_msgs/JointTrackingError"; };
const char * getMD5(){ return "a564fcc23df67e287d3c4c2aa3aef83b"; };
};
}
#endif
| 18,493 | C | 54.20597 | 117 | 0.571946 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/Trajectory.h | #ifndef _ROS_intera_motion_msgs_Trajectory_h
#define _ROS_intera_motion_msgs_Trajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "intera_motion_msgs/Waypoint.h"
#include "intera_motion_msgs/TrajectoryOptions.h"
namespace intera_motion_msgs
{
class Trajectory : public ros::Msg
{
public:
typedef const char* _label_type;
_label_type label;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t waypoints_length;
typedef intera_motion_msgs::Waypoint _waypoints_type;
_waypoints_type st_waypoints;
_waypoints_type * waypoints;
typedef intera_motion_msgs::TrajectoryOptions _trajectory_options_type;
_trajectory_options_type trajectory_options;
Trajectory():
label(""),
joint_names_length(0), joint_names(NULL),
waypoints_length(0), waypoints(NULL),
trajectory_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_label = strlen(this->label);
varToArr(outbuffer + offset, length_label);
offset += 4;
memcpy(outbuffer + offset, this->label, length_label);
offset += length_label;
*(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->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);
}
offset += this->trajectory_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_label;
arrToVar(length_label, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_label; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_label-1]=0;
this->label = (char *)(inbuffer + offset-1);
offset += length_label;
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 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 = (intera_motion_msgs::Waypoint*)realloc(this->waypoints, waypoints_lengthT * sizeof(intera_motion_msgs::Waypoint));
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(intera_motion_msgs::Waypoint));
}
offset += this->trajectory_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "intera_motion_msgs/Trajectory"; };
const char * getMD5(){ return "9ab7e6d17ba67f0a6b00ab5f35f6d93e"; };
};
}
#endif
| 5,202 | C | 40.624 | 140 | 0.609189 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/WaypointOptions.h | #ifndef _ROS_intera_motion_msgs_WaypointOptions_h
#define _ROS_intera_motion_msgs_WaypointOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace intera_motion_msgs
{
class WaypointOptions : public ros::Msg
{
public:
typedef const char* _label_type;
_label_type label;
typedef double _max_joint_speed_ratio_type;
_max_joint_speed_ratio_type max_joint_speed_ratio;
uint32_t joint_tolerances_length;
typedef double _joint_tolerances_type;
_joint_tolerances_type st_joint_tolerances;
_joint_tolerances_type * joint_tolerances;
uint32_t max_joint_accel_length;
typedef double _max_joint_accel_type;
_max_joint_accel_type st_max_joint_accel;
_max_joint_accel_type * max_joint_accel;
typedef double _max_linear_speed_type;
_max_linear_speed_type max_linear_speed;
typedef double _max_linear_accel_type;
_max_linear_accel_type max_linear_accel;
typedef double _max_rotational_speed_type;
_max_rotational_speed_type max_rotational_speed;
typedef double _max_rotational_accel_type;
_max_rotational_accel_type max_rotational_accel;
typedef double _corner_distance_type;
_corner_distance_type corner_distance;
WaypointOptions():
label(""),
max_joint_speed_ratio(0),
joint_tolerances_length(0), joint_tolerances(NULL),
max_joint_accel_length(0), max_joint_accel(NULL),
max_linear_speed(0),
max_linear_accel(0),
max_rotational_speed(0),
max_rotational_accel(0),
corner_distance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_label = strlen(this->label);
varToArr(outbuffer + offset, length_label);
offset += 4;
memcpy(outbuffer + offset, this->label, length_label);
offset += length_label;
union {
double real;
uint64_t base;
} u_max_joint_speed_ratio;
u_max_joint_speed_ratio.real = this->max_joint_speed_ratio;
*(outbuffer + offset + 0) = (u_max_joint_speed_ratio.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_joint_speed_ratio.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_joint_speed_ratio.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_joint_speed_ratio.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_joint_speed_ratio.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_joint_speed_ratio.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_joint_speed_ratio.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_joint_speed_ratio.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_joint_speed_ratio);
*(outbuffer + offset + 0) = (this->joint_tolerances_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_tolerances_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_tolerances_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_tolerances_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_tolerances_length);
for( uint32_t i = 0; i < joint_tolerances_length; i++){
union {
double real;
uint64_t base;
} u_joint_tolerancesi;
u_joint_tolerancesi.real = this->joint_tolerances[i];
*(outbuffer + offset + 0) = (u_joint_tolerancesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_tolerancesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_tolerancesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_tolerancesi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_tolerancesi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_tolerancesi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_tolerancesi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_tolerancesi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_tolerances[i]);
}
*(outbuffer + offset + 0) = (this->max_joint_accel_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_joint_accel_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_joint_accel_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_joint_accel_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_joint_accel_length);
for( uint32_t i = 0; i < max_joint_accel_length; i++){
union {
double real;
uint64_t base;
} u_max_joint_acceli;
u_max_joint_acceli.real = this->max_joint_accel[i];
*(outbuffer + offset + 0) = (u_max_joint_acceli.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_joint_acceli.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_joint_acceli.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_joint_acceli.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_joint_acceli.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_joint_acceli.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_joint_acceli.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_joint_acceli.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_joint_accel[i]);
}
union {
double real;
uint64_t base;
} u_max_linear_speed;
u_max_linear_speed.real = this->max_linear_speed;
*(outbuffer + offset + 0) = (u_max_linear_speed.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_linear_speed.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_linear_speed.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_linear_speed.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_linear_speed.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_linear_speed.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_linear_speed.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_linear_speed.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_linear_speed);
union {
double real;
uint64_t base;
} u_max_linear_accel;
u_max_linear_accel.real = this->max_linear_accel;
*(outbuffer + offset + 0) = (u_max_linear_accel.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_linear_accel.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_linear_accel.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_linear_accel.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_linear_accel.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_linear_accel.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_linear_accel.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_linear_accel.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_linear_accel);
union {
double real;
uint64_t base;
} u_max_rotational_speed;
u_max_rotational_speed.real = this->max_rotational_speed;
*(outbuffer + offset + 0) = (u_max_rotational_speed.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_rotational_speed.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_rotational_speed.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_rotational_speed.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_rotational_speed.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_rotational_speed.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_rotational_speed.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_rotational_speed.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_rotational_speed);
union {
double real;
uint64_t base;
} u_max_rotational_accel;
u_max_rotational_accel.real = this->max_rotational_accel;
*(outbuffer + offset + 0) = (u_max_rotational_accel.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_rotational_accel.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_rotational_accel.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_rotational_accel.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_rotational_accel.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_rotational_accel.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_rotational_accel.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_rotational_accel.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_rotational_accel);
union {
double real;
uint64_t base;
} u_corner_distance;
u_corner_distance.real = this->corner_distance;
*(outbuffer + offset + 0) = (u_corner_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_corner_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_corner_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_corner_distance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_corner_distance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_corner_distance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_corner_distance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_corner_distance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->corner_distance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_label;
arrToVar(length_label, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_label; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_label-1]=0;
this->label = (char *)(inbuffer + offset-1);
offset += length_label;
union {
double real;
uint64_t base;
} u_max_joint_speed_ratio;
u_max_joint_speed_ratio.base = 0;
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_joint_speed_ratio = u_max_joint_speed_ratio.real;
offset += sizeof(this->max_joint_speed_ratio);
uint32_t joint_tolerances_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_tolerances_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_tolerances_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_tolerances_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_tolerances_length);
if(joint_tolerances_lengthT > joint_tolerances_length)
this->joint_tolerances = (double*)realloc(this->joint_tolerances, joint_tolerances_lengthT * sizeof(double));
joint_tolerances_length = joint_tolerances_lengthT;
for( uint32_t i = 0; i < joint_tolerances_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_tolerances;
u_st_joint_tolerances.base = 0;
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_tolerances = u_st_joint_tolerances.real;
offset += sizeof(this->st_joint_tolerances);
memcpy( &(this->joint_tolerances[i]), &(this->st_joint_tolerances), sizeof(double));
}
uint32_t max_joint_accel_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_joint_accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_joint_accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_joint_accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_joint_accel_length);
if(max_joint_accel_lengthT > max_joint_accel_length)
this->max_joint_accel = (double*)realloc(this->max_joint_accel, max_joint_accel_lengthT * sizeof(double));
max_joint_accel_length = max_joint_accel_lengthT;
for( uint32_t i = 0; i < max_joint_accel_length; i++){
union {
double real;
uint64_t base;
} u_st_max_joint_accel;
u_st_max_joint_accel.base = 0;
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_joint_accel = u_st_max_joint_accel.real;
offset += sizeof(this->st_max_joint_accel);
memcpy( &(this->max_joint_accel[i]), &(this->st_max_joint_accel), sizeof(double));
}
union {
double real;
uint64_t base;
} u_max_linear_speed;
u_max_linear_speed.base = 0;
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_linear_speed = u_max_linear_speed.real;
offset += sizeof(this->max_linear_speed);
union {
double real;
uint64_t base;
} u_max_linear_accel;
u_max_linear_accel.base = 0;
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_linear_accel = u_max_linear_accel.real;
offset += sizeof(this->max_linear_accel);
union {
double real;
uint64_t base;
} u_max_rotational_speed;
u_max_rotational_speed.base = 0;
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_rotational_speed = u_max_rotational_speed.real;
offset += sizeof(this->max_rotational_speed);
union {
double real;
uint64_t base;
} u_max_rotational_accel;
u_max_rotational_accel.base = 0;
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_rotational_accel = u_max_rotational_accel.real;
offset += sizeof(this->max_rotational_accel);
union {
double real;
uint64_t base;
} u_corner_distance;
u_corner_distance.base = 0;
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->corner_distance = u_corner_distance.real;
offset += sizeof(this->corner_distance);
return offset;
}
const char * getType(){ return "intera_motion_msgs/WaypointOptions"; };
const char * getMD5(){ return "1b4687d4e536269b06e629169723339f"; };
};
}
#endif
| 19,258 | C | 53.713068 | 117 | 0.55904 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/EndpointTrackingError.h | #ifndef _ROS_intera_motion_msgs_EndpointTrackingError_h
#define _ROS_intera_motion_msgs_EndpointTrackingError_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace intera_motion_msgs
{
class EndpointTrackingError : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _trajectory_id_type;
_trajectory_id_type trajectory_id;
typedef double _trajectory_time_type;
_trajectory_time_type trajectory_time;
typedef const char* _active_endpoint_type;
_active_endpoint_type active_endpoint;
typedef geometry_msgs::Pose _pose_error_type;
_pose_error_type pose_error;
typedef geometry_msgs::Twist _twist_error_type;
_twist_error_type twist_error;
typedef geometry_msgs::Pose _pose_command_type;
_pose_command_type pose_command;
typedef geometry_msgs::Twist _twist_command_type;
_twist_command_type twist_command;
EndpointTrackingError():
header(),
trajectory_id(0),
trajectory_time(0),
active_endpoint(""),
pose_error(),
twist_error(),
pose_command(),
twist_command()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.real = this->trajectory_time;
*(outbuffer + offset + 0) = (u_trajectory_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_trajectory_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_trajectory_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_trajectory_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_trajectory_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_trajectory_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_trajectory_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_trajectory_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->trajectory_time);
uint32_t length_active_endpoint = strlen(this->active_endpoint);
varToArr(outbuffer + offset, length_active_endpoint);
offset += 4;
memcpy(outbuffer + offset, this->active_endpoint, length_active_endpoint);
offset += length_active_endpoint;
offset += this->pose_error.serialize(outbuffer + offset);
offset += this->twist_error.serialize(outbuffer + offset);
offset += this->pose_command.serialize(outbuffer + offset);
offset += this->twist_command.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->trajectory_id = ((uint32_t) (*(inbuffer + offset)));
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.base = 0;
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->trajectory_time = u_trajectory_time.real;
offset += sizeof(this->trajectory_time);
uint32_t length_active_endpoint;
arrToVar(length_active_endpoint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_active_endpoint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_active_endpoint-1]=0;
this->active_endpoint = (char *)(inbuffer + offset-1);
offset += length_active_endpoint;
offset += this->pose_error.deserialize(inbuffer + offset);
offset += this->twist_error.deserialize(inbuffer + offset);
offset += this->pose_command.deserialize(inbuffer + offset);
offset += this->twist_command.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "intera_motion_msgs/EndpointTrackingError"; };
const char * getMD5(){ return "c266cbf60fc5f871b5909394c05032fc"; };
};
}
#endif
| 5,418 | C | 41.007752 | 83 | 0.604467 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/Waypoint.h | #ifndef _ROS_intera_motion_msgs_Waypoint_h
#define _ROS_intera_motion_msgs_Waypoint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
#include "intera_motion_msgs/WaypointOptions.h"
namespace intera_motion_msgs
{
class Waypoint : public ros::Msg
{
public:
uint32_t joint_positions_length;
typedef double _joint_positions_type;
_joint_positions_type st_joint_positions;
_joint_positions_type * joint_positions;
typedef const char* _active_endpoint_type;
_active_endpoint_type active_endpoint;
typedef geometry_msgs::PoseStamped _pose_type;
_pose_type pose;
typedef intera_motion_msgs::WaypointOptions _options_type;
_options_type options;
Waypoint():
joint_positions_length(0), joint_positions(NULL),
active_endpoint(""),
pose(),
options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joint_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_positions_length);
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_joint_positionsi;
u_joint_positionsi.real = this->joint_positions[i];
*(outbuffer + offset + 0) = (u_joint_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_positions[i]);
}
uint32_t length_active_endpoint = strlen(this->active_endpoint);
varToArr(outbuffer + offset, length_active_endpoint);
offset += 4;
memcpy(outbuffer + offset, this->active_endpoint, length_active_endpoint);
offset += length_active_endpoint;
offset += this->pose.serialize(outbuffer + offset);
offset += this->options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joint_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_positions_length);
if(joint_positions_lengthT > joint_positions_length)
this->joint_positions = (double*)realloc(this->joint_positions, joint_positions_lengthT * sizeof(double));
joint_positions_length = joint_positions_lengthT;
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_positions;
u_st_joint_positions.base = 0;
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_positions = u_st_joint_positions.real;
offset += sizeof(this->st_joint_positions);
memcpy( &(this->joint_positions[i]), &(this->st_joint_positions), sizeof(double));
}
uint32_t length_active_endpoint;
arrToVar(length_active_endpoint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_active_endpoint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_active_endpoint-1]=0;
this->active_endpoint = (char *)(inbuffer + offset-1);
offset += length_active_endpoint;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "intera_motion_msgs/Waypoint"; };
const char * getMD5(){ return "8284b290b22204acc5e4d8000467b033"; };
};
}
#endif
| 5,202 | C | 42.358333 | 114 | 0.601499 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/InterpolatedPath.h | #ifndef _ROS_intera_motion_msgs_InterpolatedPath_h
#define _ROS_intera_motion_msgs_InterpolatedPath_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "intera_motion_msgs/WaypointSimple.h"
namespace intera_motion_msgs
{
class InterpolatedPath : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _label_type;
_label_type label;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t interpolated_path_length;
typedef intera_motion_msgs::WaypointSimple _interpolated_path_type;
_interpolated_path_type st_interpolated_path;
_interpolated_path_type * interpolated_path;
InterpolatedPath():
header(),
label(""),
joint_names_length(0), joint_names(NULL),
interpolated_path_length(0), interpolated_path(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_label = strlen(this->label);
varToArr(outbuffer + offset, length_label);
offset += 4;
memcpy(outbuffer + offset, this->label, length_label);
offset += length_label;
*(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->interpolated_path_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->interpolated_path_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->interpolated_path_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->interpolated_path_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->interpolated_path_length);
for( uint32_t i = 0; i < interpolated_path_length; i++){
offset += this->interpolated_path[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_label;
arrToVar(length_label, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_label; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_label-1]=0;
this->label = (char *)(inbuffer + offset-1);
offset += length_label;
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 interpolated_path_lengthT = ((uint32_t) (*(inbuffer + offset)));
interpolated_path_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
interpolated_path_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
interpolated_path_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->interpolated_path_length);
if(interpolated_path_lengthT > interpolated_path_length)
this->interpolated_path = (intera_motion_msgs::WaypointSimple*)realloc(this->interpolated_path, interpolated_path_lengthT * sizeof(intera_motion_msgs::WaypointSimple));
interpolated_path_length = interpolated_path_lengthT;
for( uint32_t i = 0; i < interpolated_path_length; i++){
offset += this->st_interpolated_path.deserialize(inbuffer + offset);
memcpy( &(this->interpolated_path[i]), &(this->st_interpolated_path), sizeof(intera_motion_msgs::WaypointSimple));
}
return offset;
}
const char * getType(){ return "intera_motion_msgs/InterpolatedPath"; };
const char * getMD5(){ return "4e078bdc2ed88b86420f5b19cbd78219"; };
};
}
#endif
| 5,396 | C | 42.176 | 176 | 0.618977 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/TrajectoryAnalysis.h | #ifndef _ROS_intera_motion_msgs_TrajectoryAnalysis_h
#define _ROS_intera_motion_msgs_TrajectoryAnalysis_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace intera_motion_msgs
{
class TrajectoryAnalysis : public ros::Msg
{
public:
typedef double _planned_duration_type;
_planned_duration_type planned_duration;
typedef double _measured_duration_type;
_measured_duration_type measured_duration;
uint32_t min_angle_command_length;
typedef double _min_angle_command_type;
_min_angle_command_type st_min_angle_command;
_min_angle_command_type * min_angle_command;
uint32_t max_angle_command_length;
typedef double _max_angle_command_type;
_max_angle_command_type st_max_angle_command;
_max_angle_command_type * max_angle_command;
uint32_t peak_speed_command_length;
typedef double _peak_speed_command_type;
_peak_speed_command_type st_peak_speed_command;
_peak_speed_command_type * peak_speed_command;
uint32_t peak_accel_command_length;
typedef double _peak_accel_command_type;
_peak_accel_command_type st_peak_accel_command;
_peak_accel_command_type * peak_accel_command;
uint32_t peak_jerk_command_length;
typedef double _peak_jerk_command_type;
_peak_jerk_command_type st_peak_jerk_command;
_peak_jerk_command_type * peak_jerk_command;
typedef double _min_time_rate_type;
_min_time_rate_type min_time_rate;
typedef double _max_time_rate_type;
_max_time_rate_type max_time_rate;
uint32_t max_position_error_length;
typedef double _max_position_error_type;
_max_position_error_type st_max_position_error;
_max_position_error_type * max_position_error;
uint32_t max_velocity_error_length;
typedef double _max_velocity_error_type;
_max_velocity_error_type st_max_velocity_error;
_max_velocity_error_type * max_velocity_error;
TrajectoryAnalysis():
planned_duration(0),
measured_duration(0),
min_angle_command_length(0), min_angle_command(NULL),
max_angle_command_length(0), max_angle_command(NULL),
peak_speed_command_length(0), peak_speed_command(NULL),
peak_accel_command_length(0), peak_accel_command(NULL),
peak_jerk_command_length(0), peak_jerk_command(NULL),
min_time_rate(0),
max_time_rate(0),
max_position_error_length(0), max_position_error(NULL),
max_velocity_error_length(0), max_velocity_error(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_planned_duration;
u_planned_duration.real = this->planned_duration;
*(outbuffer + offset + 0) = (u_planned_duration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planned_duration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planned_duration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planned_duration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planned_duration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planned_duration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planned_duration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planned_duration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planned_duration);
union {
double real;
uint64_t base;
} u_measured_duration;
u_measured_duration.real = this->measured_duration;
*(outbuffer + offset + 0) = (u_measured_duration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_measured_duration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_measured_duration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_measured_duration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_measured_duration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_measured_duration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_measured_duration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_measured_duration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->measured_duration);
*(outbuffer + offset + 0) = (this->min_angle_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_angle_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_angle_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_angle_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_angle_command_length);
for( uint32_t i = 0; i < min_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_min_angle_commandi;
u_min_angle_commandi.real = this->min_angle_command[i];
*(outbuffer + offset + 0) = (u_min_angle_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_angle_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_angle_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_angle_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_angle_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_angle_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_angle_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_angle_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_angle_command[i]);
}
*(outbuffer + offset + 0) = (this->max_angle_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_angle_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_angle_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_angle_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_angle_command_length);
for( uint32_t i = 0; i < max_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_max_angle_commandi;
u_max_angle_commandi.real = this->max_angle_command[i];
*(outbuffer + offset + 0) = (u_max_angle_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_angle_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_angle_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_angle_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_angle_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_angle_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_angle_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_angle_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_angle_command[i]);
}
*(outbuffer + offset + 0) = (this->peak_speed_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->peak_speed_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->peak_speed_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->peak_speed_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->peak_speed_command_length);
for( uint32_t i = 0; i < peak_speed_command_length; i++){
union {
double real;
uint64_t base;
} u_peak_speed_commandi;
u_peak_speed_commandi.real = this->peak_speed_command[i];
*(outbuffer + offset + 0) = (u_peak_speed_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_peak_speed_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_peak_speed_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_peak_speed_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_peak_speed_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_peak_speed_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_peak_speed_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_peak_speed_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->peak_speed_command[i]);
}
*(outbuffer + offset + 0) = (this->peak_accel_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->peak_accel_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->peak_accel_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->peak_accel_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->peak_accel_command_length);
for( uint32_t i = 0; i < peak_accel_command_length; i++){
union {
double real;
uint64_t base;
} u_peak_accel_commandi;
u_peak_accel_commandi.real = this->peak_accel_command[i];
*(outbuffer + offset + 0) = (u_peak_accel_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_peak_accel_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_peak_accel_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_peak_accel_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_peak_accel_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_peak_accel_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_peak_accel_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_peak_accel_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->peak_accel_command[i]);
}
*(outbuffer + offset + 0) = (this->peak_jerk_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->peak_jerk_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->peak_jerk_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->peak_jerk_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->peak_jerk_command_length);
for( uint32_t i = 0; i < peak_jerk_command_length; i++){
union {
double real;
uint64_t base;
} u_peak_jerk_commandi;
u_peak_jerk_commandi.real = this->peak_jerk_command[i];
*(outbuffer + offset + 0) = (u_peak_jerk_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_peak_jerk_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_peak_jerk_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_peak_jerk_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_peak_jerk_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_peak_jerk_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_peak_jerk_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_peak_jerk_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->peak_jerk_command[i]);
}
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.real = this->min_time_rate;
*(outbuffer + offset + 0) = (u_min_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.real = this->max_time_rate;
*(outbuffer + offset + 0) = (u_max_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_time_rate);
*(outbuffer + offset + 0) = (this->max_position_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_position_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_position_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_position_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_position_error_length);
for( uint32_t i = 0; i < max_position_error_length; i++){
union {
double real;
uint64_t base;
} u_max_position_errori;
u_max_position_errori.real = this->max_position_error[i];
*(outbuffer + offset + 0) = (u_max_position_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_position_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_position_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_position_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_position_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_position_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_position_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_position_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_position_error[i]);
}
*(outbuffer + offset + 0) = (this->max_velocity_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_velocity_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_velocity_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_velocity_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_velocity_error_length);
for( uint32_t i = 0; i < max_velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_max_velocity_errori;
u_max_velocity_errori.real = this->max_velocity_error[i];
*(outbuffer + offset + 0) = (u_max_velocity_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity_error[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_planned_duration;
u_planned_duration.base = 0;
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planned_duration = u_planned_duration.real;
offset += sizeof(this->planned_duration);
union {
double real;
uint64_t base;
} u_measured_duration;
u_measured_duration.base = 0;
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->measured_duration = u_measured_duration.real;
offset += sizeof(this->measured_duration);
uint32_t min_angle_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
min_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
min_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
min_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_angle_command_length);
if(min_angle_command_lengthT > min_angle_command_length)
this->min_angle_command = (double*)realloc(this->min_angle_command, min_angle_command_lengthT * sizeof(double));
min_angle_command_length = min_angle_command_lengthT;
for( uint32_t i = 0; i < min_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_st_min_angle_command;
u_st_min_angle_command.base = 0;
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_min_angle_command = u_st_min_angle_command.real;
offset += sizeof(this->st_min_angle_command);
memcpy( &(this->min_angle_command[i]), &(this->st_min_angle_command), sizeof(double));
}
uint32_t max_angle_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_angle_command_length);
if(max_angle_command_lengthT > max_angle_command_length)
this->max_angle_command = (double*)realloc(this->max_angle_command, max_angle_command_lengthT * sizeof(double));
max_angle_command_length = max_angle_command_lengthT;
for( uint32_t i = 0; i < max_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_st_max_angle_command;
u_st_max_angle_command.base = 0;
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_angle_command = u_st_max_angle_command.real;
offset += sizeof(this->st_max_angle_command);
memcpy( &(this->max_angle_command[i]), &(this->st_max_angle_command), sizeof(double));
}
uint32_t peak_speed_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
peak_speed_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
peak_speed_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
peak_speed_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->peak_speed_command_length);
if(peak_speed_command_lengthT > peak_speed_command_length)
this->peak_speed_command = (double*)realloc(this->peak_speed_command, peak_speed_command_lengthT * sizeof(double));
peak_speed_command_length = peak_speed_command_lengthT;
for( uint32_t i = 0; i < peak_speed_command_length; i++){
union {
double real;
uint64_t base;
} u_st_peak_speed_command;
u_st_peak_speed_command.base = 0;
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_peak_speed_command = u_st_peak_speed_command.real;
offset += sizeof(this->st_peak_speed_command);
memcpy( &(this->peak_speed_command[i]), &(this->st_peak_speed_command), sizeof(double));
}
uint32_t peak_accel_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
peak_accel_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
peak_accel_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
peak_accel_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->peak_accel_command_length);
if(peak_accel_command_lengthT > peak_accel_command_length)
this->peak_accel_command = (double*)realloc(this->peak_accel_command, peak_accel_command_lengthT * sizeof(double));
peak_accel_command_length = peak_accel_command_lengthT;
for( uint32_t i = 0; i < peak_accel_command_length; i++){
union {
double real;
uint64_t base;
} u_st_peak_accel_command;
u_st_peak_accel_command.base = 0;
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_peak_accel_command = u_st_peak_accel_command.real;
offset += sizeof(this->st_peak_accel_command);
memcpy( &(this->peak_accel_command[i]), &(this->st_peak_accel_command), sizeof(double));
}
uint32_t peak_jerk_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
peak_jerk_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
peak_jerk_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
peak_jerk_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->peak_jerk_command_length);
if(peak_jerk_command_lengthT > peak_jerk_command_length)
this->peak_jerk_command = (double*)realloc(this->peak_jerk_command, peak_jerk_command_lengthT * sizeof(double));
peak_jerk_command_length = peak_jerk_command_lengthT;
for( uint32_t i = 0; i < peak_jerk_command_length; i++){
union {
double real;
uint64_t base;
} u_st_peak_jerk_command;
u_st_peak_jerk_command.base = 0;
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_peak_jerk_command = u_st_peak_jerk_command.real;
offset += sizeof(this->st_peak_jerk_command);
memcpy( &(this->peak_jerk_command[i]), &(this->st_peak_jerk_command), sizeof(double));
}
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.base = 0;
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_time_rate = u_min_time_rate.real;
offset += sizeof(this->min_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.base = 0;
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_time_rate = u_max_time_rate.real;
offset += sizeof(this->max_time_rate);
uint32_t max_position_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_position_error_length);
if(max_position_error_lengthT > max_position_error_length)
this->max_position_error = (double*)realloc(this->max_position_error, max_position_error_lengthT * sizeof(double));
max_position_error_length = max_position_error_lengthT;
for( uint32_t i = 0; i < max_position_error_length; i++){
union {
double real;
uint64_t base;
} u_st_max_position_error;
u_st_max_position_error.base = 0;
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_position_error = u_st_max_position_error.real;
offset += sizeof(this->st_max_position_error);
memcpy( &(this->max_position_error[i]), &(this->st_max_position_error), sizeof(double));
}
uint32_t max_velocity_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_velocity_error_length);
if(max_velocity_error_lengthT > max_velocity_error_length)
this->max_velocity_error = (double*)realloc(this->max_velocity_error, max_velocity_error_lengthT * sizeof(double));
max_velocity_error_length = max_velocity_error_lengthT;
for( uint32_t i = 0; i < max_velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_st_max_velocity_error;
u_st_max_velocity_error.base = 0;
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_velocity_error = u_st_max_velocity_error.real;
offset += sizeof(this->st_max_velocity_error);
memcpy( &(this->max_velocity_error[i]), &(this->st_max_velocity_error), sizeof(double));
}
return offset;
}
const char * getType(){ return "intera_motion_msgs/TrajectoryAnalysis"; };
const char * getMD5(){ return "f30ec541413b4eb2cecc0d0af7d30ad4"; };
};
}
#endif
| 31,539 | C | 58.397363 | 123 | 0.564476 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/WaypointSimple.h | #ifndef _ROS_intera_motion_msgs_WaypointSimple_h
#define _ROS_intera_motion_msgs_WaypointSimple_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace intera_motion_msgs
{
class WaypointSimple : public ros::Msg
{
public:
uint32_t joint_positions_length;
typedef double _joint_positions_type;
_joint_positions_type st_joint_positions;
_joint_positions_type * joint_positions;
typedef const char* _active_endpoint_type;
_active_endpoint_type active_endpoint;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef int32_t _segment_index_type;
_segment_index_type segment_index;
typedef double _time_type;
_time_type time;
WaypointSimple():
joint_positions_length(0), joint_positions(NULL),
active_endpoint(""),
pose(),
segment_index(0),
time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joint_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_positions_length);
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_joint_positionsi;
u_joint_positionsi.real = this->joint_positions[i];
*(outbuffer + offset + 0) = (u_joint_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_positions[i]);
}
uint32_t length_active_endpoint = strlen(this->active_endpoint);
varToArr(outbuffer + offset, length_active_endpoint);
offset += 4;
memcpy(outbuffer + offset, this->active_endpoint, length_active_endpoint);
offset += length_active_endpoint;
offset += this->pose.serialize(outbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_segment_index;
u_segment_index.real = this->segment_index;
*(outbuffer + offset + 0) = (u_segment_index.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_segment_index.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_segment_index.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_segment_index.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->segment_index);
union {
double real;
uint64_t base;
} u_time;
u_time.real = this->time;
*(outbuffer + offset + 0) = (u_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joint_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_positions_length);
if(joint_positions_lengthT > joint_positions_length)
this->joint_positions = (double*)realloc(this->joint_positions, joint_positions_lengthT * sizeof(double));
joint_positions_length = joint_positions_lengthT;
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_positions;
u_st_joint_positions.base = 0;
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_positions = u_st_joint_positions.real;
offset += sizeof(this->st_joint_positions);
memcpy( &(this->joint_positions[i]), &(this->st_joint_positions), sizeof(double));
}
uint32_t length_active_endpoint;
arrToVar(length_active_endpoint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_active_endpoint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_active_endpoint-1]=0;
this->active_endpoint = (char *)(inbuffer + offset-1);
offset += length_active_endpoint;
offset += this->pose.deserialize(inbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_segment_index;
u_segment_index.base = 0;
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->segment_index = u_segment_index.real;
offset += sizeof(this->segment_index);
union {
double real;
uint64_t base;
} u_time;
u_time.base = 0;
u_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time = u_time.real;
offset += sizeof(this->time);
return offset;
}
const char * getType(){ return "intera_motion_msgs/WaypointSimple"; };
const char * getMD5(){ return "f29bcd94cca5f378ef52eb965645d7ce"; };
};
}
#endif
| 7,564 | C | 43.5 | 114 | 0.562269 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/MotionStatus.h | #ifndef _ROS_intera_motion_msgs_MotionStatus_h
#define _ROS_intera_motion_msgs_MotionStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace intera_motion_msgs
{
class MotionStatus : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _motion_status_type;
_motion_status_type motion_status;
typedef const char* _current_trajectory_type;
_current_trajectory_type current_trajectory;
typedef uint32_t _current_waypoint_type;
_current_waypoint_type current_waypoint;
typedef uint32_t _motion_request_type;
_motion_request_type motion_request;
enum { MOTION_IDLE = idle };
enum { MOTION_PENDING = pending };
enum { MOTION_RUNNING = running };
enum { MOTION_STOPPING = stopping };
enum { MOTION_DONE = done };
enum { MOTION_PREEMPTED = preempted };
enum { MOTION_ERROR = error };
MotionStatus():
header(),
motion_status(""),
current_trajectory(""),
current_waypoint(0),
motion_request(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_motion_status = strlen(this->motion_status);
varToArr(outbuffer + offset, length_motion_status);
offset += 4;
memcpy(outbuffer + offset, this->motion_status, length_motion_status);
offset += length_motion_status;
uint32_t length_current_trajectory = strlen(this->current_trajectory);
varToArr(outbuffer + offset, length_current_trajectory);
offset += 4;
memcpy(outbuffer + offset, this->current_trajectory, length_current_trajectory);
offset += length_current_trajectory;
*(outbuffer + offset + 0) = (this->current_waypoint >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->current_waypoint >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->current_waypoint >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->current_waypoint >> (8 * 3)) & 0xFF;
offset += sizeof(this->current_waypoint);
*(outbuffer + offset + 0) = (this->motion_request >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->motion_request >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->motion_request >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->motion_request >> (8 * 3)) & 0xFF;
offset += sizeof(this->motion_request);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_motion_status;
arrToVar(length_motion_status, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_motion_status; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_motion_status-1]=0;
this->motion_status = (char *)(inbuffer + offset-1);
offset += length_motion_status;
uint32_t length_current_trajectory;
arrToVar(length_current_trajectory, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_current_trajectory; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_current_trajectory-1]=0;
this->current_trajectory = (char *)(inbuffer + offset-1);
offset += length_current_trajectory;
this->current_waypoint = ((uint32_t) (*(inbuffer + offset)));
this->current_waypoint |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->current_waypoint |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->current_waypoint |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->current_waypoint);
this->motion_request = ((uint32_t) (*(inbuffer + offset)));
this->motion_request |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->motion_request |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->motion_request |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->motion_request);
return offset;
}
const char * getType(){ return "intera_motion_msgs/MotionStatus"; };
const char * getMD5(){ return "178c2a9a52d756f9d73396be4ec1a07c"; };
};
}
#endif
| 4,448 | C | 38.723214 | 86 | 0.610612 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/shape_msgs/MeshTriangle.h | #ifndef _ROS_shape_msgs_MeshTriangle_h
#define _ROS_shape_msgs_MeshTriangle_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace shape_msgs
{
class MeshTriangle : public ros::Msg
{
public:
uint32_t vertex_indices[3];
MeshTriangle():
vertex_indices()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
for( uint32_t i = 0; i < 3; i++){
*(outbuffer + offset + 0) = (this->vertex_indices[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertex_indices[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertex_indices[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertex_indices[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertex_indices[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
for( uint32_t i = 0; i < 3; i++){
this->vertex_indices[i] = ((uint32_t) (*(inbuffer + offset)));
this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vertex_indices[i]);
}
return offset;
}
const char * getType(){ return "shape_msgs/MeshTriangle"; };
const char * getMD5(){ return "23688b2e6d2de3d32fe8af104a903253"; };
};
}
#endif
| 1,542 | C | 27.054545 | 84 | 0.559663 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/shape_msgs/SolidPrimitive.h | #ifndef _ROS_shape_msgs_SolidPrimitive_h
#define _ROS_shape_msgs_SolidPrimitive_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace shape_msgs
{
class SolidPrimitive : public ros::Msg
{
public:
typedef uint8_t _type_type;
_type_type type;
uint32_t dimensions_length;
typedef double _dimensions_type;
_dimensions_type st_dimensions;
_dimensions_type * dimensions;
enum { BOX = 1 };
enum { SPHERE = 2 };
enum { CYLINDER = 3 };
enum { CONE = 4 };
enum { BOX_X = 0 };
enum { BOX_Y = 1 };
enum { BOX_Z = 2 };
enum { SPHERE_RADIUS = 0 };
enum { CYLINDER_HEIGHT = 0 };
enum { CYLINDER_RADIUS = 1 };
enum { CONE_HEIGHT = 0 };
enum { CONE_RADIUS = 1 };
SolidPrimitive():
type(0),
dimensions_length(0), dimensions(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
offset += sizeof(this->type);
*(outbuffer + offset + 0) = (this->dimensions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->dimensions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->dimensions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->dimensions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->dimensions_length);
for( uint32_t i = 0; i < dimensions_length; i++){
union {
double real;
uint64_t base;
} u_dimensionsi;
u_dimensionsi.real = this->dimensions[i];
*(outbuffer + offset + 0) = (u_dimensionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dimensionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dimensionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dimensionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_dimensionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_dimensionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_dimensionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_dimensionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->dimensions[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->type);
uint32_t dimensions_lengthT = ((uint32_t) (*(inbuffer + offset)));
dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->dimensions_length);
if(dimensions_lengthT > dimensions_length)
this->dimensions = (double*)realloc(this->dimensions, dimensions_lengthT * sizeof(double));
dimensions_length = dimensions_lengthT;
for( uint32_t i = 0; i < dimensions_length; i++){
union {
double real;
uint64_t base;
} u_st_dimensions;
u_st_dimensions.base = 0;
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_dimensions = u_st_dimensions.real;
offset += sizeof(this->st_dimensions);
memcpy( &(this->dimensions[i]), &(this->st_dimensions), sizeof(double));
}
return offset;
}
const char * getType(){ return "shape_msgs/SolidPrimitive"; };
const char * getMD5(){ return "d8f8cbc74c5ff283fca29569ccefb45d"; };
};
}
#endif
| 4,239 | C | 37.545454 | 99 | 0.551309 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/shape_msgs/Mesh.h | #ifndef _ROS_shape_msgs_Mesh_h
#define _ROS_shape_msgs_Mesh_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "shape_msgs/MeshTriangle.h"
#include "geometry_msgs/Point.h"
namespace shape_msgs
{
class Mesh : public ros::Msg
{
public:
uint32_t triangles_length;
typedef shape_msgs::MeshTriangle _triangles_type;
_triangles_type st_triangles;
_triangles_type * triangles;
uint32_t vertices_length;
typedef geometry_msgs::Point _vertices_type;
_vertices_type st_vertices;
_vertices_type * vertices;
Mesh():
triangles_length(0), triangles(NULL),
vertices_length(0), vertices(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->triangles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->triangles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->triangles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->triangles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->triangles_length);
for( uint32_t i = 0; i < triangles_length; i++){
offset += this->triangles[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->vertices_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertices_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertices_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertices_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertices_length);
for( uint32_t i = 0; i < vertices_length; i++){
offset += this->vertices[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t triangles_lengthT = ((uint32_t) (*(inbuffer + offset)));
triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->triangles_length);
if(triangles_lengthT > triangles_length)
this->triangles = (shape_msgs::MeshTriangle*)realloc(this->triangles, triangles_lengthT * sizeof(shape_msgs::MeshTriangle));
triangles_length = triangles_lengthT;
for( uint32_t i = 0; i < triangles_length; i++){
offset += this->st_triangles.deserialize(inbuffer + offset);
memcpy( &(this->triangles[i]), &(this->st_triangles), sizeof(shape_msgs::MeshTriangle));
}
uint32_t vertices_lengthT = ((uint32_t) (*(inbuffer + offset)));
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vertices_length);
if(vertices_lengthT > vertices_length)
this->vertices = (geometry_msgs::Point*)realloc(this->vertices, vertices_lengthT * sizeof(geometry_msgs::Point));
vertices_length = vertices_lengthT;
for( uint32_t i = 0; i < vertices_length; i++){
offset += this->st_vertices.deserialize(inbuffer + offset);
memcpy( &(this->vertices[i]), &(this->st_vertices), sizeof(geometry_msgs::Point));
}
return offset;
}
const char * getType(){ return "shape_msgs/Mesh"; };
const char * getMD5(){ return "1ffdae9486cd3316a121c578b47a85cc"; };
};
}
#endif
| 3,642 | C | 39.032967 | 132 | 0.598298 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxList.h | #ifndef _ROS_SERVICE_DemuxList_h
#define _ROS_SERVICE_DemuxList_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXLIST[] = "topic_tools/DemuxList";
class DemuxListRequest : public ros::Msg
{
public:
DemuxListRequest()
{
}
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 DEMUXLIST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DemuxListResponse : public ros::Msg
{
public:
uint32_t topics_length;
typedef char* _topics_type;
_topics_type st_topics;
_topics_type * topics;
DemuxListResponse():
topics_length(0), topics(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->topics_length);
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_topicsi = strlen(this->topics[i]);
varToArr(outbuffer + offset, length_topicsi);
offset += 4;
memcpy(outbuffer + offset, this->topics[i], length_topicsi);
offset += length_topicsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->topics_length);
if(topics_lengthT > topics_length)
this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
topics_length = topics_lengthT;
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_st_topics;
arrToVar(length_st_topics, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_topics; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_topics-1]=0;
this->st_topics = (char *)(inbuffer + offset-1);
offset += length_st_topics;
memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
}
return offset;
}
const char * getType(){ return DEMUXLIST; };
const char * getMD5(){ return "b0eef9a05d4e829092fc2f2c3c2aad3d"; };
};
class DemuxList {
public:
typedef DemuxListRequest Request;
typedef DemuxListResponse Response;
};
}
#endif
| 3,042 | C | 27.175926 | 85 | 0.592373 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxAdd.h | #ifndef _ROS_SERVICE_DemuxAdd_h
#define _ROS_SERVICE_DemuxAdd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXADD[] = "topic_tools/DemuxAdd";
class DemuxAddRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
DemuxAddRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return DEMUXADD; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class DemuxAddResponse : public ros::Msg
{
public:
DemuxAddResponse()
{
}
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 DEMUXADD; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DemuxAdd {
public:
typedef DemuxAddRequest Request;
typedef DemuxAddResponse Response;
};
}
#endif
| 1,861 | C | 20.159091 | 72 | 0.61741 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/MuxAdd.h | #ifndef _ROS_SERVICE_MuxAdd_h
#define _ROS_SERVICE_MuxAdd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXADD[] = "topic_tools/MuxAdd";
class MuxAddRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
MuxAddRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return MUXADD; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class MuxAddResponse : public ros::Msg
{
public:
MuxAddResponse()
{
}
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 MUXADD; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class MuxAdd {
public:
typedef MuxAddRequest Request;
typedef MuxAddResponse Response;
};
}
#endif
| 1,835 | C | 19.863636 | 72 | 0.611989 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxSelect.h | #ifndef _ROS_SERVICE_DemuxSelect_h
#define _ROS_SERVICE_DemuxSelect_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXSELECT[] = "topic_tools/DemuxSelect";
class DemuxSelectRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
DemuxSelectRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return DEMUXSELECT; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class DemuxSelectResponse : public ros::Msg
{
public:
typedef const char* _prev_topic_type;
_prev_topic_type prev_topic;
DemuxSelectResponse():
prev_topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_prev_topic = strlen(this->prev_topic);
varToArr(outbuffer + offset, length_prev_topic);
offset += 4;
memcpy(outbuffer + offset, this->prev_topic, length_prev_topic);
offset += length_prev_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_prev_topic;
arrToVar(length_prev_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_prev_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_prev_topic-1]=0;
this->prev_topic = (char *)(inbuffer + offset-1);
offset += length_prev_topic;
return offset;
}
const char * getType(){ return DEMUXSELECT; };
const char * getMD5(){ return "3db0a473debdbafea387c9e49358c320"; };
};
class DemuxSelect {
public:
typedef DemuxSelectRequest Request;
typedef DemuxSelectResponse Response;
};
}
#endif
| 2,602 | C | 23.790476 | 72 | 0.621445 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxDelete.h | #ifndef _ROS_SERVICE_DemuxDelete_h
#define _ROS_SERVICE_DemuxDelete_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXDELETE[] = "topic_tools/DemuxDelete";
class DemuxDeleteRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
DemuxDeleteRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return DEMUXDELETE; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class DemuxDeleteResponse : public ros::Msg
{
public:
DemuxDeleteResponse()
{
}
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 DEMUXDELETE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DemuxDelete {
public:
typedef DemuxDeleteRequest Request;
typedef DemuxDeleteResponse Response;
};
}
#endif
| 1,900 | C | 20.602272 | 72 | 0.625263 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/IMUdata.h | #ifndef _ROS_mini_ros_IMUdata_h
#define _ROS_mini_ros_IMUdata_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class IMUdata : public ros::Msg
{
public:
typedef float _roll_type;
_roll_type roll;
typedef float _pitch_type;
_pitch_type pitch;
typedef float _acc_x_type;
_acc_x_type acc_x;
typedef float _acc_y_type;
_acc_y_type acc_y;
typedef float _acc_z_type;
_acc_z_type acc_z;
typedef float _gyro_x_type;
_gyro_x_type gyro_x;
typedef float _gyro_y_type;
_gyro_y_type gyro_y;
typedef float _gyro_z_type;
_gyro_z_type gyro_z;
IMUdata():
roll(0),
pitch(0),
acc_x(0),
acc_y(0),
acc_z(0),
gyro_x(0),
gyro_y(0),
gyro_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
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_acc_x;
u_acc_x.real = this->acc_x;
*(outbuffer + offset + 0) = (u_acc_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acc_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acc_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acc_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->acc_x);
union {
float real;
uint32_t base;
} u_acc_y;
u_acc_y.real = this->acc_y;
*(outbuffer + offset + 0) = (u_acc_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acc_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acc_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acc_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->acc_y);
union {
float real;
uint32_t base;
} u_acc_z;
u_acc_z.real = this->acc_z;
*(outbuffer + offset + 0) = (u_acc_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acc_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acc_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acc_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->acc_z);
union {
float real;
uint32_t base;
} u_gyro_x;
u_gyro_x.real = this->gyro_x;
*(outbuffer + offset + 0) = (u_gyro_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gyro_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gyro_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gyro_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->gyro_x);
union {
float real;
uint32_t base;
} u_gyro_y;
u_gyro_y.real = this->gyro_y;
*(outbuffer + offset + 0) = (u_gyro_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gyro_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gyro_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gyro_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->gyro_y);
union {
float real;
uint32_t base;
} u_gyro_z;
u_gyro_z.real = this->gyro_z;
*(outbuffer + offset + 0) = (u_gyro_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gyro_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gyro_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gyro_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->gyro_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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_acc_x;
u_acc_x.base = 0;
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->acc_x = u_acc_x.real;
offset += sizeof(this->acc_x);
union {
float real;
uint32_t base;
} u_acc_y;
u_acc_y.base = 0;
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->acc_y = u_acc_y.real;
offset += sizeof(this->acc_y);
union {
float real;
uint32_t base;
} u_acc_z;
u_acc_z.base = 0;
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->acc_z = u_acc_z.real;
offset += sizeof(this->acc_z);
union {
float real;
uint32_t base;
} u_gyro_x;
u_gyro_x.base = 0;
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->gyro_x = u_gyro_x.real;
offset += sizeof(this->gyro_x);
union {
float real;
uint32_t base;
} u_gyro_y;
u_gyro_y.base = 0;
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->gyro_y = u_gyro_y.real;
offset += sizeof(this->gyro_y);
union {
float real;
uint32_t base;
} u_gyro_z;
u_gyro_z.base = 0;
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->gyro_z = u_gyro_z.real;
offset += sizeof(this->gyro_z);
return offset;
}
const char * getType(){ return "mini_ros/IMUdata"; };
const char * getMD5(){ return "3a27cb61fd87ce5110e1d6a4a68a0126"; };
};
}
#endif
| 8,306 | C | 34.961039 | 74 | 0.476884 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/CalibServo.h | #ifndef _ROS_SERVICE_CalibServo_h
#define _ROS_SERVICE_CalibServo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
static const char CALIBSERVO[] = "mini_ros/CalibServo";
class CalibServoRequest : public ros::Msg
{
public:
typedef int8_t _servo_num_type;
_servo_num_type servo_num;
typedef int32_t _servo_pulse_type;
_servo_pulse_type servo_pulse;
CalibServoRequest():
servo_num(0),
servo_pulse(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.real = this->servo_num;
*(outbuffer + offset + 0) = (u_servo_num.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.real = this->servo_pulse;
*(outbuffer + offset + 0) = (u_servo_pulse.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_servo_pulse.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_servo_pulse.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_servo_pulse.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->servo_pulse);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.base = 0;
u_servo_num.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->servo_num = u_servo_num.real;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.base = 0;
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->servo_pulse = u_servo_pulse.real;
offset += sizeof(this->servo_pulse);
return offset;
}
const char * getType(){ return CALIBSERVO; };
const char * getMD5(){ return "372c64510294fc8eec78b728b048d2c9"; };
};
class CalibServoResponse : public ros::Msg
{
public:
typedef const char* _Response_type;
_Response_type Response;
CalibServoResponse():
Response("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_Response = strlen(this->Response);
varToArr(outbuffer + offset, length_Response);
offset += 4;
memcpy(outbuffer + offset, this->Response, length_Response);
offset += length_Response;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_Response;
arrToVar(length_Response, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_Response; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_Response-1]=0;
this->Response = (char *)(inbuffer + offset-1);
offset += length_Response;
return offset;
}
const char * getType(){ return CALIBSERVO; };
const char * getMD5(){ return "e9ca8778f2b24ad03f8213b9fe82be44"; };
};
class CalibServo {
public:
typedef CalibServoRequest Request;
typedef CalibServoResponse Response;
};
}
#endif
| 3,607 | C | 26.753846 | 79 | 0.578043 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JointPulse.h | #ifndef _ROS_mini_ros_JointPulse_h
#define _ROS_mini_ros_JointPulse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JointPulse : public ros::Msg
{
public:
typedef int8_t _servo_num_type;
_servo_num_type servo_num;
typedef int32_t _servo_pulse_type;
_servo_pulse_type servo_pulse;
JointPulse():
servo_num(0),
servo_pulse(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.real = this->servo_num;
*(outbuffer + offset + 0) = (u_servo_num.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.real = this->servo_pulse;
*(outbuffer + offset + 0) = (u_servo_pulse.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_servo_pulse.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_servo_pulse.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_servo_pulse.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->servo_pulse);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.base = 0;
u_servo_num.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->servo_num = u_servo_num.real;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.base = 0;
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->servo_pulse = u_servo_pulse.real;
offset += sizeof(this->servo_pulse);
return offset;
}
const char * getType(){ return "mini_ros/JointPulse"; };
const char * getMD5(){ return "372c64510294fc8eec78b728b048d2c9"; };
};
}
#endif
| 2,309 | C | 27.518518 | 79 | 0.547423 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/ContactData.h | #ifndef _ROS_mini_ros_ContactData_h
#define _ROS_mini_ros_ContactData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class ContactData : public ros::Msg
{
public:
typedef bool _FL_type;
_FL_type FL;
typedef bool _FR_type;
_FR_type FR;
typedef bool _BL_type;
_BL_type BL;
typedef bool _BR_type;
_BR_type BR;
ContactData():
FL(0),
FR(0),
BL(0),
BR(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_FL;
u_FL.real = this->FL;
*(outbuffer + offset + 0) = (u_FL.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->FL);
union {
bool real;
uint8_t base;
} u_FR;
u_FR.real = this->FR;
*(outbuffer + offset + 0) = (u_FR.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->FR);
union {
bool real;
uint8_t base;
} u_BL;
u_BL.real = this->BL;
*(outbuffer + offset + 0) = (u_BL.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->BL);
union {
bool real;
uint8_t base;
} u_BR;
u_BR.real = this->BR;
*(outbuffer + offset + 0) = (u_BR.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->BR);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_FL;
u_FL.base = 0;
u_FL.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->FL = u_FL.real;
offset += sizeof(this->FL);
union {
bool real;
uint8_t base;
} u_FR;
u_FR.base = 0;
u_FR.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->FR = u_FR.real;
offset += sizeof(this->FR);
union {
bool real;
uint8_t base;
} u_BL;
u_BL.base = 0;
u_BL.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->BL = u_BL.real;
offset += sizeof(this->BL);
union {
bool real;
uint8_t base;
} u_BR;
u_BR.base = 0;
u_BR.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->BR = u_BR.real;
offset += sizeof(this->BR);
return offset;
}
const char * getType(){ return "mini_ros/ContactData"; };
const char * getMD5(){ return "e1e8fe4de4334f7698a7f305ee06dce8"; };
};
}
#endif
| 2,552 | C | 22 | 72 | 0.484718 |