file_path
stringlengths 21
224
| content
stringlengths 0
80.8M
|
|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/navfn/MakeNavPlan.h | #ifndef _ROS_SERVICE_MakeNavPlan_h
#define _ROS_SERVICE_MakeNavPlan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
namespace navfn
{
static const char MAKENAVPLAN[] = "navfn/MakeNavPlan";
class MakeNavPlanRequest : public ros::Msg
{
public:
typedef geometry_msgs::PoseStamped _start_type;
_start_type start;
typedef geometry_msgs::PoseStamped _goal_type;
_goal_type goal;
MakeNavPlanRequest():
start(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->start.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->start.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return MAKENAVPLAN; };
const char * getMD5(){ return "2fe3126bd5b2d56edd5005220333d4fd"; };
};
class MakeNavPlanResponse : public ros::Msg
{
public:
typedef uint8_t _plan_found_type;
_plan_found_type plan_found;
typedef const char* _error_message_type;
_error_message_type error_message;
uint32_t path_length;
typedef geometry_msgs::PoseStamped _path_type;
_path_type st_path;
_path_type * path;
MakeNavPlanResponse():
plan_found(0),
error_message(""),
path_length(0), path(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->plan_found >> (8 * 0)) & 0xFF;
offset += sizeof(this->plan_found);
uint32_t length_error_message = strlen(this->error_message);
varToArr(outbuffer + offset, length_error_message);
offset += 4;
memcpy(outbuffer + offset, this->error_message, length_error_message);
offset += length_error_message;
*(outbuffer + offset + 0) = (this->path_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->path_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->path_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->path_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->path_length);
for( uint32_t i = 0; i < path_length; i++){
offset += this->path[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->plan_found = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->plan_found);
uint32_t length_error_message;
arrToVar(length_error_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_error_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_error_message-1]=0;
this->error_message = (char *)(inbuffer + offset-1);
offset += length_error_message;
uint32_t path_lengthT = ((uint32_t) (*(inbuffer + offset)));
path_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
path_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
path_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->path_length);
if(path_lengthT > path_length)
this->path = (geometry_msgs::PoseStamped*)realloc(this->path, path_lengthT * sizeof(geometry_msgs::PoseStamped));
path_length = path_lengthT;
for( uint32_t i = 0; i < path_length; i++){
offset += this->st_path.deserialize(inbuffer + offset);
memcpy( &(this->path[i]), &(this->st_path), sizeof(geometry_msgs::PoseStamped));
}
return offset;
}
const char * getType(){ return MAKENAVPLAN; };
const char * getMD5(){ return "8b8ed7edf1b237dc9ddda8c8ffed5d3a"; };
};
class MakeNavPlan {
public:
typedef MakeNavPlanRequest Request;
typedef MakeNavPlanResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/navfn/SetCostmap.h | #ifndef _ROS_SERVICE_SetCostmap_h
#define _ROS_SERVICE_SetCostmap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace navfn
{
static const char SETCOSTMAP[] = "navfn/SetCostmap";
class SetCostmapRequest : public ros::Msg
{
public:
uint32_t costs_length;
typedef uint8_t _costs_type;
_costs_type st_costs;
_costs_type * costs;
typedef uint16_t _height_type;
_height_type height;
typedef uint16_t _width_type;
_width_type width;
SetCostmapRequest():
costs_length(0), costs(NULL),
height(0),
width(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->costs_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->costs_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->costs_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->costs_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->costs_length);
for( uint32_t i = 0; i < costs_length; i++){
*(outbuffer + offset + 0) = (this->costs[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->costs[i]);
}
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
offset += sizeof(this->height);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
offset += sizeof(this->width);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t costs_lengthT = ((uint32_t) (*(inbuffer + offset)));
costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->costs_length);
if(costs_lengthT > costs_length)
this->costs = (uint8_t*)realloc(this->costs, costs_lengthT * sizeof(uint8_t));
costs_length = costs_lengthT;
for( uint32_t i = 0; i < costs_length; i++){
this->st_costs = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_costs);
memcpy( &(this->costs[i]), &(this->st_costs), sizeof(uint8_t));
}
this->height = ((uint16_t) (*(inbuffer + offset)));
this->height |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->height);
this->width = ((uint16_t) (*(inbuffer + offset)));
this->width |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->width);
return offset;
}
const char * getType(){ return SETCOSTMAP; };
const char * getMD5(){ return "370ec969cdb71f9cde7c7cbe0d752308"; };
};
class SetCostmapResponse : public ros::Msg
{
public:
SetCostmapResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return SETCOSTMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetCostmap {
public:
typedef SetCostmapRequest Request;
typedef SetCostmapResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupAction.h | #ifndef _ROS_moveit_msgs_MoveGroupAction_h
#define _ROS_moveit_msgs_MoveGroupAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveGroupActionGoal.h"
#include "moveit_msgs/MoveGroupActionResult.h"
#include "moveit_msgs/MoveGroupActionFeedback.h"
namespace moveit_msgs
{
class MoveGroupAction : public ros::Msg
{
public:
typedef moveit_msgs::MoveGroupActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::MoveGroupActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::MoveGroupActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
MoveGroupAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupAction"; };
const char * getMD5(){ return "be9c7984423000efe94194063f359cfc"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/OrientationConstraint.h | #ifndef _ROS_moveit_msgs_OrientationConstraint_h
#define _ROS_moveit_msgs_OrientationConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Quaternion.h"
namespace moveit_msgs
{
class OrientationConstraint : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Quaternion _orientation_type;
_orientation_type orientation;
typedef const char* _link_name_type;
_link_name_type link_name;
typedef double _absolute_x_axis_tolerance_type;
_absolute_x_axis_tolerance_type absolute_x_axis_tolerance;
typedef double _absolute_y_axis_tolerance_type;
_absolute_y_axis_tolerance_type absolute_y_axis_tolerance;
typedef double _absolute_z_axis_tolerance_type;
_absolute_z_axis_tolerance_type absolute_z_axis_tolerance;
typedef double _weight_type;
_weight_type weight;
OrientationConstraint():
header(),
orientation(),
link_name(""),
absolute_x_axis_tolerance(0),
absolute_y_axis_tolerance(0),
absolute_z_axis_tolerance(0),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->orientation.serialize(outbuffer + offset);
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_absolute_x_axis_tolerance;
u_absolute_x_axis_tolerance.real = this->absolute_x_axis_tolerance;
*(outbuffer + offset + 0) = (u_absolute_x_axis_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_absolute_x_axis_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_absolute_x_axis_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_absolute_x_axis_tolerance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_absolute_x_axis_tolerance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_absolute_x_axis_tolerance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_absolute_x_axis_tolerance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_absolute_x_axis_tolerance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->absolute_x_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_y_axis_tolerance;
u_absolute_y_axis_tolerance.real = this->absolute_y_axis_tolerance;
*(outbuffer + offset + 0) = (u_absolute_y_axis_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_absolute_y_axis_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_absolute_y_axis_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_absolute_y_axis_tolerance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_absolute_y_axis_tolerance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_absolute_y_axis_tolerance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_absolute_y_axis_tolerance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_absolute_y_axis_tolerance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->absolute_y_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_z_axis_tolerance;
u_absolute_z_axis_tolerance.real = this->absolute_z_axis_tolerance;
*(outbuffer + offset + 0) = (u_absolute_z_axis_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_absolute_z_axis_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_absolute_z_axis_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_absolute_z_axis_tolerance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_absolute_z_axis_tolerance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_absolute_z_axis_tolerance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_absolute_z_axis_tolerance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_absolute_z_axis_tolerance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->absolute_z_axis_tolerance);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->orientation.deserialize(inbuffer + offset);
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_absolute_x_axis_tolerance;
u_absolute_x_axis_tolerance.base = 0;
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->absolute_x_axis_tolerance = u_absolute_x_axis_tolerance.real;
offset += sizeof(this->absolute_x_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_y_axis_tolerance;
u_absolute_y_axis_tolerance.base = 0;
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->absolute_y_axis_tolerance = u_absolute_y_axis_tolerance.real;
offset += sizeof(this->absolute_y_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_z_axis_tolerance;
u_absolute_z_axis_tolerance.base = 0;
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->absolute_z_axis_tolerance = u_absolute_z_axis_tolerance.real;
offset += sizeof(this->absolute_z_axis_tolerance);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/OrientationConstraint"; };
const char * getMD5(){ return "ab5cefb9bc4c0089620f5eb4caf4e59a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetMotionSequence.h | #ifndef _ROS_SERVICE_GetMotionSequence_h
#define _ROS_SERVICE_GetMotionSequence_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceRequest.h"
#include "moveit_msgs/MotionSequenceResponse.h"
namespace moveit_msgs
{
static const char GETMOTIONSEQUENCE[] = "moveit_msgs/GetMotionSequence";
class GetMotionSequenceRequest : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceRequest _request_type;
_request_type request;
GetMotionSequenceRequest():
request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONSEQUENCE; };
const char * getMD5(){ return "bae3996834a2cd1013b32c29e6a79b4e"; };
};
class GetMotionSequenceResponse : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceResponse _response_type;
_response_type response;
GetMotionSequenceResponse():
response()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->response.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->response.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONSEQUENCE; };
const char * getMD5(){ return "039cee462ada3f0feb5f4e2e12baefae"; };
};
class GetMotionSequence {
public:
typedef GetMotionSequenceRequest Request;
typedef GetMotionSequenceResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceResponse.h | #ifndef _ROS_moveit_msgs_MotionSequenceResponse_h
#define _ROS_moveit_msgs_MotionSequenceResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
class MotionSequenceResponse : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _sequence_start_type;
_sequence_start_type sequence_start;
uint32_t planned_trajectories_length;
typedef moveit_msgs::RobotTrajectory _planned_trajectories_type;
_planned_trajectories_type st_planned_trajectories;
_planned_trajectories_type * planned_trajectories;
typedef double _planning_time_type;
_planning_time_type planning_time;
MotionSequenceResponse():
error_code(),
sequence_start(),
planned_trajectories_length(0), planned_trajectories(NULL),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->sequence_start.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->planned_trajectories_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planned_trajectories_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planned_trajectories_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planned_trajectories_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planned_trajectories_length);
for( uint32_t i = 0; i < planned_trajectories_length; i++){
offset += this->planned_trajectories[i].serialize(outbuffer + offset);
}
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->sequence_start.deserialize(inbuffer + offset);
uint32_t planned_trajectories_lengthT = ((uint32_t) (*(inbuffer + offset)));
planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planned_trajectories_length);
if(planned_trajectories_lengthT > planned_trajectories_length)
this->planned_trajectories = (moveit_msgs::RobotTrajectory*)realloc(this->planned_trajectories, planned_trajectories_lengthT * sizeof(moveit_msgs::RobotTrajectory));
planned_trajectories_length = planned_trajectories_lengthT;
for( uint32_t i = 0; i < planned_trajectories_length; i++){
offset += this->st_planned_trajectories.deserialize(inbuffer + offset);
memcpy( &(this->planned_trajectories[i]), &(this->st_planned_trajectories), sizeof(moveit_msgs::RobotTrajectory));
}
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionSequenceResponse"; };
const char * getMD5(){ return "3b9d4e8079db4576e4829d30617a3d1d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ChangeControlDimensions.h | #ifndef _ROS_SERVICE_ChangeControlDimensions_h
#define _ROS_SERVICE_ChangeControlDimensions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char CHANGECONTROLDIMENSIONS[] = "moveit_msgs/ChangeControlDimensions";
class ChangeControlDimensionsRequest : public ros::Msg
{
public:
typedef bool _control_x_translation_type;
_control_x_translation_type control_x_translation;
typedef bool _control_y_translation_type;
_control_y_translation_type control_y_translation;
typedef bool _control_z_translation_type;
_control_z_translation_type control_z_translation;
typedef bool _control_x_rotation_type;
_control_x_rotation_type control_x_rotation;
typedef bool _control_y_rotation_type;
_control_y_rotation_type control_y_rotation;
typedef bool _control_z_rotation_type;
_control_z_rotation_type control_z_rotation;
ChangeControlDimensionsRequest():
control_x_translation(0),
control_y_translation(0),
control_z_translation(0),
control_x_rotation(0),
control_y_rotation(0),
control_z_rotation(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_control_x_translation;
u_control_x_translation.real = this->control_x_translation;
*(outbuffer + offset + 0) = (u_control_x_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_x_translation);
union {
bool real;
uint8_t base;
} u_control_y_translation;
u_control_y_translation.real = this->control_y_translation;
*(outbuffer + offset + 0) = (u_control_y_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_y_translation);
union {
bool real;
uint8_t base;
} u_control_z_translation;
u_control_z_translation.real = this->control_z_translation;
*(outbuffer + offset + 0) = (u_control_z_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_z_translation);
union {
bool real;
uint8_t base;
} u_control_x_rotation;
u_control_x_rotation.real = this->control_x_rotation;
*(outbuffer + offset + 0) = (u_control_x_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_x_rotation);
union {
bool real;
uint8_t base;
} u_control_y_rotation;
u_control_y_rotation.real = this->control_y_rotation;
*(outbuffer + offset + 0) = (u_control_y_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_y_rotation);
union {
bool real;
uint8_t base;
} u_control_z_rotation;
u_control_z_rotation.real = this->control_z_rotation;
*(outbuffer + offset + 0) = (u_control_z_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_z_rotation);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_control_x_translation;
u_control_x_translation.base = 0;
u_control_x_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_x_translation = u_control_x_translation.real;
offset += sizeof(this->control_x_translation);
union {
bool real;
uint8_t base;
} u_control_y_translation;
u_control_y_translation.base = 0;
u_control_y_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_y_translation = u_control_y_translation.real;
offset += sizeof(this->control_y_translation);
union {
bool real;
uint8_t base;
} u_control_z_translation;
u_control_z_translation.base = 0;
u_control_z_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_z_translation = u_control_z_translation.real;
offset += sizeof(this->control_z_translation);
union {
bool real;
uint8_t base;
} u_control_x_rotation;
u_control_x_rotation.base = 0;
u_control_x_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_x_rotation = u_control_x_rotation.real;
offset += sizeof(this->control_x_rotation);
union {
bool real;
uint8_t base;
} u_control_y_rotation;
u_control_y_rotation.base = 0;
u_control_y_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_y_rotation = u_control_y_rotation.real;
offset += sizeof(this->control_y_rotation);
union {
bool real;
uint8_t base;
} u_control_z_rotation;
u_control_z_rotation.base = 0;
u_control_z_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_z_rotation = u_control_z_rotation.real;
offset += sizeof(this->control_z_rotation);
return offset;
}
const char * getType(){ return CHANGECONTROLDIMENSIONS; };
const char * getMD5(){ return "64c0dd6d519e78f5ce2626b06dab34c1"; };
};
class ChangeControlDimensionsResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
ChangeControlDimensionsResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return CHANGECONTROLDIMENSIONS; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class ChangeControlDimensions {
public:
typedef ChangeControlDimensionsRequest Request;
typedef ChangeControlDimensionsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GraspPlanning.h | #ifndef _ROS_SERVICE_GraspPlanning_h
#define _ROS_SERVICE_GraspPlanning_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/Grasp.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/CollisionObject.h"
namespace moveit_msgs
{
static const char GRASPPLANNING[] = "moveit_msgs/GraspPlanning";
class GraspPlanningRequest : public ros::Msg
{
public:
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::CollisionObject _target_type;
_target_type target;
uint32_t support_surfaces_length;
typedef char* _support_surfaces_type;
_support_surfaces_type st_support_surfaces;
_support_surfaces_type * support_surfaces;
uint32_t candidate_grasps_length;
typedef moveit_msgs::Grasp _candidate_grasps_type;
_candidate_grasps_type st_candidate_grasps;
_candidate_grasps_type * candidate_grasps;
uint32_t movable_obstacles_length;
typedef moveit_msgs::CollisionObject _movable_obstacles_type;
_movable_obstacles_type st_movable_obstacles;
_movable_obstacles_type * movable_obstacles;
GraspPlanningRequest():
group_name(""),
target(),
support_surfaces_length(0), support_surfaces(NULL),
candidate_grasps_length(0), candidate_grasps(NULL),
movable_obstacles_length(0), movable_obstacles(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->target.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->support_surfaces_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->support_surfaces_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->support_surfaces_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->support_surfaces_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->support_surfaces_length);
for( uint32_t i = 0; i < support_surfaces_length; i++){
uint32_t length_support_surfacesi = strlen(this->support_surfaces[i]);
varToArr(outbuffer + offset, length_support_surfacesi);
offset += 4;
memcpy(outbuffer + offset, this->support_surfaces[i], length_support_surfacesi);
offset += length_support_surfacesi;
}
*(outbuffer + offset + 0) = (this->candidate_grasps_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->candidate_grasps_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->candidate_grasps_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->candidate_grasps_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->candidate_grasps_length);
for( uint32_t i = 0; i < candidate_grasps_length; i++){
offset += this->candidate_grasps[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->movable_obstacles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->movable_obstacles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->movable_obstacles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->movable_obstacles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->movable_obstacles_length);
for( uint32_t i = 0; i < movable_obstacles_length; i++){
offset += this->movable_obstacles[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->target.deserialize(inbuffer + offset);
uint32_t support_surfaces_lengthT = ((uint32_t) (*(inbuffer + offset)));
support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->support_surfaces_length);
if(support_surfaces_lengthT > support_surfaces_length)
this->support_surfaces = (char**)realloc(this->support_surfaces, support_surfaces_lengthT * sizeof(char*));
support_surfaces_length = support_surfaces_lengthT;
for( uint32_t i = 0; i < support_surfaces_length; i++){
uint32_t length_st_support_surfaces;
arrToVar(length_st_support_surfaces, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_support_surfaces; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_support_surfaces-1]=0;
this->st_support_surfaces = (char *)(inbuffer + offset-1);
offset += length_st_support_surfaces;
memcpy( &(this->support_surfaces[i]), &(this->st_support_surfaces), sizeof(char*));
}
uint32_t candidate_grasps_lengthT = ((uint32_t) (*(inbuffer + offset)));
candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->candidate_grasps_length);
if(candidate_grasps_lengthT > candidate_grasps_length)
this->candidate_grasps = (moveit_msgs::Grasp*)realloc(this->candidate_grasps, candidate_grasps_lengthT * sizeof(moveit_msgs::Grasp));
candidate_grasps_length = candidate_grasps_lengthT;
for( uint32_t i = 0; i < candidate_grasps_length; i++){
offset += this->st_candidate_grasps.deserialize(inbuffer + offset);
memcpy( &(this->candidate_grasps[i]), &(this->st_candidate_grasps), sizeof(moveit_msgs::Grasp));
}
uint32_t movable_obstacles_lengthT = ((uint32_t) (*(inbuffer + offset)));
movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->movable_obstacles_length);
if(movable_obstacles_lengthT > movable_obstacles_length)
this->movable_obstacles = (moveit_msgs::CollisionObject*)realloc(this->movable_obstacles, movable_obstacles_lengthT * sizeof(moveit_msgs::CollisionObject));
movable_obstacles_length = movable_obstacles_lengthT;
for( uint32_t i = 0; i < movable_obstacles_length; i++){
offset += this->st_movable_obstacles.deserialize(inbuffer + offset);
memcpy( &(this->movable_obstacles[i]), &(this->st_movable_obstacles), sizeof(moveit_msgs::CollisionObject));
}
return offset;
}
const char * getType(){ return GRASPPLANNING; };
const char * getMD5(){ return "c234e9a645708cc86b57a43999746ae6"; };
};
class GraspPlanningResponse : public ros::Msg
{
public:
uint32_t grasps_length;
typedef moveit_msgs::Grasp _grasps_type;
_grasps_type st_grasps;
_grasps_type * grasps;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GraspPlanningResponse():
grasps_length(0), grasps(NULL),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->grasps_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->grasps_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->grasps_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->grasps_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->grasps_length);
for( uint32_t i = 0; i < grasps_length; i++){
offset += this->grasps[i].serialize(outbuffer + offset);
}
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t grasps_lengthT = ((uint32_t) (*(inbuffer + offset)));
grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->grasps_length);
if(grasps_lengthT > grasps_length)
this->grasps = (moveit_msgs::Grasp*)realloc(this->grasps, grasps_lengthT * sizeof(moveit_msgs::Grasp));
grasps_length = grasps_lengthT;
for( uint32_t i = 0; i < grasps_length; i++){
offset += this->st_grasps.deserialize(inbuffer + offset);
memcpy( &(this->grasps[i]), &(this->st_grasps), sizeof(moveit_msgs::Grasp));
}
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GRASPPLANNING; };
const char * getMD5(){ return "bb8169d403b6e9f96bf61e22a50d13ae"; };
};
class GraspPlanning {
public:
typedef GraspPlanningRequest Request;
typedef GraspPlanningResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupResult.h | #ifndef _ROS_moveit_msgs_PickupResult_h
#define _ROS_moveit_msgs_PickupResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/Grasp.h"
namespace moveit_msgs
{
class PickupResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
uint32_t trajectory_stages_length;
typedef moveit_msgs::RobotTrajectory _trajectory_stages_type;
_trajectory_stages_type st_trajectory_stages;
_trajectory_stages_type * trajectory_stages;
uint32_t trajectory_descriptions_length;
typedef char* _trajectory_descriptions_type;
_trajectory_descriptions_type st_trajectory_descriptions;
_trajectory_descriptions_type * trajectory_descriptions;
typedef moveit_msgs::Grasp _grasp_type;
_grasp_type grasp;
typedef double _planning_time_type;
_planning_time_type planning_time;
PickupResult():
error_code(),
trajectory_start(),
trajectory_stages_length(0), trajectory_stages(NULL),
trajectory_descriptions_length(0), trajectory_descriptions(NULL),
grasp(),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->trajectory_start.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_stages_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_stages_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_stages_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_stages_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_stages_length);
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->trajectory_stages[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->trajectory_descriptions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_descriptions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_descriptions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_descriptions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_descriptions_length);
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_trajectory_descriptionsi = strlen(this->trajectory_descriptions[i]);
varToArr(outbuffer + offset, length_trajectory_descriptionsi);
offset += 4;
memcpy(outbuffer + offset, this->trajectory_descriptions[i], length_trajectory_descriptionsi);
offset += length_trajectory_descriptionsi;
}
offset += this->grasp.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t trajectory_stages_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_stages_length);
if(trajectory_stages_lengthT > trajectory_stages_length)
this->trajectory_stages = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory_stages, trajectory_stages_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_stages_length = trajectory_stages_lengthT;
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->st_trajectory_stages.deserialize(inbuffer + offset);
memcpy( &(this->trajectory_stages[i]), &(this->st_trajectory_stages), sizeof(moveit_msgs::RobotTrajectory));
}
uint32_t trajectory_descriptions_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_descriptions_length);
if(trajectory_descriptions_lengthT > trajectory_descriptions_length)
this->trajectory_descriptions = (char**)realloc(this->trajectory_descriptions, trajectory_descriptions_lengthT * sizeof(char*));
trajectory_descriptions_length = trajectory_descriptions_lengthT;
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_st_trajectory_descriptions;
arrToVar(length_st_trajectory_descriptions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_trajectory_descriptions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_trajectory_descriptions-1]=0;
this->st_trajectory_descriptions = (char *)(inbuffer + offset-1);
offset += length_st_trajectory_descriptions;
memcpy( &(this->trajectory_descriptions[i]), &(this->st_trajectory_descriptions), sizeof(char*));
}
offset += this->grasp.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupResult"; };
const char * getMD5(){ return "c1e72234397d9de0761966243e264774"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanRequest.h | #ifndef _ROS_moveit_msgs_MotionPlanRequest_h
#define _ROS_moveit_msgs_MotionPlanRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/WorkspaceParameters.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/Constraints.h"
#include "moveit_msgs/TrajectoryConstraints.h"
namespace moveit_msgs
{
class MotionPlanRequest : public ros::Msg
{
public:
typedef moveit_msgs::WorkspaceParameters _workspace_parameters_type;
_workspace_parameters_type workspace_parameters;
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
uint32_t goal_constraints_length;
typedef moveit_msgs::Constraints _goal_constraints_type;
_goal_constraints_type st_goal_constraints;
_goal_constraints_type * goal_constraints;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
typedef moveit_msgs::TrajectoryConstraints _trajectory_constraints_type;
_trajectory_constraints_type trajectory_constraints;
typedef const char* _planner_id_type;
_planner_id_type planner_id;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef int32_t _num_planning_attempts_type;
_num_planning_attempts_type num_planning_attempts;
typedef double _allowed_planning_time_type;
_allowed_planning_time_type allowed_planning_time;
typedef double _max_velocity_scaling_factor_type;
_max_velocity_scaling_factor_type max_velocity_scaling_factor;
typedef double _max_acceleration_scaling_factor_type;
_max_acceleration_scaling_factor_type max_acceleration_scaling_factor;
MotionPlanRequest():
workspace_parameters(),
start_state(),
goal_constraints_length(0), goal_constraints(NULL),
path_constraints(),
trajectory_constraints(),
planner_id(""),
group_name(""),
num_planning_attempts(0),
allowed_planning_time(0),
max_velocity_scaling_factor(0),
max_acceleration_scaling_factor(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->workspace_parameters.serialize(outbuffer + offset);
offset += this->start_state.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->goal_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_constraints_length);
for( uint32_t i = 0; i < goal_constraints_length; i++){
offset += this->goal_constraints[i].serialize(outbuffer + offset);
}
offset += this->path_constraints.serialize(outbuffer + offset);
offset += this->trajectory_constraints.serialize(outbuffer + offset);
uint32_t length_planner_id = strlen(this->planner_id);
varToArr(outbuffer + offset, length_planner_id);
offset += 4;
memcpy(outbuffer + offset, this->planner_id, length_planner_id);
offset += length_planner_id;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
union {
int32_t real;
uint32_t base;
} u_num_planning_attempts;
u_num_planning_attempts.real = this->num_planning_attempts;
*(outbuffer + offset + 0) = (u_num_planning_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_num_planning_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_num_planning_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_num_planning_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->num_planning_attempts);
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.real = this->allowed_planning_time;
*(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->allowed_planning_time);
union {
double real;
uint64_t base;
} u_max_velocity_scaling_factor;
u_max_velocity_scaling_factor.real = this->max_velocity_scaling_factor;
*(outbuffer + offset + 0) = (u_max_velocity_scaling_factor.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity_scaling_factor.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity_scaling_factor.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity_scaling_factor.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity_scaling_factor.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity_scaling_factor.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity_scaling_factor.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity_scaling_factor.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity_scaling_factor);
union {
double real;
uint64_t base;
} u_max_acceleration_scaling_factor;
u_max_acceleration_scaling_factor.real = this->max_acceleration_scaling_factor;
*(outbuffer + offset + 0) = (u_max_acceleration_scaling_factor.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_acceleration_scaling_factor.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_acceleration_scaling_factor.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_acceleration_scaling_factor.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_acceleration_scaling_factor.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_acceleration_scaling_factor.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_acceleration_scaling_factor.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_acceleration_scaling_factor.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_acceleration_scaling_factor);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->workspace_parameters.deserialize(inbuffer + offset);
offset += this->start_state.deserialize(inbuffer + offset);
uint32_t goal_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_constraints_length);
if(goal_constraints_lengthT > goal_constraints_length)
this->goal_constraints = (moveit_msgs::Constraints*)realloc(this->goal_constraints, goal_constraints_lengthT * sizeof(moveit_msgs::Constraints));
goal_constraints_length = goal_constraints_lengthT;
for( uint32_t i = 0; i < goal_constraints_length; i++){
offset += this->st_goal_constraints.deserialize(inbuffer + offset);
memcpy( &(this->goal_constraints[i]), &(this->st_goal_constraints), sizeof(moveit_msgs::Constraints));
}
offset += this->path_constraints.deserialize(inbuffer + offset);
offset += this->trajectory_constraints.deserialize(inbuffer + offset);
uint32_t length_planner_id;
arrToVar(length_planner_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_id-1]=0;
this->planner_id = (char *)(inbuffer + offset-1);
offset += length_planner_id;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
union {
int32_t real;
uint32_t base;
} u_num_planning_attempts;
u_num_planning_attempts.base = 0;
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->num_planning_attempts = u_num_planning_attempts.real;
offset += sizeof(this->num_planning_attempts);
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.base = 0;
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->allowed_planning_time = u_allowed_planning_time.real;
offset += sizeof(this->allowed_planning_time);
union {
double real;
uint64_t base;
} u_max_velocity_scaling_factor;
u_max_velocity_scaling_factor.base = 0;
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_velocity_scaling_factor = u_max_velocity_scaling_factor.real;
offset += sizeof(this->max_velocity_scaling_factor);
union {
double real;
uint64_t base;
} u_max_acceleration_scaling_factor;
u_max_acceleration_scaling_factor.base = 0;
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_acceleration_scaling_factor = u_max_acceleration_scaling_factor.real;
offset += sizeof(this->max_acceleration_scaling_factor);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanRequest"; };
const char * getMD5(){ return "c3bec13a525a6ae66e0fc57b768fdca6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceActionFeedback.h | #ifndef _ROS_moveit_msgs_PlaceActionFeedback_h
#define _ROS_moveit_msgs_PlaceActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/PlaceFeedback.h"
namespace moveit_msgs
{
class PlaceActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PlaceFeedback _feedback_type;
_feedback_type feedback;
PlaceActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryFeedback.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryFeedback_h
#define _ROS_moveit_msgs_ExecuteTrajectoryFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class ExecuteTrajectoryFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
ExecuteTrajectoryFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryGoal.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryGoal_h
#define _ROS_moveit_msgs_ExecuteTrajectoryGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
class ExecuteTrajectoryGoal : public ros::Msg
{
public:
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type trajectory;
ExecuteTrajectoryGoal():
trajectory()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryGoal"; };
const char * getMD5(){ return "054c09e62210d7faad2f9fffdad07b57"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupActionResult.h | #ifndef _ROS_moveit_msgs_PickupActionResult_h
#define _ROS_moveit_msgs_PickupActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/PickupResult.h"
namespace moveit_msgs
{
class PickupActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PickupResult _result_type;
_result_type result;
PickupActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupActionResult"; };
const char * getMD5(){ return "4c148688ab234ff8a8c02f1b8360c1bb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/Grasp.h | #ifndef _ROS_moveit_msgs_Grasp_h
#define _ROS_moveit_msgs_Grasp_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "geometry_msgs/PoseStamped.h"
#include "moveit_msgs/GripperTranslation.h"
namespace moveit_msgs
{
class Grasp : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef trajectory_msgs::JointTrajectory _pre_grasp_posture_type;
_pre_grasp_posture_type pre_grasp_posture;
typedef trajectory_msgs::JointTrajectory _grasp_posture_type;
_grasp_posture_type grasp_posture;
typedef geometry_msgs::PoseStamped _grasp_pose_type;
_grasp_pose_type grasp_pose;
typedef double _grasp_quality_type;
_grasp_quality_type grasp_quality;
typedef moveit_msgs::GripperTranslation _pre_grasp_approach_type;
_pre_grasp_approach_type pre_grasp_approach;
typedef moveit_msgs::GripperTranslation _post_grasp_retreat_type;
_post_grasp_retreat_type post_grasp_retreat;
typedef moveit_msgs::GripperTranslation _post_place_retreat_type;
_post_place_retreat_type post_place_retreat;
typedef float _max_contact_force_type;
_max_contact_force_type max_contact_force;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
Grasp():
id(""),
pre_grasp_posture(),
grasp_posture(),
grasp_pose(),
grasp_quality(0),
pre_grasp_approach(),
post_grasp_retreat(),
post_place_retreat(),
max_contact_force(0),
allowed_touch_objects_length(0), allowed_touch_objects(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
offset += this->pre_grasp_posture.serialize(outbuffer + offset);
offset += this->grasp_posture.serialize(outbuffer + offset);
offset += this->grasp_pose.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_grasp_quality;
u_grasp_quality.real = this->grasp_quality;
*(outbuffer + offset + 0) = (u_grasp_quality.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_grasp_quality.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_grasp_quality.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_grasp_quality.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_grasp_quality.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_grasp_quality.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_grasp_quality.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_grasp_quality.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->grasp_quality);
offset += this->pre_grasp_approach.serialize(outbuffer + offset);
offset += this->post_grasp_retreat.serialize(outbuffer + offset);
offset += this->post_place_retreat.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_max_contact_force;
u_max_contact_force.real = this->max_contact_force;
*(outbuffer + offset + 0) = (u_max_contact_force.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_contact_force.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_contact_force.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_contact_force.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_contact_force);
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
offset += this->pre_grasp_posture.deserialize(inbuffer + offset);
offset += this->grasp_posture.deserialize(inbuffer + offset);
offset += this->grasp_pose.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_grasp_quality;
u_grasp_quality.base = 0;
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->grasp_quality = u_grasp_quality.real;
offset += sizeof(this->grasp_quality);
offset += this->pre_grasp_approach.deserialize(inbuffer + offset);
offset += this->post_grasp_retreat.deserialize(inbuffer + offset);
offset += this->post_place_retreat.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_max_contact_force;
u_max_contact_force.base = 0;
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->max_contact_force = u_max_contact_force.real;
offset += sizeof(this->max_contact_force);
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/Grasp"; };
const char * getMD5(){ return "e26c8fb64f589c33c5d5e54bd7b5e4cb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ContactInformation.h | #ifndef _ROS_moveit_msgs_ContactInformation_h
#define _ROS_moveit_msgs_ContactInformation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point.h"
#include "geometry_msgs/Vector3.h"
namespace moveit_msgs
{
class ContactInformation : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Point _position_type;
_position_type position;
typedef geometry_msgs::Vector3 _normal_type;
_normal_type normal;
typedef double _depth_type;
_depth_type depth;
typedef const char* _contact_body_1_type;
_contact_body_1_type contact_body_1;
typedef uint32_t _body_type_1_type;
_body_type_1_type body_type_1;
typedef const char* _contact_body_2_type;
_contact_body_2_type contact_body_2;
typedef uint32_t _body_type_2_type;
_body_type_2_type body_type_2;
enum { ROBOT_LINK = 0 };
enum { WORLD_OBJECT = 1 };
enum { ROBOT_ATTACHED = 2 };
ContactInformation():
header(),
position(),
normal(),
depth(0),
contact_body_1(""),
body_type_1(0),
contact_body_2(""),
body_type_2(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->position.serialize(outbuffer + offset);
offset += this->normal.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_depth;
u_depth.real = this->depth;
*(outbuffer + offset + 0) = (u_depth.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_depth.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_depth.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_depth.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_depth.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_depth.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_depth.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_depth.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->depth);
uint32_t length_contact_body_1 = strlen(this->contact_body_1);
varToArr(outbuffer + offset, length_contact_body_1);
offset += 4;
memcpy(outbuffer + offset, this->contact_body_1, length_contact_body_1);
offset += length_contact_body_1;
*(outbuffer + offset + 0) = (this->body_type_1 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->body_type_1 >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->body_type_1 >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->body_type_1 >> (8 * 3)) & 0xFF;
offset += sizeof(this->body_type_1);
uint32_t length_contact_body_2 = strlen(this->contact_body_2);
varToArr(outbuffer + offset, length_contact_body_2);
offset += 4;
memcpy(outbuffer + offset, this->contact_body_2, length_contact_body_2);
offset += length_contact_body_2;
*(outbuffer + offset + 0) = (this->body_type_2 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->body_type_2 >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->body_type_2 >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->body_type_2 >> (8 * 3)) & 0xFF;
offset += sizeof(this->body_type_2);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->position.deserialize(inbuffer + offset);
offset += this->normal.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_depth;
u_depth.base = 0;
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->depth = u_depth.real;
offset += sizeof(this->depth);
uint32_t length_contact_body_1;
arrToVar(length_contact_body_1, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_contact_body_1; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_contact_body_1-1]=0;
this->contact_body_1 = (char *)(inbuffer + offset-1);
offset += length_contact_body_1;
this->body_type_1 = ((uint32_t) (*(inbuffer + offset)));
this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->body_type_1);
uint32_t length_contact_body_2;
arrToVar(length_contact_body_2, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_contact_body_2; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_contact_body_2-1]=0;
this->contact_body_2 = (char *)(inbuffer + offset-1);
offset += length_contact_body_2;
this->body_type_2 = ((uint32_t) (*(inbuffer + offset)));
this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->body_type_2);
return offset;
}
const char * getType(){ return "moveit_msgs/ContactInformation"; };
const char * getMD5(){ return "116228ca08b0c286ec5ca32a50fdc17b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningSceneComponents.h | #ifndef _ROS_moveit_msgs_PlanningSceneComponents_h
#define _ROS_moveit_msgs_PlanningSceneComponents_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlanningSceneComponents : public ros::Msg
{
public:
typedef uint32_t _components_type;
_components_type components;
enum { SCENE_SETTINGS = 1 };
enum { ROBOT_STATE = 2 };
enum { ROBOT_STATE_ATTACHED_OBJECTS = 4 };
enum { WORLD_OBJECT_NAMES = 8 };
enum { WORLD_OBJECT_GEOMETRY = 16 };
enum { OCTOMAP = 32 };
enum { TRANSFORMS = 64 };
enum { ALLOWED_COLLISION_MATRIX = 128 };
enum { LINK_PADDING_AND_SCALING = 256 };
enum { OBJECT_COLORS = 512 };
PlanningSceneComponents():
components(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->components >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->components >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->components >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->components >> (8 * 3)) & 0xFF;
offset += sizeof(this->components);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->components = ((uint32_t) (*(inbuffer + offset)));
this->components |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->components |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->components |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->components);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningSceneComponents"; };
const char * getMD5(){ return "bc993e784476960b918b6e7ad5bb58ce"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupActionFeedback.h | #ifndef _ROS_moveit_msgs_PickupActionFeedback_h
#define _ROS_moveit_msgs_PickupActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/PickupFeedback.h"
namespace moveit_msgs
{
class PickupActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PickupFeedback _feedback_type;
_feedback_type feedback;
PickupActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryResult.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryResult_h
#define _ROS_moveit_msgs_ExecuteTrajectoryResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class ExecuteTrajectoryResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
ExecuteTrajectoryResult():
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryResult"; };
const char * getMD5(){ return "1f7ab918f5d0c5312f25263d3d688122"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ChangeDriftDimensions.h | #ifndef _ROS_SERVICE_ChangeDriftDimensions_h
#define _ROS_SERVICE_ChangeDriftDimensions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Transform.h"
namespace moveit_msgs
{
static const char CHANGEDRIFTDIMENSIONS[] = "moveit_msgs/ChangeDriftDimensions";
class ChangeDriftDimensionsRequest : public ros::Msg
{
public:
typedef bool _drift_x_translation_type;
_drift_x_translation_type drift_x_translation;
typedef bool _drift_y_translation_type;
_drift_y_translation_type drift_y_translation;
typedef bool _drift_z_translation_type;
_drift_z_translation_type drift_z_translation;
typedef bool _drift_x_rotation_type;
_drift_x_rotation_type drift_x_rotation;
typedef bool _drift_y_rotation_type;
_drift_y_rotation_type drift_y_rotation;
typedef bool _drift_z_rotation_type;
_drift_z_rotation_type drift_z_rotation;
typedef geometry_msgs::Transform _transform_jog_frame_to_drift_frame_type;
_transform_jog_frame_to_drift_frame_type transform_jog_frame_to_drift_frame;
ChangeDriftDimensionsRequest():
drift_x_translation(0),
drift_y_translation(0),
drift_z_translation(0),
drift_x_rotation(0),
drift_y_rotation(0),
drift_z_rotation(0),
transform_jog_frame_to_drift_frame()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_drift_x_translation;
u_drift_x_translation.real = this->drift_x_translation;
*(outbuffer + offset + 0) = (u_drift_x_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_x_translation);
union {
bool real;
uint8_t base;
} u_drift_y_translation;
u_drift_y_translation.real = this->drift_y_translation;
*(outbuffer + offset + 0) = (u_drift_y_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_y_translation);
union {
bool real;
uint8_t base;
} u_drift_z_translation;
u_drift_z_translation.real = this->drift_z_translation;
*(outbuffer + offset + 0) = (u_drift_z_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_z_translation);
union {
bool real;
uint8_t base;
} u_drift_x_rotation;
u_drift_x_rotation.real = this->drift_x_rotation;
*(outbuffer + offset + 0) = (u_drift_x_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_x_rotation);
union {
bool real;
uint8_t base;
} u_drift_y_rotation;
u_drift_y_rotation.real = this->drift_y_rotation;
*(outbuffer + offset + 0) = (u_drift_y_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_y_rotation);
union {
bool real;
uint8_t base;
} u_drift_z_rotation;
u_drift_z_rotation.real = this->drift_z_rotation;
*(outbuffer + offset + 0) = (u_drift_z_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_z_rotation);
offset += this->transform_jog_frame_to_drift_frame.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_drift_x_translation;
u_drift_x_translation.base = 0;
u_drift_x_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_x_translation = u_drift_x_translation.real;
offset += sizeof(this->drift_x_translation);
union {
bool real;
uint8_t base;
} u_drift_y_translation;
u_drift_y_translation.base = 0;
u_drift_y_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_y_translation = u_drift_y_translation.real;
offset += sizeof(this->drift_y_translation);
union {
bool real;
uint8_t base;
} u_drift_z_translation;
u_drift_z_translation.base = 0;
u_drift_z_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_z_translation = u_drift_z_translation.real;
offset += sizeof(this->drift_z_translation);
union {
bool real;
uint8_t base;
} u_drift_x_rotation;
u_drift_x_rotation.base = 0;
u_drift_x_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_x_rotation = u_drift_x_rotation.real;
offset += sizeof(this->drift_x_rotation);
union {
bool real;
uint8_t base;
} u_drift_y_rotation;
u_drift_y_rotation.base = 0;
u_drift_y_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_y_rotation = u_drift_y_rotation.real;
offset += sizeof(this->drift_y_rotation);
union {
bool real;
uint8_t base;
} u_drift_z_rotation;
u_drift_z_rotation.base = 0;
u_drift_z_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_z_rotation = u_drift_z_rotation.real;
offset += sizeof(this->drift_z_rotation);
offset += this->transform_jog_frame_to_drift_frame.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return CHANGEDRIFTDIMENSIONS; };
const char * getMD5(){ return "4a5ce44f94cdee672e699df89b1ebaf1"; };
};
class ChangeDriftDimensionsResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
ChangeDriftDimensionsResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return CHANGEDRIFTDIMENSIONS; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class ChangeDriftDimensions {
public:
typedef ChangeDriftDimensionsRequest Request;
typedef ChangeDriftDimensionsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPositionFK.h | #ifndef _ROS_SERVICE_GetPositionFK_h
#define _ROS_SERVICE_GetPositionFK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "geometry_msgs/PoseStamped.h"
#include "std_msgs/Header.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char GETPOSITIONFK[] = "moveit_msgs/GetPositionFK";
class GetPositionFKRequest : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t fk_link_names_length;
typedef char* _fk_link_names_type;
_fk_link_names_type st_fk_link_names;
_fk_link_names_type * fk_link_names;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
GetPositionFKRequest():
header(),
fk_link_names_length(0), fk_link_names(NULL),
robot_state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->fk_link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fk_link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fk_link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fk_link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fk_link_names_length);
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_fk_link_namesi = strlen(this->fk_link_names[i]);
varToArr(outbuffer + offset, length_fk_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->fk_link_names[i], length_fk_link_namesi);
offset += length_fk_link_namesi;
}
offset += this->robot_state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t fk_link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fk_link_names_length);
if(fk_link_names_lengthT > fk_link_names_length)
this->fk_link_names = (char**)realloc(this->fk_link_names, fk_link_names_lengthT * sizeof(char*));
fk_link_names_length = fk_link_names_lengthT;
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_st_fk_link_names;
arrToVar(length_st_fk_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_fk_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_fk_link_names-1]=0;
this->st_fk_link_names = (char *)(inbuffer + offset-1);
offset += length_st_fk_link_names;
memcpy( &(this->fk_link_names[i]), &(this->st_fk_link_names), sizeof(char*));
}
offset += this->robot_state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONFK; };
const char * getMD5(){ return "1d1ed72044ed56f6246c31b522781797"; };
};
class GetPositionFKResponse : public ros::Msg
{
public:
uint32_t pose_stamped_length;
typedef geometry_msgs::PoseStamped _pose_stamped_type;
_pose_stamped_type st_pose_stamped;
_pose_stamped_type * pose_stamped;
uint32_t fk_link_names_length;
typedef char* _fk_link_names_type;
_fk_link_names_type st_fk_link_names;
_fk_link_names_type * fk_link_names;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetPositionFKResponse():
pose_stamped_length(0), pose_stamped(NULL),
fk_link_names_length(0), fk_link_names(NULL),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->pose_stamped_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamped_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamped_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamped_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamped_length);
for( uint32_t i = 0; i < pose_stamped_length; i++){
offset += this->pose_stamped[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->fk_link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fk_link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fk_link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fk_link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fk_link_names_length);
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_fk_link_namesi = strlen(this->fk_link_names[i]);
varToArr(outbuffer + offset, length_fk_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->fk_link_names[i], length_fk_link_namesi);
offset += length_fk_link_namesi;
}
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t pose_stamped_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamped_length);
if(pose_stamped_lengthT > pose_stamped_length)
this->pose_stamped = (geometry_msgs::PoseStamped*)realloc(this->pose_stamped, pose_stamped_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamped_length = pose_stamped_lengthT;
for( uint32_t i = 0; i < pose_stamped_length; i++){
offset += this->st_pose_stamped.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamped[i]), &(this->st_pose_stamped), sizeof(geometry_msgs::PoseStamped));
}
uint32_t fk_link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fk_link_names_length);
if(fk_link_names_lengthT > fk_link_names_length)
this->fk_link_names = (char**)realloc(this->fk_link_names, fk_link_names_lengthT * sizeof(char*));
fk_link_names_length = fk_link_names_lengthT;
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_st_fk_link_names;
arrToVar(length_st_fk_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_fk_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_fk_link_names-1]=0;
this->st_fk_link_names = (char *)(inbuffer + offset-1);
offset += length_st_fk_link_names;
memcpy( &(this->fk_link_names[i]), &(this->st_fk_link_names), sizeof(char*));
}
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONFK; };
const char * getMD5(){ return "297215cf4fdfe0008356995ae621dae6"; };
};
class GetPositionFK {
public:
typedef GetPositionFKRequest Request;
typedef GetPositionFKResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CheckIfRobotStateExistsInWarehouse.h | #ifndef _ROS_SERVICE_CheckIfRobotStateExistsInWarehouse_h
#define _ROS_SERVICE_CheckIfRobotStateExistsInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char CHECKIFROBOTSTATEEXISTSINWAREHOUSE[] = "moveit_msgs/CheckIfRobotStateExistsInWarehouse";
class CheckIfRobotStateExistsInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
CheckIfRobotStateExistsInWarehouseRequest():
name(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return CHECKIFROBOTSTATEEXISTSINWAREHOUSE; };
const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; };
};
class CheckIfRobotStateExistsInWarehouseResponse : public ros::Msg
{
public:
typedef bool _exists_type;
_exists_type exists;
CheckIfRobotStateExistsInWarehouseResponse():
exists(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_exists;
u_exists.real = this->exists;
*(outbuffer + offset + 0) = (u_exists.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->exists);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_exists;
u_exists.base = 0;
u_exists.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->exists = u_exists.real;
offset += sizeof(this->exists);
return offset;
}
const char * getType(){ return CHECKIFROBOTSTATEEXISTSINWAREHOUSE; };
const char * getMD5(){ return "e8c90de4adc1219c86af9c2874c0c1b5"; };
};
class CheckIfRobotStateExistsInWarehouse {
public:
typedef CheckIfRobotStateExistsInWarehouseRequest Request;
typedef CheckIfRobotStateExistsInWarehouseResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DeleteRobotStateFromWarehouse.h | #ifndef _ROS_SERVICE_DeleteRobotStateFromWarehouse_h
#define _ROS_SERVICE_DeleteRobotStateFromWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char DELETEROBOTSTATEFROMWAREHOUSE[] = "moveit_msgs/DeleteRobotStateFromWarehouse";
class DeleteRobotStateFromWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
DeleteRobotStateFromWarehouseRequest():
name(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return DELETEROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; };
};
class DeleteRobotStateFromWarehouseResponse : public ros::Msg
{
public:
DeleteRobotStateFromWarehouseResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return DELETEROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DeleteRobotStateFromWarehouse {
public:
typedef DeleteRobotStateFromWarehouseRequest Request;
typedef DeleteRobotStateFromWarehouseResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupGoal.h | #ifndef _ROS_moveit_msgs_PickupGoal_h
#define _ROS_moveit_msgs_PickupGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/Grasp.h"
#include "moveit_msgs/Constraints.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class PickupGoal : public ros::Msg
{
public:
typedef const char* _target_name_type;
_target_name_type target_name;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef const char* _end_effector_type;
_end_effector_type end_effector;
uint32_t possible_grasps_length;
typedef moveit_msgs::Grasp _possible_grasps_type;
_possible_grasps_type st_possible_grasps;
_possible_grasps_type * possible_grasps;
typedef const char* _support_surface_name_type;
_support_surface_name_type support_surface_name;
typedef bool _allow_gripper_support_collision_type;
_allow_gripper_support_collision_type allow_gripper_support_collision;
uint32_t attached_object_touch_links_length;
typedef char* _attached_object_touch_links_type;
_attached_object_touch_links_type st_attached_object_touch_links;
_attached_object_touch_links_type * attached_object_touch_links;
typedef bool _minimize_object_distance_type;
_minimize_object_distance_type minimize_object_distance;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
typedef const char* _planner_id_type;
_planner_id_type planner_id;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
typedef double _allowed_planning_time_type;
_allowed_planning_time_type allowed_planning_time;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
PickupGoal():
target_name(""),
group_name(""),
end_effector(""),
possible_grasps_length(0), possible_grasps(NULL),
support_surface_name(""),
allow_gripper_support_collision(0),
attached_object_touch_links_length(0), attached_object_touch_links(NULL),
minimize_object_distance(0),
path_constraints(),
planner_id(""),
allowed_touch_objects_length(0), allowed_touch_objects(NULL),
allowed_planning_time(0),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_target_name = strlen(this->target_name);
varToArr(outbuffer + offset, length_target_name);
offset += 4;
memcpy(outbuffer + offset, this->target_name, length_target_name);
offset += length_target_name;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
uint32_t length_end_effector = strlen(this->end_effector);
varToArr(outbuffer + offset, length_end_effector);
offset += 4;
memcpy(outbuffer + offset, this->end_effector, length_end_effector);
offset += length_end_effector;
*(outbuffer + offset + 0) = (this->possible_grasps_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->possible_grasps_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->possible_grasps_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->possible_grasps_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->possible_grasps_length);
for( uint32_t i = 0; i < possible_grasps_length; i++){
offset += this->possible_grasps[i].serialize(outbuffer + offset);
}
uint32_t length_support_surface_name = strlen(this->support_surface_name);
varToArr(outbuffer + offset, length_support_surface_name);
offset += 4;
memcpy(outbuffer + offset, this->support_surface_name, length_support_surface_name);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.real = this->allow_gripper_support_collision;
*(outbuffer + offset + 0) = (u_allow_gripper_support_collision.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->allow_gripper_support_collision);
*(outbuffer + offset + 0) = (this->attached_object_touch_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->attached_object_touch_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->attached_object_touch_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->attached_object_touch_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->attached_object_touch_links_length);
for( uint32_t i = 0; i < attached_object_touch_links_length; i++){
uint32_t length_attached_object_touch_linksi = strlen(this->attached_object_touch_links[i]);
varToArr(outbuffer + offset, length_attached_object_touch_linksi);
offset += 4;
memcpy(outbuffer + offset, this->attached_object_touch_links[i], length_attached_object_touch_linksi);
offset += length_attached_object_touch_linksi;
}
union {
bool real;
uint8_t base;
} u_minimize_object_distance;
u_minimize_object_distance.real = this->minimize_object_distance;
*(outbuffer + offset + 0) = (u_minimize_object_distance.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->minimize_object_distance);
offset += this->path_constraints.serialize(outbuffer + offset);
uint32_t length_planner_id = strlen(this->planner_id);
varToArr(outbuffer + offset, length_planner_id);
offset += 4;
memcpy(outbuffer + offset, this->planner_id, length_planner_id);
offset += length_planner_id;
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.real = this->allowed_planning_time;
*(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_target_name;
arrToVar(length_target_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target_name-1]=0;
this->target_name = (char *)(inbuffer + offset-1);
offset += length_target_name;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t length_end_effector;
arrToVar(length_end_effector, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_end_effector; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_end_effector-1]=0;
this->end_effector = (char *)(inbuffer + offset-1);
offset += length_end_effector;
uint32_t possible_grasps_lengthT = ((uint32_t) (*(inbuffer + offset)));
possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->possible_grasps_length);
if(possible_grasps_lengthT > possible_grasps_length)
this->possible_grasps = (moveit_msgs::Grasp*)realloc(this->possible_grasps, possible_grasps_lengthT * sizeof(moveit_msgs::Grasp));
possible_grasps_length = possible_grasps_lengthT;
for( uint32_t i = 0; i < possible_grasps_length; i++){
offset += this->st_possible_grasps.deserialize(inbuffer + offset);
memcpy( &(this->possible_grasps[i]), &(this->st_possible_grasps), sizeof(moveit_msgs::Grasp));
}
uint32_t length_support_surface_name;
arrToVar(length_support_surface_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_support_surface_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_support_surface_name-1]=0;
this->support_surface_name = (char *)(inbuffer + offset-1);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.base = 0;
u_allow_gripper_support_collision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->allow_gripper_support_collision = u_allow_gripper_support_collision.real;
offset += sizeof(this->allow_gripper_support_collision);
uint32_t attached_object_touch_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->attached_object_touch_links_length);
if(attached_object_touch_links_lengthT > attached_object_touch_links_length)
this->attached_object_touch_links = (char**)realloc(this->attached_object_touch_links, attached_object_touch_links_lengthT * sizeof(char*));
attached_object_touch_links_length = attached_object_touch_links_lengthT;
for( uint32_t i = 0; i < attached_object_touch_links_length; i++){
uint32_t length_st_attached_object_touch_links;
arrToVar(length_st_attached_object_touch_links, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_attached_object_touch_links; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_attached_object_touch_links-1]=0;
this->st_attached_object_touch_links = (char *)(inbuffer + offset-1);
offset += length_st_attached_object_touch_links;
memcpy( &(this->attached_object_touch_links[i]), &(this->st_attached_object_touch_links), sizeof(char*));
}
union {
bool real;
uint8_t base;
} u_minimize_object_distance;
u_minimize_object_distance.base = 0;
u_minimize_object_distance.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->minimize_object_distance = u_minimize_object_distance.real;
offset += sizeof(this->minimize_object_distance);
offset += this->path_constraints.deserialize(inbuffer + offset);
uint32_t length_planner_id;
arrToVar(length_planner_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_id-1]=0;
this->planner_id = (char *)(inbuffer + offset-1);
offset += length_planner_id;
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.base = 0;
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->allowed_planning_time = u_allowed_planning_time.real;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupGoal"; };
const char * getMD5(){ return "458c6ab3761d73e99b070063f7b74c2a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryAction.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryAction_h
#define _ROS_moveit_msgs_ExecuteTrajectoryAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/ExecuteTrajectoryActionGoal.h"
#include "moveit_msgs/ExecuteTrajectoryActionResult.h"
#include "moveit_msgs/ExecuteTrajectoryActionFeedback.h"
namespace moveit_msgs
{
class ExecuteTrajectoryAction : public ros::Msg
{
public:
typedef moveit_msgs::ExecuteTrajectoryActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::ExecuteTrajectoryActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::ExecuteTrajectoryActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
ExecuteTrajectoryAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryAction"; };
const char * getMD5(){ return "24e882ecd7f84f3e3299d504b8e3deae"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceAction.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceAction_h
#define _ROS_moveit_msgs_MoveGroupSequenceAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveGroupSequenceActionGoal.h"
#include "moveit_msgs/MoveGroupSequenceActionResult.h"
#include "moveit_msgs/MoveGroupSequenceActionFeedback.h"
namespace moveit_msgs
{
class MoveGroupSequenceAction : public ros::Msg
{
public:
typedef moveit_msgs::MoveGroupSequenceActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::MoveGroupSequenceActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::MoveGroupSequenceActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
MoveGroupSequenceAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceAction"; };
const char * getMD5(){ return "146b2ccf95324a792cf72761e640ab31"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RobotState.h | #ifndef _ROS_moveit_msgs_RobotState_h
#define _ROS_moveit_msgs_RobotState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/JointState.h"
#include "sensor_msgs/MultiDOFJointState.h"
#include "moveit_msgs/AttachedCollisionObject.h"
namespace moveit_msgs
{
class RobotState : public ros::Msg
{
public:
typedef sensor_msgs::JointState _joint_state_type;
_joint_state_type joint_state;
typedef sensor_msgs::MultiDOFJointState _multi_dof_joint_state_type;
_multi_dof_joint_state_type multi_dof_joint_state;
uint32_t attached_collision_objects_length;
typedef moveit_msgs::AttachedCollisionObject _attached_collision_objects_type;
_attached_collision_objects_type st_attached_collision_objects;
_attached_collision_objects_type * attached_collision_objects;
typedef bool _is_diff_type;
_is_diff_type is_diff;
RobotState():
joint_state(),
multi_dof_joint_state(),
attached_collision_objects_length(0), attached_collision_objects(NULL),
is_diff(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->joint_state.serialize(outbuffer + offset);
offset += this->multi_dof_joint_state.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->attached_collision_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->attached_collision_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->attached_collision_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->attached_collision_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->attached_collision_objects_length);
for( uint32_t i = 0; i < attached_collision_objects_length; i++){
offset += this->attached_collision_objects[i].serialize(outbuffer + offset);
}
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.real = this->is_diff;
*(outbuffer + offset + 0) = (u_is_diff.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_diff);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->joint_state.deserialize(inbuffer + offset);
offset += this->multi_dof_joint_state.deserialize(inbuffer + offset);
uint32_t attached_collision_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->attached_collision_objects_length);
if(attached_collision_objects_lengthT > attached_collision_objects_length)
this->attached_collision_objects = (moveit_msgs::AttachedCollisionObject*)realloc(this->attached_collision_objects, attached_collision_objects_lengthT * sizeof(moveit_msgs::AttachedCollisionObject));
attached_collision_objects_length = attached_collision_objects_lengthT;
for( uint32_t i = 0; i < attached_collision_objects_length; i++){
offset += this->st_attached_collision_objects.deserialize(inbuffer + offset);
memcpy( &(this->attached_collision_objects[i]), &(this->st_attached_collision_objects), sizeof(moveit_msgs::AttachedCollisionObject));
}
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.base = 0;
u_is_diff.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_diff = u_is_diff.real;
offset += sizeof(this->is_diff);
return offset;
}
const char * getType(){ return "moveit_msgs/RobotState"; };
const char * getMD5(){ return "217a2e8e5547f4162b13a37db9cb4da4"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupResult.h | #ifndef _ROS_moveit_msgs_MoveGroupResult_h
#define _ROS_moveit_msgs_MoveGroupResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
class MoveGroupResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef moveit_msgs::RobotTrajectory _planned_trajectory_type;
_planned_trajectory_type planned_trajectory;
typedef moveit_msgs::RobotTrajectory _executed_trajectory_type;
_executed_trajectory_type executed_trajectory;
typedef double _planning_time_type;
_planning_time_type planning_time;
MoveGroupResult():
error_code(),
trajectory_start(),
planned_trajectory(),
executed_trajectory(),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->trajectory_start.serialize(outbuffer + offset);
offset += this->planned_trajectory.serialize(outbuffer + offset);
offset += this->executed_trajectory.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->trajectory_start.deserialize(inbuffer + offset);
offset += this->planned_trajectory.deserialize(inbuffer + offset);
offset += this->executed_trajectory.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupResult"; };
const char * getMD5(){ return "34098589d402fee7ae9c3fd413e5a6c6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceRequest.h | #ifndef _ROS_moveit_msgs_MotionSequenceRequest_h
#define _ROS_moveit_msgs_MotionSequenceRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceItem.h"
namespace moveit_msgs
{
class MotionSequenceRequest : public ros::Msg
{
public:
uint32_t items_length;
typedef moveit_msgs::MotionSequenceItem _items_type;
_items_type st_items;
_items_type * items;
MotionSequenceRequest():
items_length(0), items(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->items_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->items_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->items_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->items_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->items_length);
for( uint32_t i = 0; i < items_length; i++){
offset += this->items[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t items_lengthT = ((uint32_t) (*(inbuffer + offset)));
items_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
items_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
items_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->items_length);
if(items_lengthT > items_length)
this->items = (moveit_msgs::MotionSequenceItem*)realloc(this->items, items_lengthT * sizeof(moveit_msgs::MotionSequenceItem));
items_length = items_lengthT;
for( uint32_t i = 0; i < items_length; i++){
offset += this->st_items.deserialize(inbuffer + offset);
memcpy( &(this->items[i]), &(this->st_items), sizeof(moveit_msgs::MotionSequenceItem));
}
return offset;
}
const char * getType(){ return "moveit_msgs/MotionSequenceRequest"; };
const char * getMD5(){ return "c89266756409bea218f39a7f05ef21a1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryActionGoal.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryActionGoal_h
#define _ROS_moveit_msgs_ExecuteTrajectoryActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/ExecuteTrajectoryGoal.h"
namespace moveit_msgs
{
class ExecuteTrajectoryActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::ExecuteTrajectoryGoal _goal_type;
_goal_type goal;
ExecuteTrajectoryActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryActionGoal"; };
const char * getMD5(){ return "36f350977c67bc94e8cd408452bad0f0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceResult.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceResult_h
#define _ROS_moveit_msgs_MoveGroupSequenceResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceResponse.h"
namespace moveit_msgs
{
class MoveGroupSequenceResult : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceResponse _response_type;
_response_type response;
MoveGroupSequenceResult():
response()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->response.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->response.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceResult"; };
const char * getMD5(){ return "039cee462ada3f0feb5f4e2e12baefae"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPlanningScene.h | #ifndef _ROS_SERVICE_GetPlanningScene_h
#define _ROS_SERVICE_GetPlanningScene_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlanningScene.h"
#include "moveit_msgs/PlanningSceneComponents.h"
namespace moveit_msgs
{
static const char GETPLANNINGSCENE[] = "moveit_msgs/GetPlanningScene";
class GetPlanningSceneRequest : public ros::Msg
{
public:
typedef moveit_msgs::PlanningSceneComponents _components_type;
_components_type components;
GetPlanningSceneRequest():
components()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->components.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->components.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLANNINGSCENE; };
const char * getMD5(){ return "d81da6c0e5e015646a4efe344f33d7dc"; };
};
class GetPlanningSceneResponse : public ros::Msg
{
public:
typedef moveit_msgs::PlanningScene _scene_type;
_scene_type scene;
GetPlanningSceneResponse():
scene()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->scene.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->scene.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLANNINGSCENE; };
const char * getMD5(){ return "7bedc4871b1d0af6ec8b8996db347e7f"; };
};
class GetPlanningScene {
public:
typedef GetPlanningSceneRequest Request;
typedef GetPlanningSceneResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/JointConstraint.h | #ifndef _ROS_moveit_msgs_JointConstraint_h
#define _ROS_moveit_msgs_JointConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class JointConstraint : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef double _position_type;
_position_type position;
typedef double _tolerance_above_type;
_tolerance_above_type tolerance_above;
typedef double _tolerance_below_type;
_tolerance_below_type tolerance_below;
typedef double _weight_type;
_weight_type weight;
JointConstraint():
joint_name(""),
position(0),
tolerance_above(0),
tolerance_below(0),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_name;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_tolerance_above;
u_tolerance_above.real = this->tolerance_above;
*(outbuffer + offset + 0) = (u_tolerance_above.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_tolerance_above.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_tolerance_above.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_tolerance_above.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_tolerance_above.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_tolerance_above.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_tolerance_above.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_tolerance_above.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->tolerance_above);
union {
double real;
uint64_t base;
} u_tolerance_below;
u_tolerance_below.real = this->tolerance_below;
*(outbuffer + offset + 0) = (u_tolerance_below.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_tolerance_below.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_tolerance_below.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_tolerance_below.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_tolerance_below.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_tolerance_below.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_tolerance_below.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_tolerance_below.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->tolerance_below);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_name;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_tolerance_above;
u_tolerance_above.base = 0;
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->tolerance_above = u_tolerance_above.real;
offset += sizeof(this->tolerance_above);
union {
double real;
uint64_t base;
} u_tolerance_below;
u_tolerance_below.base = 0;
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->tolerance_below = u_tolerance_below.real;
offset += sizeof(this->tolerance_below);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/JointConstraint"; };
const char * getMD5(){ return "c02a15146bec0ce13564807805b008f0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetStateValidity.h | #ifndef _ROS_SERVICE_GetStateValidity_h
#define _ROS_SERVICE_GetStateValidity_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/ConstraintEvalResult.h"
#include "moveit_msgs/CostSource.h"
#include "moveit_msgs/ContactInformation.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
static const char GETSTATEVALIDITY[] = "moveit_msgs/GetStateValidity";
class GetStateValidityRequest : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type constraints;
GetStateValidityRequest():
robot_state(),
group_name(""),
constraints()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->robot_state.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->constraints.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->robot_state.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->constraints.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETSTATEVALIDITY; };
const char * getMD5(){ return "b569c609cafad20ba7d0e46e70e7cab1"; };
};
class GetStateValidityResponse : public ros::Msg
{
public:
typedef bool _valid_type;
_valid_type valid;
uint32_t contacts_length;
typedef moveit_msgs::ContactInformation _contacts_type;
_contacts_type st_contacts;
_contacts_type * contacts;
uint32_t cost_sources_length;
typedef moveit_msgs::CostSource _cost_sources_type;
_cost_sources_type st_cost_sources;
_cost_sources_type * cost_sources;
uint32_t constraint_result_length;
typedef moveit_msgs::ConstraintEvalResult _constraint_result_type;
_constraint_result_type st_constraint_result;
_constraint_result_type * constraint_result;
GetStateValidityResponse():
valid(0),
contacts_length(0), contacts(NULL),
cost_sources_length(0), cost_sources(NULL),
constraint_result_length(0), constraint_result(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_valid;
u_valid.real = this->valid;
*(outbuffer + offset + 0) = (u_valid.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->valid);
*(outbuffer + offset + 0) = (this->contacts_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->contacts_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->contacts_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->contacts_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->contacts_length);
for( uint32_t i = 0; i < contacts_length; i++){
offset += this->contacts[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->cost_sources_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cost_sources_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cost_sources_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cost_sources_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cost_sources_length);
for( uint32_t i = 0; i < cost_sources_length; i++){
offset += this->cost_sources[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->constraint_result_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->constraint_result_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->constraint_result_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->constraint_result_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->constraint_result_length);
for( uint32_t i = 0; i < constraint_result_length; i++){
offset += this->constraint_result[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_valid;
u_valid.base = 0;
u_valid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->valid = u_valid.real;
offset += sizeof(this->valid);
uint32_t contacts_lengthT = ((uint32_t) (*(inbuffer + offset)));
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->contacts_length);
if(contacts_lengthT > contacts_length)
this->contacts = (moveit_msgs::ContactInformation*)realloc(this->contacts, contacts_lengthT * sizeof(moveit_msgs::ContactInformation));
contacts_length = contacts_lengthT;
for( uint32_t i = 0; i < contacts_length; i++){
offset += this->st_contacts.deserialize(inbuffer + offset);
memcpy( &(this->contacts[i]), &(this->st_contacts), sizeof(moveit_msgs::ContactInformation));
}
uint32_t cost_sources_lengthT = ((uint32_t) (*(inbuffer + offset)));
cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cost_sources_length);
if(cost_sources_lengthT > cost_sources_length)
this->cost_sources = (moveit_msgs::CostSource*)realloc(this->cost_sources, cost_sources_lengthT * sizeof(moveit_msgs::CostSource));
cost_sources_length = cost_sources_lengthT;
for( uint32_t i = 0; i < cost_sources_length; i++){
offset += this->st_cost_sources.deserialize(inbuffer + offset);
memcpy( &(this->cost_sources[i]), &(this->st_cost_sources), sizeof(moveit_msgs::CostSource));
}
uint32_t constraint_result_lengthT = ((uint32_t) (*(inbuffer + offset)));
constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->constraint_result_length);
if(constraint_result_lengthT > constraint_result_length)
this->constraint_result = (moveit_msgs::ConstraintEvalResult*)realloc(this->constraint_result, constraint_result_lengthT * sizeof(moveit_msgs::ConstraintEvalResult));
constraint_result_length = constraint_result_lengthT;
for( uint32_t i = 0; i < constraint_result_length; i++){
offset += this->st_constraint_result.deserialize(inbuffer + offset);
memcpy( &(this->constraint_result[i]), &(this->st_constraint_result), sizeof(moveit_msgs::ConstraintEvalResult));
}
return offset;
}
const char * getType(){ return GETSTATEVALIDITY; };
const char * getMD5(){ return "e326fb22b7448f29c0e726d9270d9929"; };
};
class GetStateValidity {
public:
typedef GetStateValidityRequest Request;
typedef GetStateValidityResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/QueryPlannerInterfaces.h | #ifndef _ROS_SERVICE_QueryPlannerInterfaces_h
#define _ROS_SERVICE_QueryPlannerInterfaces_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlannerInterfaceDescription.h"
namespace moveit_msgs
{
static const char QUERYPLANNERINTERFACES[] = "moveit_msgs/QueryPlannerInterfaces";
class QueryPlannerInterfacesRequest : public ros::Msg
{
public:
QueryPlannerInterfacesRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return QUERYPLANNERINTERFACES; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class QueryPlannerInterfacesResponse : public ros::Msg
{
public:
uint32_t planner_interfaces_length;
typedef moveit_msgs::PlannerInterfaceDescription _planner_interfaces_type;
_planner_interfaces_type st_planner_interfaces;
_planner_interfaces_type * planner_interfaces;
QueryPlannerInterfacesResponse():
planner_interfaces_length(0), planner_interfaces(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->planner_interfaces_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planner_interfaces_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planner_interfaces_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planner_interfaces_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planner_interfaces_length);
for( uint32_t i = 0; i < planner_interfaces_length; i++){
offset += this->planner_interfaces[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t planner_interfaces_lengthT = ((uint32_t) (*(inbuffer + offset)));
planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planner_interfaces_length);
if(planner_interfaces_lengthT > planner_interfaces_length)
this->planner_interfaces = (moveit_msgs::PlannerInterfaceDescription*)realloc(this->planner_interfaces, planner_interfaces_lengthT * sizeof(moveit_msgs::PlannerInterfaceDescription));
planner_interfaces_length = planner_interfaces_lengthT;
for( uint32_t i = 0; i < planner_interfaces_length; i++){
offset += this->st_planner_interfaces.deserialize(inbuffer + offset);
memcpy( &(this->planner_interfaces[i]), &(this->st_planner_interfaces), sizeof(moveit_msgs::PlannerInterfaceDescription));
}
return offset;
}
const char * getType(){ return QUERYPLANNERINTERFACES; };
const char * getMD5(){ return "acd3317a4c5631f33127fb428209db05"; };
};
class QueryPlannerInterfaces {
public:
typedef QueryPlannerInterfacesRequest Request;
typedef QueryPlannerInterfacesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SetPlannerParams.h | #ifndef _ROS_SERVICE_SetPlannerParams_h
#define _ROS_SERVICE_SetPlannerParams_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlannerParams.h"
namespace moveit_msgs
{
static const char SETPLANNERPARAMS[] = "moveit_msgs/SetPlannerParams";
class SetPlannerParamsRequest : public ros::Msg
{
public:
typedef const char* _planner_config_type;
_planner_config_type planner_config;
typedef const char* _group_type;
_group_type group;
typedef moveit_msgs::PlannerParams _params_type;
_params_type params;
typedef bool _replace_type;
_replace_type replace;
SetPlannerParamsRequest():
planner_config(""),
group(""),
params(),
replace(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_planner_config = strlen(this->planner_config);
varToArr(outbuffer + offset, length_planner_config);
offset += 4;
memcpy(outbuffer + offset, this->planner_config, length_planner_config);
offset += length_planner_config;
uint32_t length_group = strlen(this->group);
varToArr(outbuffer + offset, length_group);
offset += 4;
memcpy(outbuffer + offset, this->group, length_group);
offset += length_group;
offset += this->params.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_replace;
u_replace.real = this->replace;
*(outbuffer + offset + 0) = (u_replace.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->replace);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_planner_config;
arrToVar(length_planner_config, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_config; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_config-1]=0;
this->planner_config = (char *)(inbuffer + offset-1);
offset += length_planner_config;
uint32_t length_group;
arrToVar(length_group, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group-1]=0;
this->group = (char *)(inbuffer + offset-1);
offset += length_group;
offset += this->params.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_replace;
u_replace.base = 0;
u_replace.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->replace = u_replace.real;
offset += sizeof(this->replace);
return offset;
}
const char * getType(){ return SETPLANNERPARAMS; };
const char * getMD5(){ return "86762d89189c5f52cda7680fdbceb1db"; };
};
class SetPlannerParamsResponse : public ros::Msg
{
public:
SetPlannerParamsResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return SETPLANNERPARAMS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetPlannerParams {
public:
typedef SetPlannerParamsRequest Request;
typedef SetPlannerParamsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceActionGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceActionGoal_h
#define _ROS_moveit_msgs_MoveGroupSequenceActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/MoveGroupSequenceGoal.h"
namespace moveit_msgs
{
class MoveGroupSequenceActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::MoveGroupSequenceGoal _goal_type;
_goal_type goal;
MoveGroupSequenceActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceActionGoal"; };
const char * getMD5(){ return "33db6638fb44f932dc55788fa9d72325"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceLocation.h | #ifndef _ROS_moveit_msgs_PlaceLocation_h
#define _ROS_moveit_msgs_PlaceLocation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "geometry_msgs/PoseStamped.h"
#include "moveit_msgs/GripperTranslation.h"
namespace moveit_msgs
{
class PlaceLocation : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef trajectory_msgs::JointTrajectory _post_place_posture_type;
_post_place_posture_type post_place_posture;
typedef geometry_msgs::PoseStamped _place_pose_type;
_place_pose_type place_pose;
typedef moveit_msgs::GripperTranslation _pre_place_approach_type;
_pre_place_approach_type pre_place_approach;
typedef moveit_msgs::GripperTranslation _post_place_retreat_type;
_post_place_retreat_type post_place_retreat;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
PlaceLocation():
id(""),
post_place_posture(),
place_pose(),
pre_place_approach(),
post_place_retreat(),
allowed_touch_objects_length(0), allowed_touch_objects(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
offset += this->post_place_posture.serialize(outbuffer + offset);
offset += this->place_pose.serialize(outbuffer + offset);
offset += this->pre_place_approach.serialize(outbuffer + offset);
offset += this->post_place_retreat.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
offset += this->post_place_posture.deserialize(inbuffer + offset);
offset += this->place_pose.deserialize(inbuffer + offset);
offset += this->pre_place_approach.deserialize(inbuffer + offset);
offset += this->post_place_retreat.deserialize(inbuffer + offset);
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceLocation"; };
const char * getMD5(){ return "f3dbcaca40fb29ede2af78b3e1831128"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/Constraints.h | #ifndef _ROS_moveit_msgs_Constraints_h
#define _ROS_moveit_msgs_Constraints_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/JointConstraint.h"
#include "moveit_msgs/PositionConstraint.h"
#include "moveit_msgs/OrientationConstraint.h"
#include "moveit_msgs/VisibilityConstraint.h"
namespace moveit_msgs
{
class Constraints : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
uint32_t joint_constraints_length;
typedef moveit_msgs::JointConstraint _joint_constraints_type;
_joint_constraints_type st_joint_constraints;
_joint_constraints_type * joint_constraints;
uint32_t position_constraints_length;
typedef moveit_msgs::PositionConstraint _position_constraints_type;
_position_constraints_type st_position_constraints;
_position_constraints_type * position_constraints;
uint32_t orientation_constraints_length;
typedef moveit_msgs::OrientationConstraint _orientation_constraints_type;
_orientation_constraints_type st_orientation_constraints;
_orientation_constraints_type * orientation_constraints;
uint32_t visibility_constraints_length;
typedef moveit_msgs::VisibilityConstraint _visibility_constraints_type;
_visibility_constraints_type st_visibility_constraints;
_visibility_constraints_type * visibility_constraints;
Constraints():
name(""),
joint_constraints_length(0), joint_constraints(NULL),
position_constraints_length(0), position_constraints(NULL),
orientation_constraints_length(0), orientation_constraints(NULL),
visibility_constraints_length(0), visibility_constraints(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
*(outbuffer + offset + 0) = (this->joint_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_constraints_length);
for( uint32_t i = 0; i < joint_constraints_length; i++){
offset += this->joint_constraints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->position_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_constraints_length);
for( uint32_t i = 0; i < position_constraints_length; i++){
offset += this->position_constraints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->orientation_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->orientation_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->orientation_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->orientation_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->orientation_constraints_length);
for( uint32_t i = 0; i < orientation_constraints_length; i++){
offset += this->orientation_constraints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->visibility_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->visibility_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->visibility_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->visibility_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->visibility_constraints_length);
for( uint32_t i = 0; i < visibility_constraints_length; i++){
offset += this->visibility_constraints[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t joint_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_constraints_length);
if(joint_constraints_lengthT > joint_constraints_length)
this->joint_constraints = (moveit_msgs::JointConstraint*)realloc(this->joint_constraints, joint_constraints_lengthT * sizeof(moveit_msgs::JointConstraint));
joint_constraints_length = joint_constraints_lengthT;
for( uint32_t i = 0; i < joint_constraints_length; i++){
offset += this->st_joint_constraints.deserialize(inbuffer + offset);
memcpy( &(this->joint_constraints[i]), &(this->st_joint_constraints), sizeof(moveit_msgs::JointConstraint));
}
uint32_t position_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_constraints_length);
if(position_constraints_lengthT > position_constraints_length)
this->position_constraints = (moveit_msgs::PositionConstraint*)realloc(this->position_constraints, position_constraints_lengthT * sizeof(moveit_msgs::PositionConstraint));
position_constraints_length = position_constraints_lengthT;
for( uint32_t i = 0; i < position_constraints_length; i++){
offset += this->st_position_constraints.deserialize(inbuffer + offset);
memcpy( &(this->position_constraints[i]), &(this->st_position_constraints), sizeof(moveit_msgs::PositionConstraint));
}
uint32_t orientation_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->orientation_constraints_length);
if(orientation_constraints_lengthT > orientation_constraints_length)
this->orientation_constraints = (moveit_msgs::OrientationConstraint*)realloc(this->orientation_constraints, orientation_constraints_lengthT * sizeof(moveit_msgs::OrientationConstraint));
orientation_constraints_length = orientation_constraints_lengthT;
for( uint32_t i = 0; i < orientation_constraints_length; i++){
offset += this->st_orientation_constraints.deserialize(inbuffer + offset);
memcpy( &(this->orientation_constraints[i]), &(this->st_orientation_constraints), sizeof(moveit_msgs::OrientationConstraint));
}
uint32_t visibility_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->visibility_constraints_length);
if(visibility_constraints_lengthT > visibility_constraints_length)
this->visibility_constraints = (moveit_msgs::VisibilityConstraint*)realloc(this->visibility_constraints, visibility_constraints_lengthT * sizeof(moveit_msgs::VisibilityConstraint));
visibility_constraints_length = visibility_constraints_lengthT;
for( uint32_t i = 0; i < visibility_constraints_length; i++){
offset += this->st_visibility_constraints.deserialize(inbuffer + offset);
memcpy( &(this->visibility_constraints[i]), &(this->st_visibility_constraints), sizeof(moveit_msgs::VisibilityConstraint));
}
return offset;
}
const char * getType(){ return "moveit_msgs/Constraints"; };
const char * getMD5(){ return "8d5ce8d34ef26c65fb5d43c9e99bf6e0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupActionResult.h | #ifndef _ROS_moveit_msgs_MoveGroupActionResult_h
#define _ROS_moveit_msgs_MoveGroupActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/MoveGroupResult.h"
namespace moveit_msgs
{
class MoveGroupActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupResult _result_type;
_result_type result;
MoveGroupActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupActionResult"; };
const char * getMD5(){ return "6ee8682a508d60603228accdc4a2b30b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteKnownTrajectory.h | #ifndef _ROS_SERVICE_ExecuteKnownTrajectory_h
#define _ROS_SERVICE_ExecuteKnownTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
static const char EXECUTEKNOWNTRAJECTORY[] = "moveit_msgs/ExecuteKnownTrajectory";
class ExecuteKnownTrajectoryRequest : public ros::Msg
{
public:
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type trajectory;
typedef bool _wait_for_execution_type;
_wait_for_execution_type wait_for_execution;
ExecuteKnownTrajectoryRequest():
trajectory(),
wait_for_execution(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_wait_for_execution;
u_wait_for_execution.real = this->wait_for_execution;
*(outbuffer + offset + 0) = (u_wait_for_execution.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->wait_for_execution);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_wait_for_execution;
u_wait_for_execution.base = 0;
u_wait_for_execution.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->wait_for_execution = u_wait_for_execution.real;
offset += sizeof(this->wait_for_execution);
return offset;
}
const char * getType(){ return EXECUTEKNOWNTRAJECTORY; };
const char * getMD5(){ return "2a3d2a0b337c6a27da4468bb351928e5"; };
};
class ExecuteKnownTrajectoryResponse : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
ExecuteKnownTrajectoryResponse():
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return EXECUTEKNOWNTRAJECTORY; };
const char * getMD5(){ return "1f7ab918f5d0c5312f25263d3d688122"; };
};
class ExecuteKnownTrajectory {
public:
typedef ExecuteKnownTrajectoryRequest Request;
typedef ExecuteKnownTrajectoryResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveItErrorCodes.h | #ifndef _ROS_moveit_msgs_MoveItErrorCodes_h
#define _ROS_moveit_msgs_MoveItErrorCodes_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class MoveItErrorCodes : public ros::Msg
{
public:
typedef int32_t _val_type;
_val_type val;
enum { SUCCESS = 1 };
enum { FAILURE = 99999 };
enum { PLANNING_FAILED = -1 };
enum { INVALID_MOTION_PLAN = -2 };
enum { MOTION_PLAN_INVALIDATED_BY_ENVIRONMENT_CHANGE = -3 };
enum { CONTROL_FAILED = -4 };
enum { UNABLE_TO_AQUIRE_SENSOR_DATA = -5 };
enum { TIMED_OUT = -6 };
enum { PREEMPTED = -7 };
enum { START_STATE_IN_COLLISION = -10 };
enum { START_STATE_VIOLATES_PATH_CONSTRAINTS = -11 };
enum { GOAL_IN_COLLISION = -12 };
enum { GOAL_VIOLATES_PATH_CONSTRAINTS = -13 };
enum { GOAL_CONSTRAINTS_VIOLATED = -14 };
enum { INVALID_GROUP_NAME = -15 };
enum { INVALID_GOAL_CONSTRAINTS = -16 };
enum { INVALID_ROBOT_STATE = -17 };
enum { INVALID_LINK_NAME = -18 };
enum { INVALID_OBJECT_NAME = -19 };
enum { FRAME_TRANSFORM_FAILURE = -21 };
enum { COLLISION_CHECKING_UNAVAILABLE = -22 };
enum { ROBOT_STATE_STALE = -23 };
enum { SENSOR_INFO_STALE = -24 };
enum { NO_IK_SOLUTION = -31 };
MoveItErrorCodes():
val(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_val;
u_val.real = this->val;
*(outbuffer + offset + 0) = (u_val.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_val.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_val.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_val.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->val);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_val;
u_val.base = 0;
u_val.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_val.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_val.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_val.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->val = u_val.real;
offset += sizeof(this->val);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveItErrorCodes"; };
const char * getMD5(){ return "aa336b18d80531f66439810112c0a43e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ConstraintEvalResult.h | #ifndef _ROS_moveit_msgs_ConstraintEvalResult_h
#define _ROS_moveit_msgs_ConstraintEvalResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class ConstraintEvalResult : public ros::Msg
{
public:
typedef bool _result_type;
_result_type result;
typedef double _distance_type;
_distance_type distance;
ConstraintEvalResult():
result(0),
distance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_result;
u_result.real = this->result;
*(outbuffer + offset + 0) = (u_result.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->result);
union {
double real;
uint64_t base;
} u_distance;
u_distance.real = this->distance;
*(outbuffer + offset + 0) = (u_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_distance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_distance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_distance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_distance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_distance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->distance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_result;
u_result.base = 0;
u_result.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->result = u_result.real;
offset += sizeof(this->result);
union {
double real;
uint64_t base;
} u_distance;
u_distance.base = 0;
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->distance = u_distance.real;
offset += sizeof(this->distance);
return offset;
}
const char * getType(){ return "moveit_msgs/ConstraintEvalResult"; };
const char * getMD5(){ return "093643083d24f6488cb5a868bd47c090"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AllowedCollisionEntry.h | #ifndef _ROS_moveit_msgs_AllowedCollisionEntry_h
#define _ROS_moveit_msgs_AllowedCollisionEntry_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class AllowedCollisionEntry : public ros::Msg
{
public:
uint32_t enabled_length;
typedef bool _enabled_type;
_enabled_type st_enabled;
_enabled_type * enabled;
AllowedCollisionEntry():
enabled_length(0), enabled(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->enabled_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->enabled_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->enabled_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->enabled_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->enabled_length);
for( uint32_t i = 0; i < enabled_length; i++){
union {
bool real;
uint8_t base;
} u_enabledi;
u_enabledi.real = this->enabled[i];
*(outbuffer + offset + 0) = (u_enabledi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->enabled[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t enabled_lengthT = ((uint32_t) (*(inbuffer + offset)));
enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->enabled_length);
if(enabled_lengthT > enabled_length)
this->enabled = (bool*)realloc(this->enabled, enabled_lengthT * sizeof(bool));
enabled_length = enabled_lengthT;
for( uint32_t i = 0; i < enabled_length; i++){
union {
bool real;
uint8_t base;
} u_st_enabled;
u_st_enabled.base = 0;
u_st_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_enabled = u_st_enabled.real;
offset += sizeof(this->st_enabled);
memcpy( &(this->enabled[i]), &(this->st_enabled), sizeof(bool));
}
return offset;
}
const char * getType(){ return "moveit_msgs/AllowedCollisionEntry"; };
const char * getMD5(){ return "90d1ae1850840724bb043562fe3285fc"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ApplyPlanningScene.h | #ifndef _ROS_SERVICE_ApplyPlanningScene_h
#define _ROS_SERVICE_ApplyPlanningScene_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlanningScene.h"
namespace moveit_msgs
{
static const char APPLYPLANNINGSCENE[] = "moveit_msgs/ApplyPlanningScene";
class ApplyPlanningSceneRequest : public ros::Msg
{
public:
typedef moveit_msgs::PlanningScene _scene_type;
_scene_type scene;
ApplyPlanningSceneRequest():
scene()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->scene.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->scene.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return APPLYPLANNINGSCENE; };
const char * getMD5(){ return "7bedc4871b1d0af6ec8b8996db347e7f"; };
};
class ApplyPlanningSceneResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
ApplyPlanningSceneResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return APPLYPLANNINGSCENE; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class ApplyPlanningScene {
public:
typedef ApplyPlanningSceneRequest Request;
typedef ApplyPlanningSceneResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CostSource.h | #ifndef _ROS_moveit_msgs_CostSource_h
#define _ROS_moveit_msgs_CostSource_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
namespace moveit_msgs
{
class CostSource : public ros::Msg
{
public:
typedef double _cost_density_type;
_cost_density_type cost_density;
typedef geometry_msgs::Vector3 _aabb_min_type;
_aabb_min_type aabb_min;
typedef geometry_msgs::Vector3 _aabb_max_type;
_aabb_max_type aabb_max;
CostSource():
cost_density(0),
aabb_min(),
aabb_max()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_cost_density;
u_cost_density.real = this->cost_density;
*(outbuffer + offset + 0) = (u_cost_density.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cost_density.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cost_density.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cost_density.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_cost_density.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_cost_density.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_cost_density.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_cost_density.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->cost_density);
offset += this->aabb_min.serialize(outbuffer + offset);
offset += this->aabb_max.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_cost_density;
u_cost_density.base = 0;
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->cost_density = u_cost_density.real;
offset += sizeof(this->cost_density);
offset += this->aabb_min.deserialize(inbuffer + offset);
offset += this->aabb_max.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/CostSource"; };
const char * getMD5(){ return "abb7e013237dacaaa8b97e704102f908"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LinkPadding.h | #ifndef _ROS_moveit_msgs_LinkPadding_h
#define _ROS_moveit_msgs_LinkPadding_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class LinkPadding : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef double _padding_type;
_padding_type padding;
LinkPadding():
link_name(""),
padding(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_padding;
u_padding.real = this->padding;
*(outbuffer + offset + 0) = (u_padding.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_padding.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_padding.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_padding.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_padding.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_padding.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_padding.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_padding.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->padding);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_padding;
u_padding.base = 0;
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->padding = u_padding.real;
offset += sizeof(this->padding);
return offset;
}
const char * getType(){ return "moveit_msgs/LinkPadding"; };
const char * getMD5(){ return "b3ea75670df55c696fedee97774d5947"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ObjectColor.h | #ifndef _ROS_moveit_msgs_ObjectColor_h
#define _ROS_moveit_msgs_ObjectColor_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/ColorRGBA.h"
namespace moveit_msgs
{
class ObjectColor : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef std_msgs::ColorRGBA _color_type;
_color_type color;
ObjectColor():
id(""),
color()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
offset += this->color.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
offset += this->color.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ObjectColor"; };
const char * getMD5(){ return "ec3bd6f103430e64b2ae706a67d8488e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryActionFeedback.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryActionFeedback_h
#define _ROS_moveit_msgs_ExecuteTrajectoryActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/ExecuteTrajectoryFeedback.h"
namespace moveit_msgs
{
class ExecuteTrajectoryActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::ExecuteTrajectoryFeedback _feedback_type;
_feedback_type feedback;
ExecuteTrajectoryActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceGoal.h | #ifndef _ROS_moveit_msgs_PlaceGoal_h
#define _ROS_moveit_msgs_PlaceGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlaceLocation.h"
#include "moveit_msgs/Constraints.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class PlaceGoal : public ros::Msg
{
public:
typedef const char* _group_name_type;
_group_name_type group_name;
typedef const char* _attached_object_name_type;
_attached_object_name_type attached_object_name;
uint32_t place_locations_length;
typedef moveit_msgs::PlaceLocation _place_locations_type;
_place_locations_type st_place_locations;
_place_locations_type * place_locations;
typedef bool _place_eef_type;
_place_eef_type place_eef;
typedef const char* _support_surface_name_type;
_support_surface_name_type support_surface_name;
typedef bool _allow_gripper_support_collision_type;
_allow_gripper_support_collision_type allow_gripper_support_collision;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
typedef const char* _planner_id_type;
_planner_id_type planner_id;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
typedef double _allowed_planning_time_type;
_allowed_planning_time_type allowed_planning_time;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
PlaceGoal():
group_name(""),
attached_object_name(""),
place_locations_length(0), place_locations(NULL),
place_eef(0),
support_surface_name(""),
allow_gripper_support_collision(0),
path_constraints(),
planner_id(""),
allowed_touch_objects_length(0), allowed_touch_objects(NULL),
allowed_planning_time(0),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
uint32_t length_attached_object_name = strlen(this->attached_object_name);
varToArr(outbuffer + offset, length_attached_object_name);
offset += 4;
memcpy(outbuffer + offset, this->attached_object_name, length_attached_object_name);
offset += length_attached_object_name;
*(outbuffer + offset + 0) = (this->place_locations_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->place_locations_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->place_locations_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->place_locations_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->place_locations_length);
for( uint32_t i = 0; i < place_locations_length; i++){
offset += this->place_locations[i].serialize(outbuffer + offset);
}
union {
bool real;
uint8_t base;
} u_place_eef;
u_place_eef.real = this->place_eef;
*(outbuffer + offset + 0) = (u_place_eef.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->place_eef);
uint32_t length_support_surface_name = strlen(this->support_surface_name);
varToArr(outbuffer + offset, length_support_surface_name);
offset += 4;
memcpy(outbuffer + offset, this->support_surface_name, length_support_surface_name);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.real = this->allow_gripper_support_collision;
*(outbuffer + offset + 0) = (u_allow_gripper_support_collision.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->allow_gripper_support_collision);
offset += this->path_constraints.serialize(outbuffer + offset);
uint32_t length_planner_id = strlen(this->planner_id);
varToArr(outbuffer + offset, length_planner_id);
offset += 4;
memcpy(outbuffer + offset, this->planner_id, length_planner_id);
offset += length_planner_id;
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.real = this->allowed_planning_time;
*(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t length_attached_object_name;
arrToVar(length_attached_object_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_attached_object_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_attached_object_name-1]=0;
this->attached_object_name = (char *)(inbuffer + offset-1);
offset += length_attached_object_name;
uint32_t place_locations_lengthT = ((uint32_t) (*(inbuffer + offset)));
place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->place_locations_length);
if(place_locations_lengthT > place_locations_length)
this->place_locations = (moveit_msgs::PlaceLocation*)realloc(this->place_locations, place_locations_lengthT * sizeof(moveit_msgs::PlaceLocation));
place_locations_length = place_locations_lengthT;
for( uint32_t i = 0; i < place_locations_length; i++){
offset += this->st_place_locations.deserialize(inbuffer + offset);
memcpy( &(this->place_locations[i]), &(this->st_place_locations), sizeof(moveit_msgs::PlaceLocation));
}
union {
bool real;
uint8_t base;
} u_place_eef;
u_place_eef.base = 0;
u_place_eef.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->place_eef = u_place_eef.real;
offset += sizeof(this->place_eef);
uint32_t length_support_surface_name;
arrToVar(length_support_surface_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_support_surface_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_support_surface_name-1]=0;
this->support_surface_name = (char *)(inbuffer + offset-1);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.base = 0;
u_allow_gripper_support_collision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->allow_gripper_support_collision = u_allow_gripper_support_collision.real;
offset += sizeof(this->allow_gripper_support_collision);
offset += this->path_constraints.deserialize(inbuffer + offset);
uint32_t length_planner_id;
arrToVar(length_planner_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_id-1]=0;
this->planner_id = (char *)(inbuffer + offset-1);
offset += length_planner_id;
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.base = 0;
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->allowed_planning_time = u_allowed_planning_time.real;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceGoal"; };
const char * getMD5(){ return "e3f3e956e536ccd313fd8f23023f0a94"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryActionResult.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryActionResult_h
#define _ROS_moveit_msgs_ExecuteTrajectoryActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/ExecuteTrajectoryResult.h"
namespace moveit_msgs
{
class ExecuteTrajectoryActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::ExecuteTrajectoryResult _result_type;
_result_type result;
ExecuteTrajectoryActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryActionResult"; };
const char * getMD5(){ return "8aaeab5c1cdb613e6a2913ebcc104c0d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/JointLimits.h | #ifndef _ROS_moveit_msgs_JointLimits_h
#define _ROS_moveit_msgs_JointLimits_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class JointLimits : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef bool _has_position_limits_type;
_has_position_limits_type has_position_limits;
typedef double _min_position_type;
_min_position_type min_position;
typedef double _max_position_type;
_max_position_type max_position;
typedef bool _has_velocity_limits_type;
_has_velocity_limits_type has_velocity_limits;
typedef double _max_velocity_type;
_max_velocity_type max_velocity;
typedef bool _has_acceleration_limits_type;
_has_acceleration_limits_type has_acceleration_limits;
typedef double _max_acceleration_type;
_max_acceleration_type max_acceleration;
JointLimits():
joint_name(""),
has_position_limits(0),
min_position(0),
max_position(0),
has_velocity_limits(0),
max_velocity(0),
has_acceleration_limits(0),
max_acceleration(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_name;
union {
bool real;
uint8_t base;
} u_has_position_limits;
u_has_position_limits.real = this->has_position_limits;
*(outbuffer + offset + 0) = (u_has_position_limits.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_position_limits);
union {
double real;
uint64_t base;
} u_min_position;
u_min_position.real = this->min_position;
*(outbuffer + offset + 0) = (u_min_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_position);
union {
double real;
uint64_t base;
} u_max_position;
u_max_position.real = this->max_position;
*(outbuffer + offset + 0) = (u_max_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_position);
union {
bool real;
uint8_t base;
} u_has_velocity_limits;
u_has_velocity_limits.real = this->has_velocity_limits;
*(outbuffer + offset + 0) = (u_has_velocity_limits.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_velocity_limits);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.real = this->max_velocity;
*(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity);
union {
bool real;
uint8_t base;
} u_has_acceleration_limits;
u_has_acceleration_limits.real = this->has_acceleration_limits;
*(outbuffer + offset + 0) = (u_has_acceleration_limits.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_acceleration_limits);
union {
double real;
uint64_t base;
} u_max_acceleration;
u_max_acceleration.real = this->max_acceleration;
*(outbuffer + offset + 0) = (u_max_acceleration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_acceleration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_acceleration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_acceleration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_acceleration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_acceleration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_acceleration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_acceleration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_acceleration);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_name;
union {
bool real;
uint8_t base;
} u_has_position_limits;
u_has_position_limits.base = 0;
u_has_position_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_position_limits = u_has_position_limits.real;
offset += sizeof(this->has_position_limits);
union {
double real;
uint64_t base;
} u_min_position;
u_min_position.base = 0;
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_position = u_min_position.real;
offset += sizeof(this->min_position);
union {
double real;
uint64_t base;
} u_max_position;
u_max_position.base = 0;
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_position = u_max_position.real;
offset += sizeof(this->max_position);
union {
bool real;
uint8_t base;
} u_has_velocity_limits;
u_has_velocity_limits.base = 0;
u_has_velocity_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_velocity_limits = u_has_velocity_limits.real;
offset += sizeof(this->has_velocity_limits);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.base = 0;
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_velocity = u_max_velocity.real;
offset += sizeof(this->max_velocity);
union {
bool real;
uint8_t base;
} u_has_acceleration_limits;
u_has_acceleration_limits.base = 0;
u_has_acceleration_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_acceleration_limits = u_has_acceleration_limits.real;
offset += sizeof(this->has_acceleration_limits);
union {
double real;
uint64_t base;
} u_max_acceleration;
u_max_acceleration.base = 0;
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_acceleration = u_max_acceleration.real;
offset += sizeof(this->max_acceleration);
return offset;
}
const char * getType(){ return "moveit_msgs/JointLimits"; };
const char * getMD5(){ return "8ca618c7329ea46142cbc864a2efe856"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningOptions.h | #ifndef _ROS_moveit_msgs_PlanningOptions_h
#define _ROS_moveit_msgs_PlanningOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlanningScene.h"
namespace moveit_msgs
{
class PlanningOptions : public ros::Msg
{
public:
typedef moveit_msgs::PlanningScene _planning_scene_diff_type;
_planning_scene_diff_type planning_scene_diff;
typedef bool _plan_only_type;
_plan_only_type plan_only;
typedef bool _look_around_type;
_look_around_type look_around;
typedef int32_t _look_around_attempts_type;
_look_around_attempts_type look_around_attempts;
typedef double _max_safe_execution_cost_type;
_max_safe_execution_cost_type max_safe_execution_cost;
typedef bool _replan_type;
_replan_type replan;
typedef int32_t _replan_attempts_type;
_replan_attempts_type replan_attempts;
typedef double _replan_delay_type;
_replan_delay_type replan_delay;
PlanningOptions():
planning_scene_diff(),
plan_only(0),
look_around(0),
look_around_attempts(0),
max_safe_execution_cost(0),
replan(0),
replan_attempts(0),
replan_delay(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->planning_scene_diff.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_plan_only;
u_plan_only.real = this->plan_only;
*(outbuffer + offset + 0) = (u_plan_only.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->plan_only);
union {
bool real;
uint8_t base;
} u_look_around;
u_look_around.real = this->look_around;
*(outbuffer + offset + 0) = (u_look_around.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->look_around);
union {
int32_t real;
uint32_t base;
} u_look_around_attempts;
u_look_around_attempts.real = this->look_around_attempts;
*(outbuffer + offset + 0) = (u_look_around_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_look_around_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_look_around_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_look_around_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->look_around_attempts);
union {
double real;
uint64_t base;
} u_max_safe_execution_cost;
u_max_safe_execution_cost.real = this->max_safe_execution_cost;
*(outbuffer + offset + 0) = (u_max_safe_execution_cost.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_safe_execution_cost.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_safe_execution_cost.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_safe_execution_cost.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_safe_execution_cost.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_safe_execution_cost.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_safe_execution_cost.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_safe_execution_cost.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_safe_execution_cost);
union {
bool real;
uint8_t base;
} u_replan;
u_replan.real = this->replan;
*(outbuffer + offset + 0) = (u_replan.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->replan);
union {
int32_t real;
uint32_t base;
} u_replan_attempts;
u_replan_attempts.real = this->replan_attempts;
*(outbuffer + offset + 0) = (u_replan_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_replan_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_replan_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_replan_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->replan_attempts);
union {
double real;
uint64_t base;
} u_replan_delay;
u_replan_delay.real = this->replan_delay;
*(outbuffer + offset + 0) = (u_replan_delay.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_replan_delay.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_replan_delay.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_replan_delay.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_replan_delay.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_replan_delay.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_replan_delay.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_replan_delay.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->replan_delay);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->planning_scene_diff.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_plan_only;
u_plan_only.base = 0;
u_plan_only.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->plan_only = u_plan_only.real;
offset += sizeof(this->plan_only);
union {
bool real;
uint8_t base;
} u_look_around;
u_look_around.base = 0;
u_look_around.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->look_around = u_look_around.real;
offset += sizeof(this->look_around);
union {
int32_t real;
uint32_t base;
} u_look_around_attempts;
u_look_around_attempts.base = 0;
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->look_around_attempts = u_look_around_attempts.real;
offset += sizeof(this->look_around_attempts);
union {
double real;
uint64_t base;
} u_max_safe_execution_cost;
u_max_safe_execution_cost.base = 0;
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_safe_execution_cost = u_max_safe_execution_cost.real;
offset += sizeof(this->max_safe_execution_cost);
union {
bool real;
uint8_t base;
} u_replan;
u_replan.base = 0;
u_replan.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->replan = u_replan.real;
offset += sizeof(this->replan);
union {
int32_t real;
uint32_t base;
} u_replan_attempts;
u_replan_attempts.base = 0;
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->replan_attempts = u_replan_attempts.real;
offset += sizeof(this->replan_attempts);
union {
double real;
uint64_t base;
} u_replan_delay;
u_replan_delay.base = 0;
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->replan_delay = u_replan_delay.real;
offset += sizeof(this->replan_delay);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningOptions"; };
const char * getMD5(){ return "3934e50ede2ecea03e532aade900ab50"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/VisibilityConstraint.h | #ifndef _ROS_moveit_msgs_VisibilityConstraint_h
#define _ROS_moveit_msgs_VisibilityConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
namespace moveit_msgs
{
class VisibilityConstraint : public ros::Msg
{
public:
typedef double _target_radius_type;
_target_radius_type target_radius;
typedef geometry_msgs::PoseStamped _target_pose_type;
_target_pose_type target_pose;
typedef int32_t _cone_sides_type;
_cone_sides_type cone_sides;
typedef geometry_msgs::PoseStamped _sensor_pose_type;
_sensor_pose_type sensor_pose;
typedef double _max_view_angle_type;
_max_view_angle_type max_view_angle;
typedef double _max_range_angle_type;
_max_range_angle_type max_range_angle;
typedef uint8_t _sensor_view_direction_type;
_sensor_view_direction_type sensor_view_direction;
typedef double _weight_type;
_weight_type weight;
enum { SENSOR_Z = 0 };
enum { SENSOR_Y = 1 };
enum { SENSOR_X = 2 };
VisibilityConstraint():
target_radius(0),
target_pose(),
cone_sides(0),
sensor_pose(),
max_view_angle(0),
max_range_angle(0),
sensor_view_direction(0),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_target_radius;
u_target_radius.real = this->target_radius;
*(outbuffer + offset + 0) = (u_target_radius.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_target_radius.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_target_radius.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_target_radius.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_target_radius.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_target_radius.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_target_radius.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_target_radius.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->target_radius);
offset += this->target_pose.serialize(outbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_cone_sides;
u_cone_sides.real = this->cone_sides;
*(outbuffer + offset + 0) = (u_cone_sides.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cone_sides.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cone_sides.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cone_sides.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cone_sides);
offset += this->sensor_pose.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_max_view_angle;
u_max_view_angle.real = this->max_view_angle;
*(outbuffer + offset + 0) = (u_max_view_angle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_view_angle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_view_angle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_view_angle.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_view_angle.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_view_angle.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_view_angle.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_view_angle.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_view_angle);
union {
double real;
uint64_t base;
} u_max_range_angle;
u_max_range_angle.real = this->max_range_angle;
*(outbuffer + offset + 0) = (u_max_range_angle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_range_angle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_range_angle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_range_angle.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_range_angle.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_range_angle.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_range_angle.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_range_angle.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_range_angle);
*(outbuffer + offset + 0) = (this->sensor_view_direction >> (8 * 0)) & 0xFF;
offset += sizeof(this->sensor_view_direction);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_target_radius;
u_target_radius.base = 0;
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->target_radius = u_target_radius.real;
offset += sizeof(this->target_radius);
offset += this->target_pose.deserialize(inbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_cone_sides;
u_cone_sides.base = 0;
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->cone_sides = u_cone_sides.real;
offset += sizeof(this->cone_sides);
offset += this->sensor_pose.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_max_view_angle;
u_max_view_angle.base = 0;
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_view_angle = u_max_view_angle.real;
offset += sizeof(this->max_view_angle);
union {
double real;
uint64_t base;
} u_max_range_angle;
u_max_range_angle.base = 0;
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_range_angle = u_max_range_angle.real;
offset += sizeof(this->max_range_angle);
this->sensor_view_direction = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->sensor_view_direction);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/VisibilityConstraint"; };
const char * getMD5(){ return "62cda903bfe31ff2e5fcdc3810d577ad"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PositionConstraint.h | #ifndef _ROS_moveit_msgs_PositionConstraint_h
#define _ROS_moveit_msgs_PositionConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Vector3.h"
#include "moveit_msgs/BoundingVolume.h"
namespace moveit_msgs
{
class PositionConstraint : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _link_name_type;
_link_name_type link_name;
typedef geometry_msgs::Vector3 _target_point_offset_type;
_target_point_offset_type target_point_offset;
typedef moveit_msgs::BoundingVolume _constraint_region_type;
_constraint_region_type constraint_region;
typedef double _weight_type;
_weight_type weight;
PositionConstraint():
header(),
link_name(""),
target_point_offset(),
constraint_region(),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
offset += this->target_point_offset.serialize(outbuffer + offset);
offset += this->constraint_region.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
offset += this->target_point_offset.deserialize(inbuffer + offset);
offset += this->constraint_region.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/PositionConstraint"; };
const char * getMD5(){ return "c83edf208d87d3aa3169f47775a58e6a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceAction.h | #ifndef _ROS_moveit_msgs_PlaceAction_h
#define _ROS_moveit_msgs_PlaceAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlaceActionGoal.h"
#include "moveit_msgs/PlaceActionResult.h"
#include "moveit_msgs/PlaceActionFeedback.h"
namespace moveit_msgs
{
class PlaceAction : public ros::Msg
{
public:
typedef moveit_msgs::PlaceActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::PlaceActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::PlaceActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
PlaceAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceAction"; };
const char * getMD5(){ return "75889272b1933a2dc1af2de3bb645a64"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningSceneWorld.h | #ifndef _ROS_moveit_msgs_PlanningSceneWorld_h
#define _ROS_moveit_msgs_PlanningSceneWorld_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/CollisionObject.h"
#include "octomap_msgs/OctomapWithPose.h"
namespace moveit_msgs
{
class PlanningSceneWorld : public ros::Msg
{
public:
uint32_t collision_objects_length;
typedef moveit_msgs::CollisionObject _collision_objects_type;
_collision_objects_type st_collision_objects;
_collision_objects_type * collision_objects;
typedef octomap_msgs::OctomapWithPose _octomap_type;
_octomap_type octomap;
PlanningSceneWorld():
collision_objects_length(0), collision_objects(NULL),
octomap()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->collision_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->collision_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->collision_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->collision_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->collision_objects_length);
for( uint32_t i = 0; i < collision_objects_length; i++){
offset += this->collision_objects[i].serialize(outbuffer + offset);
}
offset += this->octomap.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t collision_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->collision_objects_length);
if(collision_objects_lengthT > collision_objects_length)
this->collision_objects = (moveit_msgs::CollisionObject*)realloc(this->collision_objects, collision_objects_lengthT * sizeof(moveit_msgs::CollisionObject));
collision_objects_length = collision_objects_lengthT;
for( uint32_t i = 0; i < collision_objects_length; i++){
offset += this->st_collision_objects.deserialize(inbuffer + offset);
memcpy( &(this->collision_objects[i]), &(this->st_collision_objects), sizeof(moveit_msgs::CollisionObject));
}
offset += this->octomap.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningSceneWorld"; };
const char * getMD5(){ return "373d88390d1db385335639f687723ee6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AttachedCollisionObject.h | #ifndef _ROS_moveit_msgs_AttachedCollisionObject_h
#define _ROS_moveit_msgs_AttachedCollisionObject_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/CollisionObject.h"
#include "trajectory_msgs/JointTrajectory.h"
namespace moveit_msgs
{
class AttachedCollisionObject : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef moveit_msgs::CollisionObject _object_type;
_object_type object;
uint32_t touch_links_length;
typedef char* _touch_links_type;
_touch_links_type st_touch_links;
_touch_links_type * touch_links;
typedef trajectory_msgs::JointTrajectory _detach_posture_type;
_detach_posture_type detach_posture;
typedef double _weight_type;
_weight_type weight;
AttachedCollisionObject():
link_name(""),
object(),
touch_links_length(0), touch_links(NULL),
detach_posture(),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
offset += this->object.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->touch_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->touch_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->touch_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->touch_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->touch_links_length);
for( uint32_t i = 0; i < touch_links_length; i++){
uint32_t length_touch_linksi = strlen(this->touch_links[i]);
varToArr(outbuffer + offset, length_touch_linksi);
offset += 4;
memcpy(outbuffer + offset, this->touch_links[i], length_touch_linksi);
offset += length_touch_linksi;
}
offset += this->detach_posture.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
offset += this->object.deserialize(inbuffer + offset);
uint32_t touch_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->touch_links_length);
if(touch_links_lengthT > touch_links_length)
this->touch_links = (char**)realloc(this->touch_links, touch_links_lengthT * sizeof(char*));
touch_links_length = touch_links_lengthT;
for( uint32_t i = 0; i < touch_links_length; i++){
uint32_t length_st_touch_links;
arrToVar(length_st_touch_links, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_touch_links; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_touch_links-1]=0;
this->st_touch_links = (char *)(inbuffer + offset-1);
offset += length_st_touch_links;
memcpy( &(this->touch_links[i]), &(this->st_touch_links), sizeof(char*));
}
offset += this->detach_posture.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/AttachedCollisionObject"; };
const char * getMD5(){ return "3ceac60b21e85bbd6c5b0ab9d476b752"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AllowedCollisionMatrix.h | #ifndef _ROS_moveit_msgs_AllowedCollisionMatrix_h
#define _ROS_moveit_msgs_AllowedCollisionMatrix_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/AllowedCollisionEntry.h"
namespace moveit_msgs
{
class AllowedCollisionMatrix : public ros::Msg
{
public:
uint32_t entry_names_length;
typedef char* _entry_names_type;
_entry_names_type st_entry_names;
_entry_names_type * entry_names;
uint32_t entry_values_length;
typedef moveit_msgs::AllowedCollisionEntry _entry_values_type;
_entry_values_type st_entry_values;
_entry_values_type * entry_values;
uint32_t default_entry_names_length;
typedef char* _default_entry_names_type;
_default_entry_names_type st_default_entry_names;
_default_entry_names_type * default_entry_names;
uint32_t default_entry_values_length;
typedef bool _default_entry_values_type;
_default_entry_values_type st_default_entry_values;
_default_entry_values_type * default_entry_values;
AllowedCollisionMatrix():
entry_names_length(0), entry_names(NULL),
entry_values_length(0), entry_values(NULL),
default_entry_names_length(0), default_entry_names(NULL),
default_entry_values_length(0), default_entry_values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->entry_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->entry_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->entry_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->entry_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->entry_names_length);
for( uint32_t i = 0; i < entry_names_length; i++){
uint32_t length_entry_namesi = strlen(this->entry_names[i]);
varToArr(outbuffer + offset, length_entry_namesi);
offset += 4;
memcpy(outbuffer + offset, this->entry_names[i], length_entry_namesi);
offset += length_entry_namesi;
}
*(outbuffer + offset + 0) = (this->entry_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->entry_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->entry_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->entry_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->entry_values_length);
for( uint32_t i = 0; i < entry_values_length; i++){
offset += this->entry_values[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->default_entry_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->default_entry_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->default_entry_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->default_entry_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->default_entry_names_length);
for( uint32_t i = 0; i < default_entry_names_length; i++){
uint32_t length_default_entry_namesi = strlen(this->default_entry_names[i]);
varToArr(outbuffer + offset, length_default_entry_namesi);
offset += 4;
memcpy(outbuffer + offset, this->default_entry_names[i], length_default_entry_namesi);
offset += length_default_entry_namesi;
}
*(outbuffer + offset + 0) = (this->default_entry_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->default_entry_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->default_entry_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->default_entry_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->default_entry_values_length);
for( uint32_t i = 0; i < default_entry_values_length; i++){
union {
bool real;
uint8_t base;
} u_default_entry_valuesi;
u_default_entry_valuesi.real = this->default_entry_values[i];
*(outbuffer + offset + 0) = (u_default_entry_valuesi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->default_entry_values[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t entry_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->entry_names_length);
if(entry_names_lengthT > entry_names_length)
this->entry_names = (char**)realloc(this->entry_names, entry_names_lengthT * sizeof(char*));
entry_names_length = entry_names_lengthT;
for( uint32_t i = 0; i < entry_names_length; i++){
uint32_t length_st_entry_names;
arrToVar(length_st_entry_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_entry_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_entry_names-1]=0;
this->st_entry_names = (char *)(inbuffer + offset-1);
offset += length_st_entry_names;
memcpy( &(this->entry_names[i]), &(this->st_entry_names), sizeof(char*));
}
uint32_t entry_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->entry_values_length);
if(entry_values_lengthT > entry_values_length)
this->entry_values = (moveit_msgs::AllowedCollisionEntry*)realloc(this->entry_values, entry_values_lengthT * sizeof(moveit_msgs::AllowedCollisionEntry));
entry_values_length = entry_values_lengthT;
for( uint32_t i = 0; i < entry_values_length; i++){
offset += this->st_entry_values.deserialize(inbuffer + offset);
memcpy( &(this->entry_values[i]), &(this->st_entry_values), sizeof(moveit_msgs::AllowedCollisionEntry));
}
uint32_t default_entry_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->default_entry_names_length);
if(default_entry_names_lengthT > default_entry_names_length)
this->default_entry_names = (char**)realloc(this->default_entry_names, default_entry_names_lengthT * sizeof(char*));
default_entry_names_length = default_entry_names_lengthT;
for( uint32_t i = 0; i < default_entry_names_length; i++){
uint32_t length_st_default_entry_names;
arrToVar(length_st_default_entry_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_default_entry_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_default_entry_names-1]=0;
this->st_default_entry_names = (char *)(inbuffer + offset-1);
offset += length_st_default_entry_names;
memcpy( &(this->default_entry_names[i]), &(this->st_default_entry_names), sizeof(char*));
}
uint32_t default_entry_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->default_entry_values_length);
if(default_entry_values_lengthT > default_entry_values_length)
this->default_entry_values = (bool*)realloc(this->default_entry_values, default_entry_values_lengthT * sizeof(bool));
default_entry_values_length = default_entry_values_lengthT;
for( uint32_t i = 0; i < default_entry_values_length; i++){
union {
bool real;
uint8_t base;
} u_st_default_entry_values;
u_st_default_entry_values.base = 0;
u_st_default_entry_values.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_default_entry_values = u_st_default_entry_values.real;
offset += sizeof(this->st_default_entry_values);
memcpy( &(this->default_entry_values[i]), &(this->st_default_entry_values), sizeof(bool));
}
return offset;
}
const char * getType(){ return "moveit_msgs/AllowedCollisionMatrix"; };
const char * getMD5(){ return "aedce13587eef0d79165a075659c1879"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayTrajectory.h | #ifndef _ROS_moveit_msgs_DisplayTrajectory_h
#define _ROS_moveit_msgs_DisplayTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
class DisplayTrajectory : public ros::Msg
{
public:
typedef const char* _model_id_type;
_model_id_type model_id;
uint32_t trajectory_length;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type st_trajectory;
_trajectory_type * trajectory;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
DisplayTrajectory():
model_id(""),
trajectory_length(0), trajectory(NULL),
trajectory_start()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_id = strlen(this->model_id);
varToArr(outbuffer + offset, length_model_id);
offset += 4;
memcpy(outbuffer + offset, this->model_id, length_model_id);
offset += length_model_id;
*(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_length);
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->trajectory[i].serialize(outbuffer + offset);
}
offset += this->trajectory_start.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_id;
arrToVar(length_model_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_id-1]=0;
this->model_id = (char *)(inbuffer + offset-1);
offset += length_model_id;
uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_length);
if(trajectory_lengthT > trajectory_length)
this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_length = trajectory_lengthT;
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->st_trajectory.deserialize(inbuffer + offset);
memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory));
}
offset += this->trajectory_start.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/DisplayTrajectory"; };
const char * getMD5(){ return "c3c039261ab9e8a11457dac56b6316c8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupActionGoal.h | #ifndef _ROS_moveit_msgs_PickupActionGoal_h
#define _ROS_moveit_msgs_PickupActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/PickupGoal.h"
namespace moveit_msgs
{
class PickupActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::PickupGoal _goal_type;
_goal_type goal;
PickupActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupActionGoal"; };
const char * getMD5(){ return "9e12196da542c9a26bbc43e9655a1906"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupFeedback.h | #ifndef _ROS_moveit_msgs_PickupFeedback_h
#define _ROS_moveit_msgs_PickupFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PickupFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
PickupFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/PickupFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LinkScale.h | #ifndef _ROS_moveit_msgs_LinkScale_h
#define _ROS_moveit_msgs_LinkScale_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class LinkScale : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef double _scale_type;
_scale_type scale;
LinkScale():
link_name(""),
scale(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_scale;
u_scale.real = this->scale;
*(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_scale.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_scale.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_scale.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_scale.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->scale);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_scale;
u_scale.base = 0;
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->scale = u_scale.real;
offset += sizeof(this->scale);
return offset;
}
const char * getType(){ return "moveit_msgs/LinkScale"; };
const char * getMD5(){ return "19faf226446bfb2f645a4da6f2a56166"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPositionIK.h | #ifndef _ROS_SERVICE_GetPositionIK_h
#define _ROS_SERVICE_GetPositionIK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/PositionIKRequest.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char GETPOSITIONIK[] = "moveit_msgs/GetPositionIK";
class GetPositionIKRequest : public ros::Msg
{
public:
typedef moveit_msgs::PositionIKRequest _ik_request_type;
_ik_request_type ik_request;
GetPositionIKRequest():
ik_request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->ik_request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->ik_request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONIK; };
const char * getMD5(){ return "a67dc7e99d15c1dca32a77c22bc2d93b"; };
};
class GetPositionIKResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _solution_type;
_solution_type solution;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetPositionIKResponse():
solution(),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->solution.serialize(outbuffer + offset);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->solution.deserialize(inbuffer + offset);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONIK; };
const char * getMD5(){ return "ad50fe5fa0ddb482909be313121ea148"; };
};
class GetPositionIK {
public:
typedef GetPositionIKRequest Request;
typedef GetPositionIKResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupActionGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupActionGoal_h
#define _ROS_moveit_msgs_MoveGroupActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/MoveGroupGoal.h"
namespace moveit_msgs
{
class MoveGroupActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::MoveGroupGoal _goal_type;
_goal_type goal;
MoveGroupActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupActionGoal"; };
const char * getMD5(){ return "df11ac1a643d87b6e6a6fe5af1823709"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/WorkspaceParameters.h | #ifndef _ROS_moveit_msgs_WorkspaceParameters_h
#define _ROS_moveit_msgs_WorkspaceParameters_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Vector3.h"
namespace moveit_msgs
{
class WorkspaceParameters : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Vector3 _min_corner_type;
_min_corner_type min_corner;
typedef geometry_msgs::Vector3 _max_corner_type;
_max_corner_type max_corner;
WorkspaceParameters():
header(),
min_corner(),
max_corner()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->min_corner.serialize(outbuffer + offset);
offset += this->max_corner.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->min_corner.deserialize(inbuffer + offset);
offset += this->max_corner.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/WorkspaceParameters"; };
const char * getMD5(){ return "d639a834e7b1f927e9f1d6c30e920016"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LoadMap.h | #ifndef _ROS_SERVICE_LoadMap_h
#define _ROS_SERVICE_LoadMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char LOADMAP[] = "moveit_msgs/LoadMap";
class LoadMapRequest : public ros::Msg
{
public:
typedef const char* _filename_type;
_filename_type filename;
LoadMapRequest():
filename("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_filename;
arrToVar(length_filename, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_filename; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_filename-1]=0;
this->filename = (char *)(inbuffer + offset-1);
offset += length_filename;
return offset;
}
const char * getType(){ return LOADMAP; };
const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; };
};
class LoadMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
LoadMapResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return LOADMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class LoadMap {
public:
typedef LoadMapRequest Request;
typedef LoadMapResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceGoal_h
#define _ROS_moveit_msgs_MoveGroupSequenceGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceRequest.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class MoveGroupSequenceGoal : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceRequest _request_type;
_request_type request;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
MoveGroupSequenceGoal():
request(),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceGoal"; };
const char * getMD5(){ return "12fc6281edcaf031de4783a58087ebf1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceResult.h | #ifndef _ROS_moveit_msgs_PlaceResult_h
#define _ROS_moveit_msgs_PlaceResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/PlaceLocation.h"
namespace moveit_msgs
{
class PlaceResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
uint32_t trajectory_stages_length;
typedef moveit_msgs::RobotTrajectory _trajectory_stages_type;
_trajectory_stages_type st_trajectory_stages;
_trajectory_stages_type * trajectory_stages;
uint32_t trajectory_descriptions_length;
typedef char* _trajectory_descriptions_type;
_trajectory_descriptions_type st_trajectory_descriptions;
_trajectory_descriptions_type * trajectory_descriptions;
typedef moveit_msgs::PlaceLocation _place_location_type;
_place_location_type place_location;
typedef double _planning_time_type;
_planning_time_type planning_time;
PlaceResult():
error_code(),
trajectory_start(),
trajectory_stages_length(0), trajectory_stages(NULL),
trajectory_descriptions_length(0), trajectory_descriptions(NULL),
place_location(),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->trajectory_start.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_stages_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_stages_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_stages_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_stages_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_stages_length);
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->trajectory_stages[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->trajectory_descriptions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_descriptions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_descriptions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_descriptions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_descriptions_length);
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_trajectory_descriptionsi = strlen(this->trajectory_descriptions[i]);
varToArr(outbuffer + offset, length_trajectory_descriptionsi);
offset += 4;
memcpy(outbuffer + offset, this->trajectory_descriptions[i], length_trajectory_descriptionsi);
offset += length_trajectory_descriptionsi;
}
offset += this->place_location.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t trajectory_stages_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_stages_length);
if(trajectory_stages_lengthT > trajectory_stages_length)
this->trajectory_stages = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory_stages, trajectory_stages_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_stages_length = trajectory_stages_lengthT;
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->st_trajectory_stages.deserialize(inbuffer + offset);
memcpy( &(this->trajectory_stages[i]), &(this->st_trajectory_stages), sizeof(moveit_msgs::RobotTrajectory));
}
uint32_t trajectory_descriptions_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_descriptions_length);
if(trajectory_descriptions_lengthT > trajectory_descriptions_length)
this->trajectory_descriptions = (char**)realloc(this->trajectory_descriptions, trajectory_descriptions_lengthT * sizeof(char*));
trajectory_descriptions_length = trajectory_descriptions_lengthT;
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_st_trajectory_descriptions;
arrToVar(length_st_trajectory_descriptions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_trajectory_descriptions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_trajectory_descriptions-1]=0;
this->st_trajectory_descriptions = (char *)(inbuffer + offset-1);
offset += length_st_trajectory_descriptions;
memcpy( &(this->trajectory_descriptions[i]), &(this->st_trajectory_descriptions), sizeof(char*));
}
offset += this->place_location.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceResult"; };
const char * getMD5(){ return "94bc2148a619282cbe09156013d6c4c9"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetCartesianPath.h | #ifndef _ROS_SERVICE_GetCartesianPath_h
#define _ROS_SERVICE_GetCartesianPath_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "geometry_msgs/Pose.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
static const char GETCARTESIANPATH[] = "moveit_msgs/GetCartesianPath";
class GetCartesianPathRequest : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef const char* _link_name_type;
_link_name_type link_name;
uint32_t waypoints_length;
typedef geometry_msgs::Pose _waypoints_type;
_waypoints_type st_waypoints;
_waypoints_type * waypoints;
typedef double _max_step_type;
_max_step_type max_step;
typedef double _jump_threshold_type;
_jump_threshold_type jump_threshold;
typedef bool _avoid_collisions_type;
_avoid_collisions_type avoid_collisions;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
GetCartesianPathRequest():
header(),
start_state(),
group_name(""),
link_name(""),
waypoints_length(0), waypoints(NULL),
max_step(0),
jump_threshold(0),
avoid_collisions(0),
path_constraints()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->start_state.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
*(outbuffer + offset + 0) = (this->waypoints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->waypoints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->waypoints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->waypoints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->waypoints_length);
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->waypoints[i].serialize(outbuffer + offset);
}
union {
double real;
uint64_t base;
} u_max_step;
u_max_step.real = this->max_step;
*(outbuffer + offset + 0) = (u_max_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_step);
union {
double real;
uint64_t base;
} u_jump_threshold;
u_jump_threshold.real = this->jump_threshold;
*(outbuffer + offset + 0) = (u_jump_threshold.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_jump_threshold.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_jump_threshold.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_jump_threshold.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_jump_threshold.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_jump_threshold.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_jump_threshold.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_jump_threshold.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->jump_threshold);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.real = this->avoid_collisions;
*(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->avoid_collisions);
offset += this->path_constraints.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->start_state.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
uint32_t waypoints_lengthT = ((uint32_t) (*(inbuffer + offset)));
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->waypoints_length);
if(waypoints_lengthT > waypoints_length)
this->waypoints = (geometry_msgs::Pose*)realloc(this->waypoints, waypoints_lengthT * sizeof(geometry_msgs::Pose));
waypoints_length = waypoints_lengthT;
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->st_waypoints.deserialize(inbuffer + offset);
memcpy( &(this->waypoints[i]), &(this->st_waypoints), sizeof(geometry_msgs::Pose));
}
union {
double real;
uint64_t base;
} u_max_step;
u_max_step.base = 0;
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_step = u_max_step.real;
offset += sizeof(this->max_step);
union {
double real;
uint64_t base;
} u_jump_threshold;
u_jump_threshold.base = 0;
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->jump_threshold = u_jump_threshold.real;
offset += sizeof(this->jump_threshold);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.base = 0;
u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->avoid_collisions = u_avoid_collisions.real;
offset += sizeof(this->avoid_collisions);
offset += this->path_constraints.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETCARTESIANPATH; };
const char * getMD5(){ return "b37c16ad7ed838d811a270a8054276b6"; };
};
class GetCartesianPathResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
typedef moveit_msgs::RobotTrajectory _solution_type;
_solution_type solution;
typedef double _fraction_type;
_fraction_type fraction;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetCartesianPathResponse():
start_state(),
solution(),
fraction(0),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->start_state.serialize(outbuffer + offset);
offset += this->solution.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_fraction;
u_fraction.real = this->fraction;
*(outbuffer + offset + 0) = (u_fraction.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fraction.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fraction.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fraction.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fraction.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fraction.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fraction.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fraction.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fraction);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->start_state.deserialize(inbuffer + offset);
offset += this->solution.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_fraction;
u_fraction.base = 0;
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->fraction = u_fraction.real;
offset += sizeof(this->fraction);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETCARTESIANPATH; };
const char * getMD5(){ return "45414110461a45eb0e273e013924ce59"; };
};
class GetCartesianPath {
public:
typedef GetCartesianPathRequest Request;
typedef GetCartesianPathResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GripperTranslation.h | #ifndef _ROS_moveit_msgs_GripperTranslation_h
#define _ROS_moveit_msgs_GripperTranslation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3Stamped.h"
namespace moveit_msgs
{
class GripperTranslation : public ros::Msg
{
public:
typedef geometry_msgs::Vector3Stamped _direction_type;
_direction_type direction;
typedef float _desired_distance_type;
_desired_distance_type desired_distance;
typedef float _min_distance_type;
_min_distance_type min_distance;
GripperTranslation():
direction(),
desired_distance(0),
min_distance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->direction.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_desired_distance;
u_desired_distance.real = this->desired_distance;
*(outbuffer + offset + 0) = (u_desired_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_desired_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_desired_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_desired_distance.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->desired_distance);
union {
float real;
uint32_t base;
} u_min_distance;
u_min_distance.real = this->min_distance;
*(outbuffer + offset + 0) = (u_min_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_distance.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_distance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->direction.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_desired_distance;
u_desired_distance.base = 0;
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->desired_distance = u_desired_distance.real;
offset += sizeof(this->desired_distance);
union {
float real;
uint32_t base;
} u_min_distance;
u_min_distance.base = 0;
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->min_distance = u_min_distance.real;
offset += sizeof(this->min_distance);
return offset;
}
const char * getType(){ return "moveit_msgs/GripperTranslation"; };
const char * getMD5(){ return "b53bc0ad0f717cdec3b0e42dec300121"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceFeedback.h | #ifndef _ROS_moveit_msgs_PlaceFeedback_h
#define _ROS_moveit_msgs_PlaceFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlaceFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
PlaceFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ListRobotStatesInWarehouse.h | #ifndef _ROS_SERVICE_ListRobotStatesInWarehouse_h
#define _ROS_SERVICE_ListRobotStatesInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char LISTROBOTSTATESINWAREHOUSE[] = "moveit_msgs/ListRobotStatesInWarehouse";
class ListRobotStatesInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _regex_type;
_regex_type regex;
typedef const char* _robot_type;
_robot_type robot;
ListRobotStatesInWarehouseRequest():
regex(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_regex = strlen(this->regex);
varToArr(outbuffer + offset, length_regex);
offset += 4;
memcpy(outbuffer + offset, this->regex, length_regex);
offset += length_regex;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_regex;
arrToVar(length_regex, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_regex; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_regex-1]=0;
this->regex = (char *)(inbuffer + offset-1);
offset += length_regex;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return LISTROBOTSTATESINWAREHOUSE; };
const char * getMD5(){ return "6f0970a3ca837e2fc3ed63e314b44b42"; };
};
class ListRobotStatesInWarehouseResponse : public ros::Msg
{
public:
uint32_t states_length;
typedef char* _states_type;
_states_type st_states;
_states_type * states;
ListRobotStatesInWarehouseResponse():
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
uint32_t length_statesi = strlen(this->states[i]);
varToArr(outbuffer + offset, length_statesi);
offset += 4;
memcpy(outbuffer + offset, this->states[i], length_statesi);
offset += length_statesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (char**)realloc(this->states, states_lengthT * sizeof(char*));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
uint32_t length_st_states;
arrToVar(length_st_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_states-1]=0;
this->st_states = (char *)(inbuffer + offset-1);
offset += length_st_states;
memcpy( &(this->states[i]), &(this->st_states), sizeof(char*));
}
return offset;
}
const char * getType(){ return LISTROBOTSTATESINWAREHOUSE; };
const char * getMD5(){ return "a8656b247c0429bb79afe0ddb88eb2f5"; };
};
class ListRobotStatesInWarehouse {
public:
typedef ListRobotStatesInWarehouseRequest Request;
typedef ListRobotStatesInWarehouseResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayRobotState.h | #ifndef _ROS_moveit_msgs_DisplayRobotState_h
#define _ROS_moveit_msgs_DisplayRobotState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/ObjectColor.h"
namespace moveit_msgs
{
class DisplayRobotState : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _state_type;
_state_type state;
uint32_t highlight_links_length;
typedef moveit_msgs::ObjectColor _highlight_links_type;
_highlight_links_type st_highlight_links;
_highlight_links_type * highlight_links;
DisplayRobotState():
state(),
highlight_links_length(0), highlight_links(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->state.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->highlight_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->highlight_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->highlight_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->highlight_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->highlight_links_length);
for( uint32_t i = 0; i < highlight_links_length; i++){
offset += this->highlight_links[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->state.deserialize(inbuffer + offset);
uint32_t highlight_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->highlight_links_length);
if(highlight_links_lengthT > highlight_links_length)
this->highlight_links = (moveit_msgs::ObjectColor*)realloc(this->highlight_links, highlight_links_lengthT * sizeof(moveit_msgs::ObjectColor));
highlight_links_length = highlight_links_lengthT;
for( uint32_t i = 0; i < highlight_links_length; i++){
offset += this->st_highlight_links.deserialize(inbuffer + offset);
memcpy( &(this->highlight_links[i]), &(this->st_highlight_links), sizeof(moveit_msgs::ObjectColor));
}
return offset;
}
const char * getType(){ return "moveit_msgs/DisplayRobotState"; };
const char * getMD5(){ return "6a3bab3a33a8c47aee24481a455a21aa"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceItem.h | #ifndef _ROS_moveit_msgs_MotionSequenceItem_h
#define _ROS_moveit_msgs_MotionSequenceItem_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
namespace moveit_msgs
{
class MotionSequenceItem : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _req_type;
_req_type req;
typedef double _blend_radius_type;
_blend_radius_type blend_radius;
MotionSequenceItem():
req(),
blend_radius(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->req.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_blend_radius;
u_blend_radius.real = this->blend_radius;
*(outbuffer + offset + 0) = (u_blend_radius.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_blend_radius.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_blend_radius.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_blend_radius.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_blend_radius.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_blend_radius.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_blend_radius.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_blend_radius.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->blend_radius);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->req.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_blend_radius;
u_blend_radius.base = 0;
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->blend_radius = u_blend_radius.real;
offset += sizeof(this->blend_radius);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionSequenceItem"; };
const char * getMD5(){ return "932aef4280f479e42c693b8b285624bf"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceActionResult.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceActionResult_h
#define _ROS_moveit_msgs_MoveGroupSequenceActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/MoveGroupSequenceResult.h"
namespace moveit_msgs
{
class MoveGroupSequenceActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupSequenceResult _result_type;
_result_type result;
MoveGroupSequenceActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceActionResult"; };
const char * getMD5(){ return "e995e5b2d6c322a0395df341caa51d8e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CollisionObject.h | #ifndef _ROS_moveit_msgs_CollisionObject_h
#define _ROS_moveit_msgs_CollisionObject_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "object_recognition_msgs/ObjectType.h"
#include "shape_msgs/SolidPrimitive.h"
#include "geometry_msgs/Pose.h"
#include "shape_msgs/Mesh.h"
#include "shape_msgs/Plane.h"
namespace moveit_msgs
{
class CollisionObject : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _id_type;
_id_type id;
typedef object_recognition_msgs::ObjectType _type_type;
_type_type type;
uint32_t primitives_length;
typedef shape_msgs::SolidPrimitive _primitives_type;
_primitives_type st_primitives;
_primitives_type * primitives;
uint32_t primitive_poses_length;
typedef geometry_msgs::Pose _primitive_poses_type;
_primitive_poses_type st_primitive_poses;
_primitive_poses_type * primitive_poses;
uint32_t meshes_length;
typedef shape_msgs::Mesh _meshes_type;
_meshes_type st_meshes;
_meshes_type * meshes;
uint32_t mesh_poses_length;
typedef geometry_msgs::Pose _mesh_poses_type;
_mesh_poses_type st_mesh_poses;
_mesh_poses_type * mesh_poses;
uint32_t planes_length;
typedef shape_msgs::Plane _planes_type;
_planes_type st_planes;
_planes_type * planes;
uint32_t plane_poses_length;
typedef geometry_msgs::Pose _plane_poses_type;
_plane_poses_type st_plane_poses;
_plane_poses_type * plane_poses;
typedef int8_t _operation_type;
_operation_type operation;
enum { ADD = 0 };
enum { REMOVE = 1 };
enum { APPEND = 2 };
enum { MOVE = 3 };
CollisionObject():
header(),
id(""),
type(),
primitives_length(0), primitives(NULL),
primitive_poses_length(0), primitive_poses(NULL),
meshes_length(0), meshes(NULL),
mesh_poses_length(0), mesh_poses(NULL),
planes_length(0), planes(NULL),
plane_poses_length(0), plane_poses(NULL),
operation(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
offset += this->type.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitives_length);
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->primitives[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitive_poses_length);
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->primitive_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->meshes_length);
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->meshes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->mesh_poses_length);
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->mesh_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->planes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planes_length);
for( uint32_t i = 0; i < planes_length; i++){
offset += this->planes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->plane_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->plane_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->plane_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->plane_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->plane_poses_length);
for( uint32_t i = 0; i < plane_poses_length; i++){
offset += this->plane_poses[i].serialize(outbuffer + offset);
}
union {
int8_t real;
uint8_t base;
} u_operation;
u_operation.real = this->operation;
*(outbuffer + offset + 0) = (u_operation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->operation);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
offset += this->type.deserialize(inbuffer + offset);
uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitives_length);
if(primitives_lengthT > primitives_length)
this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive));
primitives_length = primitives_lengthT;
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->st_primitives.deserialize(inbuffer + offset);
memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive));
}
uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitive_poses_length);
if(primitive_poses_lengthT > primitive_poses_length)
this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose));
primitive_poses_length = primitive_poses_lengthT;
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->st_primitive_poses.deserialize(inbuffer + offset);
memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose));
}
uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset)));
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->meshes_length);
if(meshes_lengthT > meshes_length)
this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh));
meshes_length = meshes_lengthT;
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->st_meshes.deserialize(inbuffer + offset);
memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh));
}
uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->mesh_poses_length);
if(mesh_poses_lengthT > mesh_poses_length)
this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose));
mesh_poses_length = mesh_poses_lengthT;
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->st_mesh_poses.deserialize(inbuffer + offset);
memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose));
}
uint32_t planes_lengthT = ((uint32_t) (*(inbuffer + offset)));
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planes_length);
if(planes_lengthT > planes_length)
this->planes = (shape_msgs::Plane*)realloc(this->planes, planes_lengthT * sizeof(shape_msgs::Plane));
planes_length = planes_lengthT;
for( uint32_t i = 0; i < planes_length; i++){
offset += this->st_planes.deserialize(inbuffer + offset);
memcpy( &(this->planes[i]), &(this->st_planes), sizeof(shape_msgs::Plane));
}
uint32_t plane_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->plane_poses_length);
if(plane_poses_lengthT > plane_poses_length)
this->plane_poses = (geometry_msgs::Pose*)realloc(this->plane_poses, plane_poses_lengthT * sizeof(geometry_msgs::Pose));
plane_poses_length = plane_poses_lengthT;
for( uint32_t i = 0; i < plane_poses_length; i++){
offset += this->st_plane_poses.deserialize(inbuffer + offset);
memcpy( &(this->plane_poses[i]), &(this->st_plane_poses), sizeof(geometry_msgs::Pose));
}
union {
int8_t real;
uint8_t base;
} u_operation;
u_operation.base = 0;
u_operation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->operation = u_operation.real;
offset += sizeof(this->operation);
return offset;
}
const char * getType(){ return "moveit_msgs/CollisionObject"; };
const char * getMD5(){ return "568a161b26dc46c54a5a07621ce82cf3"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetRobotStateFromWarehouse.h | #ifndef _ROS_SERVICE_GetRobotStateFromWarehouse_h
#define _ROS_SERVICE_GetRobotStateFromWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char GETROBOTSTATEFROMWAREHOUSE[] = "moveit_msgs/GetRobotStateFromWarehouse";
class GetRobotStateFromWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
GetRobotStateFromWarehouseRequest():
name(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return GETROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; };
};
class GetRobotStateFromWarehouseResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _state_type;
_state_type state;
GetRobotStateFromWarehouseResponse():
state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "219fdfe7af6da3c7935fb948e6d5c637"; };
};
class GetRobotStateFromWarehouse {
public:
typedef GetRobotStateFromWarehouseRequest Request;
typedef GetRobotStateFromWarehouseResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceActionGoal.h | #ifndef _ROS_moveit_msgs_PlaceActionGoal_h
#define _ROS_moveit_msgs_PlaceActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/PlaceGoal.h"
namespace moveit_msgs
{
class PlaceActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::PlaceGoal _goal_type;
_goal_type goal;
PlaceActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceActionGoal"; };
const char * getMD5(){ return "facadaee390f685ed5e693ac12f5aa3d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceActionResult.h | #ifndef _ROS_moveit_msgs_PlaceActionResult_h
#define _ROS_moveit_msgs_PlaceActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/PlaceResult.h"
namespace moveit_msgs
{
class PlaceActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PlaceResult _result_type;
_result_type result;
PlaceActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceActionResult"; };
const char * getMD5(){ return "a93c9107fd23796469241f1d40422dfa"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPlannerParams.h | #ifndef _ROS_SERVICE_GetPlannerParams_h
#define _ROS_SERVICE_GetPlannerParams_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlannerParams.h"
namespace moveit_msgs
{
static const char GETPLANNERPARAMS[] = "moveit_msgs/GetPlannerParams";
class GetPlannerParamsRequest : public ros::Msg
{
public:
typedef const char* _planner_config_type;
_planner_config_type planner_config;
typedef const char* _group_type;
_group_type group;
GetPlannerParamsRequest():
planner_config(""),
group("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_planner_config = strlen(this->planner_config);
varToArr(outbuffer + offset, length_planner_config);
offset += 4;
memcpy(outbuffer + offset, this->planner_config, length_planner_config);
offset += length_planner_config;
uint32_t length_group = strlen(this->group);
varToArr(outbuffer + offset, length_group);
offset += 4;
memcpy(outbuffer + offset, this->group, length_group);
offset += length_group;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_planner_config;
arrToVar(length_planner_config, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_config; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_config-1]=0;
this->planner_config = (char *)(inbuffer + offset-1);
offset += length_planner_config;
uint32_t length_group;
arrToVar(length_group, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group-1]=0;
this->group = (char *)(inbuffer + offset-1);
offset += length_group;
return offset;
}
const char * getType(){ return GETPLANNERPARAMS; };
const char * getMD5(){ return "f548a13784550d510d791867af53ef40"; };
};
class GetPlannerParamsResponse : public ros::Msg
{
public:
typedef moveit_msgs::PlannerParams _params_type;
_params_type params;
GetPlannerParamsResponse():
params()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->params.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->params.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLANNERPARAMS; };
const char * getMD5(){ return "462b1bd59976ece800f6a48f2b0bf1a2"; };
};
class GetPlannerParams {
public:
typedef GetPlannerParamsRequest Request;
typedef GetPlannerParamsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningScene.h | #ifndef _ROS_moveit_msgs_PlanningScene_h
#define _ROS_moveit_msgs_PlanningScene_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "geometry_msgs/TransformStamped.h"
#include "moveit_msgs/AllowedCollisionMatrix.h"
#include "moveit_msgs/LinkPadding.h"
#include "moveit_msgs/LinkScale.h"
#include "moveit_msgs/ObjectColor.h"
#include "moveit_msgs/PlanningSceneWorld.h"
namespace moveit_msgs
{
class PlanningScene : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef const char* _robot_model_name_type;
_robot_model_name_type robot_model_name;
uint32_t fixed_frame_transforms_length;
typedef geometry_msgs::TransformStamped _fixed_frame_transforms_type;
_fixed_frame_transforms_type st_fixed_frame_transforms;
_fixed_frame_transforms_type * fixed_frame_transforms;
typedef moveit_msgs::AllowedCollisionMatrix _allowed_collision_matrix_type;
_allowed_collision_matrix_type allowed_collision_matrix;
uint32_t link_padding_length;
typedef moveit_msgs::LinkPadding _link_padding_type;
_link_padding_type st_link_padding;
_link_padding_type * link_padding;
uint32_t link_scale_length;
typedef moveit_msgs::LinkScale _link_scale_type;
_link_scale_type st_link_scale;
_link_scale_type * link_scale;
uint32_t object_colors_length;
typedef moveit_msgs::ObjectColor _object_colors_type;
_object_colors_type st_object_colors;
_object_colors_type * object_colors;
typedef moveit_msgs::PlanningSceneWorld _world_type;
_world_type world;
typedef bool _is_diff_type;
_is_diff_type is_diff;
PlanningScene():
name(""),
robot_state(),
robot_model_name(""),
fixed_frame_transforms_length(0), fixed_frame_transforms(NULL),
allowed_collision_matrix(),
link_padding_length(0), link_padding(NULL),
link_scale_length(0), link_scale(NULL),
object_colors_length(0), object_colors(NULL),
world(),
is_diff(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
offset += this->robot_state.serialize(outbuffer + offset);
uint32_t length_robot_model_name = strlen(this->robot_model_name);
varToArr(outbuffer + offset, length_robot_model_name);
offset += 4;
memcpy(outbuffer + offset, this->robot_model_name, length_robot_model_name);
offset += length_robot_model_name;
*(outbuffer + offset + 0) = (this->fixed_frame_transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fixed_frame_transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fixed_frame_transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fixed_frame_transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fixed_frame_transforms_length);
for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){
offset += this->fixed_frame_transforms[i].serialize(outbuffer + offset);
}
offset += this->allowed_collision_matrix.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->link_padding_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_padding_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_padding_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_padding_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_padding_length);
for( uint32_t i = 0; i < link_padding_length; i++){
offset += this->link_padding[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->link_scale_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_scale_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_scale_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_scale_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_scale_length);
for( uint32_t i = 0; i < link_scale_length; i++){
offset += this->link_scale[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->object_colors_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->object_colors_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->object_colors_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->object_colors_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->object_colors_length);
for( uint32_t i = 0; i < object_colors_length; i++){
offset += this->object_colors[i].serialize(outbuffer + offset);
}
offset += this->world.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.real = this->is_diff;
*(outbuffer + offset + 0) = (u_is_diff.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_diff);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
offset += this->robot_state.deserialize(inbuffer + offset);
uint32_t length_robot_model_name;
arrToVar(length_robot_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot_model_name-1]=0;
this->robot_model_name = (char *)(inbuffer + offset-1);
offset += length_robot_model_name;
uint32_t fixed_frame_transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fixed_frame_transforms_length);
if(fixed_frame_transforms_lengthT > fixed_frame_transforms_length)
this->fixed_frame_transforms = (geometry_msgs::TransformStamped*)realloc(this->fixed_frame_transforms, fixed_frame_transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
fixed_frame_transforms_length = fixed_frame_transforms_lengthT;
for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){
offset += this->st_fixed_frame_transforms.deserialize(inbuffer + offset);
memcpy( &(this->fixed_frame_transforms[i]), &(this->st_fixed_frame_transforms), sizeof(geometry_msgs::TransformStamped));
}
offset += this->allowed_collision_matrix.deserialize(inbuffer + offset);
uint32_t link_padding_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_padding_length);
if(link_padding_lengthT > link_padding_length)
this->link_padding = (moveit_msgs::LinkPadding*)realloc(this->link_padding, link_padding_lengthT * sizeof(moveit_msgs::LinkPadding));
link_padding_length = link_padding_lengthT;
for( uint32_t i = 0; i < link_padding_length; i++){
offset += this->st_link_padding.deserialize(inbuffer + offset);
memcpy( &(this->link_padding[i]), &(this->st_link_padding), sizeof(moveit_msgs::LinkPadding));
}
uint32_t link_scale_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_scale_length);
if(link_scale_lengthT > link_scale_length)
this->link_scale = (moveit_msgs::LinkScale*)realloc(this->link_scale, link_scale_lengthT * sizeof(moveit_msgs::LinkScale));
link_scale_length = link_scale_lengthT;
for( uint32_t i = 0; i < link_scale_length; i++){
offset += this->st_link_scale.deserialize(inbuffer + offset);
memcpy( &(this->link_scale[i]), &(this->st_link_scale), sizeof(moveit_msgs::LinkScale));
}
uint32_t object_colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->object_colors_length);
if(object_colors_lengthT > object_colors_length)
this->object_colors = (moveit_msgs::ObjectColor*)realloc(this->object_colors, object_colors_lengthT * sizeof(moveit_msgs::ObjectColor));
object_colors_length = object_colors_lengthT;
for( uint32_t i = 0; i < object_colors_length; i++){
offset += this->st_object_colors.deserialize(inbuffer + offset);
memcpy( &(this->object_colors[i]), &(this->st_object_colors), sizeof(moveit_msgs::ObjectColor));
}
offset += this->world.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.base = 0;
u_is_diff.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_diff = u_is_diff.real;
offset += sizeof(this->is_diff);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningScene"; };
const char * getMD5(){ return "89aac6d20db967ba716cba5a86b1b9d5"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupGoal_h
#define _ROS_moveit_msgs_MoveGroupGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class MoveGroupGoal : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _request_type;
_request_type request;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
MoveGroupGoal():
request(),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupGoal"; };
const char * getMD5(){ return "a6de2db49c561a49babce1a8172e8906"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RenameRobotStateInWarehouse.h | #ifndef _ROS_SERVICE_RenameRobotStateInWarehouse_h
#define _ROS_SERVICE_RenameRobotStateInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char RENAMEROBOTSTATEINWAREHOUSE[] = "moveit_msgs/RenameRobotStateInWarehouse";
class RenameRobotStateInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _old_name_type;
_old_name_type old_name;
typedef const char* _new_name_type;
_new_name_type new_name;
typedef const char* _robot_type;
_robot_type robot;
RenameRobotStateInWarehouseRequest():
old_name(""),
new_name(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_old_name = strlen(this->old_name);
varToArr(outbuffer + offset, length_old_name);
offset += 4;
memcpy(outbuffer + offset, this->old_name, length_old_name);
offset += length_old_name;
uint32_t length_new_name = strlen(this->new_name);
varToArr(outbuffer + offset, length_new_name);
offset += 4;
memcpy(outbuffer + offset, this->new_name, length_new_name);
offset += length_new_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_old_name;
arrToVar(length_old_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_old_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_old_name-1]=0;
this->old_name = (char *)(inbuffer + offset-1);
offset += length_old_name;
uint32_t length_new_name;
arrToVar(length_new_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_new_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_new_name-1]=0;
this->new_name = (char *)(inbuffer + offset-1);
offset += length_new_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return RENAMEROBOTSTATEINWAREHOUSE; };
const char * getMD5(){ return "073dc05c3fd313b947cea483c25c46b0"; };
};
class RenameRobotStateInWarehouseResponse : public ros::Msg
{
public:
RenameRobotStateInWarehouseResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return RENAMEROBOTSTATEINWAREHOUSE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class RenameRobotStateInWarehouse {
public:
typedef RenameRobotStateInWarehouseRequest Request;
typedef RenameRobotStateInWarehouseResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceFeedback_h
#define _ROS_moveit_msgs_MoveGroupSequenceFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class MoveGroupSequenceFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
MoveGroupSequenceFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/KinematicSolverInfo.h | #ifndef _ROS_moveit_msgs_KinematicSolverInfo_h
#define _ROS_moveit_msgs_KinematicSolverInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/JointLimits.h"
namespace moveit_msgs
{
class KinematicSolverInfo : public ros::Msg
{
public:
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t limits_length;
typedef moveit_msgs::JointLimits _limits_type;
_limits_type st_limits;
_limits_type * limits;
uint32_t link_names_length;
typedef char* _link_names_type;
_link_names_type st_link_names;
_link_names_type * link_names;
KinematicSolverInfo():
joint_names_length(0), joint_names(NULL),
limits_length(0), limits(NULL),
link_names_length(0), link_names(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->limits_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->limits_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->limits_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->limits_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->limits_length);
for( uint32_t i = 0; i < limits_length; i++){
offset += this->limits[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_names_length);
for( uint32_t i = 0; i < link_names_length; i++){
uint32_t length_link_namesi = strlen(this->link_names[i]);
varToArr(outbuffer + offset, length_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->link_names[i], length_link_namesi);
offset += length_link_namesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t limits_lengthT = ((uint32_t) (*(inbuffer + offset)));
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->limits_length);
if(limits_lengthT > limits_length)
this->limits = (moveit_msgs::JointLimits*)realloc(this->limits, limits_lengthT * sizeof(moveit_msgs::JointLimits));
limits_length = limits_lengthT;
for( uint32_t i = 0; i < limits_length; i++){
offset += this->st_limits.deserialize(inbuffer + offset);
memcpy( &(this->limits[i]), &(this->st_limits), sizeof(moveit_msgs::JointLimits));
}
uint32_t link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_names_length);
if(link_names_lengthT > link_names_length)
this->link_names = (char**)realloc(this->link_names, link_names_lengthT * sizeof(char*));
link_names_length = link_names_lengthT;
for( uint32_t i = 0; i < link_names_length; i++){
uint32_t length_st_link_names;
arrToVar(length_st_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_link_names-1]=0;
this->st_link_names = (char *)(inbuffer + offset-1);
offset += length_st_link_names;
memcpy( &(this->link_names[i]), &(this->st_link_names), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/KinematicSolverInfo"; };
const char * getMD5(){ return "cc048557c0f9795c392dd80f8bb00489"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PositionIKRequest.h | #ifndef _ROS_moveit_msgs_PositionIKRequest_h
#define _ROS_moveit_msgs_PositionIKRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/Constraints.h"
#include "geometry_msgs/PoseStamped.h"
#include "ros/duration.h"
namespace moveit_msgs
{
class PositionIKRequest : public ros::Msg
{
public:
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type constraints;
typedef bool _avoid_collisions_type;
_avoid_collisions_type avoid_collisions;
typedef const char* _ik_link_name_type;
_ik_link_name_type ik_link_name;
typedef geometry_msgs::PoseStamped _pose_stamped_type;
_pose_stamped_type pose_stamped;
uint32_t ik_link_names_length;
typedef char* _ik_link_names_type;
_ik_link_names_type st_ik_link_names;
_ik_link_names_type * ik_link_names;
uint32_t pose_stamped_vector_length;
typedef geometry_msgs::PoseStamped _pose_stamped_vector_type;
_pose_stamped_vector_type st_pose_stamped_vector;
_pose_stamped_vector_type * pose_stamped_vector;
typedef ros::Duration _timeout_type;
_timeout_type timeout;
typedef int32_t _attempts_type;
_attempts_type attempts;
PositionIKRequest():
group_name(""),
robot_state(),
constraints(),
avoid_collisions(0),
ik_link_name(""),
pose_stamped(),
ik_link_names_length(0), ik_link_names(NULL),
pose_stamped_vector_length(0), pose_stamped_vector(NULL),
timeout(),
attempts(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->robot_state.serialize(outbuffer + offset);
offset += this->constraints.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.real = this->avoid_collisions;
*(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->avoid_collisions);
uint32_t length_ik_link_name = strlen(this->ik_link_name);
varToArr(outbuffer + offset, length_ik_link_name);
offset += 4;
memcpy(outbuffer + offset, this->ik_link_name, length_ik_link_name);
offset += length_ik_link_name;
offset += this->pose_stamped.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->ik_link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ik_link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ik_link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ik_link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ik_link_names_length);
for( uint32_t i = 0; i < ik_link_names_length; i++){
uint32_t length_ik_link_namesi = strlen(this->ik_link_names[i]);
varToArr(outbuffer + offset, length_ik_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->ik_link_names[i], length_ik_link_namesi);
offset += length_ik_link_namesi;
}
*(outbuffer + offset + 0) = (this->pose_stamped_vector_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamped_vector_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamped_vector_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamped_vector_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamped_vector_length);
for( uint32_t i = 0; i < pose_stamped_vector_length; i++){
offset += this->pose_stamped_vector[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.sec);
*(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.nsec);
union {
int32_t real;
uint32_t base;
} u_attempts;
u_attempts.real = this->attempts;
*(outbuffer + offset + 0) = (u_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->attempts);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->robot_state.deserialize(inbuffer + offset);
offset += this->constraints.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.base = 0;
u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->avoid_collisions = u_avoid_collisions.real;
offset += sizeof(this->avoid_collisions);
uint32_t length_ik_link_name;
arrToVar(length_ik_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_ik_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_ik_link_name-1]=0;
this->ik_link_name = (char *)(inbuffer + offset-1);
offset += length_ik_link_name;
offset += this->pose_stamped.deserialize(inbuffer + offset);
uint32_t ik_link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ik_link_names_length);
if(ik_link_names_lengthT > ik_link_names_length)
this->ik_link_names = (char**)realloc(this->ik_link_names, ik_link_names_lengthT * sizeof(char*));
ik_link_names_length = ik_link_names_lengthT;
for( uint32_t i = 0; i < ik_link_names_length; i++){
uint32_t length_st_ik_link_names;
arrToVar(length_st_ik_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_ik_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_ik_link_names-1]=0;
this->st_ik_link_names = (char *)(inbuffer + offset-1);
offset += length_st_ik_link_names;
memcpy( &(this->ik_link_names[i]), &(this->st_ik_link_names), sizeof(char*));
}
uint32_t pose_stamped_vector_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamped_vector_length);
if(pose_stamped_vector_lengthT > pose_stamped_vector_length)
this->pose_stamped_vector = (geometry_msgs::PoseStamped*)realloc(this->pose_stamped_vector, pose_stamped_vector_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamped_vector_length = pose_stamped_vector_lengthT;
for( uint32_t i = 0; i < pose_stamped_vector_length; i++){
offset += this->st_pose_stamped_vector.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamped_vector[i]), &(this->st_pose_stamped_vector), sizeof(geometry_msgs::PoseStamped));
}
this->timeout.sec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.sec);
this->timeout.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.nsec);
union {
int32_t real;
uint32_t base;
} u_attempts;
u_attempts.base = 0;
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->attempts = u_attempts.real;
offset += sizeof(this->attempts);
return offset;
}
const char * getType(){ return "moveit_msgs/PositionIKRequest"; };
const char * getMD5(){ return "9936dc239c90af180ec94a51596c96f2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SaveRobotStateToWarehouse.h | #ifndef _ROS_SERVICE_SaveRobotStateToWarehouse_h
#define _ROS_SERVICE_SaveRobotStateToWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char SAVEROBOTSTATETOWAREHOUSE[] = "moveit_msgs/SaveRobotStateToWarehouse";
class SaveRobotStateToWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
typedef moveit_msgs::RobotState _state_type;
_state_type state;
SaveRobotStateToWarehouseRequest():
name(""),
robot(""),
state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
offset += this->state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
offset += this->state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SAVEROBOTSTATETOWAREHOUSE; };
const char * getMD5(){ return "7937284880c511876f85988912ec5448"; };
};
class SaveRobotStateToWarehouseResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
SaveRobotStateToWarehouseResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return SAVEROBOTSTATETOWAREHOUSE; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class SaveRobotStateToWarehouse {
public:
typedef SaveRobotStateToWarehouseRequest Request;
typedef SaveRobotStateToWarehouseResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetMotionPlan.h | #ifndef _ROS_SERVICE_GetMotionPlan_h
#define _ROS_SERVICE_GetMotionPlan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
#include "moveit_msgs/MotionPlanResponse.h"
namespace moveit_msgs
{
static const char GETMOTIONPLAN[] = "moveit_msgs/GetMotionPlan";
class GetMotionPlanRequest : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _motion_plan_request_type;
_motion_plan_request_type motion_plan_request;
GetMotionPlanRequest():
motion_plan_request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->motion_plan_request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->motion_plan_request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONPLAN; };
const char * getMD5(){ return "9dcb82c5daeb2ff8a7ab1a98b642871d"; };
};
class GetMotionPlanResponse : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanResponse _motion_plan_response_type;
_motion_plan_response_type motion_plan_response;
GetMotionPlanResponse():
motion_plan_response()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->motion_plan_response.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->motion_plan_response.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONPLAN; };
const char * getMD5(){ return "37fe7e8f0d4dfa55ccfa53d63c86ae15"; };
};
class GetMotionPlan {
public:
typedef GetMotionPlanRequest Request;
typedef GetMotionPlanResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SaveMap.h | #ifndef _ROS_SERVICE_SaveMap_h
#define _ROS_SERVICE_SaveMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char SAVEMAP[] = "moveit_msgs/SaveMap";
class SaveMapRequest : public ros::Msg
{
public:
typedef const char* _filename_type;
_filename_type filename;
SaveMapRequest():
filename("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_filename;
arrToVar(length_filename, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_filename; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_filename-1]=0;
this->filename = (char *)(inbuffer + offset-1);
offset += length_filename;
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; };
};
class SaveMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
SaveMapResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class SaveMap {
public:
typedef SaveMapRequest Request;
typedef SaveMapResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceActionFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceActionFeedback_h
#define _ROS_moveit_msgs_MoveGroupSequenceActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/MoveGroupSequenceFeedback.h"
namespace moveit_msgs
{
class MoveGroupSequenceActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupSequenceFeedback _feedback_type;
_feedback_type feedback;
MoveGroupSequenceActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanResponse.h | #ifndef _ROS_moveit_msgs_MotionPlanResponse_h
#define _ROS_moveit_msgs_MotionPlanResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class MotionPlanResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type trajectory;
typedef double _planning_time_type;
_planning_time_type planning_time;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
MotionPlanResponse():
trajectory_start(),
group_name(""),
trajectory(),
planning_time(0),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory_start.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->trajectory.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->trajectory.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanResponse"; };
const char * getMD5(){ return "e493d20ab41424c48f671e152c70fc74"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanDetailedResponse.h | #ifndef _ROS_moveit_msgs_MotionPlanDetailedResponse_h
#define _ROS_moveit_msgs_MotionPlanDetailedResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class MotionPlanDetailedResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef const char* _group_name_type;
_group_name_type group_name;
uint32_t trajectory_length;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type st_trajectory;
_trajectory_type * trajectory;
uint32_t description_length;
typedef char* _description_type;
_description_type st_description;
_description_type * description;
uint32_t processing_time_length;
typedef double _processing_time_type;
_processing_time_type st_processing_time;
_processing_time_type * processing_time;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
MotionPlanDetailedResponse():
trajectory_start(),
group_name(""),
trajectory_length(0), trajectory(NULL),
description_length(0), description(NULL),
processing_time_length(0), processing_time(NULL),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory_start.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
*(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_length);
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->trajectory[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->description_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->description_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->description_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->description_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->description_length);
for( uint32_t i = 0; i < description_length; i++){
uint32_t length_descriptioni = strlen(this->description[i]);
varToArr(outbuffer + offset, length_descriptioni);
offset += 4;
memcpy(outbuffer + offset, this->description[i], length_descriptioni);
offset += length_descriptioni;
}
*(outbuffer + offset + 0) = (this->processing_time_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->processing_time_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->processing_time_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->processing_time_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->processing_time_length);
for( uint32_t i = 0; i < processing_time_length; i++){
union {
double real;
uint64_t base;
} u_processing_timei;
u_processing_timei.real = this->processing_time[i];
*(outbuffer + offset + 0) = (u_processing_timei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_processing_timei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_processing_timei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_processing_timei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_processing_timei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_processing_timei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_processing_timei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_processing_timei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->processing_time[i]);
}
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_length);
if(trajectory_lengthT > trajectory_length)
this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_length = trajectory_lengthT;
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->st_trajectory.deserialize(inbuffer + offset);
memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory));
}
uint32_t description_lengthT = ((uint32_t) (*(inbuffer + offset)));
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->description_length);
if(description_lengthT > description_length)
this->description = (char**)realloc(this->description, description_lengthT * sizeof(char*));
description_length = description_lengthT;
for( uint32_t i = 0; i < description_length; i++){
uint32_t length_st_description;
arrToVar(length_st_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_description-1]=0;
this->st_description = (char *)(inbuffer + offset-1);
offset += length_st_description;
memcpy( &(this->description[i]), &(this->st_description), sizeof(char*));
}
uint32_t processing_time_lengthT = ((uint32_t) (*(inbuffer + offset)));
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->processing_time_length);
if(processing_time_lengthT > processing_time_length)
this->processing_time = (double*)realloc(this->processing_time, processing_time_lengthT * sizeof(double));
processing_time_length = processing_time_lengthT;
for( uint32_t i = 0; i < processing_time_length; i++){
union {
double real;
uint64_t base;
} u_st_processing_time;
u_st_processing_time.base = 0;
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_processing_time = u_st_processing_time.real;
offset += sizeof(this->st_processing_time);
memcpy( &(this->processing_time[i]), &(this->st_processing_time), sizeof(double));
}
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanDetailedResponse"; };
const char * getMD5(){ return "7b84c374bb2e37bdc0eba664f7636a8f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/TrajectoryConstraints.h | #ifndef _ROS_moveit_msgs_TrajectoryConstraints_h
#define _ROS_moveit_msgs_TrajectoryConstraints_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
class TrajectoryConstraints : public ros::Msg
{
public:
uint32_t constraints_length;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type st_constraints;
_constraints_type * constraints;
TrajectoryConstraints():
constraints_length(0), constraints(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->constraints_length);
for( uint32_t i = 0; i < constraints_length; i++){
offset += this->constraints[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->constraints_length);
if(constraints_lengthT > constraints_length)
this->constraints = (moveit_msgs::Constraints*)realloc(this->constraints, constraints_lengthT * sizeof(moveit_msgs::Constraints));
constraints_length = constraints_lengthT;
for( uint32_t i = 0; i < constraints_length; i++){
offset += this->st_constraints.deserialize(inbuffer + offset);
memcpy( &(this->constraints[i]), &(this->st_constraints), sizeof(moveit_msgs::Constraints));
}
return offset;
}
const char * getType(){ return "moveit_msgs/TrajectoryConstraints"; };
const char * getMD5(){ return "461e1a732dfebb01e7d6c75d51a51eac"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupActionFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupActionFeedback_h
#define _ROS_moveit_msgs_MoveGroupActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/MoveGroupFeedback.h"
namespace moveit_msgs
{
class MoveGroupActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupFeedback _feedback_type;
_feedback_type feedback;
MoveGroupActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupAction.h | #ifndef _ROS_moveit_msgs_PickupAction_h
#define _ROS_moveit_msgs_PickupAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PickupActionGoal.h"
#include "moveit_msgs/PickupActionResult.h"
#include "moveit_msgs/PickupActionFeedback.h"
namespace moveit_msgs
{
class PickupAction : public ros::Msg
{
public:
typedef moveit_msgs::PickupActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::PickupActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::PickupActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
PickupAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupAction"; };
const char * getMD5(){ return "966c9238fcaad4ba8d20e116b676ccc1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupFeedback_h
#define _ROS_moveit_msgs_MoveGroupFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class MoveGroupFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
MoveGroupFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlannerInterfaceDescription.h | #ifndef _ROS_moveit_msgs_PlannerInterfaceDescription_h
#define _ROS_moveit_msgs_PlannerInterfaceDescription_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlannerInterfaceDescription : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
uint32_t planner_ids_length;
typedef char* _planner_ids_type;
_planner_ids_type st_planner_ids;
_planner_ids_type * planner_ids;
PlannerInterfaceDescription():
name(""),
planner_ids_length(0), planner_ids(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
*(outbuffer + offset + 0) = (this->planner_ids_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planner_ids_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planner_ids_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planner_ids_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planner_ids_length);
for( uint32_t i = 0; i < planner_ids_length; i++){
uint32_t length_planner_idsi = strlen(this->planner_ids[i]);
varToArr(outbuffer + offset, length_planner_idsi);
offset += 4;
memcpy(outbuffer + offset, this->planner_ids[i], length_planner_idsi);
offset += length_planner_idsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t planner_ids_lengthT = ((uint32_t) (*(inbuffer + offset)));
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planner_ids_length);
if(planner_ids_lengthT > planner_ids_length)
this->planner_ids = (char**)realloc(this->planner_ids, planner_ids_lengthT * sizeof(char*));
planner_ids_length = planner_ids_lengthT;
for( uint32_t i = 0; i < planner_ids_length; i++){
uint32_t length_st_planner_ids;
arrToVar(length_st_planner_ids, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_planner_ids; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_planner_ids-1]=0;
this->st_planner_ids = (char *)(inbuffer + offset-1);
offset += length_st_planner_ids;
memcpy( &(this->planner_ids[i]), &(this->st_planner_ids), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/PlannerInterfaceDescription"; };
const char * getMD5(){ return "ea5f6e6129aa1b110ccda9900d2bf25e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/BoundingVolume.h | #ifndef _ROS_moveit_msgs_BoundingVolume_h
#define _ROS_moveit_msgs_BoundingVolume_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "shape_msgs/SolidPrimitive.h"
#include "geometry_msgs/Pose.h"
#include "shape_msgs/Mesh.h"
namespace moveit_msgs
{
class BoundingVolume : public ros::Msg
{
public:
uint32_t primitives_length;
typedef shape_msgs::SolidPrimitive _primitives_type;
_primitives_type st_primitives;
_primitives_type * primitives;
uint32_t primitive_poses_length;
typedef geometry_msgs::Pose _primitive_poses_type;
_primitive_poses_type st_primitive_poses;
_primitive_poses_type * primitive_poses;
uint32_t meshes_length;
typedef shape_msgs::Mesh _meshes_type;
_meshes_type st_meshes;
_meshes_type * meshes;
uint32_t mesh_poses_length;
typedef geometry_msgs::Pose _mesh_poses_type;
_mesh_poses_type st_mesh_poses;
_mesh_poses_type * mesh_poses;
BoundingVolume():
primitives_length(0), primitives(NULL),
primitive_poses_length(0), primitive_poses(NULL),
meshes_length(0), meshes(NULL),
mesh_poses_length(0), mesh_poses(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitives_length);
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->primitives[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitive_poses_length);
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->primitive_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->meshes_length);
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->meshes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->mesh_poses_length);
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->mesh_poses[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitives_length);
if(primitives_lengthT > primitives_length)
this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive));
primitives_length = primitives_lengthT;
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->st_primitives.deserialize(inbuffer + offset);
memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive));
}
uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitive_poses_length);
if(primitive_poses_lengthT > primitive_poses_length)
this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose));
primitive_poses_length = primitive_poses_lengthT;
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->st_primitive_poses.deserialize(inbuffer + offset);
memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose));
}
uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset)));
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->meshes_length);
if(meshes_lengthT > meshes_length)
this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh));
meshes_length = meshes_lengthT;
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->st_meshes.deserialize(inbuffer + offset);
memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh));
}
uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->mesh_poses_length);
if(mesh_poses_lengthT > mesh_poses_length)
this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose));
mesh_poses_length = mesh_poses_lengthT;
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->st_mesh_poses.deserialize(inbuffer + offset);
memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose));
}
return offset;
}
const char * getType(){ return "moveit_msgs/BoundingVolume"; };
const char * getMD5(){ return "22db94010f39e9198032cb4a1aeda26e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/OrientedBoundingBox.h | #ifndef _ROS_moveit_msgs_OrientedBoundingBox_h
#define _ROS_moveit_msgs_OrientedBoundingBox_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Point32.h"
namespace moveit_msgs
{
class OrientedBoundingBox : public ros::Msg
{
public:
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Point32 _extents_type;
_extents_type extents;
OrientedBoundingBox():
pose(),
extents()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->pose.serialize(outbuffer + offset);
offset += this->extents.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->extents.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/OrientedBoundingBox"; };
const char * getMD5(){ return "da3bd98e7cb14efa4141367a9d886ee7"; };
};
}
#endif
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.