file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/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/SingleJointPositionActionResult.h | #ifndef _ROS_control_msgs_SingleJointPositionActionResult_h
#define _ROS_control_msgs_SingleJointPositionActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/SingleJointPositionResult.h"
namespace control_msgs
{
class SingleJointPositionActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::SingleJointPositionResult _result_type;
_result_type result;
SingleJointPositionActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionActionResult"; };
const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
};
}
#endif
| 1,532 | C | 25.894736 | 85 | 0.682115 |
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/PointHeadActionGoal.h | #ifndef _ROS_control_msgs_PointHeadActionGoal_h
#define _ROS_control_msgs_PointHeadActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/PointHeadGoal.h"
namespace control_msgs
{
class PointHeadActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::PointHeadGoal _goal_type;
_goal_type goal;
PointHeadActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadActionGoal"; };
const char * getMD5(){ return "b53a8323d0ba7b310ba17a2d3a82a6b8"; };
};
}
#endif
| 1,434 | C | 24.175438 | 73 | 0.656206 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandActionFeedback.h | #ifndef _ROS_control_msgs_GripperCommandActionFeedback_h
#define _ROS_control_msgs_GripperCommandActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/GripperCommandFeedback.h"
namespace control_msgs
{
class GripperCommandActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::GripperCommandFeedback _feedback_type;
_feedback_type feedback;
GripperCommandActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandActionFeedback"; };
const char * getMD5(){ return "653dff30c045f5e6ff3feb3409f4558d"; };
};
}
#endif
| 1,523 | C | 25.736842 | 82 | 0.680236 |
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/FollowJointTrajectoryActionResult.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryActionResult_h
#define _ROS_control_msgs_FollowJointTrajectoryActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/FollowJointTrajectoryResult.h"
namespace control_msgs
{
class FollowJointTrajectoryActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::FollowJointTrajectoryResult _result_type;
_result_type result;
FollowJointTrajectoryActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryActionResult"; };
const char * getMD5(){ return "c4fb3b000dc9da4fd99699380efcc5d9"; };
};
}
#endif
| 1,546 | C | 26.14035 | 87 | 0.684994 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryGoal.h | #ifndef _ROS_control_msgs_JointTrajectoryGoal_h
#define _ROS_control_msgs_JointTrajectoryGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
namespace control_msgs
{
class JointTrajectoryGoal : public ros::Msg
{
public:
typedef trajectory_msgs::JointTrajectory _trajectory_type;
_trajectory_type trajectory;
JointTrajectoryGoal():
trajectory()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryGoal"; };
const char * getMD5(){ return "2a0eff76c870e8595636c2a562ca298e"; };
};
}
#endif
| 986 | C | 20.933333 | 73 | 0.676471 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryActionGoal.h | #ifndef _ROS_control_msgs_JointTrajectoryActionGoal_h
#define _ROS_control_msgs_JointTrajectoryActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/JointTrajectoryGoal.h"
namespace control_msgs
{
class JointTrajectoryActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::JointTrajectoryGoal _goal_type;
_goal_type goal;
JointTrajectoryActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryActionGoal"; };
const char * getMD5(){ return "a99e83ef6185f9fdd7693efe99623a86"; };
};
}
#endif
| 1,476 | C | 24.91228 | 79 | 0.665989 |
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/PointHeadActionFeedback.h | #ifndef _ROS_control_msgs_PointHeadActionFeedback_h
#define _ROS_control_msgs_PointHeadActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/PointHeadFeedback.h"
namespace control_msgs
{
class PointHeadActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::PointHeadFeedback _feedback_type;
_feedback_type feedback;
PointHeadActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadActionFeedback"; };
const char * getMD5(){ return "33c9244957176bbba97dd641119e8460"; };
};
}
#endif
| 1,488 | C | 25.122807 | 77 | 0.672715 |
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/SingleJointPositionActionGoal.h | #ifndef _ROS_control_msgs_SingleJointPositionActionGoal_h
#define _ROS_control_msgs_SingleJointPositionActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/SingleJointPositionGoal.h"
namespace control_msgs
{
class SingleJointPositionActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::SingleJointPositionGoal _goal_type;
_goal_type goal;
SingleJointPositionActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionActionGoal"; };
const char * getMD5(){ return "4b0d3d091471663e17749c1d0db90f61"; };
};
}
#endif
| 1,504 | C | 25.403508 | 83 | 0.672207 |
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/PointHeadResult.h | #ifndef _ROS_control_msgs_PointHeadResult_h
#define _ROS_control_msgs_PointHeadResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class PointHeadResult : public ros::Msg
{
public:
PointHeadResult()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/PointHeadResult"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 672 | C | 16.25641 | 72 | 0.650298 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryActionResult.h | #ifndef _ROS_control_msgs_JointTrajectoryActionResult_h
#define _ROS_control_msgs_JointTrajectoryActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/JointTrajectoryResult.h"
namespace control_msgs
{
class JointTrajectoryActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::JointTrajectoryResult _result_type;
_result_type result;
JointTrajectoryActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryActionResult"; };
const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
};
}
#endif
| 1,504 | C | 25.403508 | 81 | 0.676197 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionActionFeedback.h | #ifndef _ROS_control_msgs_SingleJointPositionActionFeedback_h
#define _ROS_control_msgs_SingleJointPositionActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/SingleJointPositionFeedback.h"
namespace control_msgs
{
class SingleJointPositionActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::SingleJointPositionFeedback _feedback_type;
_feedback_type feedback;
SingleJointPositionActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionActionFeedback"; };
const char * getMD5(){ return "3503b7cf8972f90d245850a5d8796cfa"; };
};
}
#endif
| 1,558 | C | 26.350877 | 87 | 0.68742 |
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/JointTrajectoryResult.h | #ifndef _ROS_control_msgs_JointTrajectoryResult_h
#define _ROS_control_msgs_JointTrajectoryResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class JointTrajectoryResult : public ros::Msg
{
public:
JointTrajectoryResult()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryResult"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 702 | C | 17.025641 | 75 | 0.665242 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryActionFeedback.h | #ifndef _ROS_control_msgs_JointTrajectoryActionFeedback_h
#define _ROS_control_msgs_JointTrajectoryActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/JointTrajectoryFeedback.h"
namespace control_msgs
{
class JointTrajectoryActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::JointTrajectoryFeedback _feedback_type;
_feedback_type feedback;
JointTrajectoryActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
| 1,530 | C | 25.859649 | 83 | 0.681699 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryFeedback.h | #ifndef _ROS_control_msgs_JointTrajectoryFeedback_h
#define _ROS_control_msgs_JointTrajectoryFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class JointTrajectoryFeedback : public ros::Msg
{
public:
JointTrajectoryFeedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 712 | C | 17.282051 | 77 | 0.669944 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandActionGoal.h | #ifndef _ROS_control_msgs_GripperCommandActionGoal_h
#define _ROS_control_msgs_GripperCommandActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/GripperCommandGoal.h"
namespace control_msgs
{
class GripperCommandActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::GripperCommandGoal _goal_type;
_goal_type goal;
GripperCommandActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandActionGoal"; };
const char * getMD5(){ return "aa581f648a35ed681db2ec0bf7a82bea"; };
};
}
#endif
| 1,469 | C | 24.789473 | 78 | 0.664398 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionResult.h | #ifndef _ROS_control_msgs_SingleJointPositionResult_h
#define _ROS_control_msgs_SingleJointPositionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class SingleJointPositionResult : public ros::Msg
{
public:
SingleJointPositionResult()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionResult"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 722 | C | 17.538461 | 79 | 0.674515 |
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/control_msgs/FollowJointTrajectoryFeedback.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryFeedback_h
#define _ROS_control_msgs_FollowJointTrajectoryFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "trajectory_msgs/JointTrajectoryPoint.h"
namespace control_msgs
{
class FollowJointTrajectoryFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
typedef trajectory_msgs::JointTrajectoryPoint _desired_type;
_desired_type desired;
typedef trajectory_msgs::JointTrajectoryPoint _actual_type;
_actual_type actual;
typedef trajectory_msgs::JointTrajectoryPoint _error_type;
_error_type error;
FollowJointTrajectoryFeedback():
header(),
joint_names_length(0), joint_names(NULL),
desired(),
actual(),
error()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
offset += this->desired.serialize(outbuffer + offset);
offset += this->actual.serialize(outbuffer + offset);
offset += this->error.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
offset += this->desired.deserialize(inbuffer + offset);
offset += this->actual.deserialize(inbuffer + offset);
offset += this->error.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryFeedback"; };
const char * getMD5(){ return "10817c60c2486ef6b33e97dcd87f4474"; };
};
}
#endif
| 3,715 | C | 36.918367 | 100 | 0.628264 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandActionResult.h | #ifndef _ROS_control_msgs_GripperCommandActionResult_h
#define _ROS_control_msgs_GripperCommandActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/GripperCommandResult.h"
namespace control_msgs
{
class GripperCommandActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::GripperCommandResult _result_type;
_result_type result;
GripperCommandActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandActionResult"; };
const char * getMD5(){ return "143702cb2df0f163c5283cedc5efc6b6"; };
};
}
#endif
| 1,497 | C | 25.280701 | 80 | 0.674683 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadActionResult.h | #ifndef _ROS_control_msgs_PointHeadActionResult_h
#define _ROS_control_msgs_PointHeadActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/PointHeadResult.h"
namespace control_msgs
{
class PointHeadActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::PointHeadResult _result_type;
_result_type result;
PointHeadActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadActionResult"; };
const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
};
}
#endif
| 1,462 | C | 24.666666 | 75 | 0.666895 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryActionFeedback.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryActionFeedback_h
#define _ROS_control_msgs_FollowJointTrajectoryActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/FollowJointTrajectoryFeedback.h"
namespace control_msgs
{
class FollowJointTrajectoryActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::FollowJointTrajectoryFeedback _feedback_type;
_feedback_type feedback;
FollowJointTrajectoryActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryActionFeedback"; };
const char * getMD5(){ return "d8920dc4eae9fc107e00999cce4be641"; };
};
}
#endif
| 1,572 | C | 26.596491 | 89 | 0.690204 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryActionGoal.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryActionGoal_h
#define _ROS_control_msgs_FollowJointTrajectoryActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/FollowJointTrajectoryGoal.h"
namespace control_msgs
{
class FollowJointTrajectoryActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::FollowJointTrajectoryGoal _goal_type;
_goal_type goal;
FollowJointTrajectoryActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryActionGoal"; };
const char * getMD5(){ return "cff5c1d533bf2f82dd0138d57f4304bb"; };
};
}
#endif
| 1,518 | C | 25.649122 | 85 | 0.675231 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandResult.h | #ifndef _ROS_control_msgs_GripperCommandResult_h
#define _ROS_control_msgs_GripperCommandResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class GripperCommandResult : 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;
GripperCommandResult():
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/GripperCommandResult"; };
const char * getMD5(){ return "e4cbff56d3562bcf113da5a5adeef91f"; };
};
}
#endif
| 5,050 | C | 35.338129 | 79 | 0.525941 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeActionFeedback.h | #ifndef _ROS_turtle_actionlib_ShapeActionFeedback_h
#define _ROS_turtle_actionlib_ShapeActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "turtle_actionlib/ShapeFeedback.h"
namespace turtle_actionlib
{
class ShapeActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtle_actionlib::ShapeFeedback _feedback_type;
_feedback_type feedback;
ShapeActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "turtle_actionlib/ShapeActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
| 1,484 | C | 25.052631 | 77 | 0.671833 |
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/ShapeFeedback.h | #ifndef _ROS_turtle_actionlib_ShapeFeedback_h
#define _ROS_turtle_actionlib_ShapeFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class ShapeFeedback : public ros::Msg
{
public:
ShapeFeedback()
{
}
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 "turtle_actionlib/ShapeFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 678 | C | 16.410256 | 72 | 0.653392 |
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/ShapeActionGoal.h | #ifndef _ROS_turtle_actionlib_ShapeActionGoal_h
#define _ROS_turtle_actionlib_ShapeActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "turtle_actionlib/ShapeGoal.h"
namespace turtle_actionlib
{
class ShapeActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef turtle_actionlib::ShapeGoal _goal_type;
_goal_type goal;
ShapeActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "turtle_actionlib/ShapeActionGoal"; };
const char * getMD5(){ return "dbfccd187f2ec9c593916447ffd6cc77"; };
};
}
#endif
| 1,430 | C | 24.105263 | 73 | 0.655245 |
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/turtle_actionlib/ShapeActionResult.h | #ifndef _ROS_turtle_actionlib_ShapeActionResult_h
#define _ROS_turtle_actionlib_ShapeActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "turtle_actionlib/ShapeResult.h"
namespace turtle_actionlib
{
class ShapeActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtle_actionlib::ShapeResult _result_type;
_result_type result;
ShapeActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "turtle_actionlib/ShapeActionResult"; };
const char * getMD5(){ return "c8d13d5d140f1047a2e4d3bf5c045822"; };
};
}
#endif
| 1,458 | C | 24.596491 | 75 | 0.665981 |
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/trajectory_msgs/JointTrajectory.h | #ifndef _ROS_trajectory_msgs_JointTrajectory_h
#define _ROS_trajectory_msgs_JointTrajectory_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 trajectory_msgs
{
class JointTrajectory : 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::JointTrajectoryPoint _points_type;
_points_type st_points;
_points_type * points;
JointTrajectory():
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::JointTrajectoryPoint*)realloc(this->points, points_lengthT * sizeof(trajectory_msgs::JointTrajectoryPoint));
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::JointTrajectoryPoint));
}
return offset;
}
const char * getType(){ return "trajectory_msgs/JointTrajectory"; };
const char * getMD5(){ return "65b4f94a94d1ed67169da35a02f33d3f"; };
};
}
#endif
| 4,431 | C | 40.037037 | 149 | 0.603024 |
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/Plane.h | #ifndef _ROS_shape_msgs_Plane_h
#define _ROS_shape_msgs_Plane_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace shape_msgs
{
class Plane : public ros::Msg
{
public:
double coef[4];
Plane():
coef()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
for( uint32_t i = 0; i < 4; i++){
union {
double real;
uint64_t base;
} u_coefi;
u_coefi.real = this->coef[i];
*(outbuffer + offset + 0) = (u_coefi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_coefi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_coefi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_coefi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_coefi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_coefi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_coefi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_coefi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->coef[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
for( uint32_t i = 0; i < 4; i++){
union {
double real;
uint64_t base;
} u_coefi;
u_coefi.base = 0;
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->coef[i] = u_coefi.real;
offset += sizeof(this->coef[i]);
}
return offset;
}
const char * getType(){ return "shape_msgs/Plane"; };
const char * getMD5(){ return "2c1b92ed8f31492f8e73f6a4a44ca796"; };
};
}
#endif
| 2,206 | C | 28.824324 | 73 | 0.501813 |
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/MuxList.h | #ifndef _ROS_SERVICE_MuxList_h
#define _ROS_SERVICE_MuxList_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXLIST[] = "topic_tools/MuxList";
class MuxListRequest : public ros::Msg
{
public:
MuxListRequest()
{
}
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 MUXLIST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class MuxListResponse : public ros::Msg
{
public:
uint32_t topics_length;
typedef char* _topics_type;
_topics_type st_topics;
_topics_type * topics;
MuxListResponse():
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 MUXLIST; };
const char * getMD5(){ return "b0eef9a05d4e829092fc2f2c3c2aad3d"; };
};
class MuxList {
public:
typedef MuxListRequest Request;
typedef MuxListResponse Response;
};
}
#endif
| 3,016 | C | 26.935185 | 85 | 0.588859 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/MuxSelect.h | #ifndef _ROS_SERVICE_MuxSelect_h
#define _ROS_SERVICE_MuxSelect_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXSELECT[] = "topic_tools/MuxSelect";
class MuxSelectRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
MuxSelectRequest():
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 MUXSELECT; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class MuxSelectResponse : public ros::Msg
{
public:
typedef const char* _prev_topic_type;
_prev_topic_type prev_topic;
MuxSelectResponse():
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 MUXSELECT; };
const char * getMD5(){ return "3db0a473debdbafea387c9e49358c320"; };
};
class MuxSelect {
public:
typedef MuxSelectRequest Request;
typedef MuxSelectResponse Response;
};
}
#endif
| 2,576 | C | 23.542857 | 72 | 0.617624 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/MuxDelete.h | #ifndef _ROS_SERVICE_MuxDelete_h
#define _ROS_SERVICE_MuxDelete_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXDELETE[] = "topic_tools/MuxDelete";
class MuxDeleteRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
MuxDeleteRequest():
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 MUXDELETE; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class MuxDeleteResponse : public ros::Msg
{
public:
MuxDeleteResponse()
{
}
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 MUXDELETE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class MuxDelete {
public:
typedef MuxDeleteRequest Request;
typedef MuxDeleteResponse Response;
};
}
#endif
| 1,874 | C | 20.306818 | 72 | 0.620064 |
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/BezierData.h | #ifndef _ROS_mini_ros_BezierData_h
#define _ROS_mini_ros_BezierData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class BezierData : public ros::Msg
{
public:
typedef const char* _Leg_type;
_Leg_type Leg;
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _z_type;
_z_type z;
BezierData():
Leg(""),
x(0),
y(0),
z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_Leg = strlen(this->Leg);
varToArr(outbuffer + offset, length_Leg);
offset += 4;
memcpy(outbuffer + offset, this->Leg, length_Leg);
offset += length_Leg;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_Leg;
arrToVar(length_Leg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_Leg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_Leg-1]=0;
this->Leg = (char *)(inbuffer + offset-1);
offset += length_Leg;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->z = u_z.real;
offset += sizeof(this->z);
return offset;
}
const char * getType(){ return "mini_ros/BezierData"; };
const char * getMD5(){ return "edd64deddffdf794edd8b839043b5d4e"; };
};
}
#endif
| 3,837 | C | 28.984375 | 72 | 0.482408 |
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 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JoyButtons.h | #ifndef _ROS_mini_ros_JoyButtons_h
#define _ROS_mini_ros_JoyButtons_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JoyButtons : public ros::Msg
{
public:
typedef int8_t _updown_type;
_updown_type updown;
typedef int8_t _leftright_type;
_leftright_type leftright;
typedef int8_t _left_bump_type;
_left_bump_type left_bump;
typedef int8_t _right_bump_type;
_right_bump_type right_bump;
JoyButtons():
updown(0),
leftright(0),
left_bump(0),
right_bump(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_updown;
u_updown.real = this->updown;
*(outbuffer + offset + 0) = (u_updown.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->updown);
union {
int8_t real;
uint8_t base;
} u_leftright;
u_leftright.real = this->leftright;
*(outbuffer + offset + 0) = (u_leftright.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->leftright);
union {
int8_t real;
uint8_t base;
} u_left_bump;
u_left_bump.real = this->left_bump;
*(outbuffer + offset + 0) = (u_left_bump.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->left_bump);
union {
int8_t real;
uint8_t base;
} u_right_bump;
u_right_bump.real = this->right_bump;
*(outbuffer + offset + 0) = (u_right_bump.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->right_bump);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_updown;
u_updown.base = 0;
u_updown.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->updown = u_updown.real;
offset += sizeof(this->updown);
union {
int8_t real;
uint8_t base;
} u_leftright;
u_leftright.base = 0;
u_leftright.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->leftright = u_leftright.real;
offset += sizeof(this->leftright);
union {
int8_t real;
uint8_t base;
} u_left_bump;
u_left_bump.base = 0;
u_left_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->left_bump = u_left_bump.real;
offset += sizeof(this->left_bump);
union {
int8_t real;
uint8_t base;
} u_right_bump;
u_right_bump.base = 0;
u_right_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->right_bump = u_right_bump.real;
offset += sizeof(this->right_bump);
return offset;
}
const char * getType(){ return "mini_ros/JoyButtons"; };
const char * getMD5(){ return "be1de48c3b52ec87587be0e78c2cb8cd"; };
};
}
#endif
| 2,961 | C | 25.684684 | 77 | 0.541709 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/MiniCmd.h | #ifndef _ROS_mini_ros_MiniCmd_h
#define _ROS_mini_ros_MiniCmd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class MiniCmd : public ros::Msg
{
public:
typedef const char* _motion_type;
_motion_type motion;
typedef const char* _movement_type;
_movement_type movement;
typedef float _x_velocity_type;
_x_velocity_type x_velocity;
typedef float _y_velocity_type;
_y_velocity_type y_velocity;
typedef float _rate_type;
_rate_type rate;
typedef float _roll_type;
_roll_type roll;
typedef float _pitch_type;
_pitch_type pitch;
typedef float _yaw_type;
_yaw_type yaw;
typedef float _z_type;
_z_type z;
typedef float _faster_type;
_faster_type faster;
typedef float _slower_type;
_slower_type slower;
MiniCmd():
motion(""),
movement(""),
x_velocity(0),
y_velocity(0),
rate(0),
roll(0),
pitch(0),
yaw(0),
z(0),
faster(0),
slower(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_motion = strlen(this->motion);
varToArr(outbuffer + offset, length_motion);
offset += 4;
memcpy(outbuffer + offset, this->motion, length_motion);
offset += length_motion;
uint32_t length_movement = strlen(this->movement);
varToArr(outbuffer + offset, length_movement);
offset += 4;
memcpy(outbuffer + offset, this->movement, length_movement);
offset += length_movement;
union {
float real;
uint32_t base;
} u_x_velocity;
u_x_velocity.real = this->x_velocity;
*(outbuffer + offset + 0) = (u_x_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x_velocity);
union {
float real;
uint32_t base;
} u_y_velocity;
u_y_velocity.real = this->y_velocity;
*(outbuffer + offset + 0) = (u_y_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y_velocity);
union {
float real;
uint32_t base;
} u_rate;
u_rate.real = this->rate;
*(outbuffer + offset + 0) = (u_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_rate.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->rate);
union {
float real;
uint32_t base;
} u_roll;
u_roll.real = this->roll;
*(outbuffer + offset + 0) = (u_roll.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_roll.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_roll.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_roll.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.real = this->pitch;
*(outbuffer + offset + 0) = (u_pitch.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pitch.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pitch.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pitch.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_yaw;
u_yaw.real = this->yaw;
*(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->yaw);
union {
float real;
uint32_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->z);
union {
float real;
uint32_t base;
} u_faster;
u_faster.real = this->faster;
*(outbuffer + offset + 0) = (u_faster.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_faster.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_faster.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_faster.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->faster);
union {
float real;
uint32_t base;
} u_slower;
u_slower.real = this->slower;
*(outbuffer + offset + 0) = (u_slower.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_slower.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_slower.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_slower.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->slower);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_motion;
arrToVar(length_motion, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_motion; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_motion-1]=0;
this->motion = (char *)(inbuffer + offset-1);
offset += length_motion;
uint32_t length_movement;
arrToVar(length_movement, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_movement; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_movement-1]=0;
this->movement = (char *)(inbuffer + offset-1);
offset += length_movement;
union {
float real;
uint32_t base;
} u_x_velocity;
u_x_velocity.base = 0;
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x_velocity = u_x_velocity.real;
offset += sizeof(this->x_velocity);
union {
float real;
uint32_t base;
} u_y_velocity;
u_y_velocity.base = 0;
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y_velocity = u_y_velocity.real;
offset += sizeof(this->y_velocity);
union {
float real;
uint32_t base;
} u_rate;
u_rate.base = 0;
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->rate = u_rate.real;
offset += sizeof(this->rate);
union {
float real;
uint32_t base;
} u_roll;
u_roll.base = 0;
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->roll = u_roll.real;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.base = 0;
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->pitch = u_pitch.real;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_yaw;
u_yaw.base = 0;
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->yaw = u_yaw.real;
offset += sizeof(this->yaw);
union {
float real;
uint32_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->z = u_z.real;
offset += sizeof(this->z);
union {
float real;
uint32_t base;
} u_faster;
u_faster.base = 0;
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->faster = u_faster.real;
offset += sizeof(this->faster);
union {
float real;
uint32_t base;
} u_slower;
u_slower.base = 0;
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->slower = u_slower.real;
offset += sizeof(this->slower);
return offset;
}
const char * getType(){ return "mini_ros/MiniCmd"; };
const char * getMD5(){ return "83510b9a5f454bd3ceb898b52e349406"; };
};
}
#endif
| 10,612 | C | 35.723183 | 78 | 0.50311 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JointAngles.h | #ifndef _ROS_mini_ros_JointAngles_h
#define _ROS_mini_ros_JointAngles_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JointAngles : public ros::Msg
{
public:
typedef float _fls_type;
_fls_type fls;
typedef float _fle_type;
_fle_type fle;
typedef float _flw_type;
_flw_type flw;
typedef float _frs_type;
_frs_type frs;
typedef float _fre_type;
_fre_type fre;
typedef float _frw_type;
_frw_type frw;
typedef float _bls_type;
_bls_type bls;
typedef float _ble_type;
_ble_type ble;
typedef float _blw_type;
_blw_type blw;
typedef float _brs_type;
_brs_type brs;
typedef float _bre_type;
_bre_type bre;
typedef float _brw_type;
_brw_type brw;
typedef bool _step_or_view_type;
_step_or_view_type step_or_view;
JointAngles():
fls(0),
fle(0),
flw(0),
frs(0),
fre(0),
frw(0),
bls(0),
ble(0),
blw(0),
brs(0),
bre(0),
brw(0),
step_or_view(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_fls;
u_fls.real = this->fls;
*(outbuffer + offset + 0) = (u_fls.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fls.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fls.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fls.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fls);
union {
float real;
uint32_t base;
} u_fle;
u_fle.real = this->fle;
*(outbuffer + offset + 0) = (u_fle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fle.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fle);
union {
float real;
uint32_t base;
} u_flw;
u_flw.real = this->flw;
*(outbuffer + offset + 0) = (u_flw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_flw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_flw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_flw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->flw);
union {
float real;
uint32_t base;
} u_frs;
u_frs.real = this->frs;
*(outbuffer + offset + 0) = (u_frs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_frs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_frs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_frs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->frs);
union {
float real;
uint32_t base;
} u_fre;
u_fre.real = this->fre;
*(outbuffer + offset + 0) = (u_fre.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fre.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fre.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fre.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fre);
union {
float real;
uint32_t base;
} u_frw;
u_frw.real = this->frw;
*(outbuffer + offset + 0) = (u_frw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_frw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_frw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_frw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->frw);
union {
float real;
uint32_t base;
} u_bls;
u_bls.real = this->bls;
*(outbuffer + offset + 0) = (u_bls.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_bls.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_bls.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_bls.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->bls);
union {
float real;
uint32_t base;
} u_ble;
u_ble.real = this->ble;
*(outbuffer + offset + 0) = (u_ble.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ble.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ble.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ble.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ble);
union {
float real;
uint32_t base;
} u_blw;
u_blw.real = this->blw;
*(outbuffer + offset + 0) = (u_blw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_blw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_blw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_blw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->blw);
union {
float real;
uint32_t base;
} u_brs;
u_brs.real = this->brs;
*(outbuffer + offset + 0) = (u_brs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_brs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_brs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_brs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->brs);
union {
float real;
uint32_t base;
} u_bre;
u_bre.real = this->bre;
*(outbuffer + offset + 0) = (u_bre.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_bre.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_bre.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_bre.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->bre);
union {
float real;
uint32_t base;
} u_brw;
u_brw.real = this->brw;
*(outbuffer + offset + 0) = (u_brw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_brw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_brw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_brw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->brw);
union {
bool real;
uint8_t base;
} u_step_or_view;
u_step_or_view.real = this->step_or_view;
*(outbuffer + offset + 0) = (u_step_or_view.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->step_or_view);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_fls;
u_fls.base = 0;
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fls = u_fls.real;
offset += sizeof(this->fls);
union {
float real;
uint32_t base;
} u_fle;
u_fle.base = 0;
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fle = u_fle.real;
offset += sizeof(this->fle);
union {
float real;
uint32_t base;
} u_flw;
u_flw.base = 0;
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->flw = u_flw.real;
offset += sizeof(this->flw);
union {
float real;
uint32_t base;
} u_frs;
u_frs.base = 0;
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->frs = u_frs.real;
offset += sizeof(this->frs);
union {
float real;
uint32_t base;
} u_fre;
u_fre.base = 0;
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fre = u_fre.real;
offset += sizeof(this->fre);
union {
float real;
uint32_t base;
} u_frw;
u_frw.base = 0;
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->frw = u_frw.real;
offset += sizeof(this->frw);
union {
float real;
uint32_t base;
} u_bls;
u_bls.base = 0;
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->bls = u_bls.real;
offset += sizeof(this->bls);
union {
float real;
uint32_t base;
} u_ble;
u_ble.base = 0;
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->ble = u_ble.real;
offset += sizeof(this->ble);
union {
float real;
uint32_t base;
} u_blw;
u_blw.base = 0;
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->blw = u_blw.real;
offset += sizeof(this->blw);
union {
float real;
uint32_t base;
} u_brs;
u_brs.base = 0;
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->brs = u_brs.real;
offset += sizeof(this->brs);
union {
float real;
uint32_t base;
} u_bre;
u_bre.base = 0;
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->bre = u_bre.real;
offset += sizeof(this->bre);
union {
float real;
uint32_t base;
} u_brw;
u_brw.base = 0;
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->brw = u_brw.real;
offset += sizeof(this->brw);
union {
bool real;
uint8_t base;
} u_step_or_view;
u_step_or_view.base = 0;
u_step_or_view.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->step_or_view = u_step_or_view.real;
offset += sizeof(this->step_or_view);
return offset;
}
const char * getType(){ return "mini_ros/JointAngles"; };
const char * getMD5(){ return "54bfcd55046a61d9df3827d322506389"; };
};
}
#endif
| 12,233 | C | 34.460869 | 79 | 0.467751 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/stereo_msgs/DisparityImage.h | #ifndef _ROS_stereo_msgs_DisparityImage_h
#define _ROS_stereo_msgs_DisparityImage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/Image.h"
#include "sensor_msgs/RegionOfInterest.h"
namespace stereo_msgs
{
class DisparityImage : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef sensor_msgs::Image _image_type;
_image_type image;
typedef float _f_type;
_f_type f;
typedef float _T_type;
_T_type T;
typedef sensor_msgs::RegionOfInterest _valid_window_type;
_valid_window_type valid_window;
typedef float _min_disparity_type;
_min_disparity_type min_disparity;
typedef float _max_disparity_type;
_max_disparity_type max_disparity;
typedef float _delta_d_type;
_delta_d_type delta_d;
DisparityImage():
header(),
image(),
f(0),
T(0),
valid_window(),
min_disparity(0),
max_disparity(0),
delta_d(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->image.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_f;
u_f.real = this->f;
*(outbuffer + offset + 0) = (u_f.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_f.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_f.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_f.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->f);
union {
float real;
uint32_t base;
} u_T;
u_T.real = this->T;
*(outbuffer + offset + 0) = (u_T.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_T.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_T.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_T.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->T);
offset += this->valid_window.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_min_disparity;
u_min_disparity.real = this->min_disparity;
*(outbuffer + offset + 0) = (u_min_disparity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_disparity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_disparity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_disparity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_disparity);
union {
float real;
uint32_t base;
} u_max_disparity;
u_max_disparity.real = this->max_disparity;
*(outbuffer + offset + 0) = (u_max_disparity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_disparity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_disparity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_disparity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_disparity);
union {
float real;
uint32_t base;
} u_delta_d;
u_delta_d.real = this->delta_d;
*(outbuffer + offset + 0) = (u_delta_d.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_delta_d.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_delta_d.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_delta_d.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->delta_d);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->image.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_f;
u_f.base = 0;
u_f.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->f = u_f.real;
offset += sizeof(this->f);
union {
float real;
uint32_t base;
} u_T;
u_T.base = 0;
u_T.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->T = u_T.real;
offset += sizeof(this->T);
offset += this->valid_window.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_min_disparity;
u_min_disparity.base = 0;
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->min_disparity = u_min_disparity.real;
offset += sizeof(this->min_disparity);
union {
float real;
uint32_t base;
} u_max_disparity;
u_max_disparity.base = 0;
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->max_disparity = u_max_disparity.real;
offset += sizeof(this->max_disparity);
union {
float real;
uint32_t base;
} u_delta_d;
u_delta_d.base = 0;
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->delta_d = u_delta_d.real;
offset += sizeof(this->delta_d);
return offset;
}
const char * getType(){ return "stereo_msgs/DisparityImage"; };
const char * getMD5(){ return "04a177815f75271039fa21f16acad8c9"; };
};
}
#endif
| 6,427 | C | 35.316384 | 81 | 0.526062 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/SEAJointState.h | #ifndef _ROS_baxter_core_msgs_SEAJointState_h
#define _ROS_baxter_core_msgs_SEAJointState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace baxter_core_msgs
{
class SEAJointState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t commanded_position_length;
typedef double _commanded_position_type;
_commanded_position_type st_commanded_position;
_commanded_position_type * commanded_position;
uint32_t commanded_velocity_length;
typedef double _commanded_velocity_type;
_commanded_velocity_type st_commanded_velocity;
_commanded_velocity_type * commanded_velocity;
uint32_t commanded_acceleration_length;
typedef double _commanded_acceleration_type;
_commanded_acceleration_type st_commanded_acceleration;
_commanded_acceleration_type * commanded_acceleration;
uint32_t commanded_effort_length;
typedef double _commanded_effort_type;
_commanded_effort_type st_commanded_effort;
_commanded_effort_type * commanded_effort;
uint32_t actual_position_length;
typedef double _actual_position_type;
_actual_position_type st_actual_position;
_actual_position_type * actual_position;
uint32_t actual_velocity_length;
typedef double _actual_velocity_type;
_actual_velocity_type st_actual_velocity;
_actual_velocity_type * actual_velocity;
uint32_t actual_effort_length;
typedef double _actual_effort_type;
_actual_effort_type st_actual_effort;
_actual_effort_type * actual_effort;
uint32_t gravity_model_effort_length;
typedef double _gravity_model_effort_type;
_gravity_model_effort_type st_gravity_model_effort;
_gravity_model_effort_type * gravity_model_effort;
uint32_t gravity_only_length;
typedef double _gravity_only_type;
_gravity_only_type st_gravity_only;
_gravity_only_type * gravity_only;
uint32_t hysteresis_model_effort_length;
typedef double _hysteresis_model_effort_type;
_hysteresis_model_effort_type st_hysteresis_model_effort;
_hysteresis_model_effort_type * hysteresis_model_effort;
uint32_t crosstalk_model_effort_length;
typedef double _crosstalk_model_effort_type;
_crosstalk_model_effort_type st_crosstalk_model_effort;
_crosstalk_model_effort_type * crosstalk_model_effort;
typedef double _hystState_type;
_hystState_type hystState;
SEAJointState():
header(),
name_length(0), name(NULL),
commanded_position_length(0), commanded_position(NULL),
commanded_velocity_length(0), commanded_velocity(NULL),
commanded_acceleration_length(0), commanded_acceleration(NULL),
commanded_effort_length(0), commanded_effort(NULL),
actual_position_length(0), actual_position(NULL),
actual_velocity_length(0), actual_velocity(NULL),
actual_effort_length(0), actual_effort(NULL),
gravity_model_effort_length(0), gravity_model_effort(NULL),
gravity_only_length(0), gravity_only(NULL),
hysteresis_model_effort_length(0), hysteresis_model_effort(NULL),
crosstalk_model_effort_length(0), crosstalk_model_effort(NULL),
hystState(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(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->commanded_position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_position_length);
for( uint32_t i = 0; i < commanded_position_length; i++){
union {
double real;
uint64_t base;
} u_commanded_positioni;
u_commanded_positioni.real = this->commanded_position[i];
*(outbuffer + offset + 0) = (u_commanded_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_position[i]);
}
*(outbuffer + offset + 0) = (this->commanded_velocity_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_velocity_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_velocity_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_velocity_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_velocity_length);
for( uint32_t i = 0; i < commanded_velocity_length; i++){
union {
double real;
uint64_t base;
} u_commanded_velocityi;
u_commanded_velocityi.real = this->commanded_velocity[i];
*(outbuffer + offset + 0) = (u_commanded_velocityi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_velocityi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_velocityi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_velocityi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_velocityi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_velocityi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_velocityi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_velocityi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_velocity[i]);
}
*(outbuffer + offset + 0) = (this->commanded_acceleration_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_acceleration_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_acceleration_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_acceleration_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_acceleration_length);
for( uint32_t i = 0; i < commanded_acceleration_length; i++){
union {
double real;
uint64_t base;
} u_commanded_accelerationi;
u_commanded_accelerationi.real = this->commanded_acceleration[i];
*(outbuffer + offset + 0) = (u_commanded_accelerationi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_accelerationi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_accelerationi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_accelerationi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_accelerationi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_accelerationi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_accelerationi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_accelerationi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_acceleration[i]);
}
*(outbuffer + offset + 0) = (this->commanded_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_effort_length);
for( uint32_t i = 0; i < commanded_effort_length; i++){
union {
double real;
uint64_t base;
} u_commanded_efforti;
u_commanded_efforti.real = this->commanded_effort[i];
*(outbuffer + offset + 0) = (u_commanded_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_effort[i]);
}
*(outbuffer + offset + 0) = (this->actual_position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->actual_position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->actual_position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->actual_position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->actual_position_length);
for( uint32_t i = 0; i < actual_position_length; i++){
union {
double real;
uint64_t base;
} u_actual_positioni;
u_actual_positioni.real = this->actual_position[i];
*(outbuffer + offset + 0) = (u_actual_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_actual_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_actual_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_actual_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_actual_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_actual_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_actual_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_actual_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->actual_position[i]);
}
*(outbuffer + offset + 0) = (this->actual_velocity_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->actual_velocity_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->actual_velocity_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->actual_velocity_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->actual_velocity_length);
for( uint32_t i = 0; i < actual_velocity_length; i++){
union {
double real;
uint64_t base;
} u_actual_velocityi;
u_actual_velocityi.real = this->actual_velocity[i];
*(outbuffer + offset + 0) = (u_actual_velocityi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_actual_velocityi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_actual_velocityi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_actual_velocityi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_actual_velocityi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_actual_velocityi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_actual_velocityi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_actual_velocityi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->actual_velocity[i]);
}
*(outbuffer + offset + 0) = (this->actual_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->actual_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->actual_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->actual_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->actual_effort_length);
for( uint32_t i = 0; i < actual_effort_length; i++){
union {
double real;
uint64_t base;
} u_actual_efforti;
u_actual_efforti.real = this->actual_effort[i];
*(outbuffer + offset + 0) = (u_actual_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_actual_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_actual_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_actual_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_actual_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_actual_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_actual_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_actual_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->actual_effort[i]);
}
*(outbuffer + offset + 0) = (this->gravity_model_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->gravity_model_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->gravity_model_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->gravity_model_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->gravity_model_effort_length);
for( uint32_t i = 0; i < gravity_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_gravity_model_efforti;
u_gravity_model_efforti.real = this->gravity_model_effort[i];
*(outbuffer + offset + 0) = (u_gravity_model_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gravity_model_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gravity_model_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gravity_model_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_gravity_model_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_gravity_model_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_gravity_model_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_gravity_model_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->gravity_model_effort[i]);
}
*(outbuffer + offset + 0) = (this->gravity_only_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->gravity_only_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->gravity_only_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->gravity_only_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->gravity_only_length);
for( uint32_t i = 0; i < gravity_only_length; i++){
union {
double real;
uint64_t base;
} u_gravity_onlyi;
u_gravity_onlyi.real = this->gravity_only[i];
*(outbuffer + offset + 0) = (u_gravity_onlyi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gravity_onlyi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gravity_onlyi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gravity_onlyi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_gravity_onlyi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_gravity_onlyi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_gravity_onlyi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_gravity_onlyi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->gravity_only[i]);
}
*(outbuffer + offset + 0) = (this->hysteresis_model_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->hysteresis_model_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->hysteresis_model_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->hysteresis_model_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->hysteresis_model_effort_length);
for( uint32_t i = 0; i < hysteresis_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_hysteresis_model_efforti;
u_hysteresis_model_efforti.real = this->hysteresis_model_effort[i];
*(outbuffer + offset + 0) = (u_hysteresis_model_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_hysteresis_model_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_hysteresis_model_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_hysteresis_model_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_hysteresis_model_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_hysteresis_model_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_hysteresis_model_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_hysteresis_model_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->hysteresis_model_effort[i]);
}
*(outbuffer + offset + 0) = (this->crosstalk_model_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->crosstalk_model_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->crosstalk_model_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->crosstalk_model_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->crosstalk_model_effort_length);
for( uint32_t i = 0; i < crosstalk_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_crosstalk_model_efforti;
u_crosstalk_model_efforti.real = this->crosstalk_model_effort[i];
*(outbuffer + offset + 0) = (u_crosstalk_model_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_crosstalk_model_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_crosstalk_model_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_crosstalk_model_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_crosstalk_model_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_crosstalk_model_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_crosstalk_model_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_crosstalk_model_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->crosstalk_model_effort[i]);
}
union {
double real;
uint64_t base;
} u_hystState;
u_hystState.real = this->hystState;
*(outbuffer + offset + 0) = (u_hystState.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_hystState.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_hystState.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_hystState.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_hystState.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_hystState.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_hystState.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_hystState.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->hystState);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
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 commanded_position_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_position_length);
if(commanded_position_lengthT > commanded_position_length)
this->commanded_position = (double*)realloc(this->commanded_position, commanded_position_lengthT * sizeof(double));
commanded_position_length = commanded_position_lengthT;
for( uint32_t i = 0; i < commanded_position_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_position;
u_st_commanded_position.base = 0;
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_position = u_st_commanded_position.real;
offset += sizeof(this->st_commanded_position);
memcpy( &(this->commanded_position[i]), &(this->st_commanded_position), sizeof(double));
}
uint32_t commanded_velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_velocity_length);
if(commanded_velocity_lengthT > commanded_velocity_length)
this->commanded_velocity = (double*)realloc(this->commanded_velocity, commanded_velocity_lengthT * sizeof(double));
commanded_velocity_length = commanded_velocity_lengthT;
for( uint32_t i = 0; i < commanded_velocity_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_velocity;
u_st_commanded_velocity.base = 0;
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_velocity = u_st_commanded_velocity.real;
offset += sizeof(this->st_commanded_velocity);
memcpy( &(this->commanded_velocity[i]), &(this->st_commanded_velocity), sizeof(double));
}
uint32_t commanded_acceleration_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_acceleration_length);
if(commanded_acceleration_lengthT > commanded_acceleration_length)
this->commanded_acceleration = (double*)realloc(this->commanded_acceleration, commanded_acceleration_lengthT * sizeof(double));
commanded_acceleration_length = commanded_acceleration_lengthT;
for( uint32_t i = 0; i < commanded_acceleration_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_acceleration;
u_st_commanded_acceleration.base = 0;
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_acceleration = u_st_commanded_acceleration.real;
offset += sizeof(this->st_commanded_acceleration);
memcpy( &(this->commanded_acceleration[i]), &(this->st_commanded_acceleration), sizeof(double));
}
uint32_t commanded_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_effort_length);
if(commanded_effort_lengthT > commanded_effort_length)
this->commanded_effort = (double*)realloc(this->commanded_effort, commanded_effort_lengthT * sizeof(double));
commanded_effort_length = commanded_effort_lengthT;
for( uint32_t i = 0; i < commanded_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_effort;
u_st_commanded_effort.base = 0;
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_effort = u_st_commanded_effort.real;
offset += sizeof(this->st_commanded_effort);
memcpy( &(this->commanded_effort[i]), &(this->st_commanded_effort), sizeof(double));
}
uint32_t actual_position_lengthT = ((uint32_t) (*(inbuffer + offset)));
actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->actual_position_length);
if(actual_position_lengthT > actual_position_length)
this->actual_position = (double*)realloc(this->actual_position, actual_position_lengthT * sizeof(double));
actual_position_length = actual_position_lengthT;
for( uint32_t i = 0; i < actual_position_length; i++){
union {
double real;
uint64_t base;
} u_st_actual_position;
u_st_actual_position.base = 0;
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_actual_position = u_st_actual_position.real;
offset += sizeof(this->st_actual_position);
memcpy( &(this->actual_position[i]), &(this->st_actual_position), sizeof(double));
}
uint32_t actual_velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->actual_velocity_length);
if(actual_velocity_lengthT > actual_velocity_length)
this->actual_velocity = (double*)realloc(this->actual_velocity, actual_velocity_lengthT * sizeof(double));
actual_velocity_length = actual_velocity_lengthT;
for( uint32_t i = 0; i < actual_velocity_length; i++){
union {
double real;
uint64_t base;
} u_st_actual_velocity;
u_st_actual_velocity.base = 0;
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_actual_velocity = u_st_actual_velocity.real;
offset += sizeof(this->st_actual_velocity);
memcpy( &(this->actual_velocity[i]), &(this->st_actual_velocity), sizeof(double));
}
uint32_t actual_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->actual_effort_length);
if(actual_effort_lengthT > actual_effort_length)
this->actual_effort = (double*)realloc(this->actual_effort, actual_effort_lengthT * sizeof(double));
actual_effort_length = actual_effort_lengthT;
for( uint32_t i = 0; i < actual_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_actual_effort;
u_st_actual_effort.base = 0;
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_actual_effort = u_st_actual_effort.real;
offset += sizeof(this->st_actual_effort);
memcpy( &(this->actual_effort[i]), &(this->st_actual_effort), sizeof(double));
}
uint32_t gravity_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->gravity_model_effort_length);
if(gravity_model_effort_lengthT > gravity_model_effort_length)
this->gravity_model_effort = (double*)realloc(this->gravity_model_effort, gravity_model_effort_lengthT * sizeof(double));
gravity_model_effort_length = gravity_model_effort_lengthT;
for( uint32_t i = 0; i < gravity_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_gravity_model_effort;
u_st_gravity_model_effort.base = 0;
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_gravity_model_effort = u_st_gravity_model_effort.real;
offset += sizeof(this->st_gravity_model_effort);
memcpy( &(this->gravity_model_effort[i]), &(this->st_gravity_model_effort), sizeof(double));
}
uint32_t gravity_only_lengthT = ((uint32_t) (*(inbuffer + offset)));
gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->gravity_only_length);
if(gravity_only_lengthT > gravity_only_length)
this->gravity_only = (double*)realloc(this->gravity_only, gravity_only_lengthT * sizeof(double));
gravity_only_length = gravity_only_lengthT;
for( uint32_t i = 0; i < gravity_only_length; i++){
union {
double real;
uint64_t base;
} u_st_gravity_only;
u_st_gravity_only.base = 0;
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_gravity_only = u_st_gravity_only.real;
offset += sizeof(this->st_gravity_only);
memcpy( &(this->gravity_only[i]), &(this->st_gravity_only), sizeof(double));
}
uint32_t hysteresis_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->hysteresis_model_effort_length);
if(hysteresis_model_effort_lengthT > hysteresis_model_effort_length)
this->hysteresis_model_effort = (double*)realloc(this->hysteresis_model_effort, hysteresis_model_effort_lengthT * sizeof(double));
hysteresis_model_effort_length = hysteresis_model_effort_lengthT;
for( uint32_t i = 0; i < hysteresis_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_hysteresis_model_effort;
u_st_hysteresis_model_effort.base = 0;
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_hysteresis_model_effort = u_st_hysteresis_model_effort.real;
offset += sizeof(this->st_hysteresis_model_effort);
memcpy( &(this->hysteresis_model_effort[i]), &(this->st_hysteresis_model_effort), sizeof(double));
}
uint32_t crosstalk_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->crosstalk_model_effort_length);
if(crosstalk_model_effort_lengthT > crosstalk_model_effort_length)
this->crosstalk_model_effort = (double*)realloc(this->crosstalk_model_effort, crosstalk_model_effort_lengthT * sizeof(double));
crosstalk_model_effort_length = crosstalk_model_effort_lengthT;
for( uint32_t i = 0; i < crosstalk_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_crosstalk_model_effort;
u_st_crosstalk_model_effort.base = 0;
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_crosstalk_model_effort = u_st_crosstalk_model_effort.real;
offset += sizeof(this->st_crosstalk_model_effort);
memcpy( &(this->crosstalk_model_effort[i]), &(this->st_crosstalk_model_effort), sizeof(double));
}
union {
double real;
uint64_t base;
} u_hystState;
u_hystState.base = 0;
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->hystState = u_hystState.real;
offset += sizeof(this->hystState);
return offset;
}
const char * getType(){ return "baxter_core_msgs/SEAJointState"; };
const char * getMD5(){ return "d36406dcbb6d860b1b39c4e28f81352b"; };
};
}
#endif
| 41,374 | C | 59.313411 | 138 | 0.580099 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/RobustControllerStatus.h | #ifndef _ROS_baxter_core_msgs_RobustControllerStatus_h
#define _ROS_baxter_core_msgs_RobustControllerStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class RobustControllerStatus : public ros::Msg
{
public:
typedef bool _isEnabled_type;
_isEnabled_type isEnabled;
typedef int32_t _complete_type;
_complete_type complete;
typedef const char* _controlUid_type;
_controlUid_type controlUid;
typedef bool _timedOut_type;
_timedOut_type timedOut;
uint32_t errorCodes_length;
typedef char* _errorCodes_type;
_errorCodes_type st_errorCodes;
_errorCodes_type * errorCodes;
uint32_t labels_length;
typedef char* _labels_type;
_labels_type st_labels;
_labels_type * labels;
enum { NOT_COMPLETE = 0 };
enum { COMPLETE_W_FAILURE = 1 };
enum { COMPLETE_W_SUCCESS = 2 };
RobustControllerStatus():
isEnabled(0),
complete(0),
controlUid(""),
timedOut(0),
errorCodes_length(0), errorCodes(NULL),
labels_length(0), labels(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.real = this->isEnabled;
*(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isEnabled);
union {
int32_t real;
uint32_t base;
} u_complete;
u_complete.real = this->complete;
*(outbuffer + offset + 0) = (u_complete.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_complete.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_complete.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_complete.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->complete);
uint32_t length_controlUid = strlen(this->controlUid);
varToArr(outbuffer + offset, length_controlUid);
offset += 4;
memcpy(outbuffer + offset, this->controlUid, length_controlUid);
offset += length_controlUid;
union {
bool real;
uint8_t base;
} u_timedOut;
u_timedOut.real = this->timedOut;
*(outbuffer + offset + 0) = (u_timedOut.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->timedOut);
*(outbuffer + offset + 0) = (this->errorCodes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->errorCodes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->errorCodes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->errorCodes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->errorCodes_length);
for( uint32_t i = 0; i < errorCodes_length; i++){
uint32_t length_errorCodesi = strlen(this->errorCodes[i]);
varToArr(outbuffer + offset, length_errorCodesi);
offset += 4;
memcpy(outbuffer + offset, this->errorCodes[i], length_errorCodesi);
offset += length_errorCodesi;
}
*(outbuffer + offset + 0) = (this->labels_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->labels_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->labels_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->labels_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->labels_length);
for( uint32_t i = 0; i < labels_length; i++){
uint32_t length_labelsi = strlen(this->labels[i]);
varToArr(outbuffer + offset, length_labelsi);
offset += 4;
memcpy(outbuffer + offset, this->labels[i], length_labelsi);
offset += length_labelsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.base = 0;
u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isEnabled = u_isEnabled.real;
offset += sizeof(this->isEnabled);
union {
int32_t real;
uint32_t base;
} u_complete;
u_complete.base = 0;
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->complete = u_complete.real;
offset += sizeof(this->complete);
uint32_t length_controlUid;
arrToVar(length_controlUid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_controlUid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_controlUid-1]=0;
this->controlUid = (char *)(inbuffer + offset-1);
offset += length_controlUid;
union {
bool real;
uint8_t base;
} u_timedOut;
u_timedOut.base = 0;
u_timedOut.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->timedOut = u_timedOut.real;
offset += sizeof(this->timedOut);
uint32_t errorCodes_lengthT = ((uint32_t) (*(inbuffer + offset)));
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->errorCodes_length);
if(errorCodes_lengthT > errorCodes_length)
this->errorCodes = (char**)realloc(this->errorCodes, errorCodes_lengthT * sizeof(char*));
errorCodes_length = errorCodes_lengthT;
for( uint32_t i = 0; i < errorCodes_length; i++){
uint32_t length_st_errorCodes;
arrToVar(length_st_errorCodes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_errorCodes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_errorCodes-1]=0;
this->st_errorCodes = (char *)(inbuffer + offset-1);
offset += length_st_errorCodes;
memcpy( &(this->errorCodes[i]), &(this->st_errorCodes), sizeof(char*));
}
uint32_t labels_lengthT = ((uint32_t) (*(inbuffer + offset)));
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->labels_length);
if(labels_lengthT > labels_length)
this->labels = (char**)realloc(this->labels, labels_lengthT * sizeof(char*));
labels_length = labels_lengthT;
for( uint32_t i = 0; i < labels_length; i++){
uint32_t length_st_labels;
arrToVar(length_st_labels, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_labels; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_labels-1]=0;
this->st_labels = (char *)(inbuffer + offset-1);
offset += length_st_labels;
memcpy( &(this->labels[i]), &(this->st_labels), sizeof(char*));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/RobustControllerStatus"; };
const char * getMD5(){ return "2f15441b7285d915e7e59d3618e173f2"; };
};
}
#endif
| 7,461 | C | 37.663212 | 97 | 0.576062 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CloseCamera.h | #ifndef _ROS_SERVICE_CloseCamera_h
#define _ROS_SERVICE_CloseCamera_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
static const char CLOSECAMERA[] = "baxter_core_msgs/CloseCamera";
class CloseCameraRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
CloseCameraRequest():
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
return offset;
}
const char * getType(){ return CLOSECAMERA; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class CloseCameraResponse : public ros::Msg
{
public:
typedef int32_t _err_type;
_err_type err;
CloseCameraResponse():
err(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.real = this->err;
*(outbuffer + offset + 0) = (u_err.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_err.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_err.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_err.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->err);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.base = 0;
u_err.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->err = u_err.real;
offset += sizeof(this->err);
return offset;
}
const char * getType(){ return CLOSECAMERA; };
const char * getMD5(){ return "b6e094011a4dfaee5eddf447220446cf"; };
};
class CloseCamera {
public:
typedef CloseCameraRequest Request;
typedef CloseCameraResponse Response;
};
}
#endif
| 2,814 | C | 24.133928 | 72 | 0.56823 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CollisionAvoidanceState.h | #ifndef _ROS_baxter_core_msgs_CollisionAvoidanceState_h
#define _ROS_baxter_core_msgs_CollisionAvoidanceState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace baxter_core_msgs
{
class CollisionAvoidanceState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef bool _other_arm_type;
_other_arm_type other_arm;
uint32_t collision_object_length;
typedef char* _collision_object_type;
_collision_object_type st_collision_object;
_collision_object_type * collision_object;
CollisionAvoidanceState():
header(),
other_arm(0),
collision_object_length(0), collision_object(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_other_arm;
u_other_arm.real = this->other_arm;
*(outbuffer + offset + 0) = (u_other_arm.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->other_arm);
*(outbuffer + offset + 0) = (this->collision_object_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->collision_object_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->collision_object_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->collision_object_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->collision_object_length);
for( uint32_t i = 0; i < collision_object_length; i++){
uint32_t length_collision_objecti = strlen(this->collision_object[i]);
varToArr(outbuffer + offset, length_collision_objecti);
offset += 4;
memcpy(outbuffer + offset, this->collision_object[i], length_collision_objecti);
offset += length_collision_objecti;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_other_arm;
u_other_arm.base = 0;
u_other_arm.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->other_arm = u_other_arm.real;
offset += sizeof(this->other_arm);
uint32_t collision_object_lengthT = ((uint32_t) (*(inbuffer + offset)));
collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->collision_object_length);
if(collision_object_lengthT > collision_object_length)
this->collision_object = (char**)realloc(this->collision_object, collision_object_lengthT * sizeof(char*));
collision_object_length = collision_object_lengthT;
for( uint32_t i = 0; i < collision_object_length; i++){
uint32_t length_st_collision_object;
arrToVar(length_st_collision_object, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_collision_object; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_collision_object-1]=0;
this->st_collision_object = (char *)(inbuffer + offset-1);
offset += length_st_collision_object;
memcpy( &(this->collision_object[i]), &(this->st_collision_object), sizeof(char*));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/CollisionAvoidanceState"; };
const char * getMD5(){ return "30f5cb8ae019f1ffe8b599e6d2e589c7"; };
};
}
#endif
| 3,750 | C | 36.51 | 115 | 0.6176 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/DigitalOutputCommand.h | #ifndef _ROS_baxter_core_msgs_DigitalOutputCommand_h
#define _ROS_baxter_core_msgs_DigitalOutputCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class DigitalOutputCommand : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef bool _value_type;
_value_type value;
DigitalOutputCommand():
name(""),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "baxter_core_msgs/DigitalOutputCommand"; };
const char * getMD5(){ return "23f05028c1a699fb83e22401228c3a9e"; };
};
}
#endif
| 1,843 | C | 23.918919 | 78 | 0.584373 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/URDFConfiguration.h | #ifndef _ROS_baxter_core_msgs_URDFConfiguration_h
#define _ROS_baxter_core_msgs_URDFConfiguration_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace baxter_core_msgs
{
class URDFConfiguration : public ros::Msg
{
public:
typedef ros::Time _time_type;
_time_type time;
typedef const char* _link_type;
_link_type link;
typedef const char* _joint_type;
_joint_type joint;
typedef const char* _urdf_type;
_urdf_type urdf;
URDFConfiguration():
time(),
link(""),
joint(""),
urdf("")
{
}
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);
uint32_t length_link = strlen(this->link);
varToArr(outbuffer + offset, length_link);
offset += 4;
memcpy(outbuffer + offset, this->link, length_link);
offset += length_link;
uint32_t length_joint = strlen(this->joint);
varToArr(outbuffer + offset, length_joint);
offset += 4;
memcpy(outbuffer + offset, this->joint, length_joint);
offset += length_joint;
uint32_t length_urdf = strlen(this->urdf);
varToArr(outbuffer + offset, length_urdf);
offset += 4;
memcpy(outbuffer + offset, this->urdf, length_urdf);
offset += length_urdf;
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);
uint32_t length_link;
arrToVar(length_link, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link-1]=0;
this->link = (char *)(inbuffer + offset-1);
offset += length_link;
uint32_t length_joint;
arrToVar(length_joint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint-1]=0;
this->joint = (char *)(inbuffer + offset-1);
offset += length_joint;
uint32_t length_urdf;
arrToVar(length_urdf, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_urdf; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_urdf-1]=0;
this->urdf = (char *)(inbuffer + offset-1);
offset += length_urdf;
return offset;
}
const char * getType(){ return "baxter_core_msgs/URDFConfiguration"; };
const char * getMD5(){ return "0c7028d878027820eed2aa0cbf1f5e4a"; };
};
}
#endif
| 3,935 | C | 33.526315 | 76 | 0.562897 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorProperties.h | #ifndef _ROS_baxter_core_msgs_EndEffectorProperties_h
#define _ROS_baxter_core_msgs_EndEffectorProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class EndEffectorProperties : public ros::Msg
{
public:
typedef uint32_t _id_type;
_id_type id;
typedef uint8_t _ui_type_type;
_ui_type_type ui_type;
typedef const char* _manufacturer_type;
_manufacturer_type manufacturer;
typedef const char* _product_type;
_product_type product;
typedef const char* _serial_number_type;
_serial_number_type serial_number;
typedef const char* _hardware_rev_type;
_hardware_rev_type hardware_rev;
typedef const char* _firmware_rev_type;
_firmware_rev_type firmware_rev;
typedef const char* _firmware_date_type;
_firmware_date_type firmware_date;
typedef bool _has_calibration_type;
_has_calibration_type has_calibration;
typedef bool _controls_grip_type;
_controls_grip_type controls_grip;
typedef bool _senses_grip_type;
_senses_grip_type senses_grip;
typedef bool _reverses_grip_type;
_reverses_grip_type reverses_grip;
typedef bool _controls_force_type;
_controls_force_type controls_force;
typedef bool _senses_force_type;
_senses_force_type senses_force;
typedef bool _controls_position_type;
_controls_position_type controls_position;
typedef bool _senses_position_type;
_senses_position_type senses_position;
typedef const char* _properties_type;
_properties_type properties;
enum { NO_GRIPPER = 0 };
enum { SUCTION_CUP_GRIPPER = 1 };
enum { ELECTRIC_GRIPPER = 2 };
enum { PASSIVE_GRIPPER = 3 };
EndEffectorProperties():
id(0),
ui_type(0),
manufacturer(""),
product(""),
serial_number(""),
hardware_rev(""),
firmware_rev(""),
firmware_date(""),
has_calibration(0),
controls_grip(0),
senses_grip(0),
reverses_grip(0),
controls_force(0),
senses_force(0),
controls_position(0),
senses_position(0),
properties("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
*(outbuffer + offset + 0) = (this->ui_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->ui_type);
uint32_t length_manufacturer = strlen(this->manufacturer);
varToArr(outbuffer + offset, length_manufacturer);
offset += 4;
memcpy(outbuffer + offset, this->manufacturer, length_manufacturer);
offset += length_manufacturer;
uint32_t length_product = strlen(this->product);
varToArr(outbuffer + offset, length_product);
offset += 4;
memcpy(outbuffer + offset, this->product, length_product);
offset += length_product;
uint32_t length_serial_number = strlen(this->serial_number);
varToArr(outbuffer + offset, length_serial_number);
offset += 4;
memcpy(outbuffer + offset, this->serial_number, length_serial_number);
offset += length_serial_number;
uint32_t length_hardware_rev = strlen(this->hardware_rev);
varToArr(outbuffer + offset, length_hardware_rev);
offset += 4;
memcpy(outbuffer + offset, this->hardware_rev, length_hardware_rev);
offset += length_hardware_rev;
uint32_t length_firmware_rev = strlen(this->firmware_rev);
varToArr(outbuffer + offset, length_firmware_rev);
offset += 4;
memcpy(outbuffer + offset, this->firmware_rev, length_firmware_rev);
offset += length_firmware_rev;
uint32_t length_firmware_date = strlen(this->firmware_date);
varToArr(outbuffer + offset, length_firmware_date);
offset += 4;
memcpy(outbuffer + offset, this->firmware_date, length_firmware_date);
offset += length_firmware_date;
union {
bool real;
uint8_t base;
} u_has_calibration;
u_has_calibration.real = this->has_calibration;
*(outbuffer + offset + 0) = (u_has_calibration.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_calibration);
union {
bool real;
uint8_t base;
} u_controls_grip;
u_controls_grip.real = this->controls_grip;
*(outbuffer + offset + 0) = (u_controls_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_grip);
union {
bool real;
uint8_t base;
} u_senses_grip;
u_senses_grip.real = this->senses_grip;
*(outbuffer + offset + 0) = (u_senses_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_grip);
union {
bool real;
uint8_t base;
} u_reverses_grip;
u_reverses_grip.real = this->reverses_grip;
*(outbuffer + offset + 0) = (u_reverses_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->reverses_grip);
union {
bool real;
uint8_t base;
} u_controls_force;
u_controls_force.real = this->controls_force;
*(outbuffer + offset + 0) = (u_controls_force.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_force);
union {
bool real;
uint8_t base;
} u_senses_force;
u_senses_force.real = this->senses_force;
*(outbuffer + offset + 0) = (u_senses_force.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_force);
union {
bool real;
uint8_t base;
} u_controls_position;
u_controls_position.real = this->controls_position;
*(outbuffer + offset + 0) = (u_controls_position.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_position);
union {
bool real;
uint8_t base;
} u_senses_position;
u_senses_position.real = this->senses_position;
*(outbuffer + offset + 0) = (u_senses_position.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_position);
uint32_t length_properties = strlen(this->properties);
varToArr(outbuffer + offset, length_properties);
offset += 4;
memcpy(outbuffer + offset, this->properties, length_properties);
offset += length_properties;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
this->ui_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->ui_type);
uint32_t length_manufacturer;
arrToVar(length_manufacturer, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_manufacturer; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_manufacturer-1]=0;
this->manufacturer = (char *)(inbuffer + offset-1);
offset += length_manufacturer;
uint32_t length_product;
arrToVar(length_product, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_product; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_product-1]=0;
this->product = (char *)(inbuffer + offset-1);
offset += length_product;
uint32_t length_serial_number;
arrToVar(length_serial_number, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_serial_number; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_serial_number-1]=0;
this->serial_number = (char *)(inbuffer + offset-1);
offset += length_serial_number;
uint32_t length_hardware_rev;
arrToVar(length_hardware_rev, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_hardware_rev; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_hardware_rev-1]=0;
this->hardware_rev = (char *)(inbuffer + offset-1);
offset += length_hardware_rev;
uint32_t length_firmware_rev;
arrToVar(length_firmware_rev, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_firmware_rev; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_firmware_rev-1]=0;
this->firmware_rev = (char *)(inbuffer + offset-1);
offset += length_firmware_rev;
uint32_t length_firmware_date;
arrToVar(length_firmware_date, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_firmware_date; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_firmware_date-1]=0;
this->firmware_date = (char *)(inbuffer + offset-1);
offset += length_firmware_date;
union {
bool real;
uint8_t base;
} u_has_calibration;
u_has_calibration.base = 0;
u_has_calibration.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_calibration = u_has_calibration.real;
offset += sizeof(this->has_calibration);
union {
bool real;
uint8_t base;
} u_controls_grip;
u_controls_grip.base = 0;
u_controls_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_grip = u_controls_grip.real;
offset += sizeof(this->controls_grip);
union {
bool real;
uint8_t base;
} u_senses_grip;
u_senses_grip.base = 0;
u_senses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_grip = u_senses_grip.real;
offset += sizeof(this->senses_grip);
union {
bool real;
uint8_t base;
} u_reverses_grip;
u_reverses_grip.base = 0;
u_reverses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->reverses_grip = u_reverses_grip.real;
offset += sizeof(this->reverses_grip);
union {
bool real;
uint8_t base;
} u_controls_force;
u_controls_force.base = 0;
u_controls_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_force = u_controls_force.real;
offset += sizeof(this->controls_force);
union {
bool real;
uint8_t base;
} u_senses_force;
u_senses_force.base = 0;
u_senses_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_force = u_senses_force.real;
offset += sizeof(this->senses_force);
union {
bool real;
uint8_t base;
} u_controls_position;
u_controls_position.base = 0;
u_controls_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_position = u_controls_position.real;
offset += sizeof(this->controls_position);
union {
bool real;
uint8_t base;
} u_senses_position;
u_senses_position.base = 0;
u_senses_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_position = u_senses_position.real;
offset += sizeof(this->senses_position);
uint32_t length_properties;
arrToVar(length_properties, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_properties; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_properties-1]=0;
this->properties = (char *)(inbuffer + offset-1);
offset += length_properties;
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndEffectorProperties"; };
const char * getMD5(){ return "21b83773ab9a35216d11e427573c76cc"; };
};
}
#endif
| 12,110 | C | 36.150307 | 84 | 0.591164 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CollisionDetectionState.h | #ifndef _ROS_baxter_core_msgs_CollisionDetectionState_h
#define _ROS_baxter_core_msgs_CollisionDetectionState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace baxter_core_msgs
{
class CollisionDetectionState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef bool _collision_state_type;
_collision_state_type collision_state;
CollisionDetectionState():
header(),
collision_state(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_collision_state;
u_collision_state.real = this->collision_state;
*(outbuffer + offset + 0) = (u_collision_state.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->collision_state);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_collision_state;
u_collision_state.base = 0;
u_collision_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->collision_state = u_collision_state.real;
offset += sizeof(this->collision_state);
return offset;
}
const char * getType(){ return "baxter_core_msgs/CollisionDetectionState"; };
const char * getMD5(){ return "7bde38c182b4d08fdc0635b116f65d04"; };
};
}
#endif
| 1,640 | C | 25.047619 | 82 | 0.629268 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndpointStates.h | #ifndef _ROS_baxter_core_msgs_EndpointStates_h
#define _ROS_baxter_core_msgs_EndpointStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/EndpointState.h"
namespace baxter_core_msgs
{
class EndpointStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::EndpointState _states_type;
_states_type st_states;
_states_type * states;
EndpointStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (baxter_core_msgs::EndpointState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::EndpointState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(baxter_core_msgs::EndpointState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndpointStates"; };
const char * getMD5(){ return "a0ca50a066809a5f065f39f37aa028fb"; };
};
}
#endif
| 3,916 | C | 37.40196 | 137 | 0.580439 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/SolvePositionIK.h | #ifndef _ROS_SERVICE_SolvePositionIK_h
#define _ROS_SERVICE_SolvePositionIK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
#include "sensor_msgs/JointState.h"
namespace baxter_core_msgs
{
static const char SOLVEPOSITIONIK[] = "baxter_core_msgs/SolvePositionIK";
class SolvePositionIKRequest : public ros::Msg
{
public:
uint32_t pose_stamp_length;
typedef geometry_msgs::PoseStamped _pose_stamp_type;
_pose_stamp_type st_pose_stamp;
_pose_stamp_type * pose_stamp;
uint32_t seed_angles_length;
typedef sensor_msgs::JointState _seed_angles_type;
_seed_angles_type st_seed_angles;
_seed_angles_type * seed_angles;
typedef uint8_t _seed_mode_type;
_seed_mode_type seed_mode;
enum { SEED_AUTO = 0 };
enum { SEED_USER = 1 };
enum { SEED_CURRENT = 2 };
enum { SEED_NS_MAP = 3 };
SolvePositionIKRequest():
pose_stamp_length(0), pose_stamp(NULL),
seed_angles_length(0), seed_angles(NULL),
seed_mode(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->pose_stamp_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamp_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamp_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamp_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamp_length);
for( uint32_t i = 0; i < pose_stamp_length; i++){
offset += this->pose_stamp[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->seed_angles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->seed_angles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->seed_angles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->seed_angles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->seed_angles_length);
for( uint32_t i = 0; i < seed_angles_length; i++){
offset += this->seed_angles[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->seed_mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->seed_mode);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t pose_stamp_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamp_length);
if(pose_stamp_lengthT > pose_stamp_length)
this->pose_stamp = (geometry_msgs::PoseStamped*)realloc(this->pose_stamp, pose_stamp_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamp_length = pose_stamp_lengthT;
for( uint32_t i = 0; i < pose_stamp_length; i++){
offset += this->st_pose_stamp.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamp[i]), &(this->st_pose_stamp), sizeof(geometry_msgs::PoseStamped));
}
uint32_t seed_angles_lengthT = ((uint32_t) (*(inbuffer + offset)));
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->seed_angles_length);
if(seed_angles_lengthT > seed_angles_length)
this->seed_angles = (sensor_msgs::JointState*)realloc(this->seed_angles, seed_angles_lengthT * sizeof(sensor_msgs::JointState));
seed_angles_length = seed_angles_lengthT;
for( uint32_t i = 0; i < seed_angles_length; i++){
offset += this->st_seed_angles.deserialize(inbuffer + offset);
memcpy( &(this->seed_angles[i]), &(this->st_seed_angles), sizeof(sensor_msgs::JointState));
}
this->seed_mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->seed_mode);
return offset;
}
const char * getType(){ return SOLVEPOSITIONIK; };
const char * getMD5(){ return "2587e42983d0081d0a2288230991073b"; };
};
class SolvePositionIKResponse : public ros::Msg
{
public:
uint32_t joints_length;
typedef sensor_msgs::JointState _joints_type;
_joints_type st_joints;
_joints_type * joints;
uint32_t isValid_length;
typedef bool _isValid_type;
_isValid_type st_isValid;
_isValid_type * isValid;
uint32_t result_type_length;
typedef uint8_t _result_type_type;
_result_type_type st_result_type;
_result_type_type * result_type;
enum { RESULT_INVALID = 0 };
SolvePositionIKResponse():
joints_length(0), joints(NULL),
isValid_length(0), isValid(NULL),
result_type_length(0), result_type(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joints_length);
for( uint32_t i = 0; i < joints_length; i++){
offset += this->joints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->isValid_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->isValid_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->isValid_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->isValid_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->isValid_length);
for( uint32_t i = 0; i < isValid_length; i++){
union {
bool real;
uint8_t base;
} u_isValidi;
u_isValidi.real = this->isValid[i];
*(outbuffer + offset + 0) = (u_isValidi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isValid[i]);
}
*(outbuffer + offset + 0) = (this->result_type_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->result_type_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->result_type_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->result_type_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->result_type_length);
for( uint32_t i = 0; i < result_type_length; i++){
*(outbuffer + offset + 0) = (this->result_type[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->result_type[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joints_lengthT = ((uint32_t) (*(inbuffer + offset)));
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joints_length);
if(joints_lengthT > joints_length)
this->joints = (sensor_msgs::JointState*)realloc(this->joints, joints_lengthT * sizeof(sensor_msgs::JointState));
joints_length = joints_lengthT;
for( uint32_t i = 0; i < joints_length; i++){
offset += this->st_joints.deserialize(inbuffer + offset);
memcpy( &(this->joints[i]), &(this->st_joints), sizeof(sensor_msgs::JointState));
}
uint32_t isValid_lengthT = ((uint32_t) (*(inbuffer + offset)));
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->isValid_length);
if(isValid_lengthT > isValid_length)
this->isValid = (bool*)realloc(this->isValid, isValid_lengthT * sizeof(bool));
isValid_length = isValid_lengthT;
for( uint32_t i = 0; i < isValid_length; i++){
union {
bool real;
uint8_t base;
} u_st_isValid;
u_st_isValid.base = 0;
u_st_isValid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_isValid = u_st_isValid.real;
offset += sizeof(this->st_isValid);
memcpy( &(this->isValid[i]), &(this->st_isValid), sizeof(bool));
}
uint32_t result_type_lengthT = ((uint32_t) (*(inbuffer + offset)));
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->result_type_length);
if(result_type_lengthT > result_type_length)
this->result_type = (uint8_t*)realloc(this->result_type, result_type_lengthT * sizeof(uint8_t));
result_type_length = result_type_lengthT;
for( uint32_t i = 0; i < result_type_length; i++){
this->st_result_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_result_type);
memcpy( &(this->result_type[i]), &(this->st_result_type), sizeof(uint8_t));
}
return offset;
}
const char * getType(){ return SOLVEPOSITIONIK; };
const char * getMD5(){ return "d9b0c2b3932e08421f5094cf62743b9f"; };
};
class SolvePositionIK {
public:
typedef SolvePositionIKRequest Request;
typedef SolvePositionIKResponse Response;
};
}
#endif
| 9,731 | C | 42.253333 | 139 | 0.581749 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/DigitalIOState.h | #ifndef _ROS_baxter_core_msgs_DigitalIOState_h
#define _ROS_baxter_core_msgs_DigitalIOState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class DigitalIOState : public ros::Msg
{
public:
typedef int8_t _state_type;
_state_type state;
typedef bool _isInputOnly_type;
_isInputOnly_type isInputOnly;
enum { OFF = 0 };
enum { ON = 1 };
enum { PRESSED = 1 };
enum { UNPRESSED = 0 };
DigitalIOState():
state(0),
isInputOnly(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_state;
u_state.real = this->state;
*(outbuffer + offset + 0) = (u_state.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->state);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.real = this->isInputOnly;
*(outbuffer + offset + 0) = (u_isInputOnly.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isInputOnly);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_state;
u_state.base = 0;
u_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->state = u_state.real;
offset += sizeof(this->state);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.base = 0;
u_isInputOnly.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isInputOnly = u_isInputOnly.real;
offset += sizeof(this->isInputOnly);
return offset;
}
const char * getType(){ return "baxter_core_msgs/DigitalIOState"; };
const char * getMD5(){ return "29d0be3859dae81a66b28f167ecec98c"; };
};
}
#endif
| 1,936 | C | 23.518987 | 78 | 0.56095 |
Subsets and Splits