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/moveit_msgs/RobotTrajectory.h | #ifndef _ROS_moveit_msgs_RobotTrajectory_h
#define _ROS_moveit_msgs_RobotTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "trajectory_msgs/MultiDOFJointTrajectory.h"
namespace moveit_msgs
{
class RobotTrajectory : public ros::Msg
{
public:
typedef trajectory_msgs::JointTrajectory _joint_trajectory_type;
_joint_trajectory_type joint_trajectory;
typedef trajectory_msgs::MultiDOFJointTrajectory _multi_dof_joint_trajectory_type;
_multi_dof_joint_trajectory_type multi_dof_joint_trajectory;
RobotTrajectory():
joint_trajectory(),
multi_dof_joint_trajectory()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->joint_trajectory.serialize(outbuffer + offset);
offset += this->multi_dof_joint_trajectory.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->joint_trajectory.deserialize(inbuffer + offset);
offset += this->multi_dof_joint_trajectory.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/RobotTrajectory"; };
const char * getMD5(){ return "dfa9556423d709a3729bcef664bddf67"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlannerParams.h | #ifndef _ROS_moveit_msgs_PlannerParams_h
#define _ROS_moveit_msgs_PlannerParams_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlannerParams : public ros::Msg
{
public:
uint32_t keys_length;
typedef char* _keys_type;
_keys_type st_keys;
_keys_type * keys;
uint32_t values_length;
typedef char* _values_type;
_values_type st_values;
_values_type * values;
uint32_t descriptions_length;
typedef char* _descriptions_type;
_descriptions_type st_descriptions;
_descriptions_type * descriptions;
PlannerParams():
keys_length(0), keys(NULL),
values_length(0), values(NULL),
descriptions_length(0), descriptions(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->keys_length);
for( uint32_t i = 0; i < keys_length; i++){
uint32_t length_keysi = strlen(this->keys[i]);
varToArr(outbuffer + offset, length_keysi);
offset += 4;
memcpy(outbuffer + offset, this->keys[i], length_keysi);
offset += length_keysi;
}
*(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->values_length);
for( uint32_t i = 0; i < values_length; i++){
uint32_t length_valuesi = strlen(this->values[i]);
varToArr(outbuffer + offset, length_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->values[i], length_valuesi);
offset += length_valuesi;
}
*(outbuffer + offset + 0) = (this->descriptions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->descriptions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->descriptions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->descriptions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->descriptions_length);
for( uint32_t i = 0; i < descriptions_length; i++){
uint32_t length_descriptionsi = strlen(this->descriptions[i]);
varToArr(outbuffer + offset, length_descriptionsi);
offset += 4;
memcpy(outbuffer + offset, this->descriptions[i], length_descriptionsi);
offset += length_descriptionsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->keys_length);
if(keys_lengthT > keys_length)
this->keys = (char**)realloc(this->keys, keys_lengthT * sizeof(char*));
keys_length = keys_lengthT;
for( uint32_t i = 0; i < keys_length; i++){
uint32_t length_st_keys;
arrToVar(length_st_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_keys-1]=0;
this->st_keys = (char *)(inbuffer + offset-1);
offset += length_st_keys;
memcpy( &(this->keys[i]), &(this->st_keys), sizeof(char*));
}
uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->values_length);
if(values_lengthT > values_length)
this->values = (char**)realloc(this->values, values_lengthT * sizeof(char*));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
uint32_t length_st_values;
arrToVar(length_st_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_values-1]=0;
this->st_values = (char *)(inbuffer + offset-1);
offset += length_st_values;
memcpy( &(this->values[i]), &(this->st_values), sizeof(char*));
}
uint32_t descriptions_lengthT = ((uint32_t) (*(inbuffer + offset)));
descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->descriptions_length);
if(descriptions_lengthT > descriptions_length)
this->descriptions = (char**)realloc(this->descriptions, descriptions_lengthT * sizeof(char*));
descriptions_length = descriptions_lengthT;
for( uint32_t i = 0; i < descriptions_length; i++){
uint32_t length_st_descriptions;
arrToVar(length_st_descriptions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_descriptions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_descriptions-1]=0;
this->st_descriptions = (char *)(inbuffer + offset-1);
offset += length_st_descriptions;
memcpy( &(this->descriptions[i]), &(this->st_descriptions), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/PlannerParams"; };
const char * getMD5(){ return "cebdf4927996b9026bcf59a160d64145"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/Vertices.h | #ifndef _ROS_pcl_msgs_Vertices_h
#define _ROS_pcl_msgs_Vertices_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace pcl_msgs
{
class Vertices : public ros::Msg
{
public:
uint32_t vertices_length;
typedef uint32_t _vertices_type;
_vertices_type st_vertices;
_vertices_type * vertices;
Vertices():
vertices_length(0), vertices(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->vertices_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertices_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertices_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertices_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertices_length);
for( uint32_t i = 0; i < vertices_length; i++){
*(outbuffer + offset + 0) = (this->vertices[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertices[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertices[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertices[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertices[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t vertices_lengthT = ((uint32_t) (*(inbuffer + offset)));
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vertices_length);
if(vertices_lengthT > vertices_length)
this->vertices = (uint32_t*)realloc(this->vertices, vertices_lengthT * sizeof(uint32_t));
vertices_length = vertices_lengthT;
for( uint32_t i = 0; i < vertices_length; i++){
this->st_vertices = ((uint32_t) (*(inbuffer + offset)));
this->st_vertices |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_vertices |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_vertices |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->st_vertices);
memcpy( &(this->vertices[i]), &(this->st_vertices), sizeof(uint32_t));
}
return offset;
}
const char * getType(){ return "pcl_msgs/Vertices"; };
const char * getMD5(){ return "39bd7b1c23763ddd1b882b97cb7cfe11"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/PolygonMesh.h | #ifndef _ROS_pcl_msgs_PolygonMesh_h
#define _ROS_pcl_msgs_PolygonMesh_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/PointCloud2.h"
#include "pcl_msgs/Vertices.h"
namespace pcl_msgs
{
class PolygonMesh : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef sensor_msgs::PointCloud2 _cloud_type;
_cloud_type cloud;
uint32_t polygons_length;
typedef pcl_msgs::Vertices _polygons_type;
_polygons_type st_polygons;
_polygons_type * polygons;
PolygonMesh():
header(),
cloud(),
polygons_length(0), polygons(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->cloud.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->polygons_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->polygons_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->polygons_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->polygons_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->polygons_length);
for( uint32_t i = 0; i < polygons_length; i++){
offset += this->polygons[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->cloud.deserialize(inbuffer + offset);
uint32_t polygons_lengthT = ((uint32_t) (*(inbuffer + offset)));
polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->polygons_length);
if(polygons_lengthT > polygons_length)
this->polygons = (pcl_msgs::Vertices*)realloc(this->polygons, polygons_lengthT * sizeof(pcl_msgs::Vertices));
polygons_length = polygons_lengthT;
for( uint32_t i = 0; i < polygons_length; i++){
offset += this->st_polygons.deserialize(inbuffer + offset);
memcpy( &(this->polygons[i]), &(this->st_polygons), sizeof(pcl_msgs::Vertices));
}
return offset;
}
const char * getType(){ return "pcl_msgs/PolygonMesh"; };
const char * getMD5(){ return "45a5fc6ad2cde8489600a790acc9a38a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/PointIndices.h | #ifndef _ROS_pcl_msgs_PointIndices_h
#define _ROS_pcl_msgs_PointIndices_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace pcl_msgs
{
class PointIndices : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t indices_length;
typedef int32_t _indices_type;
_indices_type st_indices;
_indices_type * indices;
PointIndices():
header(),
indices_length(0), indices(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->indices_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->indices_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->indices_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->indices_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->indices_length);
for( uint32_t i = 0; i < indices_length; i++){
union {
int32_t real;
uint32_t base;
} u_indicesi;
u_indicesi.real = this->indices[i];
*(outbuffer + offset + 0) = (u_indicesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_indicesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_indicesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_indicesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->indices[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t indices_lengthT = ((uint32_t) (*(inbuffer + offset)));
indices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
indices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
indices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->indices_length);
if(indices_lengthT > indices_length)
this->indices = (int32_t*)realloc(this->indices, indices_lengthT * sizeof(int32_t));
indices_length = indices_lengthT;
for( uint32_t i = 0; i < indices_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_indices;
u_st_indices.base = 0;
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_indices = u_st_indices.real;
offset += sizeof(this->st_indices);
memcpy( &(this->indices[i]), &(this->st_indices), sizeof(int32_t));
}
return offset;
}
const char * getType(){ return "pcl_msgs/PointIndices"; };
const char * getMD5(){ return "458c7998b7eaf99908256472e273b3d4"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/ModelCoefficients.h | #ifndef _ROS_pcl_msgs_ModelCoefficients_h
#define _ROS_pcl_msgs_ModelCoefficients_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace pcl_msgs
{
class ModelCoefficients : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t values_length;
typedef float _values_type;
_values_type st_values;
_values_type * values;
ModelCoefficients():
header(),
values_length(0), values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->values_length);
for( uint32_t i = 0; i < values_length; i++){
union {
float real;
uint32_t base;
} u_valuesi;
u_valuesi.real = this->values[i];
*(outbuffer + offset + 0) = (u_valuesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_valuesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_valuesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_valuesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->values[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->values_length);
if(values_lengthT > values_length)
this->values = (float*)realloc(this->values, values_lengthT * sizeof(float));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
union {
float real;
uint32_t base;
} u_st_values;
u_st_values.base = 0;
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_values = u_st_values.real;
offset += sizeof(this->st_values);
memcpy( &(this->values[i]), &(this->st_values), sizeof(float));
}
return offset;
}
const char * getType(){ return "pcl_msgs/ModelCoefficients"; };
const char * getMD5(){ return "ca27dea75e72cb894cd36f9e5005e93e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/Logger.h | #ifndef _ROS_roscpp_Logger_h
#define _ROS_roscpp_Logger_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace roscpp
{
class Logger : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _level_type;
_level_type level;
Logger():
name(""),
level("")
{
}
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_level = strlen(this->level);
varToArr(outbuffer + offset, length_level);
offset += 4;
memcpy(outbuffer + offset, this->level, length_level);
offset += length_level;
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_level;
arrToVar(length_level, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_level; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_level-1]=0;
this->level = (char *)(inbuffer + offset-1);
offset += length_level;
return offset;
}
const char * getType(){ return "roscpp/Logger"; };
const char * getMD5(){ return "a6069a2ff40db7bd32143dd66e1f408e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/SetLoggerLevel.h | #ifndef _ROS_SERVICE_SetLoggerLevel_h
#define _ROS_SERVICE_SetLoggerLevel_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace roscpp
{
static const char SETLOGGERLEVEL[] = "roscpp/SetLoggerLevel";
class SetLoggerLevelRequest : public ros::Msg
{
public:
typedef const char* _logger_type;
_logger_type logger;
typedef const char* _level_type;
_level_type level;
SetLoggerLevelRequest():
logger(""),
level("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_logger = strlen(this->logger);
varToArr(outbuffer + offset, length_logger);
offset += 4;
memcpy(outbuffer + offset, this->logger, length_logger);
offset += length_logger;
uint32_t length_level = strlen(this->level);
varToArr(outbuffer + offset, length_level);
offset += 4;
memcpy(outbuffer + offset, this->level, length_level);
offset += length_level;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_logger;
arrToVar(length_logger, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_logger; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_logger-1]=0;
this->logger = (char *)(inbuffer + offset-1);
offset += length_logger;
uint32_t length_level;
arrToVar(length_level, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_level; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_level-1]=0;
this->level = (char *)(inbuffer + offset-1);
offset += length_level;
return offset;
}
const char * getType(){ return SETLOGGERLEVEL; };
const char * getMD5(){ return "51da076440d78ca1684d36c868df61ea"; };
};
class SetLoggerLevelResponse : public ros::Msg
{
public:
SetLoggerLevelResponse()
{
}
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 SETLOGGERLEVEL; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetLoggerLevel {
public:
typedef SetLoggerLevelRequest Request;
typedef SetLoggerLevelResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/GetLoggers.h | #ifndef _ROS_SERVICE_GetLoggers_h
#define _ROS_SERVICE_GetLoggers_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "roscpp/Logger.h"
namespace roscpp
{
static const char GETLOGGERS[] = "roscpp/GetLoggers";
class GetLoggersRequest : public ros::Msg
{
public:
GetLoggersRequest()
{
}
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 GETLOGGERS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetLoggersResponse : public ros::Msg
{
public:
uint32_t loggers_length;
typedef roscpp::Logger _loggers_type;
_loggers_type st_loggers;
_loggers_type * loggers;
GetLoggersResponse():
loggers_length(0), loggers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->loggers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->loggers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->loggers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->loggers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->loggers_length);
for( uint32_t i = 0; i < loggers_length; i++){
offset += this->loggers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t loggers_lengthT = ((uint32_t) (*(inbuffer + offset)));
loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->loggers_length);
if(loggers_lengthT > loggers_length)
this->loggers = (roscpp::Logger*)realloc(this->loggers, loggers_lengthT * sizeof(roscpp::Logger));
loggers_length = loggers_lengthT;
for( uint32_t i = 0; i < loggers_length; i++){
offset += this->st_loggers.deserialize(inbuffer + offset);
memcpy( &(this->loggers[i]), &(this->st_loggers), sizeof(roscpp::Logger));
}
return offset;
}
const char * getType(){ return GETLOGGERS; };
const char * getMD5(){ return "32e97e85527d4678a8f9279894bb64b0"; };
};
class GetLoggers {
public:
typedef GetLoggersRequest Request;
typedef GetLoggersResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/Empty.h | #ifndef _ROS_SERVICE_Empty_h
#define _ROS_SERVICE_Empty_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace roscpp
{
static const char EMPTY[] = "roscpp/Empty";
class EmptyRequest : public ros::Msg
{
public:
EmptyRequest()
{
}
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 EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class EmptyResponse : public ros::Msg
{
public:
EmptyResponse()
{
}
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 EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class Empty {
public:
typedef EmptyRequest Request;
typedef EmptyResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/smach_msgs/SmachContainerStructure.h | #ifndef _ROS_smach_msgs_SmachContainerStructure_h
#define _ROS_smach_msgs_SmachContainerStructure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace smach_msgs
{
class SmachContainerStructure : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _path_type;
_path_type path;
uint32_t children_length;
typedef char* _children_type;
_children_type st_children;
_children_type * children;
uint32_t internal_outcomes_length;
typedef char* _internal_outcomes_type;
_internal_outcomes_type st_internal_outcomes;
_internal_outcomes_type * internal_outcomes;
uint32_t outcomes_from_length;
typedef char* _outcomes_from_type;
_outcomes_from_type st_outcomes_from;
_outcomes_from_type * outcomes_from;
uint32_t outcomes_to_length;
typedef char* _outcomes_to_type;
_outcomes_to_type st_outcomes_to;
_outcomes_to_type * outcomes_to;
uint32_t container_outcomes_length;
typedef char* _container_outcomes_type;
_container_outcomes_type st_container_outcomes;
_container_outcomes_type * container_outcomes;
SmachContainerStructure():
header(),
path(""),
children_length(0), children(NULL),
internal_outcomes_length(0), internal_outcomes(NULL),
outcomes_from_length(0), outcomes_from(NULL),
outcomes_to_length(0), outcomes_to(NULL),
container_outcomes_length(0), container_outcomes(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->children_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->children_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->children_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->children_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->children_length);
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_childreni = strlen(this->children[i]);
varToArr(outbuffer + offset, length_childreni);
offset += 4;
memcpy(outbuffer + offset, this->children[i], length_childreni);
offset += length_childreni;
}
*(outbuffer + offset + 0) = (this->internal_outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->internal_outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->internal_outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->internal_outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->internal_outcomes_length);
for( uint32_t i = 0; i < internal_outcomes_length; i++){
uint32_t length_internal_outcomesi = strlen(this->internal_outcomes[i]);
varToArr(outbuffer + offset, length_internal_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->internal_outcomes[i], length_internal_outcomesi);
offset += length_internal_outcomesi;
}
*(outbuffer + offset + 0) = (this->outcomes_from_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_from_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_from_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_from_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_from_length);
for( uint32_t i = 0; i < outcomes_from_length; i++){
uint32_t length_outcomes_fromi = strlen(this->outcomes_from[i]);
varToArr(outbuffer + offset, length_outcomes_fromi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes_from[i], length_outcomes_fromi);
offset += length_outcomes_fromi;
}
*(outbuffer + offset + 0) = (this->outcomes_to_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_to_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_to_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_to_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_to_length);
for( uint32_t i = 0; i < outcomes_to_length; i++){
uint32_t length_outcomes_toi = strlen(this->outcomes_to[i]);
varToArr(outbuffer + offset, length_outcomes_toi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes_to[i], length_outcomes_toi);
offset += length_outcomes_toi;
}
*(outbuffer + offset + 0) = (this->container_outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->container_outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->container_outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->container_outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->container_outcomes_length);
for( uint32_t i = 0; i < container_outcomes_length; i++){
uint32_t length_container_outcomesi = strlen(this->container_outcomes[i]);
varToArr(outbuffer + offset, length_container_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->container_outcomes[i], length_container_outcomesi);
offset += length_container_outcomesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t children_lengthT = ((uint32_t) (*(inbuffer + offset)));
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->children_length);
if(children_lengthT > children_length)
this->children = (char**)realloc(this->children, children_lengthT * sizeof(char*));
children_length = children_lengthT;
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_st_children;
arrToVar(length_st_children, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_children; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_children-1]=0;
this->st_children = (char *)(inbuffer + offset-1);
offset += length_st_children;
memcpy( &(this->children[i]), &(this->st_children), sizeof(char*));
}
uint32_t internal_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->internal_outcomes_length);
if(internal_outcomes_lengthT > internal_outcomes_length)
this->internal_outcomes = (char**)realloc(this->internal_outcomes, internal_outcomes_lengthT * sizeof(char*));
internal_outcomes_length = internal_outcomes_lengthT;
for( uint32_t i = 0; i < internal_outcomes_length; i++){
uint32_t length_st_internal_outcomes;
arrToVar(length_st_internal_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_internal_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_internal_outcomes-1]=0;
this->st_internal_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_internal_outcomes;
memcpy( &(this->internal_outcomes[i]), &(this->st_internal_outcomes), sizeof(char*));
}
uint32_t outcomes_from_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_from_length);
if(outcomes_from_lengthT > outcomes_from_length)
this->outcomes_from = (char**)realloc(this->outcomes_from, outcomes_from_lengthT * sizeof(char*));
outcomes_from_length = outcomes_from_lengthT;
for( uint32_t i = 0; i < outcomes_from_length; i++){
uint32_t length_st_outcomes_from;
arrToVar(length_st_outcomes_from, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes_from; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes_from-1]=0;
this->st_outcomes_from = (char *)(inbuffer + offset-1);
offset += length_st_outcomes_from;
memcpy( &(this->outcomes_from[i]), &(this->st_outcomes_from), sizeof(char*));
}
uint32_t outcomes_to_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_to_length);
if(outcomes_to_lengthT > outcomes_to_length)
this->outcomes_to = (char**)realloc(this->outcomes_to, outcomes_to_lengthT * sizeof(char*));
outcomes_to_length = outcomes_to_lengthT;
for( uint32_t i = 0; i < outcomes_to_length; i++){
uint32_t length_st_outcomes_to;
arrToVar(length_st_outcomes_to, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes_to; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes_to-1]=0;
this->st_outcomes_to = (char *)(inbuffer + offset-1);
offset += length_st_outcomes_to;
memcpy( &(this->outcomes_to[i]), &(this->st_outcomes_to), sizeof(char*));
}
uint32_t container_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->container_outcomes_length);
if(container_outcomes_lengthT > container_outcomes_length)
this->container_outcomes = (char**)realloc(this->container_outcomes, container_outcomes_lengthT * sizeof(char*));
container_outcomes_length = container_outcomes_lengthT;
for( uint32_t i = 0; i < container_outcomes_length; i++){
uint32_t length_st_container_outcomes;
arrToVar(length_st_container_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_container_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_container_outcomes-1]=0;
this->st_container_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_container_outcomes;
memcpy( &(this->container_outcomes[i]), &(this->st_container_outcomes), sizeof(char*));
}
return offset;
}
const char * getType(){ return "smach_msgs/SmachContainerStructure"; };
const char * getMD5(){ return "3d3d1e0d0f99779ee9e58101a5dcf7ea"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/smach_msgs/SmachContainerInitialStatusCmd.h | #ifndef _ROS_smach_msgs_SmachContainerInitialStatusCmd_h
#define _ROS_smach_msgs_SmachContainerInitialStatusCmd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace smach_msgs
{
class SmachContainerInitialStatusCmd : public ros::Msg
{
public:
typedef const char* _path_type;
_path_type path;
uint32_t initial_states_length;
typedef char* _initial_states_type;
_initial_states_type st_initial_states;
_initial_states_type * initial_states;
typedef const char* _local_data_type;
_local_data_type local_data;
SmachContainerInitialStatusCmd():
path(""),
initial_states_length(0), initial_states(NULL),
local_data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->initial_states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->initial_states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->initial_states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->initial_states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->initial_states_length);
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_initial_statesi = strlen(this->initial_states[i]);
varToArr(outbuffer + offset, length_initial_statesi);
offset += 4;
memcpy(outbuffer + offset, this->initial_states[i], length_initial_statesi);
offset += length_initial_statesi;
}
uint32_t length_local_data = strlen(this->local_data);
varToArr(outbuffer + offset, length_local_data);
offset += 4;
memcpy(outbuffer + offset, this->local_data, length_local_data);
offset += length_local_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t initial_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->initial_states_length);
if(initial_states_lengthT > initial_states_length)
this->initial_states = (char**)realloc(this->initial_states, initial_states_lengthT * sizeof(char*));
initial_states_length = initial_states_lengthT;
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_st_initial_states;
arrToVar(length_st_initial_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_initial_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_initial_states-1]=0;
this->st_initial_states = (char *)(inbuffer + offset-1);
offset += length_st_initial_states;
memcpy( &(this->initial_states[i]), &(this->st_initial_states), sizeof(char*));
}
uint32_t length_local_data;
arrToVar(length_local_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_local_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_local_data-1]=0;
this->local_data = (char *)(inbuffer + offset-1);
offset += length_local_data;
return offset;
}
const char * getType(){ return "smach_msgs/SmachContainerInitialStatusCmd"; };
const char * getMD5(){ return "45f8cf31fc29b829db77f23001f788d6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/smach_msgs/SmachContainerStatus.h | #ifndef _ROS_smach_msgs_SmachContainerStatus_h
#define _ROS_smach_msgs_SmachContainerStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace smach_msgs
{
class SmachContainerStatus : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _path_type;
_path_type path;
uint32_t initial_states_length;
typedef char* _initial_states_type;
_initial_states_type st_initial_states;
_initial_states_type * initial_states;
uint32_t active_states_length;
typedef char* _active_states_type;
_active_states_type st_active_states;
_active_states_type * active_states;
typedef const char* _local_data_type;
_local_data_type local_data;
typedef const char* _info_type;
_info_type info;
SmachContainerStatus():
header(),
path(""),
initial_states_length(0), initial_states(NULL),
active_states_length(0), active_states(NULL),
local_data(""),
info("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->initial_states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->initial_states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->initial_states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->initial_states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->initial_states_length);
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_initial_statesi = strlen(this->initial_states[i]);
varToArr(outbuffer + offset, length_initial_statesi);
offset += 4;
memcpy(outbuffer + offset, this->initial_states[i], length_initial_statesi);
offset += length_initial_statesi;
}
*(outbuffer + offset + 0) = (this->active_states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->active_states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->active_states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->active_states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->active_states_length);
for( uint32_t i = 0; i < active_states_length; i++){
uint32_t length_active_statesi = strlen(this->active_states[i]);
varToArr(outbuffer + offset, length_active_statesi);
offset += 4;
memcpy(outbuffer + offset, this->active_states[i], length_active_statesi);
offset += length_active_statesi;
}
uint32_t length_local_data = strlen(this->local_data);
varToArr(outbuffer + offset, length_local_data);
offset += 4;
memcpy(outbuffer + offset, this->local_data, length_local_data);
offset += length_local_data;
uint32_t length_info = strlen(this->info);
varToArr(outbuffer + offset, length_info);
offset += 4;
memcpy(outbuffer + offset, this->info, length_info);
offset += length_info;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t initial_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->initial_states_length);
if(initial_states_lengthT > initial_states_length)
this->initial_states = (char**)realloc(this->initial_states, initial_states_lengthT * sizeof(char*));
initial_states_length = initial_states_lengthT;
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_st_initial_states;
arrToVar(length_st_initial_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_initial_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_initial_states-1]=0;
this->st_initial_states = (char *)(inbuffer + offset-1);
offset += length_st_initial_states;
memcpy( &(this->initial_states[i]), &(this->st_initial_states), sizeof(char*));
}
uint32_t active_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->active_states_length);
if(active_states_lengthT > active_states_length)
this->active_states = (char**)realloc(this->active_states, active_states_lengthT * sizeof(char*));
active_states_length = active_states_lengthT;
for( uint32_t i = 0; i < active_states_length; i++){
uint32_t length_st_active_states;
arrToVar(length_st_active_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_active_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_active_states-1]=0;
this->st_active_states = (char *)(inbuffer + offset-1);
offset += length_st_active_states;
memcpy( &(this->active_states[i]), &(this->st_active_states), sizeof(char*));
}
uint32_t length_local_data;
arrToVar(length_local_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_local_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_local_data-1]=0;
this->local_data = (char *)(inbuffer + offset-1);
offset += length_local_data;
uint32_t length_info;
arrToVar(length_info, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_info; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_info-1]=0;
this->info = (char *)(inbuffer + offset-1);
offset += length_info;
return offset;
}
const char * getType(){ return "smach_msgs/SmachContainerStatus"; };
const char * getMD5(){ return "5ba2bb79ac19e3842d562a191f2a675b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/theora_image_transport/Packet.h | #ifndef _ROS_theora_image_transport_Packet_h
#define _ROS_theora_image_transport_Packet_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace theora_image_transport
{
class Packet : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t data_length;
typedef uint8_t _data_type;
_data_type st_data;
_data_type * data;
typedef int32_t _b_o_s_type;
_b_o_s_type b_o_s;
typedef int32_t _e_o_s_type;
_e_o_s_type e_o_s;
typedef int64_t _granulepos_type;
_granulepos_type granulepos;
typedef int64_t _packetno_type;
_packetno_type packetno;
Packet():
header(),
data_length(0), data(NULL),
b_o_s(0),
e_o_s(0),
granulepos(0),
packetno(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
union {
int32_t real;
uint32_t base;
} u_b_o_s;
u_b_o_s.real = this->b_o_s;
*(outbuffer + offset + 0) = (u_b_o_s.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_b_o_s.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_b_o_s.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_b_o_s.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->b_o_s);
union {
int32_t real;
uint32_t base;
} u_e_o_s;
u_e_o_s.real = this->e_o_s;
*(outbuffer + offset + 0) = (u_e_o_s.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_e_o_s.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_e_o_s.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_e_o_s.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->e_o_s);
union {
int64_t real;
uint64_t base;
} u_granulepos;
u_granulepos.real = this->granulepos;
*(outbuffer + offset + 0) = (u_granulepos.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_granulepos.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_granulepos.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_granulepos.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_granulepos.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_granulepos.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_granulepos.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_granulepos.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->granulepos);
union {
int64_t real;
uint64_t base;
} u_packetno;
u_packetno.real = this->packetno;
*(outbuffer + offset + 0) = (u_packetno.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_packetno.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_packetno.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_packetno.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_packetno.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_packetno.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_packetno.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_packetno.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->packetno);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
}
union {
int32_t real;
uint32_t base;
} u_b_o_s;
u_b_o_s.base = 0;
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->b_o_s = u_b_o_s.real;
offset += sizeof(this->b_o_s);
union {
int32_t real;
uint32_t base;
} u_e_o_s;
u_e_o_s.base = 0;
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->e_o_s = u_e_o_s.real;
offset += sizeof(this->e_o_s);
union {
int64_t real;
uint64_t base;
} u_granulepos;
u_granulepos.base = 0;
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->granulepos = u_granulepos.real;
offset += sizeof(this->granulepos);
union {
int64_t real;
uint64_t base;
} u_packetno;
u_packetno.base = 0;
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->packetno = u_packetno.real;
offset += sizeof(this->packetno);
return offset;
}
const char * getType(){ return "theora_image_transport/Packet"; };
const char * getMD5(){ return "33ac4e14a7cff32e7e0d65f18bb410f3"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetPhysicsProperties.h | #ifndef _ROS_SERVICE_SetPhysicsProperties_h
#define _ROS_SERVICE_SetPhysicsProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
#include "gazebo_msgs/ODEPhysics.h"
namespace gazebo_msgs
{
static const char SETPHYSICSPROPERTIES[] = "gazebo_msgs/SetPhysicsProperties";
class SetPhysicsPropertiesRequest : public ros::Msg
{
public:
typedef double _time_step_type;
_time_step_type time_step;
typedef double _max_update_rate_type;
_max_update_rate_type max_update_rate;
typedef geometry_msgs::Vector3 _gravity_type;
_gravity_type gravity;
typedef gazebo_msgs::ODEPhysics _ode_config_type;
_ode_config_type ode_config;
SetPhysicsPropertiesRequest():
time_step(0),
max_update_rate(0),
gravity(),
ode_config()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.real = this->time_step;
*(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.real = this->max_update_rate;
*(outbuffer + offset + 0) = (u_max_update_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_update_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_update_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_update_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_update_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_update_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_update_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_update_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_update_rate);
offset += this->gravity.serialize(outbuffer + offset);
offset += this->ode_config.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.base = 0;
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time_step = u_time_step.real;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.base = 0;
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_update_rate = u_max_update_rate.real;
offset += sizeof(this->max_update_rate);
offset += this->gravity.deserialize(inbuffer + offset);
offset += this->ode_config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETPHYSICSPROPERTIES; };
const char * getMD5(){ return "abd9f82732b52b92e9d6bb36e6a82452"; };
};
class SetPhysicsPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetPhysicsPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETPHYSICSPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetPhysicsProperties {
public:
typedef SetPhysicsPropertiesRequest Request;
typedef SetPhysicsPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetModelState.h | #ifndef _ROS_SERVICE_GetModelState_h
#define _ROS_SERVICE_GetModelState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
#include "std_msgs/Header.h"
namespace gazebo_msgs
{
static const char GETMODELSTATE[] = "gazebo_msgs/GetModelState";
class GetModelStateRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef const char* _relative_entity_name_type;
_relative_entity_name_type relative_entity_name;
GetModelStateRequest():
model_name(""),
relative_entity_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
uint32_t length_relative_entity_name = strlen(this->relative_entity_name);
varToArr(outbuffer + offset, length_relative_entity_name);
offset += 4;
memcpy(outbuffer + offset, this->relative_entity_name, length_relative_entity_name);
offset += length_relative_entity_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
uint32_t length_relative_entity_name;
arrToVar(length_relative_entity_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_relative_entity_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_relative_entity_name-1]=0;
this->relative_entity_name = (char *)(inbuffer + offset-1);
offset += length_relative_entity_name;
return offset;
}
const char * getType(){ return GETMODELSTATE; };
const char * getMD5(){ return "19d412713cefe4a67437e17a951e759e"; };
};
class GetModelStateResponse : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetModelStateResponse():
header(),
pose(),
twist(),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETMODELSTATE; };
const char * getMD5(){ return "ccd51739bb00f0141629e87b792e92b9"; };
};
class GetModelState {
public:
typedef GetModelStateRequest Request;
typedef GetModelStateResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ModelStates.h | #ifndef _ROS_gazebo_msgs_ModelStates_h
#define _ROS_gazebo_msgs_ModelStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class ModelStates : public ros::Msg
{
public:
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t pose_length;
typedef geometry_msgs::Pose _pose_type;
_pose_type st_pose;
_pose_type * pose;
uint32_t twist_length;
typedef geometry_msgs::Twist _twist_type;
_twist_type st_twist;
_twist_type * twist;
ModelStates():
name_length(0), name(NULL),
pose_length(0), pose(NULL),
twist_length(0), twist(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->pose_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_length);
for( uint32_t i = 0; i < pose_length; i++){
offset += this->pose[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->twist_length);
for( uint32_t i = 0; i < twist_length; i++){
offset += this->twist[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t pose_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_length);
if(pose_lengthT > pose_length)
this->pose = (geometry_msgs::Pose*)realloc(this->pose, pose_lengthT * sizeof(geometry_msgs::Pose));
pose_length = pose_lengthT;
for( uint32_t i = 0; i < pose_length; i++){
offset += this->st_pose.deserialize(inbuffer + offset);
memcpy( &(this->pose[i]), &(this->st_pose), sizeof(geometry_msgs::Pose));
}
uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->twist_length);
if(twist_lengthT > twist_length)
this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
twist_length = twist_lengthT;
for( uint32_t i = 0; i < twist_length; i++){
offset += this->st_twist.deserialize(inbuffer + offset);
memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ModelStates"; };
const char * getMD5(){ return "48c080191eb15c41858319b4d8a609c2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetWorldProperties.h | #ifndef _ROS_SERVICE_GetWorldProperties_h
#define _ROS_SERVICE_GetWorldProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char GETWORLDPROPERTIES[] = "gazebo_msgs/GetWorldProperties";
class GetWorldPropertiesRequest : public ros::Msg
{
public:
GetWorldPropertiesRequest()
{
}
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 GETWORLDPROPERTIES; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetWorldPropertiesResponse : public ros::Msg
{
public:
typedef double _sim_time_type;
_sim_time_type sim_time;
uint32_t model_names_length;
typedef char* _model_names_type;
_model_names_type st_model_names;
_model_names_type * model_names;
typedef bool _rendering_enabled_type;
_rendering_enabled_type rendering_enabled;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetWorldPropertiesResponse():
sim_time(0),
model_names_length(0), model_names(NULL),
rendering_enabled(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_sim_time;
u_sim_time.real = this->sim_time;
*(outbuffer + offset + 0) = (u_sim_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sim_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sim_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sim_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sim_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sim_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sim_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sim_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sim_time);
*(outbuffer + offset + 0) = (this->model_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->model_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->model_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->model_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->model_names_length);
for( uint32_t i = 0; i < model_names_length; i++){
uint32_t length_model_namesi = strlen(this->model_names[i]);
varToArr(outbuffer + offset, length_model_namesi);
offset += 4;
memcpy(outbuffer + offset, this->model_names[i], length_model_namesi);
offset += length_model_namesi;
}
union {
bool real;
uint8_t base;
} u_rendering_enabled;
u_rendering_enabled.real = this->rendering_enabled;
*(outbuffer + offset + 0) = (u_rendering_enabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->rendering_enabled);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_sim_time;
u_sim_time.base = 0;
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sim_time = u_sim_time.real;
offset += sizeof(this->sim_time);
uint32_t model_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->model_names_length);
if(model_names_lengthT > model_names_length)
this->model_names = (char**)realloc(this->model_names, model_names_lengthT * sizeof(char*));
model_names_length = model_names_lengthT;
for( uint32_t i = 0; i < model_names_length; i++){
uint32_t length_st_model_names;
arrToVar(length_st_model_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_model_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_model_names-1]=0;
this->st_model_names = (char *)(inbuffer + offset-1);
offset += length_st_model_names;
memcpy( &(this->model_names[i]), &(this->st_model_names), sizeof(char*));
}
union {
bool real;
uint8_t base;
} u_rendering_enabled;
u_rendering_enabled.base = 0;
u_rendering_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->rendering_enabled = u_rendering_enabled.real;
offset += sizeof(this->rendering_enabled);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETWORLDPROPERTIES; };
const char * getMD5(){ return "36bb0f2eccf4d8be971410c22818ba3f"; };
};
class GetWorldProperties {
public:
typedef GetWorldPropertiesRequest Request;
typedef GetWorldPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ApplyBodyWrench.h | #ifndef _ROS_SERVICE_ApplyBodyWrench_h
#define _ROS_SERVICE_ApplyBodyWrench_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
#include "geometry_msgs/Wrench.h"
#include "ros/time.h"
#include "geometry_msgs/Point.h"
namespace gazebo_msgs
{
static const char APPLYBODYWRENCH[] = "gazebo_msgs/ApplyBodyWrench";
class ApplyBodyWrenchRequest : public ros::Msg
{
public:
typedef const char* _body_name_type;
_body_name_type body_name;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
typedef geometry_msgs::Point _reference_point_type;
_reference_point_type reference_point;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type wrench;
typedef ros::Time _start_time_type;
_start_time_type start_time;
typedef ros::Duration _duration_type;
_duration_type duration;
ApplyBodyWrenchRequest():
body_name(""),
reference_frame(""),
reference_point(),
wrench(),
start_time(),
duration()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_body_name = strlen(this->body_name);
varToArr(outbuffer + offset, length_body_name);
offset += 4;
memcpy(outbuffer + offset, this->body_name, length_body_name);
offset += length_body_name;
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
offset += this->reference_point.serialize(outbuffer + offset);
offset += this->wrench.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->start_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.sec);
*(outbuffer + offset + 0) = (this->start_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.nsec);
*(outbuffer + offset + 0) = (this->duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.sec);
*(outbuffer + offset + 0) = (this->duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_body_name;
arrToVar(length_body_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_body_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_body_name-1]=0;
this->body_name = (char *)(inbuffer + offset-1);
offset += length_body_name;
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
offset += this->reference_point.deserialize(inbuffer + offset);
offset += this->wrench.deserialize(inbuffer + offset);
this->start_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.sec);
this->start_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.nsec);
this->duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.sec);
this->duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.nsec);
return offset;
}
const char * getType(){ return APPLYBODYWRENCH; };
const char * getMD5(){ return "e37e6adf97eba5095baa77dffb71e5bd"; };
};
class ApplyBodyWrenchResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
ApplyBodyWrenchResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return APPLYBODYWRENCH; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class ApplyBodyWrench {
public:
typedef ApplyBodyWrenchRequest Request;
typedef ApplyBodyWrenchResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetModelState.h | #ifndef _ROS_SERVICE_SetModelState_h
#define _ROS_SERVICE_SetModelState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/ModelState.h"
namespace gazebo_msgs
{
static const char SETMODELSTATE[] = "gazebo_msgs/SetModelState";
class SetModelStateRequest : public ros::Msg
{
public:
typedef gazebo_msgs::ModelState _model_state_type;
_model_state_type model_state;
SetModelStateRequest():
model_state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->model_state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->model_state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETMODELSTATE; };
const char * getMD5(){ return "cb042b0e91880f4661b29ea5b6234350"; };
};
class SetModelStateResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetModelStateResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETMODELSTATE; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetModelState {
public:
typedef SetModelStateRequest Request;
typedef SetModelStateResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetJointTrajectory.h | #ifndef _ROS_SERVICE_SetJointTrajectory_h
#define _ROS_SERVICE_SetJointTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char SETJOINTTRAJECTORY[] = "gazebo_msgs/SetJointTrajectory";
class SetJointTrajectoryRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef trajectory_msgs::JointTrajectory _joint_trajectory_type;
_joint_trajectory_type joint_trajectory;
typedef geometry_msgs::Pose _model_pose_type;
_model_pose_type model_pose;
typedef bool _set_model_pose_type;
_set_model_pose_type set_model_pose;
typedef bool _disable_physics_updates_type;
_disable_physics_updates_type disable_physics_updates;
SetJointTrajectoryRequest():
model_name(""),
joint_trajectory(),
model_pose(),
set_model_pose(0),
disable_physics_updates(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
offset += this->joint_trajectory.serialize(outbuffer + offset);
offset += this->model_pose.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_set_model_pose;
u_set_model_pose.real = this->set_model_pose;
*(outbuffer + offset + 0) = (u_set_model_pose.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->set_model_pose);
union {
bool real;
uint8_t base;
} u_disable_physics_updates;
u_disable_physics_updates.real = this->disable_physics_updates;
*(outbuffer + offset + 0) = (u_disable_physics_updates.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->disable_physics_updates);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
offset += this->joint_trajectory.deserialize(inbuffer + offset);
offset += this->model_pose.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_set_model_pose;
u_set_model_pose.base = 0;
u_set_model_pose.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->set_model_pose = u_set_model_pose.real;
offset += sizeof(this->set_model_pose);
union {
bool real;
uint8_t base;
} u_disable_physics_updates;
u_disable_physics_updates.base = 0;
u_disable_physics_updates.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->disable_physics_updates = u_disable_physics_updates.real;
offset += sizeof(this->disable_physics_updates);
return offset;
}
const char * getType(){ return SETJOINTTRAJECTORY; };
const char * getMD5(){ return "649dd2eba5ffd358069238825f9f85ab"; };
};
class SetJointTrajectoryResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetJointTrajectoryResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETJOINTTRAJECTORY; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetJointTrajectory {
public:
typedef SetJointTrajectoryRequest Request;
typedef SetJointTrajectoryResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/BodyRequest.h | #ifndef _ROS_SERVICE_BodyRequest_h
#define _ROS_SERVICE_BodyRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char BODYREQUEST[] = "gazebo_msgs/BodyRequest";
class BodyRequestRequest : public ros::Msg
{
public:
typedef const char* _body_name_type;
_body_name_type body_name;
BodyRequestRequest():
body_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_body_name = strlen(this->body_name);
varToArr(outbuffer + offset, length_body_name);
offset += 4;
memcpy(outbuffer + offset, this->body_name, length_body_name);
offset += length_body_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_body_name;
arrToVar(length_body_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_body_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_body_name-1]=0;
this->body_name = (char *)(inbuffer + offset-1);
offset += length_body_name;
return offset;
}
const char * getType(){ return BODYREQUEST; };
const char * getMD5(){ return "5eade9afe7f232d78005bd0cafeab755"; };
};
class BodyRequestResponse : public ros::Msg
{
public:
BodyRequestResponse()
{
}
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 BODYREQUEST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class BodyRequest {
public:
typedef BodyRequestRequest Request;
typedef BodyRequestResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetLightProperties.h | #ifndef _ROS_SERVICE_GetLightProperties_h
#define _ROS_SERVICE_GetLightProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/ColorRGBA.h"
namespace gazebo_msgs
{
static const char GETLIGHTPROPERTIES[] = "gazebo_msgs/GetLightProperties";
class GetLightPropertiesRequest : public ros::Msg
{
public:
typedef const char* _light_name_type;
_light_name_type light_name;
GetLightPropertiesRequest():
light_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_light_name = strlen(this->light_name);
varToArr(outbuffer + offset, length_light_name);
offset += 4;
memcpy(outbuffer + offset, this->light_name, length_light_name);
offset += length_light_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_light_name;
arrToVar(length_light_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_light_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_light_name-1]=0;
this->light_name = (char *)(inbuffer + offset-1);
offset += length_light_name;
return offset;
}
const char * getType(){ return GETLIGHTPROPERTIES; };
const char * getMD5(){ return "4fb676dfb4741fc866365702a859441c"; };
};
class GetLightPropertiesResponse : public ros::Msg
{
public:
typedef std_msgs::ColorRGBA _diffuse_type;
_diffuse_type diffuse;
typedef double _attenuation_constant_type;
_attenuation_constant_type attenuation_constant;
typedef double _attenuation_linear_type;
_attenuation_linear_type attenuation_linear;
typedef double _attenuation_quadratic_type;
_attenuation_quadratic_type attenuation_quadratic;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetLightPropertiesResponse():
diffuse(),
attenuation_constant(0),
attenuation_linear(0),
attenuation_quadratic(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->diffuse.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.real = this->attenuation_constant;
*(outbuffer + offset + 0) = (u_attenuation_constant.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_constant.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_constant.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_constant.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_constant.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_constant.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_constant.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_constant.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.real = this->attenuation_linear;
*(outbuffer + offset + 0) = (u_attenuation_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_linear.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_linear.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_linear.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_linear.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_linear.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.real = this->attenuation_quadratic;
*(outbuffer + offset + 0) = (u_attenuation_quadratic.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_quadratic.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_quadratic.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_quadratic.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_quadratic.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_quadratic.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_quadratic.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_quadratic.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_quadratic);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->diffuse.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.base = 0;
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_constant = u_attenuation_constant.real;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.base = 0;
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_linear = u_attenuation_linear.real;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.base = 0;
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_quadratic = u_attenuation_quadratic.real;
offset += sizeof(this->attenuation_quadratic);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETLIGHTPROPERTIES; };
const char * getMD5(){ return "9a19ddd5aab4c13b7643d1722c709f1f"; };
};
class GetLightProperties {
public:
typedef GetLightPropertiesRequest Request;
typedef GetLightPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetLinkState.h | #ifndef _ROS_SERVICE_SetLinkState_h
#define _ROS_SERVICE_SetLinkState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/LinkState.h"
namespace gazebo_msgs
{
static const char SETLINKSTATE[] = "gazebo_msgs/SetLinkState";
class SetLinkStateRequest : public ros::Msg
{
public:
typedef gazebo_msgs::LinkState _link_state_type;
_link_state_type link_state;
SetLinkStateRequest():
link_state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->link_state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->link_state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETLINKSTATE; };
const char * getMD5(){ return "22a2c757d56911b6f27868159e9a872d"; };
};
class SetLinkStateResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetLinkStateResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETLINKSTATE; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetLinkState {
public:
typedef SetLinkStateRequest Request;
typedef SetLinkStateResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ModelState.h | #ifndef _ROS_gazebo_msgs_ModelState_h
#define _ROS_gazebo_msgs_ModelState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class ModelState : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
ModelState():
model_name(""),
pose(),
twist(),
reference_frame("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return "gazebo_msgs/ModelState"; };
const char * getMD5(){ return "9330fd35f2fcd82d457e54bd54e10593"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetModelProperties.h | #ifndef _ROS_SERVICE_GetModelProperties_h
#define _ROS_SERVICE_GetModelProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char GETMODELPROPERTIES[] = "gazebo_msgs/GetModelProperties";
class GetModelPropertiesRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
GetModelPropertiesRequest():
model_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
return offset;
}
const char * getType(){ return GETMODELPROPERTIES; };
const char * getMD5(){ return "ea31c8eab6fc401383cf528a7c0984ba"; };
};
class GetModelPropertiesResponse : public ros::Msg
{
public:
typedef const char* _parent_model_name_type;
_parent_model_name_type parent_model_name;
typedef const char* _canonical_body_name_type;
_canonical_body_name_type canonical_body_name;
uint32_t body_names_length;
typedef char* _body_names_type;
_body_names_type st_body_names;
_body_names_type * body_names;
uint32_t geom_names_length;
typedef char* _geom_names_type;
_geom_names_type st_geom_names;
_geom_names_type * geom_names;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t child_model_names_length;
typedef char* _child_model_names_type;
_child_model_names_type st_child_model_names;
_child_model_names_type * child_model_names;
typedef bool _is_static_type;
_is_static_type is_static;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetModelPropertiesResponse():
parent_model_name(""),
canonical_body_name(""),
body_names_length(0), body_names(NULL),
geom_names_length(0), geom_names(NULL),
joint_names_length(0), joint_names(NULL),
child_model_names_length(0), child_model_names(NULL),
is_static(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_parent_model_name = strlen(this->parent_model_name);
varToArr(outbuffer + offset, length_parent_model_name);
offset += 4;
memcpy(outbuffer + offset, this->parent_model_name, length_parent_model_name);
offset += length_parent_model_name;
uint32_t length_canonical_body_name = strlen(this->canonical_body_name);
varToArr(outbuffer + offset, length_canonical_body_name);
offset += 4;
memcpy(outbuffer + offset, this->canonical_body_name, length_canonical_body_name);
offset += length_canonical_body_name;
*(outbuffer + offset + 0) = (this->body_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->body_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->body_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->body_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->body_names_length);
for( uint32_t i = 0; i < body_names_length; i++){
uint32_t length_body_namesi = strlen(this->body_names[i]);
varToArr(outbuffer + offset, length_body_namesi);
offset += 4;
memcpy(outbuffer + offset, this->body_names[i], length_body_namesi);
offset += length_body_namesi;
}
*(outbuffer + offset + 0) = (this->geom_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->geom_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->geom_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->geom_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->geom_names_length);
for( uint32_t i = 0; i < geom_names_length; i++){
uint32_t length_geom_namesi = strlen(this->geom_names[i]);
varToArr(outbuffer + offset, length_geom_namesi);
offset += 4;
memcpy(outbuffer + offset, this->geom_names[i], length_geom_namesi);
offset += length_geom_namesi;
}
*(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->child_model_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->child_model_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->child_model_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->child_model_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->child_model_names_length);
for( uint32_t i = 0; i < child_model_names_length; i++){
uint32_t length_child_model_namesi = strlen(this->child_model_names[i]);
varToArr(outbuffer + offset, length_child_model_namesi);
offset += 4;
memcpy(outbuffer + offset, this->child_model_names[i], length_child_model_namesi);
offset += length_child_model_namesi;
}
union {
bool real;
uint8_t base;
} u_is_static;
u_is_static.real = this->is_static;
*(outbuffer + offset + 0) = (u_is_static.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_static);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_parent_model_name;
arrToVar(length_parent_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_parent_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_parent_model_name-1]=0;
this->parent_model_name = (char *)(inbuffer + offset-1);
offset += length_parent_model_name;
uint32_t length_canonical_body_name;
arrToVar(length_canonical_body_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_canonical_body_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_canonical_body_name-1]=0;
this->canonical_body_name = (char *)(inbuffer + offset-1);
offset += length_canonical_body_name;
uint32_t body_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
body_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
body_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
body_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->body_names_length);
if(body_names_lengthT > body_names_length)
this->body_names = (char**)realloc(this->body_names, body_names_lengthT * sizeof(char*));
body_names_length = body_names_lengthT;
for( uint32_t i = 0; i < body_names_length; i++){
uint32_t length_st_body_names;
arrToVar(length_st_body_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_body_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_body_names-1]=0;
this->st_body_names = (char *)(inbuffer + offset-1);
offset += length_st_body_names;
memcpy( &(this->body_names[i]), &(this->st_body_names), sizeof(char*));
}
uint32_t geom_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
geom_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
geom_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
geom_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->geom_names_length);
if(geom_names_lengthT > geom_names_length)
this->geom_names = (char**)realloc(this->geom_names, geom_names_lengthT * sizeof(char*));
geom_names_length = geom_names_lengthT;
for( uint32_t i = 0; i < geom_names_length; i++){
uint32_t length_st_geom_names;
arrToVar(length_st_geom_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_geom_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_geom_names-1]=0;
this->st_geom_names = (char *)(inbuffer + offset-1);
offset += length_st_geom_names;
memcpy( &(this->geom_names[i]), &(this->st_geom_names), sizeof(char*));
}
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 child_model_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
child_model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
child_model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
child_model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->child_model_names_length);
if(child_model_names_lengthT > child_model_names_length)
this->child_model_names = (char**)realloc(this->child_model_names, child_model_names_lengthT * sizeof(char*));
child_model_names_length = child_model_names_lengthT;
for( uint32_t i = 0; i < child_model_names_length; i++){
uint32_t length_st_child_model_names;
arrToVar(length_st_child_model_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_child_model_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_child_model_names-1]=0;
this->st_child_model_names = (char *)(inbuffer + offset-1);
offset += length_st_child_model_names;
memcpy( &(this->child_model_names[i]), &(this->st_child_model_names), sizeof(char*));
}
union {
bool real;
uint8_t base;
} u_is_static;
u_is_static.base = 0;
u_is_static.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_static = u_is_static.real;
offset += sizeof(this->is_static);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETMODELPROPERTIES; };
const char * getMD5(){ return "b7f370938ef77b464b95f1bab3ec5028"; };
};
class GetModelProperties {
public:
typedef GetModelPropertiesRequest Request;
typedef GetModelPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ODEPhysics.h | #ifndef _ROS_gazebo_msgs_ODEPhysics_h
#define _ROS_gazebo_msgs_ODEPhysics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
class ODEPhysics : public ros::Msg
{
public:
typedef bool _auto_disable_bodies_type;
_auto_disable_bodies_type auto_disable_bodies;
typedef uint32_t _sor_pgs_precon_iters_type;
_sor_pgs_precon_iters_type sor_pgs_precon_iters;
typedef uint32_t _sor_pgs_iters_type;
_sor_pgs_iters_type sor_pgs_iters;
typedef double _sor_pgs_w_type;
_sor_pgs_w_type sor_pgs_w;
typedef double _sor_pgs_rms_error_tol_type;
_sor_pgs_rms_error_tol_type sor_pgs_rms_error_tol;
typedef double _contact_surface_layer_type;
_contact_surface_layer_type contact_surface_layer;
typedef double _contact_max_correcting_vel_type;
_contact_max_correcting_vel_type contact_max_correcting_vel;
typedef double _cfm_type;
_cfm_type cfm;
typedef double _erp_type;
_erp_type erp;
typedef uint32_t _max_contacts_type;
_max_contacts_type max_contacts;
ODEPhysics():
auto_disable_bodies(0),
sor_pgs_precon_iters(0),
sor_pgs_iters(0),
sor_pgs_w(0),
sor_pgs_rms_error_tol(0),
contact_surface_layer(0),
contact_max_correcting_vel(0),
cfm(0),
erp(0),
max_contacts(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_auto_disable_bodies;
u_auto_disable_bodies.real = this->auto_disable_bodies;
*(outbuffer + offset + 0) = (u_auto_disable_bodies.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->auto_disable_bodies);
*(outbuffer + offset + 0) = (this->sor_pgs_precon_iters >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sor_pgs_precon_iters >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sor_pgs_precon_iters >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sor_pgs_precon_iters >> (8 * 3)) & 0xFF;
offset += sizeof(this->sor_pgs_precon_iters);
*(outbuffer + offset + 0) = (this->sor_pgs_iters >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sor_pgs_iters >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sor_pgs_iters >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sor_pgs_iters >> (8 * 3)) & 0xFF;
offset += sizeof(this->sor_pgs_iters);
union {
double real;
uint64_t base;
} u_sor_pgs_w;
u_sor_pgs_w.real = this->sor_pgs_w;
*(outbuffer + offset + 0) = (u_sor_pgs_w.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sor_pgs_w.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sor_pgs_w.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sor_pgs_w.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sor_pgs_w.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sor_pgs_w.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sor_pgs_w.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sor_pgs_w.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sor_pgs_w);
union {
double real;
uint64_t base;
} u_sor_pgs_rms_error_tol;
u_sor_pgs_rms_error_tol.real = this->sor_pgs_rms_error_tol;
*(outbuffer + offset + 0) = (u_sor_pgs_rms_error_tol.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sor_pgs_rms_error_tol.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sor_pgs_rms_error_tol.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sor_pgs_rms_error_tol.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sor_pgs_rms_error_tol.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sor_pgs_rms_error_tol.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sor_pgs_rms_error_tol.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sor_pgs_rms_error_tol.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sor_pgs_rms_error_tol);
union {
double real;
uint64_t base;
} u_contact_surface_layer;
u_contact_surface_layer.real = this->contact_surface_layer;
*(outbuffer + offset + 0) = (u_contact_surface_layer.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_contact_surface_layer.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_contact_surface_layer.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_contact_surface_layer.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_contact_surface_layer.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_contact_surface_layer.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_contact_surface_layer.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_contact_surface_layer.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->contact_surface_layer);
union {
double real;
uint64_t base;
} u_contact_max_correcting_vel;
u_contact_max_correcting_vel.real = this->contact_max_correcting_vel;
*(outbuffer + offset + 0) = (u_contact_max_correcting_vel.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_contact_max_correcting_vel.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_contact_max_correcting_vel.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_contact_max_correcting_vel.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_contact_max_correcting_vel.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_contact_max_correcting_vel.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_contact_max_correcting_vel.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_contact_max_correcting_vel.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->contact_max_correcting_vel);
union {
double real;
uint64_t base;
} u_cfm;
u_cfm.real = this->cfm;
*(outbuffer + offset + 0) = (u_cfm.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cfm.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cfm.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cfm.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_cfm.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_cfm.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_cfm.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_cfm.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->cfm);
union {
double real;
uint64_t base;
} u_erp;
u_erp.real = this->erp;
*(outbuffer + offset + 0) = (u_erp.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_erp.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_erp.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_erp.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_erp.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_erp.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_erp.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_erp.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->erp);
*(outbuffer + offset + 0) = (this->max_contacts >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_contacts >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_contacts >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_contacts >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_contacts);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_auto_disable_bodies;
u_auto_disable_bodies.base = 0;
u_auto_disable_bodies.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->auto_disable_bodies = u_auto_disable_bodies.real;
offset += sizeof(this->auto_disable_bodies);
this->sor_pgs_precon_iters = ((uint32_t) (*(inbuffer + offset)));
this->sor_pgs_precon_iters |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->sor_pgs_precon_iters |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->sor_pgs_precon_iters |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sor_pgs_precon_iters);
this->sor_pgs_iters = ((uint32_t) (*(inbuffer + offset)));
this->sor_pgs_iters |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->sor_pgs_iters |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->sor_pgs_iters |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sor_pgs_iters);
union {
double real;
uint64_t base;
} u_sor_pgs_w;
u_sor_pgs_w.base = 0;
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sor_pgs_w = u_sor_pgs_w.real;
offset += sizeof(this->sor_pgs_w);
union {
double real;
uint64_t base;
} u_sor_pgs_rms_error_tol;
u_sor_pgs_rms_error_tol.base = 0;
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sor_pgs_rms_error_tol = u_sor_pgs_rms_error_tol.real;
offset += sizeof(this->sor_pgs_rms_error_tol);
union {
double real;
uint64_t base;
} u_contact_surface_layer;
u_contact_surface_layer.base = 0;
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->contact_surface_layer = u_contact_surface_layer.real;
offset += sizeof(this->contact_surface_layer);
union {
double real;
uint64_t base;
} u_contact_max_correcting_vel;
u_contact_max_correcting_vel.base = 0;
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->contact_max_correcting_vel = u_contact_max_correcting_vel.real;
offset += sizeof(this->contact_max_correcting_vel);
union {
double real;
uint64_t base;
} u_cfm;
u_cfm.base = 0;
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->cfm = u_cfm.real;
offset += sizeof(this->cfm);
union {
double real;
uint64_t base;
} u_erp;
u_erp.base = 0;
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->erp = u_erp.real;
offset += sizeof(this->erp);
this->max_contacts = ((uint32_t) (*(inbuffer + offset)));
this->max_contacts |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->max_contacts |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->max_contacts |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_contacts);
return offset;
}
const char * getType(){ return "gazebo_msgs/ODEPhysics"; };
const char * getMD5(){ return "667d56ddbd547918c32d1934503dc335"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetPhysicsProperties.h | #ifndef _ROS_SERVICE_GetPhysicsProperties_h
#define _ROS_SERVICE_GetPhysicsProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
#include "gazebo_msgs/ODEPhysics.h"
namespace gazebo_msgs
{
static const char GETPHYSICSPROPERTIES[] = "gazebo_msgs/GetPhysicsProperties";
class GetPhysicsPropertiesRequest : public ros::Msg
{
public:
GetPhysicsPropertiesRequest()
{
}
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 GETPHYSICSPROPERTIES; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetPhysicsPropertiesResponse : public ros::Msg
{
public:
typedef double _time_step_type;
_time_step_type time_step;
typedef bool _pause_type;
_pause_type pause;
typedef double _max_update_rate_type;
_max_update_rate_type max_update_rate;
typedef geometry_msgs::Vector3 _gravity_type;
_gravity_type gravity;
typedef gazebo_msgs::ODEPhysics _ode_config_type;
_ode_config_type ode_config;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetPhysicsPropertiesResponse():
time_step(0),
pause(0),
max_update_rate(0),
gravity(),
ode_config(),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.real = this->time_step;
*(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time_step);
union {
bool real;
uint8_t base;
} u_pause;
u_pause.real = this->pause;
*(outbuffer + offset + 0) = (u_pause.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->pause);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.real = this->max_update_rate;
*(outbuffer + offset + 0) = (u_max_update_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_update_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_update_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_update_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_update_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_update_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_update_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_update_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_update_rate);
offset += this->gravity.serialize(outbuffer + offset);
offset += this->ode_config.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.base = 0;
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time_step = u_time_step.real;
offset += sizeof(this->time_step);
union {
bool real;
uint8_t base;
} u_pause;
u_pause.base = 0;
u_pause.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->pause = u_pause.real;
offset += sizeof(this->pause);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.base = 0;
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_update_rate = u_max_update_rate.real;
offset += sizeof(this->max_update_rate);
offset += this->gravity.deserialize(inbuffer + offset);
offset += this->ode_config.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETPHYSICSPROPERTIES; };
const char * getMD5(){ return "575a5e74786981b7df2e3afc567693a6"; };
};
class GetPhysicsProperties {
public:
typedef GetPhysicsPropertiesRequest Request;
typedef GetPhysicsPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetLinkProperties.h | #ifndef _ROS_SERVICE_SetLinkProperties_h
#define _ROS_SERVICE_SetLinkProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char SETLINKPROPERTIES[] = "gazebo_msgs/SetLinkProperties";
class SetLinkPropertiesRequest : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef geometry_msgs::Pose _com_type;
_com_type com;
typedef bool _gravity_mode_type;
_gravity_mode_type gravity_mode;
typedef double _mass_type;
_mass_type mass;
typedef double _ixx_type;
_ixx_type ixx;
typedef double _ixy_type;
_ixy_type ixy;
typedef double _ixz_type;
_ixz_type ixz;
typedef double _iyy_type;
_iyy_type iyy;
typedef double _iyz_type;
_iyz_type iyz;
typedef double _izz_type;
_izz_type izz;
SetLinkPropertiesRequest():
link_name(""),
com(),
gravity_mode(0),
mass(0),
ixx(0),
ixy(0),
ixz(0),
iyy(0),
iyz(0),
izz(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->com.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.real = this->gravity_mode;
*(outbuffer + offset + 0) = (u_gravity_mode.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.real = this->mass;
*(outbuffer + offset + 0) = (u_mass.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mass.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mass.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mass.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_mass.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_mass.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_mass.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_mass.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.real = this->ixx;
*(outbuffer + offset + 0) = (u_ixx.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixx.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixx.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixx.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixx.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixx.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixx.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixx.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.real = this->ixy;
*(outbuffer + offset + 0) = (u_ixy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.real = this->ixz;
*(outbuffer + offset + 0) = (u_ixz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.real = this->iyy;
*(outbuffer + offset + 0) = (u_iyy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.real = this->iyz;
*(outbuffer + offset + 0) = (u_iyz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.real = this->izz;
*(outbuffer + offset + 0) = (u_izz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_izz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_izz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_izz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_izz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_izz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_izz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_izz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->izz);
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->com.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.base = 0;
u_gravity_mode.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->gravity_mode = u_gravity_mode.real;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.base = 0;
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->mass = u_mass.real;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.base = 0;
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixx = u_ixx.real;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.base = 0;
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixy = u_ixy.real;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.base = 0;
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixz = u_ixz.real;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.base = 0;
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyy = u_iyy.real;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.base = 0;
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyz = u_iyz.real;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.base = 0;
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->izz = u_izz.real;
offset += sizeof(this->izz);
return offset;
}
const char * getType(){ return SETLINKPROPERTIES; };
const char * getMD5(){ return "68ac74a4be01b165bc305b5ccdc45e91"; };
};
class SetLinkPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetLinkPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETLINKPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetLinkProperties {
public:
typedef SetLinkPropertiesRequest Request;
typedef SetLinkPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetJointProperties.h | #ifndef _ROS_SERVICE_GetJointProperties_h
#define _ROS_SERVICE_GetJointProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char GETJOINTPROPERTIES[] = "gazebo_msgs/GetJointProperties";
class GetJointPropertiesRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
GetJointPropertiesRequest():
joint_name("")
{
}
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;
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;
return offset;
}
const char * getType(){ return GETJOINTPROPERTIES; };
const char * getMD5(){ return "0be1351618e1dc030eb7959d9a4902de"; };
};
class GetJointPropertiesResponse : public ros::Msg
{
public:
typedef uint8_t _type_type;
_type_type type;
uint32_t damping_length;
typedef double _damping_type;
_damping_type st_damping;
_damping_type * damping;
uint32_t position_length;
typedef double _position_type;
_position_type st_position;
_position_type * position;
uint32_t rate_length;
typedef double _rate_type;
_rate_type st_rate;
_rate_type * rate;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
enum { REVOLUTE = 0 };
enum { CONTINUOUS = 1 };
enum { PRISMATIC = 2 };
enum { FIXED = 3 };
enum { BALL = 4 };
enum { UNIVERSAL = 5 };
GetJointPropertiesResponse():
type(0),
damping_length(0), damping(NULL),
position_length(0), position(NULL),
rate_length(0), rate(NULL),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
offset += sizeof(this->type);
*(outbuffer + offset + 0) = (this->damping_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->damping_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->damping_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->damping_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->damping_length);
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_dampingi;
u_dampingi.real = this->damping[i];
*(outbuffer + offset + 0) = (u_dampingi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dampingi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dampingi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dampingi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_dampingi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_dampingi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_dampingi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_dampingi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->damping[i]);
}
*(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_length);
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_positioni;
u_positioni.real = this->position[i];
*(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->rate_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->rate_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->rate_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->rate_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->rate_length);
for( uint32_t i = 0; i < rate_length; i++){
union {
double real;
uint64_t base;
} u_ratei;
u_ratei.real = this->rate[i];
*(outbuffer + offset + 0) = (u_ratei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ratei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ratei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ratei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ratei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ratei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ratei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ratei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->rate[i]);
}
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->type);
uint32_t damping_lengthT = ((uint32_t) (*(inbuffer + offset)));
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->damping_length);
if(damping_lengthT > damping_length)
this->damping = (double*)realloc(this->damping, damping_lengthT * sizeof(double));
damping_length = damping_lengthT;
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_st_damping;
u_st_damping.base = 0;
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_damping = u_st_damping.real;
offset += sizeof(this->st_damping);
memcpy( &(this->damping[i]), &(this->st_damping), sizeof(double));
}
uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_length);
if(position_lengthT > position_length)
this->position = (double*)realloc(this->position, position_lengthT * sizeof(double));
position_length = position_lengthT;
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_st_position;
u_st_position.base = 0;
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position = u_st_position.real;
offset += sizeof(this->st_position);
memcpy( &(this->position[i]), &(this->st_position), sizeof(double));
}
uint32_t rate_lengthT = ((uint32_t) (*(inbuffer + offset)));
rate_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
rate_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
rate_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->rate_length);
if(rate_lengthT > rate_length)
this->rate = (double*)realloc(this->rate, rate_lengthT * sizeof(double));
rate_length = rate_lengthT;
for( uint32_t i = 0; i < rate_length; i++){
union {
double real;
uint64_t base;
} u_st_rate;
u_st_rate.base = 0;
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_rate = u_st_rate.real;
offset += sizeof(this->st_rate);
memcpy( &(this->rate[i]), &(this->st_rate), sizeof(double));
}
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETJOINTPROPERTIES; };
const char * getMD5(){ return "cd7b30a39faa372283dc94c5f6457f82"; };
};
class GetJointProperties {
public:
typedef GetJointPropertiesRequest Request;
typedef GetJointPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/LinkState.h | #ifndef _ROS_gazebo_msgs_LinkState_h
#define _ROS_gazebo_msgs_LinkState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class LinkState : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
LinkState():
link_name(""),
pose(),
twist(),
reference_frame("")
{
}
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->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
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->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return "gazebo_msgs/LinkState"; };
const char * getMD5(){ return "0818ebbf28ce3a08d48ab1eaa7309ebe"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/DeleteModel.h | #ifndef _ROS_SERVICE_DeleteModel_h
#define _ROS_SERVICE_DeleteModel_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char DELETEMODEL[] = "gazebo_msgs/DeleteModel";
class DeleteModelRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
DeleteModelRequest():
model_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
return offset;
}
const char * getType(){ return DELETEMODEL; };
const char * getMD5(){ return "ea31c8eab6fc401383cf528a7c0984ba"; };
};
class DeleteModelResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
DeleteModelResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return DELETEMODEL; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class DeleteModel {
public:
typedef DeleteModelRequest Request;
typedef DeleteModelResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetLinkState.h | #ifndef _ROS_SERVICE_GetLinkState_h
#define _ROS_SERVICE_GetLinkState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/LinkState.h"
namespace gazebo_msgs
{
static const char GETLINKSTATE[] = "gazebo_msgs/GetLinkState";
class GetLinkStateRequest : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
GetLinkStateRequest():
link_name(""),
reference_frame("")
{
}
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;
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
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;
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return GETLINKSTATE; };
const char * getMD5(){ return "7551675c30aaa71f7c288d4864552001"; };
};
class GetLinkStateResponse : public ros::Msg
{
public:
typedef gazebo_msgs::LinkState _link_state_type;
_link_state_type link_state;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetLinkStateResponse():
link_state(),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->link_state.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->link_state.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETLINKSTATE; };
const char * getMD5(){ return "8ba55ad34f9c072e75c0de57b089753b"; };
};
class GetLinkState {
public:
typedef GetLinkStateRequest Request;
typedef GetLinkStateResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/LinkStates.h | #ifndef _ROS_gazebo_msgs_LinkStates_h
#define _ROS_gazebo_msgs_LinkStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class LinkStates : public ros::Msg
{
public:
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t pose_length;
typedef geometry_msgs::Pose _pose_type;
_pose_type st_pose;
_pose_type * pose;
uint32_t twist_length;
typedef geometry_msgs::Twist _twist_type;
_twist_type st_twist;
_twist_type * twist;
LinkStates():
name_length(0), name(NULL),
pose_length(0), pose(NULL),
twist_length(0), twist(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->pose_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_length);
for( uint32_t i = 0; i < pose_length; i++){
offset += this->pose[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->twist_length);
for( uint32_t i = 0; i < twist_length; i++){
offset += this->twist[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t pose_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_length);
if(pose_lengthT > pose_length)
this->pose = (geometry_msgs::Pose*)realloc(this->pose, pose_lengthT * sizeof(geometry_msgs::Pose));
pose_length = pose_lengthT;
for( uint32_t i = 0; i < pose_length; i++){
offset += this->st_pose.deserialize(inbuffer + offset);
memcpy( &(this->pose[i]), &(this->st_pose), sizeof(geometry_msgs::Pose));
}
uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->twist_length);
if(twist_lengthT > twist_length)
this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
twist_length = twist_lengthT;
for( uint32_t i = 0; i < twist_length; i++){
offset += this->st_twist.deserialize(inbuffer + offset);
memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/LinkStates"; };
const char * getMD5(){ return "48c080191eb15c41858319b4d8a609c2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ContactsState.h | #ifndef _ROS_gazebo_msgs_ContactsState_h
#define _ROS_gazebo_msgs_ContactsState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "gazebo_msgs/ContactState.h"
namespace gazebo_msgs
{
class ContactsState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t states_length;
typedef gazebo_msgs::ContactState _states_type;
_states_type st_states;
_states_type * states;
ContactsState():
header(),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (gazebo_msgs::ContactState*)realloc(this->states, states_lengthT * sizeof(gazebo_msgs::ContactState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(gazebo_msgs::ContactState));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ContactsState"; };
const char * getMD5(){ return "acbcb1601a8e525bf72509f18e6f668d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetModelConfiguration.h | #ifndef _ROS_SERVICE_SetModelConfiguration_h
#define _ROS_SERVICE_SetModelConfiguration_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char SETMODELCONFIGURATION[] = "gazebo_msgs/SetModelConfiguration";
class SetModelConfigurationRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef const char* _urdf_param_name_type;
_urdf_param_name_type urdf_param_name;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t joint_positions_length;
typedef double _joint_positions_type;
_joint_positions_type st_joint_positions;
_joint_positions_type * joint_positions;
SetModelConfigurationRequest():
model_name(""),
urdf_param_name(""),
joint_names_length(0), joint_names(NULL),
joint_positions_length(0), joint_positions(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
uint32_t length_urdf_param_name = strlen(this->urdf_param_name);
varToArr(outbuffer + offset, length_urdf_param_name);
offset += 4;
memcpy(outbuffer + offset, this->urdf_param_name, length_urdf_param_name);
offset += length_urdf_param_name;
*(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->joint_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_positions_length);
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_joint_positionsi;
u_joint_positionsi.real = this->joint_positions[i];
*(outbuffer + offset + 0) = (u_joint_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_positions[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
uint32_t length_urdf_param_name;
arrToVar(length_urdf_param_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_urdf_param_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_urdf_param_name-1]=0;
this->urdf_param_name = (char *)(inbuffer + offset-1);
offset += length_urdf_param_name;
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 joint_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_positions_length);
if(joint_positions_lengthT > joint_positions_length)
this->joint_positions = (double*)realloc(this->joint_positions, joint_positions_lengthT * sizeof(double));
joint_positions_length = joint_positions_lengthT;
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_positions;
u_st_joint_positions.base = 0;
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_positions = u_st_joint_positions.real;
offset += sizeof(this->st_joint_positions);
memcpy( &(this->joint_positions[i]), &(this->st_joint_positions), sizeof(double));
}
return offset;
}
const char * getType(){ return SETMODELCONFIGURATION; };
const char * getMD5(){ return "160eae60f51fabff255480c70afa289f"; };
};
class SetModelConfigurationResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetModelConfigurationResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETMODELCONFIGURATION; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetModelConfiguration {
public:
typedef SetModelConfigurationRequest Request;
typedef SetModelConfigurationResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetLightProperties.h | #ifndef _ROS_SERVICE_SetLightProperties_h
#define _ROS_SERVICE_SetLightProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/ColorRGBA.h"
namespace gazebo_msgs
{
static const char SETLIGHTPROPERTIES[] = "gazebo_msgs/SetLightProperties";
class SetLightPropertiesRequest : public ros::Msg
{
public:
typedef const char* _light_name_type;
_light_name_type light_name;
typedef std_msgs::ColorRGBA _diffuse_type;
_diffuse_type diffuse;
typedef double _attenuation_constant_type;
_attenuation_constant_type attenuation_constant;
typedef double _attenuation_linear_type;
_attenuation_linear_type attenuation_linear;
typedef double _attenuation_quadratic_type;
_attenuation_quadratic_type attenuation_quadratic;
SetLightPropertiesRequest():
light_name(""),
diffuse(),
attenuation_constant(0),
attenuation_linear(0),
attenuation_quadratic(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_light_name = strlen(this->light_name);
varToArr(outbuffer + offset, length_light_name);
offset += 4;
memcpy(outbuffer + offset, this->light_name, length_light_name);
offset += length_light_name;
offset += this->diffuse.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.real = this->attenuation_constant;
*(outbuffer + offset + 0) = (u_attenuation_constant.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_constant.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_constant.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_constant.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_constant.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_constant.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_constant.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_constant.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.real = this->attenuation_linear;
*(outbuffer + offset + 0) = (u_attenuation_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_linear.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_linear.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_linear.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_linear.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_linear.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.real = this->attenuation_quadratic;
*(outbuffer + offset + 0) = (u_attenuation_quadratic.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_quadratic.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_quadratic.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_quadratic.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_quadratic.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_quadratic.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_quadratic.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_quadratic.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_quadratic);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_light_name;
arrToVar(length_light_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_light_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_light_name-1]=0;
this->light_name = (char *)(inbuffer + offset-1);
offset += length_light_name;
offset += this->diffuse.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.base = 0;
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_constant = u_attenuation_constant.real;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.base = 0;
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_linear = u_attenuation_linear.real;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.base = 0;
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_quadratic = u_attenuation_quadratic.real;
offset += sizeof(this->attenuation_quadratic);
return offset;
}
const char * getType(){ return SETLIGHTPROPERTIES; };
const char * getMD5(){ return "73ad1ac5e9e312ddf7c74f38ad843f34"; };
};
class SetLightPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetLightPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETLIGHTPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetLightProperties {
public:
typedef SetLightPropertiesRequest Request;
typedef SetLightPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/WorldState.h | #ifndef _ROS_gazebo_msgs_WorldState_h
#define _ROS_gazebo_msgs_WorldState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
#include "geometry_msgs/Wrench.h"
namespace gazebo_msgs
{
class WorldState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t pose_length;
typedef geometry_msgs::Pose _pose_type;
_pose_type st_pose;
_pose_type * pose;
uint32_t twist_length;
typedef geometry_msgs::Twist _twist_type;
_twist_type st_twist;
_twist_type * twist;
uint32_t wrench_length;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type st_wrench;
_wrench_type * wrench;
WorldState():
header(),
name_length(0), name(NULL),
pose_length(0), pose(NULL),
twist_length(0), twist(NULL),
wrench_length(0), wrench(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->pose_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_length);
for( uint32_t i = 0; i < pose_length; i++){
offset += this->pose[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->twist_length);
for( uint32_t i = 0; i < twist_length; i++){
offset += this->twist[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->wrench_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->wrench_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->wrench_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->wrench_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->wrench_length);
for( uint32_t i = 0; i < wrench_length; i++){
offset += this->wrench[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t pose_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_length);
if(pose_lengthT > pose_length)
this->pose = (geometry_msgs::Pose*)realloc(this->pose, pose_lengthT * sizeof(geometry_msgs::Pose));
pose_length = pose_lengthT;
for( uint32_t i = 0; i < pose_length; i++){
offset += this->st_pose.deserialize(inbuffer + offset);
memcpy( &(this->pose[i]), &(this->st_pose), sizeof(geometry_msgs::Pose));
}
uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->twist_length);
if(twist_lengthT > twist_length)
this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
twist_length = twist_lengthT;
for( uint32_t i = 0; i < twist_length; i++){
offset += this->st_twist.deserialize(inbuffer + offset);
memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
}
uint32_t wrench_lengthT = ((uint32_t) (*(inbuffer + offset)));
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->wrench_length);
if(wrench_lengthT > wrench_length)
this->wrench = (geometry_msgs::Wrench*)realloc(this->wrench, wrench_lengthT * sizeof(geometry_msgs::Wrench));
wrench_length = wrench_lengthT;
for( uint32_t i = 0; i < wrench_length; i++){
offset += this->st_wrench.deserialize(inbuffer + offset);
memcpy( &(this->wrench[i]), &(this->st_wrench), sizeof(geometry_msgs::Wrench));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/WorldState"; };
const char * getMD5(){ return "de1a9de3ab7ba97ac0e9ec01a4eb481e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetLinkProperties.h | #ifndef _ROS_SERVICE_GetLinkProperties_h
#define _ROS_SERVICE_GetLinkProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char GETLINKPROPERTIES[] = "gazebo_msgs/GetLinkProperties";
class GetLinkPropertiesRequest : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
GetLinkPropertiesRequest():
link_name("")
{
}
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;
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;
return offset;
}
const char * getType(){ return GETLINKPROPERTIES; };
const char * getMD5(){ return "7d82d60381f1b66a30f2157f60884345"; };
};
class GetLinkPropertiesResponse : public ros::Msg
{
public:
typedef geometry_msgs::Pose _com_type;
_com_type com;
typedef bool _gravity_mode_type;
_gravity_mode_type gravity_mode;
typedef double _mass_type;
_mass_type mass;
typedef double _ixx_type;
_ixx_type ixx;
typedef double _ixy_type;
_ixy_type ixy;
typedef double _ixz_type;
_ixz_type ixz;
typedef double _iyy_type;
_iyy_type iyy;
typedef double _iyz_type;
_iyz_type iyz;
typedef double _izz_type;
_izz_type izz;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetLinkPropertiesResponse():
com(),
gravity_mode(0),
mass(0),
ixx(0),
ixy(0),
ixz(0),
iyy(0),
iyz(0),
izz(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->com.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.real = this->gravity_mode;
*(outbuffer + offset + 0) = (u_gravity_mode.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.real = this->mass;
*(outbuffer + offset + 0) = (u_mass.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mass.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mass.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mass.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_mass.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_mass.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_mass.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_mass.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.real = this->ixx;
*(outbuffer + offset + 0) = (u_ixx.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixx.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixx.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixx.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixx.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixx.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixx.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixx.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.real = this->ixy;
*(outbuffer + offset + 0) = (u_ixy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.real = this->ixz;
*(outbuffer + offset + 0) = (u_ixz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.real = this->iyy;
*(outbuffer + offset + 0) = (u_iyy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.real = this->iyz;
*(outbuffer + offset + 0) = (u_iyz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.real = this->izz;
*(outbuffer + offset + 0) = (u_izz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_izz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_izz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_izz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_izz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_izz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_izz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_izz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->izz);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->com.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.base = 0;
u_gravity_mode.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->gravity_mode = u_gravity_mode.real;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.base = 0;
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->mass = u_mass.real;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.base = 0;
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixx = u_ixx.real;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.base = 0;
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixy = u_ixy.real;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.base = 0;
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixz = u_ixz.real;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.base = 0;
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyy = u_iyy.real;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.base = 0;
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyz = u_iyz.real;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.base = 0;
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->izz = u_izz.real;
offset += sizeof(this->izz);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETLINKPROPERTIES; };
const char * getMD5(){ return "a8619f92d17cfcc3958c0fd13299443d"; };
};
class GetLinkProperties {
public:
typedef GetLinkPropertiesRequest Request;
typedef GetLinkPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetJointProperties.h | #ifndef _ROS_SERVICE_SetJointProperties_h
#define _ROS_SERVICE_SetJointProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/ODEJointProperties.h"
namespace gazebo_msgs
{
static const char SETJOINTPROPERTIES[] = "gazebo_msgs/SetJointProperties";
class SetJointPropertiesRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef gazebo_msgs::ODEJointProperties _ode_joint_config_type;
_ode_joint_config_type ode_joint_config;
SetJointPropertiesRequest():
joint_name(""),
ode_joint_config()
{
}
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;
offset += this->ode_joint_config.serialize(outbuffer + offset);
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;
offset += this->ode_joint_config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETJOINTPROPERTIES; };
const char * getMD5(){ return "331fd8f35fd27e3c1421175590258e26"; };
};
class SetJointPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetJointPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETJOINTPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetJointProperties {
public:
typedef SetJointPropertiesRequest Request;
typedef SetJointPropertiesResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ODEJointProperties.h | #ifndef _ROS_gazebo_msgs_ODEJointProperties_h
#define _ROS_gazebo_msgs_ODEJointProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
class ODEJointProperties : public ros::Msg
{
public:
uint32_t damping_length;
typedef double _damping_type;
_damping_type st_damping;
_damping_type * damping;
uint32_t hiStop_length;
typedef double _hiStop_type;
_hiStop_type st_hiStop;
_hiStop_type * hiStop;
uint32_t loStop_length;
typedef double _loStop_type;
_loStop_type st_loStop;
_loStop_type * loStop;
uint32_t erp_length;
typedef double _erp_type;
_erp_type st_erp;
_erp_type * erp;
uint32_t cfm_length;
typedef double _cfm_type;
_cfm_type st_cfm;
_cfm_type * cfm;
uint32_t stop_erp_length;
typedef double _stop_erp_type;
_stop_erp_type st_stop_erp;
_stop_erp_type * stop_erp;
uint32_t stop_cfm_length;
typedef double _stop_cfm_type;
_stop_cfm_type st_stop_cfm;
_stop_cfm_type * stop_cfm;
uint32_t fudge_factor_length;
typedef double _fudge_factor_type;
_fudge_factor_type st_fudge_factor;
_fudge_factor_type * fudge_factor;
uint32_t fmax_length;
typedef double _fmax_type;
_fmax_type st_fmax;
_fmax_type * fmax;
uint32_t vel_length;
typedef double _vel_type;
_vel_type st_vel;
_vel_type * vel;
ODEJointProperties():
damping_length(0), damping(NULL),
hiStop_length(0), hiStop(NULL),
loStop_length(0), loStop(NULL),
erp_length(0), erp(NULL),
cfm_length(0), cfm(NULL),
stop_erp_length(0), stop_erp(NULL),
stop_cfm_length(0), stop_cfm(NULL),
fudge_factor_length(0), fudge_factor(NULL),
fmax_length(0), fmax(NULL),
vel_length(0), vel(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->damping_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->damping_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->damping_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->damping_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->damping_length);
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_dampingi;
u_dampingi.real = this->damping[i];
*(outbuffer + offset + 0) = (u_dampingi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dampingi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dampingi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dampingi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_dampingi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_dampingi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_dampingi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_dampingi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->damping[i]);
}
*(outbuffer + offset + 0) = (this->hiStop_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->hiStop_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->hiStop_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->hiStop_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->hiStop_length);
for( uint32_t i = 0; i < hiStop_length; i++){
union {
double real;
uint64_t base;
} u_hiStopi;
u_hiStopi.real = this->hiStop[i];
*(outbuffer + offset + 0) = (u_hiStopi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_hiStopi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_hiStopi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_hiStopi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_hiStopi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_hiStopi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_hiStopi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_hiStopi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->hiStop[i]);
}
*(outbuffer + offset + 0) = (this->loStop_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->loStop_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->loStop_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->loStop_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->loStop_length);
for( uint32_t i = 0; i < loStop_length; i++){
union {
double real;
uint64_t base;
} u_loStopi;
u_loStopi.real = this->loStop[i];
*(outbuffer + offset + 0) = (u_loStopi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_loStopi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_loStopi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_loStopi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_loStopi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_loStopi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_loStopi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_loStopi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->loStop[i]);
}
*(outbuffer + offset + 0) = (this->erp_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->erp_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->erp_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->erp_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->erp_length);
for( uint32_t i = 0; i < erp_length; i++){
union {
double real;
uint64_t base;
} u_erpi;
u_erpi.real = this->erp[i];
*(outbuffer + offset + 0) = (u_erpi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_erpi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_erpi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_erpi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_erpi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_erpi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_erpi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_erpi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->erp[i]);
}
*(outbuffer + offset + 0) = (this->cfm_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cfm_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cfm_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cfm_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cfm_length);
for( uint32_t i = 0; i < cfm_length; i++){
union {
double real;
uint64_t base;
} u_cfmi;
u_cfmi.real = this->cfm[i];
*(outbuffer + offset + 0) = (u_cfmi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cfmi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cfmi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cfmi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_cfmi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_cfmi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_cfmi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_cfmi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->cfm[i]);
}
*(outbuffer + offset + 0) = (this->stop_erp_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stop_erp_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stop_erp_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stop_erp_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->stop_erp_length);
for( uint32_t i = 0; i < stop_erp_length; i++){
union {
double real;
uint64_t base;
} u_stop_erpi;
u_stop_erpi.real = this->stop_erp[i];
*(outbuffer + offset + 0) = (u_stop_erpi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_stop_erpi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_stop_erpi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_stop_erpi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_stop_erpi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_stop_erpi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_stop_erpi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_stop_erpi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->stop_erp[i]);
}
*(outbuffer + offset + 0) = (this->stop_cfm_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stop_cfm_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stop_cfm_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stop_cfm_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->stop_cfm_length);
for( uint32_t i = 0; i < stop_cfm_length; i++){
union {
double real;
uint64_t base;
} u_stop_cfmi;
u_stop_cfmi.real = this->stop_cfm[i];
*(outbuffer + offset + 0) = (u_stop_cfmi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_stop_cfmi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_stop_cfmi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_stop_cfmi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_stop_cfmi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_stop_cfmi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_stop_cfmi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_stop_cfmi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->stop_cfm[i]);
}
*(outbuffer + offset + 0) = (this->fudge_factor_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fudge_factor_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fudge_factor_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fudge_factor_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fudge_factor_length);
for( uint32_t i = 0; i < fudge_factor_length; i++){
union {
double real;
uint64_t base;
} u_fudge_factori;
u_fudge_factori.real = this->fudge_factor[i];
*(outbuffer + offset + 0) = (u_fudge_factori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fudge_factori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fudge_factori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fudge_factori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fudge_factori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fudge_factori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fudge_factori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fudge_factori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fudge_factor[i]);
}
*(outbuffer + offset + 0) = (this->fmax_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fmax_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fmax_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fmax_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fmax_length);
for( uint32_t i = 0; i < fmax_length; i++){
union {
double real;
uint64_t base;
} u_fmaxi;
u_fmaxi.real = this->fmax[i];
*(outbuffer + offset + 0) = (u_fmaxi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fmaxi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fmaxi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fmaxi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fmaxi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fmaxi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fmaxi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fmaxi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fmax[i]);
}
*(outbuffer + offset + 0) = (this->vel_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vel_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vel_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vel_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->vel_length);
for( uint32_t i = 0; i < vel_length; i++){
union {
double real;
uint64_t base;
} u_veli;
u_veli.real = this->vel[i];
*(outbuffer + offset + 0) = (u_veli.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_veli.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_veli.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_veli.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_veli.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_veli.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_veli.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_veli.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->vel[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t damping_lengthT = ((uint32_t) (*(inbuffer + offset)));
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->damping_length);
if(damping_lengthT > damping_length)
this->damping = (double*)realloc(this->damping, damping_lengthT * sizeof(double));
damping_length = damping_lengthT;
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_st_damping;
u_st_damping.base = 0;
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_damping = u_st_damping.real;
offset += sizeof(this->st_damping);
memcpy( &(this->damping[i]), &(this->st_damping), sizeof(double));
}
uint32_t hiStop_lengthT = ((uint32_t) (*(inbuffer + offset)));
hiStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
hiStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
hiStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->hiStop_length);
if(hiStop_lengthT > hiStop_length)
this->hiStop = (double*)realloc(this->hiStop, hiStop_lengthT * sizeof(double));
hiStop_length = hiStop_lengthT;
for( uint32_t i = 0; i < hiStop_length; i++){
union {
double real;
uint64_t base;
} u_st_hiStop;
u_st_hiStop.base = 0;
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_hiStop = u_st_hiStop.real;
offset += sizeof(this->st_hiStop);
memcpy( &(this->hiStop[i]), &(this->st_hiStop), sizeof(double));
}
uint32_t loStop_lengthT = ((uint32_t) (*(inbuffer + offset)));
loStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
loStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
loStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->loStop_length);
if(loStop_lengthT > loStop_length)
this->loStop = (double*)realloc(this->loStop, loStop_lengthT * sizeof(double));
loStop_length = loStop_lengthT;
for( uint32_t i = 0; i < loStop_length; i++){
union {
double real;
uint64_t base;
} u_st_loStop;
u_st_loStop.base = 0;
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_loStop = u_st_loStop.real;
offset += sizeof(this->st_loStop);
memcpy( &(this->loStop[i]), &(this->st_loStop), sizeof(double));
}
uint32_t erp_lengthT = ((uint32_t) (*(inbuffer + offset)));
erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->erp_length);
if(erp_lengthT > erp_length)
this->erp = (double*)realloc(this->erp, erp_lengthT * sizeof(double));
erp_length = erp_lengthT;
for( uint32_t i = 0; i < erp_length; i++){
union {
double real;
uint64_t base;
} u_st_erp;
u_st_erp.base = 0;
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_erp = u_st_erp.real;
offset += sizeof(this->st_erp);
memcpy( &(this->erp[i]), &(this->st_erp), sizeof(double));
}
uint32_t cfm_lengthT = ((uint32_t) (*(inbuffer + offset)));
cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cfm_length);
if(cfm_lengthT > cfm_length)
this->cfm = (double*)realloc(this->cfm, cfm_lengthT * sizeof(double));
cfm_length = cfm_lengthT;
for( uint32_t i = 0; i < cfm_length; i++){
union {
double real;
uint64_t base;
} u_st_cfm;
u_st_cfm.base = 0;
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_cfm = u_st_cfm.real;
offset += sizeof(this->st_cfm);
memcpy( &(this->cfm[i]), &(this->st_cfm), sizeof(double));
}
uint32_t stop_erp_lengthT = ((uint32_t) (*(inbuffer + offset)));
stop_erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
stop_erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
stop_erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stop_erp_length);
if(stop_erp_lengthT > stop_erp_length)
this->stop_erp = (double*)realloc(this->stop_erp, stop_erp_lengthT * sizeof(double));
stop_erp_length = stop_erp_lengthT;
for( uint32_t i = 0; i < stop_erp_length; i++){
union {
double real;
uint64_t base;
} u_st_stop_erp;
u_st_stop_erp.base = 0;
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_stop_erp = u_st_stop_erp.real;
offset += sizeof(this->st_stop_erp);
memcpy( &(this->stop_erp[i]), &(this->st_stop_erp), sizeof(double));
}
uint32_t stop_cfm_lengthT = ((uint32_t) (*(inbuffer + offset)));
stop_cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
stop_cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
stop_cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stop_cfm_length);
if(stop_cfm_lengthT > stop_cfm_length)
this->stop_cfm = (double*)realloc(this->stop_cfm, stop_cfm_lengthT * sizeof(double));
stop_cfm_length = stop_cfm_lengthT;
for( uint32_t i = 0; i < stop_cfm_length; i++){
union {
double real;
uint64_t base;
} u_st_stop_cfm;
u_st_stop_cfm.base = 0;
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_stop_cfm = u_st_stop_cfm.real;
offset += sizeof(this->st_stop_cfm);
memcpy( &(this->stop_cfm[i]), &(this->st_stop_cfm), sizeof(double));
}
uint32_t fudge_factor_lengthT = ((uint32_t) (*(inbuffer + offset)));
fudge_factor_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fudge_factor_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fudge_factor_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fudge_factor_length);
if(fudge_factor_lengthT > fudge_factor_length)
this->fudge_factor = (double*)realloc(this->fudge_factor, fudge_factor_lengthT * sizeof(double));
fudge_factor_length = fudge_factor_lengthT;
for( uint32_t i = 0; i < fudge_factor_length; i++){
union {
double real;
uint64_t base;
} u_st_fudge_factor;
u_st_fudge_factor.base = 0;
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_fudge_factor = u_st_fudge_factor.real;
offset += sizeof(this->st_fudge_factor);
memcpy( &(this->fudge_factor[i]), &(this->st_fudge_factor), sizeof(double));
}
uint32_t fmax_lengthT = ((uint32_t) (*(inbuffer + offset)));
fmax_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fmax_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fmax_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fmax_length);
if(fmax_lengthT > fmax_length)
this->fmax = (double*)realloc(this->fmax, fmax_lengthT * sizeof(double));
fmax_length = fmax_lengthT;
for( uint32_t i = 0; i < fmax_length; i++){
union {
double real;
uint64_t base;
} u_st_fmax;
u_st_fmax.base = 0;
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_fmax = u_st_fmax.real;
offset += sizeof(this->st_fmax);
memcpy( &(this->fmax[i]), &(this->st_fmax), sizeof(double));
}
uint32_t vel_lengthT = ((uint32_t) (*(inbuffer + offset)));
vel_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
vel_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
vel_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vel_length);
if(vel_lengthT > vel_length)
this->vel = (double*)realloc(this->vel, vel_lengthT * sizeof(double));
vel_length = vel_lengthT;
for( uint32_t i = 0; i < vel_length; i++){
union {
double real;
uint64_t base;
} u_st_vel;
u_st_vel.base = 0;
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_vel = u_st_vel.real;
offset += sizeof(this->st_vel);
memcpy( &(this->vel[i]), &(this->st_vel), sizeof(double));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ODEJointProperties"; };
const char * getMD5(){ return "1b744c32a920af979f53afe2f9c3511f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ApplyJointEffort.h | #ifndef _ROS_SERVICE_ApplyJointEffort_h
#define _ROS_SERVICE_ApplyJointEffort_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
#include "ros/time.h"
namespace gazebo_msgs
{
static const char APPLYJOINTEFFORT[] = "gazebo_msgs/ApplyJointEffort";
class ApplyJointEffortRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef double _effort_type;
_effort_type effort;
typedef ros::Time _start_time_type;
_start_time_type start_time;
typedef ros::Duration _duration_type;
_duration_type duration;
ApplyJointEffortRequest():
joint_name(""),
effort(0),
start_time(),
duration()
{
}
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_effort;
u_effort.real = this->effort;
*(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->effort);
*(outbuffer + offset + 0) = (this->start_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.sec);
*(outbuffer + offset + 0) = (this->start_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.nsec);
*(outbuffer + offset + 0) = (this->duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.sec);
*(outbuffer + offset + 0) = (this->duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.nsec);
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_effort;
u_effort.base = 0;
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->effort = u_effort.real;
offset += sizeof(this->effort);
this->start_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.sec);
this->start_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.nsec);
this->duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.sec);
this->duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.nsec);
return offset;
}
const char * getType(){ return APPLYJOINTEFFORT; };
const char * getMD5(){ return "2c3396ab9af67a509ecd2167a8fe41a2"; };
};
class ApplyJointEffortResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
ApplyJointEffortResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return APPLYJOINTEFFORT; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class ApplyJointEffort {
public:
typedef ApplyJointEffortRequest Request;
typedef ApplyJointEffortResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ContactState.h | #ifndef _ROS_gazebo_msgs_ContactState_h
#define _ROS_gazebo_msgs_ContactState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Wrench.h"
#include "geometry_msgs/Vector3.h"
namespace gazebo_msgs
{
class ContactState : public ros::Msg
{
public:
typedef const char* _info_type;
_info_type info;
typedef const char* _collision1_name_type;
_collision1_name_type collision1_name;
typedef const char* _collision2_name_type;
_collision2_name_type collision2_name;
uint32_t wrenches_length;
typedef geometry_msgs::Wrench _wrenches_type;
_wrenches_type st_wrenches;
_wrenches_type * wrenches;
typedef geometry_msgs::Wrench _total_wrench_type;
_total_wrench_type total_wrench;
uint32_t contact_positions_length;
typedef geometry_msgs::Vector3 _contact_positions_type;
_contact_positions_type st_contact_positions;
_contact_positions_type * contact_positions;
uint32_t contact_normals_length;
typedef geometry_msgs::Vector3 _contact_normals_type;
_contact_normals_type st_contact_normals;
_contact_normals_type * contact_normals;
uint32_t depths_length;
typedef double _depths_type;
_depths_type st_depths;
_depths_type * depths;
ContactState():
info(""),
collision1_name(""),
collision2_name(""),
wrenches_length(0), wrenches(NULL),
total_wrench(),
contact_positions_length(0), contact_positions(NULL),
contact_normals_length(0), contact_normals(NULL),
depths_length(0), depths(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_info = strlen(this->info);
varToArr(outbuffer + offset, length_info);
offset += 4;
memcpy(outbuffer + offset, this->info, length_info);
offset += length_info;
uint32_t length_collision1_name = strlen(this->collision1_name);
varToArr(outbuffer + offset, length_collision1_name);
offset += 4;
memcpy(outbuffer + offset, this->collision1_name, length_collision1_name);
offset += length_collision1_name;
uint32_t length_collision2_name = strlen(this->collision2_name);
varToArr(outbuffer + offset, length_collision2_name);
offset += 4;
memcpy(outbuffer + offset, this->collision2_name, length_collision2_name);
offset += length_collision2_name;
*(outbuffer + offset + 0) = (this->wrenches_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->wrenches_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->wrenches_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->wrenches_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->wrenches_length);
for( uint32_t i = 0; i < wrenches_length; i++){
offset += this->wrenches[i].serialize(outbuffer + offset);
}
offset += this->total_wrench.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->contact_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->contact_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->contact_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->contact_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->contact_positions_length);
for( uint32_t i = 0; i < contact_positions_length; i++){
offset += this->contact_positions[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->contact_normals_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->contact_normals_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->contact_normals_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->contact_normals_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->contact_normals_length);
for( uint32_t i = 0; i < contact_normals_length; i++){
offset += this->contact_normals[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->depths_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->depths_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->depths_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->depths_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->depths_length);
for( uint32_t i = 0; i < depths_length; i++){
union {
double real;
uint64_t base;
} u_depthsi;
u_depthsi.real = this->depths[i];
*(outbuffer + offset + 0) = (u_depthsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_depthsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_depthsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_depthsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_depthsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_depthsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_depthsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_depthsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->depths[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_info;
arrToVar(length_info, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_info; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_info-1]=0;
this->info = (char *)(inbuffer + offset-1);
offset += length_info;
uint32_t length_collision1_name;
arrToVar(length_collision1_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_collision1_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_collision1_name-1]=0;
this->collision1_name = (char *)(inbuffer + offset-1);
offset += length_collision1_name;
uint32_t length_collision2_name;
arrToVar(length_collision2_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_collision2_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_collision2_name-1]=0;
this->collision2_name = (char *)(inbuffer + offset-1);
offset += length_collision2_name;
uint32_t wrenches_lengthT = ((uint32_t) (*(inbuffer + offset)));
wrenches_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
wrenches_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
wrenches_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->wrenches_length);
if(wrenches_lengthT > wrenches_length)
this->wrenches = (geometry_msgs::Wrench*)realloc(this->wrenches, wrenches_lengthT * sizeof(geometry_msgs::Wrench));
wrenches_length = wrenches_lengthT;
for( uint32_t i = 0; i < wrenches_length; i++){
offset += this->st_wrenches.deserialize(inbuffer + offset);
memcpy( &(this->wrenches[i]), &(this->st_wrenches), sizeof(geometry_msgs::Wrench));
}
offset += this->total_wrench.deserialize(inbuffer + offset);
uint32_t contact_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
contact_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
contact_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
contact_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->contact_positions_length);
if(contact_positions_lengthT > contact_positions_length)
this->contact_positions = (geometry_msgs::Vector3*)realloc(this->contact_positions, contact_positions_lengthT * sizeof(geometry_msgs::Vector3));
contact_positions_length = contact_positions_lengthT;
for( uint32_t i = 0; i < contact_positions_length; i++){
offset += this->st_contact_positions.deserialize(inbuffer + offset);
memcpy( &(this->contact_positions[i]), &(this->st_contact_positions), sizeof(geometry_msgs::Vector3));
}
uint32_t contact_normals_lengthT = ((uint32_t) (*(inbuffer + offset)));
contact_normals_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
contact_normals_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
contact_normals_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->contact_normals_length);
if(contact_normals_lengthT > contact_normals_length)
this->contact_normals = (geometry_msgs::Vector3*)realloc(this->contact_normals, contact_normals_lengthT * sizeof(geometry_msgs::Vector3));
contact_normals_length = contact_normals_lengthT;
for( uint32_t i = 0; i < contact_normals_length; i++){
offset += this->st_contact_normals.deserialize(inbuffer + offset);
memcpy( &(this->contact_normals[i]), &(this->st_contact_normals), sizeof(geometry_msgs::Vector3));
}
uint32_t depths_lengthT = ((uint32_t) (*(inbuffer + offset)));
depths_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
depths_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
depths_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->depths_length);
if(depths_lengthT > depths_length)
this->depths = (double*)realloc(this->depths, depths_lengthT * sizeof(double));
depths_length = depths_lengthT;
for( uint32_t i = 0; i < depths_length; i++){
union {
double real;
uint64_t base;
} u_st_depths;
u_st_depths.base = 0;
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_depths = u_st_depths.real;
offset += sizeof(this->st_depths);
memcpy( &(this->depths[i]), &(this->st_depths), sizeof(double));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ContactState"; };
const char * getMD5(){ return "48c0ffb054b8c444f870cecea1ee50d9"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SpawnModel.h | #ifndef _ROS_SERVICE_SpawnModel_h
#define _ROS_SERVICE_SpawnModel_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char SPAWNMODEL[] = "gazebo_msgs/SpawnModel";
class SpawnModelRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef const char* _model_xml_type;
_model_xml_type model_xml;
typedef const char* _robot_namespace_type;
_robot_namespace_type robot_namespace;
typedef geometry_msgs::Pose _initial_pose_type;
_initial_pose_type initial_pose;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
SpawnModelRequest():
model_name(""),
model_xml(""),
robot_namespace(""),
initial_pose(),
reference_frame("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
uint32_t length_model_xml = strlen(this->model_xml);
varToArr(outbuffer + offset, length_model_xml);
offset += 4;
memcpy(outbuffer + offset, this->model_xml, length_model_xml);
offset += length_model_xml;
uint32_t length_robot_namespace = strlen(this->robot_namespace);
varToArr(outbuffer + offset, length_robot_namespace);
offset += 4;
memcpy(outbuffer + offset, this->robot_namespace, length_robot_namespace);
offset += length_robot_namespace;
offset += this->initial_pose.serialize(outbuffer + offset);
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
uint32_t length_model_xml;
arrToVar(length_model_xml, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_xml; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_xml-1]=0;
this->model_xml = (char *)(inbuffer + offset-1);
offset += length_model_xml;
uint32_t length_robot_namespace;
arrToVar(length_robot_namespace, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot_namespace; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot_namespace-1]=0;
this->robot_namespace = (char *)(inbuffer + offset-1);
offset += length_robot_namespace;
offset += this->initial_pose.deserialize(inbuffer + offset);
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return SPAWNMODEL; };
const char * getMD5(){ return "6d0eba5753761cd57e6263a056b79930"; };
};
class SpawnModelResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SpawnModelResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SPAWNMODEL; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SpawnModel {
public:
typedef SpawnModelRequest Request;
typedef SpawnModelResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/DeleteLight.h | #ifndef _ROS_SERVICE_DeleteLight_h
#define _ROS_SERVICE_DeleteLight_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char DELETELIGHT[] = "gazebo_msgs/DeleteLight";
class DeleteLightRequest : public ros::Msg
{
public:
typedef const char* _light_name_type;
_light_name_type light_name;
DeleteLightRequest():
light_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_light_name = strlen(this->light_name);
varToArr(outbuffer + offset, length_light_name);
offset += 4;
memcpy(outbuffer + offset, this->light_name, length_light_name);
offset += length_light_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_light_name;
arrToVar(length_light_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_light_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_light_name-1]=0;
this->light_name = (char *)(inbuffer + offset-1);
offset += length_light_name;
return offset;
}
const char * getType(){ return DELETELIGHT; };
const char * getMD5(){ return "4fb676dfb4741fc866365702a859441c"; };
};
class DeleteLightResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
DeleteLightResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return DELETELIGHT; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class DeleteLight {
public:
typedef DeleteLightRequest Request;
typedef DeleteLightResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/JointRequest.h | #ifndef _ROS_SERVICE_JointRequest_h
#define _ROS_SERVICE_JointRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char JOINTREQUEST[] = "gazebo_msgs/JointRequest";
class JointRequestRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
JointRequestRequest():
joint_name("")
{
}
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;
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;
return offset;
}
const char * getType(){ return JOINTREQUEST; };
const char * getMD5(){ return "0be1351618e1dc030eb7959d9a4902de"; };
};
class JointRequestResponse : public ros::Msg
{
public:
JointRequestResponse()
{
}
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 JOINTREQUEST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class JointRequest {
public:
typedef JointRequestRequest Request;
typedef JointRequestResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosgraph_msgs/TopicStatistics.h | #ifndef _ROS_rosgraph_msgs_TopicStatistics_h
#define _ROS_rosgraph_msgs_TopicStatistics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "ros/duration.h"
namespace rosgraph_msgs
{
class TopicStatistics : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
typedef const char* _node_pub_type;
_node_pub_type node_pub;
typedef const char* _node_sub_type;
_node_sub_type node_sub;
typedef ros::Time _window_start_type;
_window_start_type window_start;
typedef ros::Time _window_stop_type;
_window_stop_type window_stop;
typedef int32_t _delivered_msgs_type;
_delivered_msgs_type delivered_msgs;
typedef int32_t _dropped_msgs_type;
_dropped_msgs_type dropped_msgs;
typedef int32_t _traffic_type;
_traffic_type traffic;
typedef ros::Duration _period_mean_type;
_period_mean_type period_mean;
typedef ros::Duration _period_stddev_type;
_period_stddev_type period_stddev;
typedef ros::Duration _period_max_type;
_period_max_type period_max;
typedef ros::Duration _stamp_age_mean_type;
_stamp_age_mean_type stamp_age_mean;
typedef ros::Duration _stamp_age_stddev_type;
_stamp_age_stddev_type stamp_age_stddev;
typedef ros::Duration _stamp_age_max_type;
_stamp_age_max_type stamp_age_max;
TopicStatistics():
topic(""),
node_pub(""),
node_sub(""),
window_start(),
window_stop(),
delivered_msgs(0),
dropped_msgs(0),
traffic(0),
period_mean(),
period_stddev(),
period_max(),
stamp_age_mean(),
stamp_age_stddev(),
stamp_age_max()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
uint32_t length_node_pub = strlen(this->node_pub);
varToArr(outbuffer + offset, length_node_pub);
offset += 4;
memcpy(outbuffer + offset, this->node_pub, length_node_pub);
offset += length_node_pub;
uint32_t length_node_sub = strlen(this->node_sub);
varToArr(outbuffer + offset, length_node_sub);
offset += 4;
memcpy(outbuffer + offset, this->node_sub, length_node_sub);
offset += length_node_sub;
*(outbuffer + offset + 0) = (this->window_start.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_start.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_start.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_start.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_start.sec);
*(outbuffer + offset + 0) = (this->window_start.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_start.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_start.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_start.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_start.nsec);
*(outbuffer + offset + 0) = (this->window_stop.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_stop.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_stop.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_stop.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_stop.sec);
*(outbuffer + offset + 0) = (this->window_stop.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_stop.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_stop.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_stop.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_stop.nsec);
union {
int32_t real;
uint32_t base;
} u_delivered_msgs;
u_delivered_msgs.real = this->delivered_msgs;
*(outbuffer + offset + 0) = (u_delivered_msgs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_delivered_msgs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_delivered_msgs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_delivered_msgs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->delivered_msgs);
union {
int32_t real;
uint32_t base;
} u_dropped_msgs;
u_dropped_msgs.real = this->dropped_msgs;
*(outbuffer + offset + 0) = (u_dropped_msgs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dropped_msgs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dropped_msgs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dropped_msgs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->dropped_msgs);
union {
int32_t real;
uint32_t base;
} u_traffic;
u_traffic.real = this->traffic;
*(outbuffer + offset + 0) = (u_traffic.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_traffic.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_traffic.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_traffic.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->traffic);
*(outbuffer + offset + 0) = (this->period_mean.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_mean.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_mean.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_mean.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_mean.sec);
*(outbuffer + offset + 0) = (this->period_mean.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_mean.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_mean.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_mean.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_mean.nsec);
*(outbuffer + offset + 0) = (this->period_stddev.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_stddev.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_stddev.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_stddev.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_stddev.sec);
*(outbuffer + offset + 0) = (this->period_stddev.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_stddev.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_stddev.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_stddev.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_stddev.nsec);
*(outbuffer + offset + 0) = (this->period_max.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_max.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_max.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_max.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_max.sec);
*(outbuffer + offset + 0) = (this->period_max.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_max.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_max.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_max.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_max.nsec);
*(outbuffer + offset + 0) = (this->stamp_age_mean.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_mean.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_mean.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_mean.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_mean.sec);
*(outbuffer + offset + 0) = (this->stamp_age_mean.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_mean.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_mean.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_mean.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_mean.nsec);
*(outbuffer + offset + 0) = (this->stamp_age_stddev.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_stddev.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_stddev.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_stddev.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_stddev.sec);
*(outbuffer + offset + 0) = (this->stamp_age_stddev.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_stddev.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_stddev.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_stddev.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_stddev.nsec);
*(outbuffer + offset + 0) = (this->stamp_age_max.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_max.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_max.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_max.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_max.sec);
*(outbuffer + offset + 0) = (this->stamp_age_max.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_max.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_max.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_max.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_max.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
uint32_t length_node_pub;
arrToVar(length_node_pub, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_node_pub; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_node_pub-1]=0;
this->node_pub = (char *)(inbuffer + offset-1);
offset += length_node_pub;
uint32_t length_node_sub;
arrToVar(length_node_sub, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_node_sub; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_node_sub-1]=0;
this->node_sub = (char *)(inbuffer + offset-1);
offset += length_node_sub;
this->window_start.sec = ((uint32_t) (*(inbuffer + offset)));
this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_start.sec);
this->window_start.nsec = ((uint32_t) (*(inbuffer + offset)));
this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_start.nsec);
this->window_stop.sec = ((uint32_t) (*(inbuffer + offset)));
this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_stop.sec);
this->window_stop.nsec = ((uint32_t) (*(inbuffer + offset)));
this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_stop.nsec);
union {
int32_t real;
uint32_t base;
} u_delivered_msgs;
u_delivered_msgs.base = 0;
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->delivered_msgs = u_delivered_msgs.real;
offset += sizeof(this->delivered_msgs);
union {
int32_t real;
uint32_t base;
} u_dropped_msgs;
u_dropped_msgs.base = 0;
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->dropped_msgs = u_dropped_msgs.real;
offset += sizeof(this->dropped_msgs);
union {
int32_t real;
uint32_t base;
} u_traffic;
u_traffic.base = 0;
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->traffic = u_traffic.real;
offset += sizeof(this->traffic);
this->period_mean.sec = ((uint32_t) (*(inbuffer + offset)));
this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_mean.sec);
this->period_mean.nsec = ((uint32_t) (*(inbuffer + offset)));
this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_mean.nsec);
this->period_stddev.sec = ((uint32_t) (*(inbuffer + offset)));
this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_stddev.sec);
this->period_stddev.nsec = ((uint32_t) (*(inbuffer + offset)));
this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_stddev.nsec);
this->period_max.sec = ((uint32_t) (*(inbuffer + offset)));
this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_max.sec);
this->period_max.nsec = ((uint32_t) (*(inbuffer + offset)));
this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_max.nsec);
this->stamp_age_mean.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_mean.sec);
this->stamp_age_mean.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_mean.nsec);
this->stamp_age_stddev.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_stddev.sec);
this->stamp_age_stddev.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_stddev.nsec);
this->stamp_age_max.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_max.sec);
this->stamp_age_max.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_max.nsec);
return offset;
}
const char * getType(){ return "rosgraph_msgs/TopicStatistics"; };
const char * getMD5(){ return "10152ed868c5097a5e2e4a89d7daa710"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosgraph_msgs/Log.h | #ifndef _ROS_rosgraph_msgs_Log_h
#define _ROS_rosgraph_msgs_Log_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace rosgraph_msgs
{
class Log : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef int8_t _level_type;
_level_type level;
typedef const char* _name_type;
_name_type name;
typedef const char* _msg_type;
_msg_type msg;
typedef const char* _file_type;
_file_type file;
typedef const char* _function_type;
_function_type function;
typedef uint32_t _line_type;
_line_type line;
uint32_t topics_length;
typedef char* _topics_type;
_topics_type st_topics;
_topics_type * topics;
enum { DEBUG = 1 };
enum { INFO = 2 };
enum { WARN = 4 };
enum { ERROR = 8 };
enum { FATAL = 16 };
Log():
header(),
level(0),
name(""),
msg(""),
file(""),
function(""),
line(0),
topics_length(0), topics(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
int8_t real;
uint8_t base;
} u_level;
u_level.real = this->level;
*(outbuffer + offset + 0) = (u_level.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
uint32_t length_file = strlen(this->file);
varToArr(outbuffer + offset, length_file);
offset += 4;
memcpy(outbuffer + offset, this->file, length_file);
offset += length_file;
uint32_t length_function = strlen(this->function);
varToArr(outbuffer + offset, length_function);
offset += 4;
memcpy(outbuffer + offset, this->function, length_function);
offset += length_function;
*(outbuffer + offset + 0) = (this->line >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->line >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->line >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->line >> (8 * 3)) & 0xFF;
offset += sizeof(this->line);
*(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->topics_length);
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_topicsi = strlen(this->topics[i]);
varToArr(outbuffer + offset, length_topicsi);
offset += 4;
memcpy(outbuffer + offset, this->topics[i], length_topicsi);
offset += length_topicsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
int8_t real;
uint8_t base;
} u_level;
u_level.base = 0;
u_level.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->level = u_level.real;
offset += sizeof(this->level);
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_msg;
arrToVar(length_msg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_msg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_msg-1]=0;
this->msg = (char *)(inbuffer + offset-1);
offset += length_msg;
uint32_t length_file;
arrToVar(length_file, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_file; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_file-1]=0;
this->file = (char *)(inbuffer + offset-1);
offset += length_file;
uint32_t length_function;
arrToVar(length_function, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_function; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_function-1]=0;
this->function = (char *)(inbuffer + offset-1);
offset += length_function;
this->line = ((uint32_t) (*(inbuffer + offset)));
this->line |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->line |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->line |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->line);
uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->topics_length);
if(topics_lengthT > topics_length)
this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
topics_length = topics_lengthT;
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_st_topics;
arrToVar(length_st_topics, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_topics; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_topics-1]=0;
this->st_topics = (char *)(inbuffer + offset-1);
offset += length_st_topics;
memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
}
return offset;
}
const char * getType(){ return "rosgraph_msgs/Log"; };
const char * getMD5(){ return "acffd30cd6b6de30f120938c17c593fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosgraph_msgs/Clock.h | #ifndef _ROS_rosgraph_msgs_Clock_h
#define _ROS_rosgraph_msgs_Clock_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace rosgraph_msgs
{
class Clock : public ros::Msg
{
public:
typedef ros::Time _clock_type;
_clock_type clock;
Clock():
clock()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->clock.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->clock.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->clock.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->clock.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->clock.sec);
*(outbuffer + offset + 0) = (this->clock.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->clock.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->clock.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->clock.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->clock.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->clock.sec = ((uint32_t) (*(inbuffer + offset)));
this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->clock.sec);
this->clock.nsec = ((uint32_t) (*(inbuffer + offset)));
this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->clock.nsec);
return offset;
}
const char * getType(){ return "rosgraph_msgs/Clock"; };
const char * getMD5(){ return "a9c97c1d230cfc112e270351a944ee47"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerInit.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerInit_h
#define _ROS_visualization_msgs_InteractiveMarkerInit_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "visualization_msgs/InteractiveMarker.h"
namespace visualization_msgs
{
class InteractiveMarkerInit : public ros::Msg
{
public:
typedef const char* _server_id_type;
_server_id_type server_id;
typedef uint64_t _seq_num_type;
_seq_num_type seq_num;
uint32_t markers_length;
typedef visualization_msgs::InteractiveMarker _markers_type;
_markers_type st_markers;
_markers_type * markers;
InteractiveMarkerInit():
server_id(""),
seq_num(0),
markers_length(0), markers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_server_id = strlen(this->server_id);
varToArr(outbuffer + offset, length_server_id);
offset += 4;
memcpy(outbuffer + offset, this->server_id, length_server_id);
offset += length_server_id;
*(outbuffer + offset + 0) = (this->seq_num >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->seq_num >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->seq_num >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->seq_num >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (this->seq_num >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (this->seq_num >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (this->seq_num >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (this->seq_num >> (8 * 7)) & 0xFF;
offset += sizeof(this->seq_num);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_server_id;
arrToVar(length_server_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_server_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_server_id-1]=0;
this->server_id = (char *)(inbuffer + offset-1);
offset += length_server_id;
this->seq_num = ((uint64_t) (*(inbuffer + offset)));
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
offset += sizeof(this->seq_num);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::InteractiveMarker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::InteractiveMarker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::InteractiveMarker));
}
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerInit"; };
const char * getMD5(){ return "d5f2c5045a72456d228676ab91048734"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/Marker.h | #ifndef _ROS_visualization_msgs_Marker_h
#define _ROS_visualization_msgs_Marker_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Vector3.h"
#include "std_msgs/ColorRGBA.h"
#include "ros/duration.h"
#include "geometry_msgs/Point.h"
namespace visualization_msgs
{
class Marker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _ns_type;
_ns_type ns;
typedef int32_t _id_type;
_id_type id;
typedef int32_t _type_type;
_type_type type;
typedef int32_t _action_type;
_action_type action;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Vector3 _scale_type;
_scale_type scale;
typedef std_msgs::ColorRGBA _color_type;
_color_type color;
typedef ros::Duration _lifetime_type;
_lifetime_type lifetime;
typedef bool _frame_locked_type;
_frame_locked_type frame_locked;
uint32_t points_length;
typedef geometry_msgs::Point _points_type;
_points_type st_points;
_points_type * points;
uint32_t colors_length;
typedef std_msgs::ColorRGBA _colors_type;
_colors_type st_colors;
_colors_type * colors;
typedef const char* _text_type;
_text_type text;
typedef const char* _mesh_resource_type;
_mesh_resource_type mesh_resource;
typedef bool _mesh_use_embedded_materials_type;
_mesh_use_embedded_materials_type mesh_use_embedded_materials;
enum { ARROW = 0 };
enum { CUBE = 1 };
enum { SPHERE = 2 };
enum { CYLINDER = 3 };
enum { LINE_STRIP = 4 };
enum { LINE_LIST = 5 };
enum { CUBE_LIST = 6 };
enum { SPHERE_LIST = 7 };
enum { POINTS = 8 };
enum { TEXT_VIEW_FACING = 9 };
enum { MESH_RESOURCE = 10 };
enum { TRIANGLE_LIST = 11 };
enum { ADD = 0 };
enum { MODIFY = 0 };
enum { DELETE = 2 };
enum { DELETEALL = 3 };
Marker():
header(),
ns(""),
id(0),
type(0),
action(0),
pose(),
scale(),
color(),
lifetime(),
frame_locked(0),
points_length(0), points(NULL),
colors_length(0), colors(NULL),
text(""),
mesh_resource(""),
mesh_use_embedded_materials(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_ns = strlen(this->ns);
varToArr(outbuffer + offset, length_ns);
offset += 4;
memcpy(outbuffer + offset, this->ns, length_ns);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.real = this->type;
*(outbuffer + offset + 0) = (u_type.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_type.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_type.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_type.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.real = this->action;
*(outbuffer + offset + 0) = (u_action.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_action.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_action.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_action.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->action);
offset += this->pose.serialize(outbuffer + offset);
offset += this->scale.serialize(outbuffer + offset);
offset += this->color.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->lifetime.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.sec);
*(outbuffer + offset + 0) = (this->lifetime.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.nsec);
union {
bool real;
uint8_t base;
} u_frame_locked;
u_frame_locked.real = this->frame_locked;
*(outbuffer + offset + 0) = (u_frame_locked.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->frame_locked);
*(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->points_length);
for( uint32_t i = 0; i < points_length; i++){
offset += this->points[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->colors_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->colors_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->colors_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->colors_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->colors_length);
for( uint32_t i = 0; i < colors_length; i++){
offset += this->colors[i].serialize(outbuffer + offset);
}
uint32_t length_text = strlen(this->text);
varToArr(outbuffer + offset, length_text);
offset += 4;
memcpy(outbuffer + offset, this->text, length_text);
offset += length_text;
uint32_t length_mesh_resource = strlen(this->mesh_resource);
varToArr(outbuffer + offset, length_mesh_resource);
offset += 4;
memcpy(outbuffer + offset, this->mesh_resource, length_mesh_resource);
offset += length_mesh_resource;
union {
bool real;
uint8_t base;
} u_mesh_use_embedded_materials;
u_mesh_use_embedded_materials.real = this->mesh_use_embedded_materials;
*(outbuffer + offset + 0) = (u_mesh_use_embedded_materials.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->mesh_use_embedded_materials);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_ns;
arrToVar(length_ns, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_ns; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_ns-1]=0;
this->ns = (char *)(inbuffer + offset-1);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.base = 0;
u_type.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->type = u_type.real;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.base = 0;
u_action.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->action = u_action.real;
offset += sizeof(this->action);
offset += this->pose.deserialize(inbuffer + offset);
offset += this->scale.deserialize(inbuffer + offset);
offset += this->color.deserialize(inbuffer + offset);
this->lifetime.sec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.sec);
this->lifetime.nsec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.nsec);
union {
bool real;
uint8_t base;
} u_frame_locked;
u_frame_locked.base = 0;
u_frame_locked.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->frame_locked = u_frame_locked.real;
offset += sizeof(this->frame_locked);
uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->points_length);
if(points_lengthT > points_length)
this->points = (geometry_msgs::Point*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point));
points_length = points_lengthT;
for( uint32_t i = 0; i < points_length; i++){
offset += this->st_points.deserialize(inbuffer + offset);
memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point));
}
uint32_t colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->colors_length);
if(colors_lengthT > colors_length)
this->colors = (std_msgs::ColorRGBA*)realloc(this->colors, colors_lengthT * sizeof(std_msgs::ColorRGBA));
colors_length = colors_lengthT;
for( uint32_t i = 0; i < colors_length; i++){
offset += this->st_colors.deserialize(inbuffer + offset);
memcpy( &(this->colors[i]), &(this->st_colors), sizeof(std_msgs::ColorRGBA));
}
uint32_t length_text;
arrToVar(length_text, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_text; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_text-1]=0;
this->text = (char *)(inbuffer + offset-1);
offset += length_text;
uint32_t length_mesh_resource;
arrToVar(length_mesh_resource, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_mesh_resource; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_mesh_resource-1]=0;
this->mesh_resource = (char *)(inbuffer + offset-1);
offset += length_mesh_resource;
union {
bool real;
uint8_t base;
} u_mesh_use_embedded_materials;
u_mesh_use_embedded_materials.base = 0;
u_mesh_use_embedded_materials.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->mesh_use_embedded_materials = u_mesh_use_embedded_materials.real;
offset += sizeof(this->mesh_use_embedded_materials);
return offset;
}
const char * getType(){ return "visualization_msgs/Marker"; };
const char * getMD5(){ return "4048c9de2a16f4ae8e0538085ebf1b97"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/MarkerArray.h | #ifndef _ROS_visualization_msgs_MarkerArray_h
#define _ROS_visualization_msgs_MarkerArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "visualization_msgs/Marker.h"
namespace visualization_msgs
{
class MarkerArray : public ros::Msg
{
public:
uint32_t markers_length;
typedef visualization_msgs::Marker _markers_type;
_markers_type st_markers;
_markers_type * markers;
MarkerArray():
markers_length(0), markers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::Marker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::Marker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::Marker));
}
return offset;
}
const char * getType(){ return "visualization_msgs/MarkerArray"; };
const char * getMD5(){ return "d155b9ce5188fbaf89745847fd5882d7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerUpdate.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerUpdate_h
#define _ROS_visualization_msgs_InteractiveMarkerUpdate_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "visualization_msgs/InteractiveMarker.h"
#include "visualization_msgs/InteractiveMarkerPose.h"
namespace visualization_msgs
{
class InteractiveMarkerUpdate : public ros::Msg
{
public:
typedef const char* _server_id_type;
_server_id_type server_id;
typedef uint64_t _seq_num_type;
_seq_num_type seq_num;
typedef uint8_t _type_type;
_type_type type;
uint32_t markers_length;
typedef visualization_msgs::InteractiveMarker _markers_type;
_markers_type st_markers;
_markers_type * markers;
uint32_t poses_length;
typedef visualization_msgs::InteractiveMarkerPose _poses_type;
_poses_type st_poses;
_poses_type * poses;
uint32_t erases_length;
typedef char* _erases_type;
_erases_type st_erases;
_erases_type * erases;
enum { KEEP_ALIVE = 0 };
enum { UPDATE = 1 };
InteractiveMarkerUpdate():
server_id(""),
seq_num(0),
type(0),
markers_length(0), markers(NULL),
poses_length(0), poses(NULL),
erases_length(0), erases(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_server_id = strlen(this->server_id);
varToArr(outbuffer + offset, length_server_id);
offset += 4;
memcpy(outbuffer + offset, this->server_id, length_server_id);
offset += length_server_id;
*(outbuffer + offset + 0) = (this->seq_num >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->seq_num >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->seq_num >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->seq_num >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (this->seq_num >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (this->seq_num >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (this->seq_num >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (this->seq_num >> (8 * 7)) & 0xFF;
offset += sizeof(this->seq_num);
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
offset += sizeof(this->type);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->poses_length);
for( uint32_t i = 0; i < poses_length; i++){
offset += this->poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->erases_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->erases_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->erases_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->erases_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->erases_length);
for( uint32_t i = 0; i < erases_length; i++){
uint32_t length_erasesi = strlen(this->erases[i]);
varToArr(outbuffer + offset, length_erasesi);
offset += 4;
memcpy(outbuffer + offset, this->erases[i], length_erasesi);
offset += length_erasesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_server_id;
arrToVar(length_server_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_server_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_server_id-1]=0;
this->server_id = (char *)(inbuffer + offset-1);
offset += length_server_id;
this->seq_num = ((uint64_t) (*(inbuffer + offset)));
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
offset += sizeof(this->seq_num);
this->type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->type);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::InteractiveMarker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::InteractiveMarker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::InteractiveMarker));
}
uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->poses_length);
if(poses_lengthT > poses_length)
this->poses = (visualization_msgs::InteractiveMarkerPose*)realloc(this->poses, poses_lengthT * sizeof(visualization_msgs::InteractiveMarkerPose));
poses_length = poses_lengthT;
for( uint32_t i = 0; i < poses_length; i++){
offset += this->st_poses.deserialize(inbuffer + offset);
memcpy( &(this->poses[i]), &(this->st_poses), sizeof(visualization_msgs::InteractiveMarkerPose));
}
uint32_t erases_lengthT = ((uint32_t) (*(inbuffer + offset)));
erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->erases_length);
if(erases_lengthT > erases_length)
this->erases = (char**)realloc(this->erases, erases_lengthT * sizeof(char*));
erases_length = erases_lengthT;
for( uint32_t i = 0; i < erases_length; i++){
uint32_t length_st_erases;
arrToVar(length_st_erases, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_erases; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_erases-1]=0;
this->st_erases = (char *)(inbuffer + offset-1);
offset += length_st_erases;
memcpy( &(this->erases[i]), &(this->st_erases), sizeof(char*));
}
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerUpdate"; };
const char * getMD5(){ return "710d308d0a9276d65945e92dd30b3946"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/MenuEntry.h | #ifndef _ROS_visualization_msgs_MenuEntry_h
#define _ROS_visualization_msgs_MenuEntry_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace visualization_msgs
{
class MenuEntry : public ros::Msg
{
public:
typedef uint32_t _id_type;
_id_type id;
typedef uint32_t _parent_id_type;
_parent_id_type parent_id;
typedef const char* _title_type;
_title_type title;
typedef const char* _command_type;
_command_type command;
typedef uint8_t _command_type_type;
_command_type_type command_type;
enum { FEEDBACK = 0 };
enum { ROSRUN = 1 };
enum { ROSLAUNCH = 2 };
MenuEntry():
id(0),
parent_id(0),
title(""),
command(""),
command_type(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
*(outbuffer + offset + 0) = (this->parent_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parent_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parent_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parent_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->parent_id);
uint32_t length_title = strlen(this->title);
varToArr(outbuffer + offset, length_title);
offset += 4;
memcpy(outbuffer + offset, this->title, length_title);
offset += length_title;
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
*(outbuffer + offset + 0) = (this->command_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->command_type);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
this->parent_id = ((uint32_t) (*(inbuffer + offset)));
this->parent_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->parent_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->parent_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parent_id);
uint32_t length_title;
arrToVar(length_title, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_title; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_title-1]=0;
this->title = (char *)(inbuffer + offset-1);
offset += length_title;
uint32_t length_command;
arrToVar(length_command, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command-1]=0;
this->command = (char *)(inbuffer + offset-1);
offset += length_command;
this->command_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->command_type);
return offset;
}
const char * getType(){ return "visualization_msgs/MenuEntry"; };
const char * getMD5(){ return "b90ec63024573de83b57aa93eb39be2d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerPose.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerPose_h
#define _ROS_visualization_msgs_InteractiveMarkerPose_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
namespace visualization_msgs
{
class InteractiveMarkerPose : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef const char* _name_type;
_name_type name;
InteractiveMarkerPose():
header(),
pose(),
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerPose"; };
const char * getMD5(){ return "a6e6833209a196a38d798dadb02c81f8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerControl.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerControl_h
#define _ROS_visualization_msgs_InteractiveMarkerControl_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Quaternion.h"
#include "visualization_msgs/Marker.h"
namespace visualization_msgs
{
class InteractiveMarkerControl : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef geometry_msgs::Quaternion _orientation_type;
_orientation_type orientation;
typedef uint8_t _orientation_mode_type;
_orientation_mode_type orientation_mode;
typedef uint8_t _interaction_mode_type;
_interaction_mode_type interaction_mode;
typedef bool _always_visible_type;
_always_visible_type always_visible;
uint32_t markers_length;
typedef visualization_msgs::Marker _markers_type;
_markers_type st_markers;
_markers_type * markers;
typedef bool _independent_marker_orientation_type;
_independent_marker_orientation_type independent_marker_orientation;
typedef const char* _description_type;
_description_type description;
enum { INHERIT = 0 };
enum { FIXED = 1 };
enum { VIEW_FACING = 2 };
enum { NONE = 0 };
enum { MENU = 1 };
enum { BUTTON = 2 };
enum { MOVE_AXIS = 3 };
enum { MOVE_PLANE = 4 };
enum { ROTATE_AXIS = 5 };
enum { MOVE_ROTATE = 6 };
enum { MOVE_3D = 7 };
enum { ROTATE_3D = 8 };
enum { MOVE_ROTATE_3D = 9 };
InteractiveMarkerControl():
name(""),
orientation(),
orientation_mode(0),
interaction_mode(0),
always_visible(0),
markers_length(0), markers(NULL),
independent_marker_orientation(0),
description("")
{
}
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->orientation.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->orientation_mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->orientation_mode);
*(outbuffer + offset + 0) = (this->interaction_mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->interaction_mode);
union {
bool real;
uint8_t base;
} u_always_visible;
u_always_visible.real = this->always_visible;
*(outbuffer + offset + 0) = (u_always_visible.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->always_visible);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
union {
bool real;
uint8_t base;
} u_independent_marker_orientation;
u_independent_marker_orientation.real = this->independent_marker_orientation;
*(outbuffer + offset + 0) = (u_independent_marker_orientation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->independent_marker_orientation);
uint32_t length_description = strlen(this->description);
varToArr(outbuffer + offset, length_description);
offset += 4;
memcpy(outbuffer + offset, this->description, length_description);
offset += length_description;
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->orientation.deserialize(inbuffer + offset);
this->orientation_mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->orientation_mode);
this->interaction_mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->interaction_mode);
union {
bool real;
uint8_t base;
} u_always_visible;
u_always_visible.base = 0;
u_always_visible.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->always_visible = u_always_visible.real;
offset += sizeof(this->always_visible);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::Marker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::Marker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::Marker));
}
union {
bool real;
uint8_t base;
} u_independent_marker_orientation;
u_independent_marker_orientation.base = 0;
u_independent_marker_orientation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->independent_marker_orientation = u_independent_marker_orientation.real;
offset += sizeof(this->independent_marker_orientation);
uint32_t length_description;
arrToVar(length_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_description-1]=0;
this->description = (char *)(inbuffer + offset-1);
offset += length_description;
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerControl"; };
const char * getMD5(){ return "b3c81e785788195d1840b86c28da1aac"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/ImageMarker.h | #ifndef _ROS_visualization_msgs_ImageMarker_h
#define _ROS_visualization_msgs_ImageMarker_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 "std_msgs/ColorRGBA.h"
#include "ros/duration.h"
namespace visualization_msgs
{
class ImageMarker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _ns_type;
_ns_type ns;
typedef int32_t _id_type;
_id_type id;
typedef int32_t _type_type;
_type_type type;
typedef int32_t _action_type;
_action_type action;
typedef geometry_msgs::Point _position_type;
_position_type position;
typedef float _scale_type;
_scale_type scale;
typedef std_msgs::ColorRGBA _outline_color_type;
_outline_color_type outline_color;
typedef uint8_t _filled_type;
_filled_type filled;
typedef std_msgs::ColorRGBA _fill_color_type;
_fill_color_type fill_color;
typedef ros::Duration _lifetime_type;
_lifetime_type lifetime;
uint32_t points_length;
typedef geometry_msgs::Point _points_type;
_points_type st_points;
_points_type * points;
uint32_t outline_colors_length;
typedef std_msgs::ColorRGBA _outline_colors_type;
_outline_colors_type st_outline_colors;
_outline_colors_type * outline_colors;
enum { CIRCLE = 0 };
enum { LINE_STRIP = 1 };
enum { LINE_LIST = 2 };
enum { POLYGON = 3 };
enum { POINTS = 4 };
enum { ADD = 0 };
enum { REMOVE = 1 };
ImageMarker():
header(),
ns(""),
id(0),
type(0),
action(0),
position(),
scale(0),
outline_color(),
filled(0),
fill_color(),
lifetime(),
points_length(0), points(NULL),
outline_colors_length(0), outline_colors(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_ns = strlen(this->ns);
varToArr(outbuffer + offset, length_ns);
offset += 4;
memcpy(outbuffer + offset, this->ns, length_ns);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.real = this->type;
*(outbuffer + offset + 0) = (u_type.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_type.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_type.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_type.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.real = this->action;
*(outbuffer + offset + 0) = (u_action.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_action.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_action.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_action.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->action);
offset += this->position.serialize(outbuffer + offset);
union {
float real;
uint32_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;
offset += sizeof(this->scale);
offset += this->outline_color.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->filled >> (8 * 0)) & 0xFF;
offset += sizeof(this->filled);
offset += this->fill_color.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->lifetime.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.sec);
*(outbuffer + offset + 0) = (this->lifetime.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.nsec);
*(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->points_length);
for( uint32_t i = 0; i < points_length; i++){
offset += this->points[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->outline_colors_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outline_colors_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outline_colors_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outline_colors_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outline_colors_length);
for( uint32_t i = 0; i < outline_colors_length; i++){
offset += this->outline_colors[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_ns;
arrToVar(length_ns, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_ns; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_ns-1]=0;
this->ns = (char *)(inbuffer + offset-1);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.base = 0;
u_type.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->type = u_type.real;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.base = 0;
u_action.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->action = u_action.real;
offset += sizeof(this->action);
offset += this->position.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_scale;
u_scale.base = 0;
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->scale = u_scale.real;
offset += sizeof(this->scale);
offset += this->outline_color.deserialize(inbuffer + offset);
this->filled = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->filled);
offset += this->fill_color.deserialize(inbuffer + offset);
this->lifetime.sec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.sec);
this->lifetime.nsec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.nsec);
uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->points_length);
if(points_lengthT > points_length)
this->points = (geometry_msgs::Point*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point));
points_length = points_lengthT;
for( uint32_t i = 0; i < points_length; i++){
offset += this->st_points.deserialize(inbuffer + offset);
memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point));
}
uint32_t outline_colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outline_colors_length);
if(outline_colors_lengthT > outline_colors_length)
this->outline_colors = (std_msgs::ColorRGBA*)realloc(this->outline_colors, outline_colors_lengthT * sizeof(std_msgs::ColorRGBA));
outline_colors_length = outline_colors_lengthT;
for( uint32_t i = 0; i < outline_colors_length; i++){
offset += this->st_outline_colors.deserialize(inbuffer + offset);
memcpy( &(this->outline_colors[i]), &(this->st_outline_colors), sizeof(std_msgs::ColorRGBA));
}
return offset;
}
const char * getType(){ return "visualization_msgs/ImageMarker"; };
const char * getMD5(){ return "1de93c67ec8858b831025a08fbf1b35c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerFeedback.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerFeedback_h
#define _ROS_visualization_msgs_InteractiveMarkerFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Point.h"
namespace visualization_msgs
{
class InteractiveMarkerFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _client_id_type;
_client_id_type client_id;
typedef const char* _marker_name_type;
_marker_name_type marker_name;
typedef const char* _control_name_type;
_control_name_type control_name;
typedef uint8_t _event_type_type;
_event_type_type event_type;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef uint32_t _menu_entry_id_type;
_menu_entry_id_type menu_entry_id;
typedef geometry_msgs::Point _mouse_point_type;
_mouse_point_type mouse_point;
typedef bool _mouse_point_valid_type;
_mouse_point_valid_type mouse_point_valid;
enum { KEEP_ALIVE = 0 };
enum { POSE_UPDATE = 1 };
enum { MENU_SELECT = 2 };
enum { BUTTON_CLICK = 3 };
enum { MOUSE_DOWN = 4 };
enum { MOUSE_UP = 5 };
InteractiveMarkerFeedback():
header(),
client_id(""),
marker_name(""),
control_name(""),
event_type(0),
pose(),
menu_entry_id(0),
mouse_point(),
mouse_point_valid(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_client_id = strlen(this->client_id);
varToArr(outbuffer + offset, length_client_id);
offset += 4;
memcpy(outbuffer + offset, this->client_id, length_client_id);
offset += length_client_id;
uint32_t length_marker_name = strlen(this->marker_name);
varToArr(outbuffer + offset, length_marker_name);
offset += 4;
memcpy(outbuffer + offset, this->marker_name, length_marker_name);
offset += length_marker_name;
uint32_t length_control_name = strlen(this->control_name);
varToArr(outbuffer + offset, length_control_name);
offset += 4;
memcpy(outbuffer + offset, this->control_name, length_control_name);
offset += length_control_name;
*(outbuffer + offset + 0) = (this->event_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->event_type);
offset += this->pose.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->menu_entry_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->menu_entry_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->menu_entry_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->menu_entry_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->menu_entry_id);
offset += this->mouse_point.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_mouse_point_valid;
u_mouse_point_valid.real = this->mouse_point_valid;
*(outbuffer + offset + 0) = (u_mouse_point_valid.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->mouse_point_valid);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_client_id;
arrToVar(length_client_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_client_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_client_id-1]=0;
this->client_id = (char *)(inbuffer + offset-1);
offset += length_client_id;
uint32_t length_marker_name;
arrToVar(length_marker_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_marker_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_marker_name-1]=0;
this->marker_name = (char *)(inbuffer + offset-1);
offset += length_marker_name;
uint32_t length_control_name;
arrToVar(length_control_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_control_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_control_name-1]=0;
this->control_name = (char *)(inbuffer + offset-1);
offset += length_control_name;
this->event_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->event_type);
offset += this->pose.deserialize(inbuffer + offset);
this->menu_entry_id = ((uint32_t) (*(inbuffer + offset)));
this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->menu_entry_id);
offset += this->mouse_point.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_mouse_point_valid;
u_mouse_point_valid.base = 0;
u_mouse_point_valid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->mouse_point_valid = u_mouse_point_valid.real;
offset += sizeof(this->mouse_point_valid);
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerFeedback"; };
const char * getMD5(){ return "ab0f1eee058667e28c19ff3ffc3f4b78"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarker.h | #ifndef _ROS_visualization_msgs_InteractiveMarker_h
#define _ROS_visualization_msgs_InteractiveMarker_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "visualization_msgs/MenuEntry.h"
#include "visualization_msgs/InteractiveMarkerControl.h"
namespace visualization_msgs
{
class InteractiveMarker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef const char* _name_type;
_name_type name;
typedef const char* _description_type;
_description_type description;
typedef float _scale_type;
_scale_type scale;
uint32_t menu_entries_length;
typedef visualization_msgs::MenuEntry _menu_entries_type;
_menu_entries_type st_menu_entries;
_menu_entries_type * menu_entries;
uint32_t controls_length;
typedef visualization_msgs::InteractiveMarkerControl _controls_type;
_controls_type st_controls;
_controls_type * controls;
InteractiveMarker():
header(),
pose(),
name(""),
description(""),
scale(0),
menu_entries_length(0), menu_entries(NULL),
controls_length(0), controls(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
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_description = strlen(this->description);
varToArr(outbuffer + offset, length_description);
offset += 4;
memcpy(outbuffer + offset, this->description, length_description);
offset += length_description;
union {
float real;
uint32_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;
offset += sizeof(this->scale);
*(outbuffer + offset + 0) = (this->menu_entries_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->menu_entries_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->menu_entries_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->menu_entries_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->menu_entries_length);
for( uint32_t i = 0; i < menu_entries_length; i++){
offset += this->menu_entries[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->controls_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->controls_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->controls_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->controls_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->controls_length);
for( uint32_t i = 0; i < controls_length; i++){
offset += this->controls[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
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_description;
arrToVar(length_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_description-1]=0;
this->description = (char *)(inbuffer + offset-1);
offset += length_description;
union {
float real;
uint32_t base;
} u_scale;
u_scale.base = 0;
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->scale = u_scale.real;
offset += sizeof(this->scale);
uint32_t menu_entries_lengthT = ((uint32_t) (*(inbuffer + offset)));
menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->menu_entries_length);
if(menu_entries_lengthT > menu_entries_length)
this->menu_entries = (visualization_msgs::MenuEntry*)realloc(this->menu_entries, menu_entries_lengthT * sizeof(visualization_msgs::MenuEntry));
menu_entries_length = menu_entries_lengthT;
for( uint32_t i = 0; i < menu_entries_length; i++){
offset += this->st_menu_entries.deserialize(inbuffer + offset);
memcpy( &(this->menu_entries[i]), &(this->st_menu_entries), sizeof(visualization_msgs::MenuEntry));
}
uint32_t controls_lengthT = ((uint32_t) (*(inbuffer + offset)));
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->controls_length);
if(controls_lengthT > controls_length)
this->controls = (visualization_msgs::InteractiveMarkerControl*)realloc(this->controls, controls_lengthT * sizeof(visualization_msgs::InteractiveMarkerControl));
controls_length = controls_lengthT;
for( uint32_t i = 0; i < controls_length; i++){
offset += this->st_controls.deserialize(inbuffer + offset);
memcpy( &(this->controls[i]), &(this->st_controls), sizeof(visualization_msgs::InteractiveMarkerControl));
}
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarker"; };
const char * getMD5(){ return "dd86d22909d5a3364b384492e35c10af"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/IntParameter.h | #ifndef _ROS_dynamic_reconfigure_IntParameter_h
#define _ROS_dynamic_reconfigure_IntParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class IntParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef int32_t _value_type;
_value_type value;
IntParameter():
name(""),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/IntParameter"; };
const char * getMD5(){ return "65fedc7a0cbfb8db035e46194a350bf1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/Group.h | #ifndef _ROS_dynamic_reconfigure_Group_h
#define _ROS_dynamic_reconfigure_Group_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/ParamDescription.h"
namespace dynamic_reconfigure
{
class Group : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _type_type;
_type_type type;
uint32_t parameters_length;
typedef dynamic_reconfigure::ParamDescription _parameters_type;
_parameters_type st_parameters;
_parameters_type * parameters;
typedef int32_t _parent_type;
_parent_type parent;
typedef int32_t _id_type;
_id_type id;
Group():
name(""),
type(""),
parameters_length(0), parameters(NULL),
parent(0),
id(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;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
*(outbuffer + offset + 0) = (this->parameters_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameters_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameters_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameters_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameters_length);
for( uint32_t i = 0; i < parameters_length; i++){
offset += this->parameters[i].serialize(outbuffer + offset);
}
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.real = this->parent;
*(outbuffer + offset + 0) = (u_parent.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_parent.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_parent.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_parent.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->parent);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
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_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
uint32_t parameters_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameters_length);
if(parameters_lengthT > parameters_length)
this->parameters = (dynamic_reconfigure::ParamDescription*)realloc(this->parameters, parameters_lengthT * sizeof(dynamic_reconfigure::ParamDescription));
parameters_length = parameters_lengthT;
for( uint32_t i = 0; i < parameters_length; i++){
offset += this->st_parameters.deserialize(inbuffer + offset);
memcpy( &(this->parameters[i]), &(this->st_parameters), sizeof(dynamic_reconfigure::ParamDescription));
}
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.base = 0;
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->parent = u_parent.real;
offset += sizeof(this->parent);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/Group"; };
const char * getMD5(){ return "9e8cd9e9423c94823db3614dd8b1cf7a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/StrParameter.h | #ifndef _ROS_dynamic_reconfigure_StrParameter_h
#define _ROS_dynamic_reconfigure_StrParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class StrParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _value_type;
_value_type value;
StrParameter():
name(""),
value("")
{
}
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_value = strlen(this->value);
varToArr(outbuffer + offset, length_value);
offset += 4;
memcpy(outbuffer + offset, this->value, length_value);
offset += length_value;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_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_value;
arrToVar(length_value, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_value; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_value-1]=0;
this->value = (char *)(inbuffer + offset-1);
offset += length_value;
return offset;
}
const char * getType(){ return "dynamic_reconfigure/StrParameter"; };
const char * getMD5(){ return "bc6ccc4a57f61779c8eaae61e9f422e0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/SensorLevels.h | #ifndef _ROS_dynamic_reconfigure_SensorLevels_h
#define _ROS_dynamic_reconfigure_SensorLevels_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class SensorLevels : public ros::Msg
{
public:
enum { RECONFIGURE_CLOSE = 3 };
enum { RECONFIGURE_STOP = 1 };
enum { RECONFIGURE_RUNNING = 0 };
SensorLevels()
{
}
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 "dynamic_reconfigure/SensorLevels"; };
const char * getMD5(){ return "6322637bee96d5489db6e2127c47602c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/BoolParameter.h | #ifndef _ROS_dynamic_reconfigure_BoolParameter_h
#define _ROS_dynamic_reconfigure_BoolParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class BoolParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef bool _value_type;
_value_type value;
BoolParameter():
name(""),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/BoolParameter"; };
const char * getMD5(){ return "23f05028c1a699fb83e22401228c3a9e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/GroupState.h | #ifndef _ROS_dynamic_reconfigure_GroupState_h
#define _ROS_dynamic_reconfigure_GroupState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class GroupState : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef bool _state_type;
_state_type state;
typedef int32_t _id_type;
_id_type id;
typedef int32_t _parent_type;
_parent_type parent;
GroupState():
name(""),
state(0),
id(0),
parent(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
bool real;
uint8_t base;
} u_state;
u_state.real = this->state;
*(outbuffer + offset + 0) = (u_state.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->state);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.real = this->parent;
*(outbuffer + offset + 0) = (u_parent.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_parent.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_parent.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_parent.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->parent);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
bool real;
uint8_t base;
} u_state;
u_state.base = 0;
u_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->state = u_state.real;
offset += sizeof(this->state);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.base = 0;
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->parent = u_parent.real;
offset += sizeof(this->parent);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/GroupState"; };
const char * getMD5(){ return "a2d87f51dc22930325041a2f8b1571f8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/ParamDescription.h | #ifndef _ROS_dynamic_reconfigure_ParamDescription_h
#define _ROS_dynamic_reconfigure_ParamDescription_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class ParamDescription : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _type_type;
_type_type type;
typedef uint32_t _level_type;
_level_type level;
typedef const char* _description_type;
_description_type description;
typedef const char* _edit_method_type;
_edit_method_type edit_method;
ParamDescription():
name(""),
type(""),
level(0),
description(""),
edit_method("")
{
}
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_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
*(outbuffer + offset + 0) = (this->level >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->level >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->level >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->level >> (8 * 3)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_description = strlen(this->description);
varToArr(outbuffer + offset, length_description);
offset += 4;
memcpy(outbuffer + offset, this->description, length_description);
offset += length_description;
uint32_t length_edit_method = strlen(this->edit_method);
varToArr(outbuffer + offset, length_edit_method);
offset += 4;
memcpy(outbuffer + offset, this->edit_method, length_edit_method);
offset += length_edit_method;
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_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
this->level = ((uint32_t) (*(inbuffer + offset)));
this->level |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->level |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->level |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->level);
uint32_t length_description;
arrToVar(length_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_description-1]=0;
this->description = (char *)(inbuffer + offset-1);
offset += length_description;
uint32_t length_edit_method;
arrToVar(length_edit_method, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_edit_method; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_edit_method-1]=0;
this->edit_method = (char *)(inbuffer + offset-1);
offset += length_edit_method;
return offset;
}
const char * getType(){ return "dynamic_reconfigure/ParamDescription"; };
const char * getMD5(){ return "7434fcb9348c13054e0c3b267c8cb34d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/Reconfigure.h | #ifndef _ROS_SERVICE_Reconfigure_h
#define _ROS_SERVICE_Reconfigure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/Config.h"
namespace dynamic_reconfigure
{
static const char RECONFIGURE[] = "dynamic_reconfigure/Reconfigure";
class ReconfigureRequest : public ros::Msg
{
public:
typedef dynamic_reconfigure::Config _config_type;
_config_type config;
ReconfigureRequest():
config()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->config.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return RECONFIGURE; };
const char * getMD5(){ return "ac41a77620a4a0348b7001641796a8a1"; };
};
class ReconfigureResponse : public ros::Msg
{
public:
typedef dynamic_reconfigure::Config _config_type;
_config_type config;
ReconfigureResponse():
config()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->config.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return RECONFIGURE; };
const char * getMD5(){ return "ac41a77620a4a0348b7001641796a8a1"; };
};
class Reconfigure {
public:
typedef ReconfigureRequest Request;
typedef ReconfigureResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/Config.h | #ifndef _ROS_dynamic_reconfigure_Config_h
#define _ROS_dynamic_reconfigure_Config_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/BoolParameter.h"
#include "dynamic_reconfigure/IntParameter.h"
#include "dynamic_reconfigure/StrParameter.h"
#include "dynamic_reconfigure/DoubleParameter.h"
#include "dynamic_reconfigure/GroupState.h"
namespace dynamic_reconfigure
{
class Config : public ros::Msg
{
public:
uint32_t bools_length;
typedef dynamic_reconfigure::BoolParameter _bools_type;
_bools_type st_bools;
_bools_type * bools;
uint32_t ints_length;
typedef dynamic_reconfigure::IntParameter _ints_type;
_ints_type st_ints;
_ints_type * ints;
uint32_t strs_length;
typedef dynamic_reconfigure::StrParameter _strs_type;
_strs_type st_strs;
_strs_type * strs;
uint32_t doubles_length;
typedef dynamic_reconfigure::DoubleParameter _doubles_type;
_doubles_type st_doubles;
_doubles_type * doubles;
uint32_t groups_length;
typedef dynamic_reconfigure::GroupState _groups_type;
_groups_type st_groups;
_groups_type * groups;
Config():
bools_length(0), bools(NULL),
ints_length(0), ints(NULL),
strs_length(0), strs(NULL),
doubles_length(0), doubles(NULL),
groups_length(0), groups(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->bools_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->bools_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->bools_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->bools_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->bools_length);
for( uint32_t i = 0; i < bools_length; i++){
offset += this->bools[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->ints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints_length);
for( uint32_t i = 0; i < ints_length; i++){
offset += this->ints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->strs_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->strs_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->strs_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->strs_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->strs_length);
for( uint32_t i = 0; i < strs_length; i++){
offset += this->strs[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->doubles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->doubles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->doubles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->doubles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->doubles_length);
for( uint32_t i = 0; i < doubles_length; i++){
offset += this->doubles[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->groups_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->groups_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->groups_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->groups_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->groups_length);
for( uint32_t i = 0; i < groups_length; i++){
offset += this->groups[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t bools_lengthT = ((uint32_t) (*(inbuffer + offset)));
bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->bools_length);
if(bools_lengthT > bools_length)
this->bools = (dynamic_reconfigure::BoolParameter*)realloc(this->bools, bools_lengthT * sizeof(dynamic_reconfigure::BoolParameter));
bools_length = bools_lengthT;
for( uint32_t i = 0; i < bools_length; i++){
offset += this->st_bools.deserialize(inbuffer + offset);
memcpy( &(this->bools[i]), &(this->st_bools), sizeof(dynamic_reconfigure::BoolParameter));
}
uint32_t ints_lengthT = ((uint32_t) (*(inbuffer + offset)));
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ints_length);
if(ints_lengthT > ints_length)
this->ints = (dynamic_reconfigure::IntParameter*)realloc(this->ints, ints_lengthT * sizeof(dynamic_reconfigure::IntParameter));
ints_length = ints_lengthT;
for( uint32_t i = 0; i < ints_length; i++){
offset += this->st_ints.deserialize(inbuffer + offset);
memcpy( &(this->ints[i]), &(this->st_ints), sizeof(dynamic_reconfigure::IntParameter));
}
uint32_t strs_lengthT = ((uint32_t) (*(inbuffer + offset)));
strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->strs_length);
if(strs_lengthT > strs_length)
this->strs = (dynamic_reconfigure::StrParameter*)realloc(this->strs, strs_lengthT * sizeof(dynamic_reconfigure::StrParameter));
strs_length = strs_lengthT;
for( uint32_t i = 0; i < strs_length; i++){
offset += this->st_strs.deserialize(inbuffer + offset);
memcpy( &(this->strs[i]), &(this->st_strs), sizeof(dynamic_reconfigure::StrParameter));
}
uint32_t doubles_lengthT = ((uint32_t) (*(inbuffer + offset)));
doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->doubles_length);
if(doubles_lengthT > doubles_length)
this->doubles = (dynamic_reconfigure::DoubleParameter*)realloc(this->doubles, doubles_lengthT * sizeof(dynamic_reconfigure::DoubleParameter));
doubles_length = doubles_lengthT;
for( uint32_t i = 0; i < doubles_length; i++){
offset += this->st_doubles.deserialize(inbuffer + offset);
memcpy( &(this->doubles[i]), &(this->st_doubles), sizeof(dynamic_reconfigure::DoubleParameter));
}
uint32_t groups_lengthT = ((uint32_t) (*(inbuffer + offset)));
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->groups_length);
if(groups_lengthT > groups_length)
this->groups = (dynamic_reconfigure::GroupState*)realloc(this->groups, groups_lengthT * sizeof(dynamic_reconfigure::GroupState));
groups_length = groups_lengthT;
for( uint32_t i = 0; i < groups_length; i++){
offset += this->st_groups.deserialize(inbuffer + offset);
memcpy( &(this->groups[i]), &(this->st_groups), sizeof(dynamic_reconfigure::GroupState));
}
return offset;
}
const char * getType(){ return "dynamic_reconfigure/Config"; };
const char * getMD5(){ return "958f16a05573709014982821e6822580"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/DoubleParameter.h | #ifndef _ROS_dynamic_reconfigure_DoubleParameter_h
#define _ROS_dynamic_reconfigure_DoubleParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class DoubleParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef double _value_type;
_value_type value;
DoubleParameter():
name(""),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
double real;
uint64_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_value.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_value.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_value.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_value.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
double real;
uint64_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/DoubleParameter"; };
const char * getMD5(){ return "d8512f27253c0f65f928a67c329cd658"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/ConfigDescription.h | #ifndef _ROS_dynamic_reconfigure_ConfigDescription_h
#define _ROS_dynamic_reconfigure_ConfigDescription_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/Group.h"
#include "dynamic_reconfigure/Config.h"
namespace dynamic_reconfigure
{
class ConfigDescription : public ros::Msg
{
public:
uint32_t groups_length;
typedef dynamic_reconfigure::Group _groups_type;
_groups_type st_groups;
_groups_type * groups;
typedef dynamic_reconfigure::Config _max_type;
_max_type max;
typedef dynamic_reconfigure::Config _min_type;
_min_type min;
typedef dynamic_reconfigure::Config _dflt_type;
_dflt_type dflt;
ConfigDescription():
groups_length(0), groups(NULL),
max(),
min(),
dflt()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->groups_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->groups_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->groups_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->groups_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->groups_length);
for( uint32_t i = 0; i < groups_length; i++){
offset += this->groups[i].serialize(outbuffer + offset);
}
offset += this->max.serialize(outbuffer + offset);
offset += this->min.serialize(outbuffer + offset);
offset += this->dflt.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t groups_lengthT = ((uint32_t) (*(inbuffer + offset)));
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->groups_length);
if(groups_lengthT > groups_length)
this->groups = (dynamic_reconfigure::Group*)realloc(this->groups, groups_lengthT * sizeof(dynamic_reconfigure::Group));
groups_length = groups_lengthT;
for( uint32_t i = 0; i < groups_length; i++){
offset += this->st_groups.deserialize(inbuffer + offset);
memcpy( &(this->groups[i]), &(this->st_groups), sizeof(dynamic_reconfigure::Group));
}
offset += this->max.deserialize(inbuffer + offset);
offset += this->min.deserialize(inbuffer + offset);
offset += this->dflt.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/ConfigDescription"; };
const char * getMD5(){ return "757ce9d44ba8ddd801bb30bc456f946f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/costmap_2d/VoxelGrid.h | #ifndef _ROS_costmap_2d_VoxelGrid_h
#define _ROS_costmap_2d_VoxelGrid_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point32.h"
#include "geometry_msgs/Vector3.h"
namespace costmap_2d
{
class VoxelGrid : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t data_length;
typedef uint32_t _data_type;
_data_type st_data;
_data_type * data;
typedef geometry_msgs::Point32 _origin_type;
_origin_type origin;
typedef geometry_msgs::Vector3 _resolutions_type;
_resolutions_type resolutions;
typedef uint32_t _size_x_type;
_size_x_type size_x;
typedef uint32_t _size_y_type;
_size_y_type size_y;
typedef uint32_t _size_z_type;
_size_z_type size_z;
VoxelGrid():
header(),
data_length(0), data(NULL),
origin(),
resolutions(),
size_x(0),
size_y(0),
size_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->data[i]);
}
offset += this->origin.serialize(outbuffer + offset);
offset += this->resolutions.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->size_x >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->size_x >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->size_x >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->size_x >> (8 * 3)) & 0xFF;
offset += sizeof(this->size_x);
*(outbuffer + offset + 0) = (this->size_y >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->size_y >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->size_y >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->size_y >> (8 * 3)) & 0xFF;
offset += sizeof(this->size_y);
*(outbuffer + offset + 0) = (this->size_z >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->size_z >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->size_z >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->size_z >> (8 * 3)) & 0xFF;
offset += sizeof(this->size_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (uint32_t*)realloc(this->data, data_lengthT * sizeof(uint32_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint32_t) (*(inbuffer + offset)));
this->st_data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint32_t));
}
offset += this->origin.deserialize(inbuffer + offset);
offset += this->resolutions.deserialize(inbuffer + offset);
this->size_x = ((uint32_t) (*(inbuffer + offset)));
this->size_x |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->size_x |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->size_x |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->size_x);
this->size_y = ((uint32_t) (*(inbuffer + offset)));
this->size_y |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->size_y |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->size_y |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->size_y);
this->size_z = ((uint32_t) (*(inbuffer + offset)));
this->size_z |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->size_z |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->size_z |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->size_z);
return offset;
}
const char * getType(){ return "costmap_2d/VoxelGrid"; };
const char * getMD5(){ return "48a040827e1322073d78ece5a497029c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/laser_assembler/AssembleScans2.h | #ifndef _ROS_SERVICE_AssembleScans2_h
#define _ROS_SERVICE_AssembleScans2_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/PointCloud2.h"
#include "ros/time.h"
namespace laser_assembler
{
static const char ASSEMBLESCANS2[] = "laser_assembler/AssembleScans2";
class AssembleScans2Request : public ros::Msg
{
public:
typedef ros::Time _begin_type;
_begin_type begin;
typedef ros::Time _end_type;
_end_type end;
AssembleScans2Request():
begin(),
end()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->begin.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.sec);
*(outbuffer + offset + 0) = (this->begin.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.nsec);
*(outbuffer + offset + 0) = (this->end.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.sec);
*(outbuffer + offset + 0) = (this->end.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->begin.sec = ((uint32_t) (*(inbuffer + offset)));
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.sec);
this->begin.nsec = ((uint32_t) (*(inbuffer + offset)));
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.nsec);
this->end.sec = ((uint32_t) (*(inbuffer + offset)));
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.sec);
this->end.nsec = ((uint32_t) (*(inbuffer + offset)));
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.nsec);
return offset;
}
const char * getType(){ return ASSEMBLESCANS2; };
const char * getMD5(){ return "b341004f74e15bf5e1b2053a9183bdc7"; };
};
class AssembleScans2Response : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud2 _cloud_type;
_cloud_type cloud;
AssembleScans2Response():
cloud()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->cloud.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->cloud.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return ASSEMBLESCANS2; };
const char * getMD5(){ return "96cec5374164b3b3d1d7ef5d7628a7ed"; };
};
class AssembleScans2 {
public:
typedef AssembleScans2Request Request;
typedef AssembleScans2Response Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/laser_assembler/AssembleScans.h | #ifndef _ROS_SERVICE_AssembleScans_h
#define _ROS_SERVICE_AssembleScans_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "sensor_msgs/PointCloud.h"
namespace laser_assembler
{
static const char ASSEMBLESCANS[] = "laser_assembler/AssembleScans";
class AssembleScansRequest : public ros::Msg
{
public:
typedef ros::Time _begin_type;
_begin_type begin;
typedef ros::Time _end_type;
_end_type end;
AssembleScansRequest():
begin(),
end()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->begin.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.sec);
*(outbuffer + offset + 0) = (this->begin.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.nsec);
*(outbuffer + offset + 0) = (this->end.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.sec);
*(outbuffer + offset + 0) = (this->end.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->begin.sec = ((uint32_t) (*(inbuffer + offset)));
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.sec);
this->begin.nsec = ((uint32_t) (*(inbuffer + offset)));
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.nsec);
this->end.sec = ((uint32_t) (*(inbuffer + offset)));
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.sec);
this->end.nsec = ((uint32_t) (*(inbuffer + offset)));
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.nsec);
return offset;
}
const char * getType(){ return ASSEMBLESCANS; };
const char * getMD5(){ return "b341004f74e15bf5e1b2053a9183bdc7"; };
};
class AssembleScansResponse : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud _cloud_type;
_cloud_type cloud;
AssembleScansResponse():
cloud()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->cloud.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->cloud.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return ASSEMBLESCANS; };
const char * getMD5(){ return "4217b28a903e4ad7869a83b3653110ff"; };
};
class AssembleScans {
public:
typedef AssembleScansRequest Request;
typedef AssembleScansResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_srvs/Trigger.h | #ifndef _ROS_SERVICE_Trigger_h
#define _ROS_SERVICE_Trigger_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_srvs
{
static const char TRIGGER[] = "std_srvs/Trigger";
class TriggerRequest : public ros::Msg
{
public:
TriggerRequest()
{
}
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 TRIGGER; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class TriggerResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _message_type;
_message_type message;
TriggerResponse():
success(0),
message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
return offset;
}
const char * getType(){ return TRIGGER; };
const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
};
class Trigger {
public:
typedef TriggerRequest Request;
typedef TriggerResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_srvs/SetBool.h | #ifndef _ROS_SERVICE_SetBool_h
#define _ROS_SERVICE_SetBool_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_srvs
{
static const char SETBOOL[] = "std_srvs/SetBool";
class SetBoolRequest : public ros::Msg
{
public:
typedef bool _data_type;
_data_type data;
SetBoolRequest():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return SETBOOL; };
const char * getMD5(){ return "8b94c1b53db61fb6aed406028ad6332a"; };
};
class SetBoolResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _message_type;
_message_type message;
SetBoolResponse():
success(0),
message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
return offset;
}
const char * getType(){ return SETBOOL; };
const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
};
class SetBool {
public:
typedef SetBoolRequest Request;
typedef SetBoolResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_srvs/Empty.h | #ifndef _ROS_SERVICE_Empty_h
#define _ROS_SERVICE_Empty_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_srvs
{
static const char EMPTY[] = "std_srvs/Empty";
class EmptyRequest : public ros::Msg
{
public:
EmptyRequest()
{
}
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 EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class EmptyResponse : public ros::Msg
{
public:
EmptyResponse()
{
}
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 EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class Empty {
public:
typedef EmptyRequest Request;
typedef EmptyResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciActionFeedback.h | #ifndef _ROS_actionlib_tutorials_FibonacciActionFeedback_h
#define _ROS_actionlib_tutorials_FibonacciActionFeedback_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 "actionlib_tutorials/FibonacciFeedback.h"
namespace actionlib_tutorials
{
class FibonacciActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::FibonacciFeedback _feedback_type;
_feedback_type feedback;
FibonacciActionFeedback():
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 "actionlib_tutorials/FibonacciActionFeedback"; };
const char * getMD5(){ return "73b8497a9f629a31c0020900e4148f07"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingActionGoal.h | #ifndef _ROS_actionlib_tutorials_AveragingActionGoal_h
#define _ROS_actionlib_tutorials_AveragingActionGoal_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 "actionlib_tutorials/AveragingGoal.h"
namespace actionlib_tutorials
{
class AveragingActionGoal : 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 actionlib_tutorials::AveragingGoal _goal_type;
_goal_type goal;
AveragingActionGoal():
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 "actionlib_tutorials/AveragingActionGoal"; };
const char * getMD5(){ return "1561825b734ebd6039851c501e3fb570"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciGoal.h | #ifndef _ROS_actionlib_tutorials_FibonacciGoal_h
#define _ROS_actionlib_tutorials_FibonacciGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class FibonacciGoal : public ros::Msg
{
public:
typedef int32_t _order_type;
_order_type order;
FibonacciGoal():
order(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_order;
u_order.real = this->order;
*(outbuffer + offset + 0) = (u_order.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_order.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_order.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_order.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->order);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_order;
u_order.base = 0;
u_order.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_order.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_order.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_order.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->order = u_order.real;
offset += sizeof(this->order);
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciGoal"; };
const char * getMD5(){ return "6889063349a00b249bd1661df429d822"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingResult.h | #ifndef _ROS_actionlib_tutorials_AveragingResult_h
#define _ROS_actionlib_tutorials_AveragingResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class AveragingResult : public ros::Msg
{
public:
typedef float _mean_type;
_mean_type mean;
typedef float _std_dev_type;
_std_dev_type std_dev;
AveragingResult():
mean(0),
std_dev(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_mean;
u_mean.real = this->mean;
*(outbuffer + offset + 0) = (u_mean.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mean.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mean.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mean.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.real = this->std_dev;
*(outbuffer + offset + 0) = (u_std_dev.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_std_dev.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_std_dev.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_std_dev.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->std_dev);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_mean;
u_mean.base = 0;
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->mean = u_mean.real;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.base = 0;
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->std_dev = u_std_dev.real;
offset += sizeof(this->std_dev);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingResult"; };
const char * getMD5(){ return "d5c7decf6df75ffb4367a05c1bcc7612"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciResult.h | #ifndef _ROS_actionlib_tutorials_FibonacciResult_h
#define _ROS_actionlib_tutorials_FibonacciResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class FibonacciResult : public ros::Msg
{
public:
uint32_t sequence_length;
typedef int32_t _sequence_type;
_sequence_type st_sequence;
_sequence_type * sequence;
FibonacciResult():
sequence_length(0), sequence(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->sequence_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sequence_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sequence_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sequence_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence_length);
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_sequencei;
u_sequencei.real = this->sequence[i];
*(outbuffer + offset + 0) = (u_sequencei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sequencei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sequencei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sequencei.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t sequence_lengthT = ((uint32_t) (*(inbuffer + offset)));
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sequence_length);
if(sequence_lengthT > sequence_length)
this->sequence = (int32_t*)realloc(this->sequence, sequence_lengthT * sizeof(int32_t));
sequence_length = sequence_lengthT;
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_sequence;
u_st_sequence.base = 0;
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_sequence = u_st_sequence.real;
offset += sizeof(this->st_sequence);
memcpy( &(this->sequence[i]), &(this->st_sequence), sizeof(int32_t));
}
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciResult"; };
const char * getMD5(){ return "b81e37d2a31925a0e8ae261a8699cb79"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciActionGoal.h | #ifndef _ROS_actionlib_tutorials_FibonacciActionGoal_h
#define _ROS_actionlib_tutorials_FibonacciActionGoal_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 "actionlib_tutorials/FibonacciGoal.h"
namespace actionlib_tutorials
{
class FibonacciActionGoal : 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 actionlib_tutorials::FibonacciGoal _goal_type;
_goal_type goal;
FibonacciActionGoal():
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 "actionlib_tutorials/FibonacciActionGoal"; };
const char * getMD5(){ return "006871c7fa1d0e3d5fe2226bf17b2a94"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingFeedback.h | #ifndef _ROS_actionlib_tutorials_AveragingFeedback_h
#define _ROS_actionlib_tutorials_AveragingFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class AveragingFeedback : public ros::Msg
{
public:
typedef int32_t _sample_type;
_sample_type sample;
typedef float _data_type;
_data_type data;
typedef float _mean_type;
_mean_type mean;
typedef float _std_dev_type;
_std_dev_type std_dev;
AveragingFeedback():
sample(0),
data(0),
mean(0),
std_dev(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sample;
u_sample.real = this->sample;
*(outbuffer + offset + 0) = (u_sample.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sample.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sample.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sample.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sample);
union {
float real;
uint32_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->data);
union {
float real;
uint32_t base;
} u_mean;
u_mean.real = this->mean;
*(outbuffer + offset + 0) = (u_mean.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mean.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mean.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mean.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.real = this->std_dev;
*(outbuffer + offset + 0) = (u_std_dev.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_std_dev.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_std_dev.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_std_dev.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->std_dev);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sample;
u_sample.base = 0;
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->sample = u_sample.real;
offset += sizeof(this->sample);
union {
float real;
uint32_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->data = u_data.real;
offset += sizeof(this->data);
union {
float real;
uint32_t base;
} u_mean;
u_mean.base = 0;
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->mean = u_mean.real;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.base = 0;
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->std_dev = u_std_dev.real;
offset += sizeof(this->std_dev);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingFeedback"; };
const char * getMD5(){ return "9e8dfc53c2f2a032ca33fa80ec46fd4f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingAction.h | #ifndef _ROS_actionlib_tutorials_AveragingAction_h
#define _ROS_actionlib_tutorials_AveragingAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib_tutorials/AveragingActionGoal.h"
#include "actionlib_tutorials/AveragingActionResult.h"
#include "actionlib_tutorials/AveragingActionFeedback.h"
namespace actionlib_tutorials
{
class AveragingAction : public ros::Msg
{
public:
typedef actionlib_tutorials::AveragingActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib_tutorials::AveragingActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib_tutorials::AveragingActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
AveragingAction():
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 "actionlib_tutorials/AveragingAction"; };
const char * getMD5(){ return "628678f2b4fa6a5951746a4a2d39e716"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciActionResult.h | #ifndef _ROS_actionlib_tutorials_FibonacciActionResult_h
#define _ROS_actionlib_tutorials_FibonacciActionResult_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 "actionlib_tutorials/FibonacciResult.h"
namespace actionlib_tutorials
{
class FibonacciActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::FibonacciResult _result_type;
_result_type result;
FibonacciActionResult():
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 "actionlib_tutorials/FibonacciActionResult"; };
const char * getMD5(){ return "bee73a9fe29ae25e966e105f5553dd03"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingActionFeedback.h | #ifndef _ROS_actionlib_tutorials_AveragingActionFeedback_h
#define _ROS_actionlib_tutorials_AveragingActionFeedback_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 "actionlib_tutorials/AveragingFeedback.h"
namespace actionlib_tutorials
{
class AveragingActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::AveragingFeedback _feedback_type;
_feedback_type feedback;
AveragingActionFeedback():
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 "actionlib_tutorials/AveragingActionFeedback"; };
const char * getMD5(){ return "78a4a09241b1791069223ae7ebd5b16b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciFeedback.h | #ifndef _ROS_actionlib_tutorials_FibonacciFeedback_h
#define _ROS_actionlib_tutorials_FibonacciFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class FibonacciFeedback : public ros::Msg
{
public:
uint32_t sequence_length;
typedef int32_t _sequence_type;
_sequence_type st_sequence;
_sequence_type * sequence;
FibonacciFeedback():
sequence_length(0), sequence(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->sequence_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sequence_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sequence_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sequence_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence_length);
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_sequencei;
u_sequencei.real = this->sequence[i];
*(outbuffer + offset + 0) = (u_sequencei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sequencei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sequencei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sequencei.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t sequence_lengthT = ((uint32_t) (*(inbuffer + offset)));
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sequence_length);
if(sequence_lengthT > sequence_length)
this->sequence = (int32_t*)realloc(this->sequence, sequence_lengthT * sizeof(int32_t));
sequence_length = sequence_lengthT;
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_sequence;
u_st_sequence.base = 0;
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_sequence = u_st_sequence.real;
offset += sizeof(this->st_sequence);
memcpy( &(this->sequence[i]), &(this->st_sequence), sizeof(int32_t));
}
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciFeedback"; };
const char * getMD5(){ return "b81e37d2a31925a0e8ae261a8699cb79"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciAction.h | #ifndef _ROS_actionlib_tutorials_FibonacciAction_h
#define _ROS_actionlib_tutorials_FibonacciAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib_tutorials/FibonacciActionGoal.h"
#include "actionlib_tutorials/FibonacciActionResult.h"
#include "actionlib_tutorials/FibonacciActionFeedback.h"
namespace actionlib_tutorials
{
class FibonacciAction : public ros::Msg
{
public:
typedef actionlib_tutorials::FibonacciActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib_tutorials::FibonacciActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib_tutorials::FibonacciActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
FibonacciAction():
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 "actionlib_tutorials/FibonacciAction"; };
const char * getMD5(){ return "f59df5767bf7634684781c92598b2406"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingActionResult.h | #ifndef _ROS_actionlib_tutorials_AveragingActionResult_h
#define _ROS_actionlib_tutorials_AveragingActionResult_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 "actionlib_tutorials/AveragingResult.h"
namespace actionlib_tutorials
{
class AveragingActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::AveragingResult _result_type;
_result_type result;
AveragingActionResult():
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 "actionlib_tutorials/AveragingActionResult"; };
const char * getMD5(){ return "8672cb489d347580acdcd05c5d497497"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingGoal.h | #ifndef _ROS_actionlib_tutorials_AveragingGoal_h
#define _ROS_actionlib_tutorials_AveragingGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class AveragingGoal : public ros::Msg
{
public:
typedef int32_t _samples_type;
_samples_type samples;
AveragingGoal():
samples(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_samples;
u_samples.real = this->samples;
*(outbuffer + offset + 0) = (u_samples.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_samples.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_samples.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_samples.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->samples);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_samples;
u_samples.base = 0;
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->samples = u_samples.real;
offset += sizeof(this->samples);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingGoal"; };
const char * getMD5(){ return "32c9b10ef9b253faa93b93f564762c8f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapActionFeedback.h | #ifndef _ROS_nav_msgs_GetMapActionFeedback_h
#define _ROS_nav_msgs_GetMapActionFeedback_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 "nav_msgs/GetMapFeedback.h"
namespace nav_msgs
{
class GetMapActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef nav_msgs::GetMapFeedback _feedback_type;
_feedback_type feedback;
GetMapActionFeedback():
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 "nav_msgs/GetMapActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/MapMetaData.h | #ifndef _ROS_nav_msgs_MapMetaData_h
#define _ROS_nav_msgs_MapMetaData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "geometry_msgs/Pose.h"
namespace nav_msgs
{
class MapMetaData : public ros::Msg
{
public:
typedef ros::Time _map_load_time_type;
_map_load_time_type map_load_time;
typedef float _resolution_type;
_resolution_type resolution;
typedef uint32_t _width_type;
_width_type width;
typedef uint32_t _height_type;
_height_type height;
typedef geometry_msgs::Pose _origin_type;
_origin_type origin;
MapMetaData():
map_load_time(),
resolution(0),
width(0),
height(0),
origin()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->map_load_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->map_load_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->map_load_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->map_load_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->map_load_time.sec);
*(outbuffer + offset + 0) = (this->map_load_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->map_load_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->map_load_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->map_load_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->map_load_time.nsec);
union {
float real;
uint32_t base;
} u_resolution;
u_resolution.real = this->resolution;
*(outbuffer + offset + 0) = (u_resolution.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_resolution.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_resolution.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_resolution.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->resolution);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
offset += this->origin.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->map_load_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->map_load_time.sec);
this->map_load_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->map_load_time.nsec);
union {
float real;
uint32_t base;
} u_resolution;
u_resolution.base = 0;
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->resolution = u_resolution.real;
offset += sizeof(this->resolution);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
offset += this->origin.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "nav_msgs/MapMetaData"; };
const char * getMD5(){ return "10cfc8a2818024d3248802c00c95f11b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/SetMap.h | #ifndef _ROS_SERVICE_SetMap_h
#define _ROS_SERVICE_SetMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
#include "geometry_msgs/PoseWithCovarianceStamped.h"
namespace nav_msgs
{
static const char SETMAP[] = "nav_msgs/SetMap";
class SetMapRequest : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
typedef geometry_msgs::PoseWithCovarianceStamped _initial_pose_type;
_initial_pose_type initial_pose;
SetMapRequest():
map(),
initial_pose()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
offset += this->initial_pose.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
offset += this->initial_pose.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETMAP; };
const char * getMD5(){ return "91149a20d7be299b87c340df8cc94fd4"; };
};
class SetMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
SetMapResponse():
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 SETMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class SetMap {
public:
typedef SetMapRequest Request;
typedef SetMapResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapActionResult.h | #ifndef _ROS_nav_msgs_GetMapActionResult_h
#define _ROS_nav_msgs_GetMapActionResult_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 "nav_msgs/GetMapResult.h"
namespace nav_msgs
{
class GetMapActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef nav_msgs::GetMapResult _result_type;
_result_type result;
GetMapActionResult():
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 "nav_msgs/GetMapActionResult"; };
const char * getMD5(){ return "ac66e5b9a79bb4bbd33dab245236c892"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMap.h | #ifndef _ROS_SERVICE_GetMap_h
#define _ROS_SERVICE_GetMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace nav_msgs
{
static const char GETMAP[] = "nav_msgs/GetMap";
class GetMapRequest : public ros::Msg
{
public:
GetMapRequest()
{
}
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 GETMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetMapResponse : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
GetMapResponse():
map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMAP; };
const char * getMD5(){ return "6cdd0a18e0aff5b0a3ca2326a89b54ff"; };
};
class GetMap {
public:
typedef GetMapRequest Request;
typedef GetMapResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetPlan.h | #ifndef _ROS_SERVICE_GetPlan_h
#define _ROS_SERVICE_GetPlan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
#include "nav_msgs/Path.h"
namespace nav_msgs
{
static const char GETPLAN[] = "nav_msgs/GetPlan";
class GetPlanRequest : public ros::Msg
{
public:
typedef geometry_msgs::PoseStamped _start_type;
_start_type start;
typedef geometry_msgs::PoseStamped _goal_type;
_goal_type goal;
typedef float _tolerance_type;
_tolerance_type tolerance;
GetPlanRequest():
start(),
goal(),
tolerance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->start.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_tolerance;
u_tolerance.real = this->tolerance;
*(outbuffer + offset + 0) = (u_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_tolerance.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->tolerance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->start.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_tolerance;
u_tolerance.base = 0;
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->tolerance = u_tolerance.real;
offset += sizeof(this->tolerance);
return offset;
}
const char * getType(){ return GETPLAN; };
const char * getMD5(){ return "e25a43e0752bcca599a8c2eef8282df8"; };
};
class GetPlanResponse : public ros::Msg
{
public:
typedef nav_msgs::Path _plan_type;
_plan_type plan;
GetPlanResponse():
plan()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->plan.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->plan.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLAN; };
const char * getMD5(){ return "0002bc113c0259d71f6cf8cbc9430e18"; };
};
class GetPlan {
public:
typedef GetPlanRequest Request;
typedef GetPlanResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapActionGoal.h | #ifndef _ROS_nav_msgs_GetMapActionGoal_h
#define _ROS_nav_msgs_GetMapActionGoal_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 "nav_msgs/GetMapGoal.h"
namespace nav_msgs
{
class GetMapActionGoal : 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 nav_msgs::GetMapGoal _goal_type;
_goal_type goal;
GetMapActionGoal():
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 "nav_msgs/GetMapActionGoal"; };
const char * getMD5(){ return "4b30be6cd12b9e72826df56b481f40e0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapResult.h | #ifndef _ROS_nav_msgs_GetMapResult_h
#define _ROS_nav_msgs_GetMapResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace nav_msgs
{
class GetMapResult : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
GetMapResult():
map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "nav_msgs/GetMapResult"; };
const char * getMD5(){ return "6cdd0a18e0aff5b0a3ca2326a89b54ff"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GridCells.h | #ifndef _ROS_nav_msgs_GridCells_h
#define _ROS_nav_msgs_GridCells_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point.h"
namespace nav_msgs
{
class GridCells : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef float _cell_width_type;
_cell_width_type cell_width;
typedef float _cell_height_type;
_cell_height_type cell_height;
uint32_t cells_length;
typedef geometry_msgs::Point _cells_type;
_cells_type st_cells;
_cells_type * cells;
GridCells():
header(),
cell_width(0),
cell_height(0),
cells_length(0), cells(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_cell_width;
u_cell_width.real = this->cell_width;
*(outbuffer + offset + 0) = (u_cell_width.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cell_width.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cell_width.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cell_width.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cell_width);
union {
float real;
uint32_t base;
} u_cell_height;
u_cell_height.real = this->cell_height;
*(outbuffer + offset + 0) = (u_cell_height.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cell_height.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cell_height.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cell_height.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cell_height);
*(outbuffer + offset + 0) = (this->cells_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cells_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cells_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cells_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cells_length);
for( uint32_t i = 0; i < cells_length; i++){
offset += this->cells[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_cell_width;
u_cell_width.base = 0;
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->cell_width = u_cell_width.real;
offset += sizeof(this->cell_width);
union {
float real;
uint32_t base;
} u_cell_height;
u_cell_height.base = 0;
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->cell_height = u_cell_height.real;
offset += sizeof(this->cell_height);
uint32_t cells_lengthT = ((uint32_t) (*(inbuffer + offset)));
cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cells_length);
if(cells_lengthT > cells_length)
this->cells = (geometry_msgs::Point*)realloc(this->cells, cells_lengthT * sizeof(geometry_msgs::Point));
cells_length = cells_lengthT;
for( uint32_t i = 0; i < cells_length; i++){
offset += this->st_cells.deserialize(inbuffer + offset);
memcpy( &(this->cells[i]), &(this->st_cells), sizeof(geometry_msgs::Point));
}
return offset;
}
const char * getType(){ return "nav_msgs/GridCells"; };
const char * getMD5(){ return "b9e4f5df6d28e272ebde00a3994830f5"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/Path.h | #ifndef _ROS_nav_msgs_Path_h
#define _ROS_nav_msgs_Path_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/PoseStamped.h"
namespace nav_msgs
{
class Path : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t poses_length;
typedef geometry_msgs::PoseStamped _poses_type;
_poses_type st_poses;
_poses_type * poses;
Path():
header(),
poses_length(0), poses(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->poses_length);
for( uint32_t i = 0; i < poses_length; i++){
offset += this->poses[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->poses_length);
if(poses_lengthT > poses_length)
this->poses = (geometry_msgs::PoseStamped*)realloc(this->poses, poses_lengthT * sizeof(geometry_msgs::PoseStamped));
poses_length = poses_lengthT;
for( uint32_t i = 0; i < poses_length; i++){
offset += this->st_poses.deserialize(inbuffer + offset);
memcpy( &(this->poses[i]), &(this->st_poses), sizeof(geometry_msgs::PoseStamped));
}
return offset;
}
const char * getType(){ return "nav_msgs/Path"; };
const char * getMD5(){ return "6227e2b7e9cce15051f669a5e197bbf7"; };
};
}
#endif
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.