file_path
stringlengths 21
202
| content
stringlengths 12
1.02M
| size
int64 12
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 10
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/BoundingVolume.h | #ifndef _ROS_moveit_msgs_BoundingVolume_h
#define _ROS_moveit_msgs_BoundingVolume_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "shape_msgs/SolidPrimitive.h"
#include "geometry_msgs/Pose.h"
#include "shape_msgs/Mesh.h"
namespace moveit_msgs
{
class BoundingVolume : public ros::Msg
{
public:
uint32_t primitives_length;
typedef shape_msgs::SolidPrimitive _primitives_type;
_primitives_type st_primitives;
_primitives_type * primitives;
uint32_t primitive_poses_length;
typedef geometry_msgs::Pose _primitive_poses_type;
_primitive_poses_type st_primitive_poses;
_primitive_poses_type * primitive_poses;
uint32_t meshes_length;
typedef shape_msgs::Mesh _meshes_type;
_meshes_type st_meshes;
_meshes_type * meshes;
uint32_t mesh_poses_length;
typedef geometry_msgs::Pose _mesh_poses_type;
_mesh_poses_type st_mesh_poses;
_mesh_poses_type * mesh_poses;
BoundingVolume():
primitives_length(0), primitives(NULL),
primitive_poses_length(0), primitive_poses(NULL),
meshes_length(0), meshes(NULL),
mesh_poses_length(0), mesh_poses(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitives_length);
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->primitives[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitive_poses_length);
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->primitive_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->meshes_length);
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->meshes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->mesh_poses_length);
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->mesh_poses[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitives_length);
if(primitives_lengthT > primitives_length)
this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive));
primitives_length = primitives_lengthT;
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->st_primitives.deserialize(inbuffer + offset);
memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive));
}
uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitive_poses_length);
if(primitive_poses_lengthT > primitive_poses_length)
this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose));
primitive_poses_length = primitive_poses_lengthT;
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->st_primitive_poses.deserialize(inbuffer + offset);
memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose));
}
uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset)));
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->meshes_length);
if(meshes_lengthT > meshes_length)
this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh));
meshes_length = meshes_lengthT;
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->st_meshes.deserialize(inbuffer + offset);
memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh));
}
uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->mesh_poses_length);
if(mesh_poses_lengthT > mesh_poses_length)
this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose));
mesh_poses_length = mesh_poses_lengthT;
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->st_mesh_poses.deserialize(inbuffer + offset);
memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose));
}
return offset;
}
const char * getType(){ return "moveit_msgs/BoundingVolume"; };
const char * getMD5(){ return "22db94010f39e9198032cb4a1aeda26e"; };
};
}
#endif
| 6,874 | C | 47.415493 | 140 | 0.600669 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/OrientedBoundingBox.h | #ifndef _ROS_moveit_msgs_OrientedBoundingBox_h
#define _ROS_moveit_msgs_OrientedBoundingBox_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Point32.h"
namespace moveit_msgs
{
class OrientedBoundingBox : public ros::Msg
{
public:
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Point32 _extents_type;
_extents_type extents;
OrientedBoundingBox():
pose(),
extents()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->pose.serialize(outbuffer + offset);
offset += this->extents.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->extents.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/OrientedBoundingBox"; };
const char * getMD5(){ return "da3bd98e7cb14efa4141367a9d886ee7"; };
};
}
#endif
| 1,176 | C | 22.078431 | 72 | 0.657313 |
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
| 1,404 | C | 26.549019 | 88 | 0.695869 |
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
| 6,192 | C | 40.286666 | 103 | 0.581718 |
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
| 2,579 | C | 34.833333 | 97 | 0.562233 |
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
| 2,603 | C | 32.818181 | 117 | 0.609297 |
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
| 3,084 | C | 33.662921 | 92 | 0.56096 |
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
| 3,051 | C | 33.292134 | 85 | 0.558178 |
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
| 2,567 | C | 23.457143 | 72 | 0.623296 |
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
| 2,685 | C | 26.690721 | 106 | 0.604469 |
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
| 1,190 | C | 15.774648 | 72 | 0.619328 |
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
| 12,015 | C | 47.647773 | 121 | 0.611735 |
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
| 4,165 | C | 36.872727 | 109 | 0.618007 |
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
| 7,036 | C | 40.394117 | 109 | 0.608016 |
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
| 7,486 | C | 39.690217 | 83 | 0.50895 |
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
| 6,707 | C | 35.857143 | 83 | 0.573133 |
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
| 4,898 | C | 30.006329 | 90 | 0.630053 |
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
| 5,116 | C | 38.976562 | 112 | 0.560594 |
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
| 7,002 | C | 35.284974 | 100 | 0.58012 |
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
| 7,720 | C | 37.605 | 82 | 0.590415 |
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
| 2,906 | C | 24.955357 | 78 | 0.625602 |
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
| 5,442 | C | 30.830409 | 90 | 0.623117 |
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
| 1,964 | C | 21.329545 | 72 | 0.629328 |
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
| 9,498 | C | 41.217778 | 89 | 0.594862 |
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
| 2,885 | C | 24.767857 | 78 | 0.622877 |
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
| 2,599 | C | 29.588235 | 80 | 0.63486 |
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
| 13,779 | C | 41.662539 | 118 | 0.602366 |
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
| 14,584 | C | 49.642361 | 94 | 0.53209 |
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
| 14,529 | C | 38.16442 | 79 | 0.500723 |
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
| 12,219 | C | 40.849315 | 93 | 0.540879 |
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
| 2,578 | C | 29.341176 | 80 | 0.631885 |
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
| 3,300 | C | 25.837398 | 78 | 0.614848 |
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
| 4,353 | C | 28.821918 | 80 | 0.624627 |
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
| 2,350 | C | 32.112676 | 125 | 0.602979 |
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
| 9,438 | C | 40.21834 | 114 | 0.599809 |
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
| 6,783 | C | 41.4 | 117 | 0.565679 |
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
| 3,719 | C | 27.837209 | 78 | 0.632428 |
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
| 28,133 | C | 49.329159 | 105 | 0.510646 |
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
| 7,975 | C | 38.29064 | 82 | 0.558997 |
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
| 10,777 | C | 47.116071 | 152 | 0.596084 |
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
| 5,817 | C | 31.322222 | 80 | 0.625236 |
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
| 1,993 | C | 21.659091 | 72 | 0.634722 |
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
| 18,654 | C | 52.606322 | 88 | 0.545138 |
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
| 6,464 | C | 33.758064 | 85 | 0.559097 |
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
| 2,053 | C | 31.603174 | 77 | 0.539698 |
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
| 4,257 | C | 40.339805 | 152 | 0.575758 |
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
| 12,639 | C | 39.383386 | 115 | 0.552575 |
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
| 2,166 | C | 32.338461 | 130 | 0.608033 |
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
| 7,886 | C | 44.068571 | 154 | 0.57266 |
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
| 3,764 | C | 33.541284 | 76 | 0.557651 |
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
| 1,802 | C | 25.514706 | 81 | 0.63374 |
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
| 6,517 | C | 37.797619 | 130 | 0.610557 |
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
| 11,066 | C | 41.079848 | 137 | 0.545455 |
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
| 5,650 | C | 36.177631 | 85 | 0.602832 |
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
| 6,727 | C | 40.78882 | 169 | 0.602497 |
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
| 5,382 | C | 35.619047 | 161 | 0.560572 |
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
| 808 | C | 18.261904 | 73 | 0.636139 |
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
| 3,687 | C | 29.229508 | 74 | 0.521562 |
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
| 4,049 | C | 32.75 | 77 | 0.595703 |
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
| 1,774 | C | 20.646341 | 72 | 0.653326 |
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
| 8,011 | C | 46.408284 | 150 | 0.587442 |
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
| 2,821 | C | 33.839506 | 127 | 0.615385 |
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
| 5,334 | C | 40.356589 | 85 | 0.531871 |
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
| 4,357 | C | 34.145161 | 77 | 0.551985 |
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
| 4,342 | C | 34.024193 | 77 | 0.550438 |
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
| 2,428 | C | 21.915094 | 74 | 0.595552 |
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
| 2,937 | C | 22.693548 | 74 | 0.573715 |
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
| 1,652 | C | 25.238095 | 74 | 0.554479 |
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
| 2,633 | C | 29.275862 | 76 | 0.524497 |
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
| 2,951 | C | 34.566265 | 95 | 0.569637 |
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
| 1,504 | C | 25.403508 | 82 | 0.676197 |
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
| 1,696 | C | 28.771929 | 81 | 0.702241 |
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
| 1,694 | C | 25.904761 | 75 | 0.565525 |
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
| 4,966 | C | 40.739495 | 85 | 0.538663 |
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
| 2,317 | C | 21.950495 | 74 | 0.611998 |
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
| 1,441 | C | 17.727272 | 72 | 0.625954 |
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
| 2,941 | C | 25.267857 | 77 | 0.592996 |
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
| 875 | C | 18.466666 | 72 | 0.635429 |
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
| 4,405 | C | 36.02521 | 112 | 0.552554 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapAction.h | #ifndef _ROS_nav_msgs_GetMapAction_h
#define _ROS_nav_msgs_GetMapAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/GetMapActionGoal.h"
#include "nav_msgs/GetMapActionResult.h"
#include "nav_msgs/GetMapActionFeedback.h"
namespace nav_msgs
{
class GetMapAction : public ros::Msg
{
public:
typedef nav_msgs::GetMapActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef nav_msgs::GetMapActionResult _action_result_type;
_action_result_type action_result;
typedef nav_msgs::GetMapActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
GetMapAction():
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 "nav_msgs/GetMapAction"; };
const char * getMD5(){ return "e611ad23fbf237c031b7536416dc7cd7"; };
};
}
#endif
| 1,553 | C | 26.263157 | 72 | 0.674823 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestAction.h | #ifndef _ROS_actionlib_TestAction_h
#define _ROS_actionlib_TestAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib/TestActionGoal.h"
#include "actionlib/TestActionResult.h"
#include "actionlib/TestActionFeedback.h"
namespace actionlib
{
class TestAction : public ros::Msg
{
public:
typedef actionlib::TestActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib::TestActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib::TestActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
TestAction():
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/TestAction"; };
const char * getMD5(){ return "991e87a72802262dfbe5d1b3cf6efc9a"; };
};
}
#endif
| 1,541 | C | 26.052631 | 72 | 0.67878 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestResult.h | #ifndef _ROS_actionlib_TestResult_h
#define _ROS_actionlib_TestResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestResult : public ros::Msg
{
public:
typedef int32_t _result_type;
_result_type result;
TestResult():
result(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_result;
u_result.real = this->result;
*(outbuffer + offset + 0) = (u_result.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_result.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_result.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_result.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->result);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_result;
u_result.base = 0;
u_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->result = u_result.real;
offset += sizeof(this->result);
return offset;
}
const char * getType(){ return "actionlib/TestResult"; };
const char * getMD5(){ return "034a8e20d6a306665e3a5b340fab3f09"; };
};
}
#endif
| 1,618 | C | 24.698412 | 74 | 0.54759 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsActionResult.h | #ifndef _ROS_actionlib_TwoIntsActionResult_h
#define _ROS_actionlib_TwoIntsActionResult_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/TwoIntsResult.h"
namespace actionlib
{
class TwoIntsActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib::TwoIntsResult _result_type;
_result_type result;
TwoIntsActionResult():
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/TwoIntsActionResult"; };
const char * getMD5(){ return "3ba7dea8b8cddcae4528ade4ef74b6e7"; };
};
}
#endif
| 1,430 | C | 24.105263 | 72 | 0.663636 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestGoal.h | #ifndef _ROS_actionlib_TestGoal_h
#define _ROS_actionlib_TestGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestGoal : public ros::Msg
{
public:
typedef int32_t _goal_type;
_goal_type goal;
TestGoal():
goal(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_goal;
u_goal.real = this->goal;
*(outbuffer + offset + 0) = (u_goal.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_goal.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_goal.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_goal.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_goal;
u_goal.base = 0;
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->goal = u_goal.real;
offset += sizeof(this->goal);
return offset;
}
const char * getType(){ return "actionlib/TestGoal"; };
const char * getMD5(){ return "18df0149936b7aa95588e3862476ebde"; };
};
}
#endif
| 1,566 | C | 23.873015 | 72 | 0.532567 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestGoal.h | #ifndef _ROS_actionlib_TestRequestGoal_h
#define _ROS_actionlib_TestRequestGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
namespace actionlib
{
class TestRequestGoal : public ros::Msg
{
public:
typedef int32_t _terminate_status_type;
_terminate_status_type terminate_status;
typedef bool _ignore_cancel_type;
_ignore_cancel_type ignore_cancel;
typedef const char* _result_text_type;
_result_text_type result_text;
typedef int32_t _the_result_type;
_the_result_type the_result;
typedef bool _is_simple_client_type;
_is_simple_client_type is_simple_client;
typedef ros::Duration _delay_accept_type;
_delay_accept_type delay_accept;
typedef ros::Duration _delay_terminate_type;
_delay_terminate_type delay_terminate;
typedef ros::Duration _pause_status_type;
_pause_status_type pause_status;
enum { TERMINATE_SUCCESS = 0 };
enum { TERMINATE_ABORTED = 1 };
enum { TERMINATE_REJECTED = 2 };
enum { TERMINATE_LOSE = 3 };
enum { TERMINATE_DROP = 4 };
enum { TERMINATE_EXCEPTION = 5 };
TestRequestGoal():
terminate_status(0),
ignore_cancel(0),
result_text(""),
the_result(0),
is_simple_client(0),
delay_accept(),
delay_terminate(),
pause_status()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_terminate_status;
u_terminate_status.real = this->terminate_status;
*(outbuffer + offset + 0) = (u_terminate_status.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_terminate_status.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_terminate_status.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_terminate_status.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->terminate_status);
union {
bool real;
uint8_t base;
} u_ignore_cancel;
u_ignore_cancel.real = this->ignore_cancel;
*(outbuffer + offset + 0) = (u_ignore_cancel.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->ignore_cancel);
uint32_t length_result_text = strlen(this->result_text);
varToArr(outbuffer + offset, length_result_text);
offset += 4;
memcpy(outbuffer + offset, this->result_text, length_result_text);
offset += length_result_text;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.real = this->the_result;
*(outbuffer + offset + 0) = (u_the_result.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_the_result.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_the_result.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_the_result.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_client;
u_is_simple_client.real = this->is_simple_client;
*(outbuffer + offset + 0) = (u_is_simple_client.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_simple_client);
*(outbuffer + offset + 0) = (this->delay_accept.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_accept.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_accept.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_accept.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_accept.sec);
*(outbuffer + offset + 0) = (this->delay_accept.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_accept.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_accept.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_accept.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_accept.nsec);
*(outbuffer + offset + 0) = (this->delay_terminate.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_terminate.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_terminate.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_terminate.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_terminate.sec);
*(outbuffer + offset + 0) = (this->delay_terminate.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_terminate.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_terminate.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_terminate.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_terminate.nsec);
*(outbuffer + offset + 0) = (this->pause_status.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pause_status.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pause_status.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pause_status.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->pause_status.sec);
*(outbuffer + offset + 0) = (this->pause_status.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pause_status.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pause_status.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pause_status.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->pause_status.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_terminate_status;
u_terminate_status.base = 0;
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->terminate_status = u_terminate_status.real;
offset += sizeof(this->terminate_status);
union {
bool real;
uint8_t base;
} u_ignore_cancel;
u_ignore_cancel.base = 0;
u_ignore_cancel.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->ignore_cancel = u_ignore_cancel.real;
offset += sizeof(this->ignore_cancel);
uint32_t length_result_text;
arrToVar(length_result_text, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_result_text; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_result_text-1]=0;
this->result_text = (char *)(inbuffer + offset-1);
offset += length_result_text;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.base = 0;
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->the_result = u_the_result.real;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_client;
u_is_simple_client.base = 0;
u_is_simple_client.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_simple_client = u_is_simple_client.real;
offset += sizeof(this->is_simple_client);
this->delay_accept.sec = ((uint32_t) (*(inbuffer + offset)));
this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_accept.sec);
this->delay_accept.nsec = ((uint32_t) (*(inbuffer + offset)));
this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_accept.nsec);
this->delay_terminate.sec = ((uint32_t) (*(inbuffer + offset)));
this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_terminate.sec);
this->delay_terminate.nsec = ((uint32_t) (*(inbuffer + offset)));
this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_terminate.nsec);
this->pause_status.sec = ((uint32_t) (*(inbuffer + offset)));
this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pause_status.sec);
this->pause_status.nsec = ((uint32_t) (*(inbuffer + offset)));
this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pause_status.nsec);
return offset;
}
const char * getType(){ return "actionlib/TestRequestGoal"; };
const char * getMD5(){ return "db5d00ba98302d6c6dd3737e9a03ceea"; };
};
}
#endif
| 10,031 | C | 45.444444 | 87 | 0.558469 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestFeedback.h | #ifndef _ROS_actionlib_TestFeedback_h
#define _ROS_actionlib_TestFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestFeedback : public ros::Msg
{
public:
typedef int32_t _feedback_type;
_feedback_type feedback;
TestFeedback():
feedback(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_feedback;
u_feedback.real = this->feedback;
*(outbuffer + offset + 0) = (u_feedback.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_feedback.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_feedback.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_feedback.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->feedback);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_feedback;
u_feedback.base = 0;
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->feedback = u_feedback.real;
offset += sizeof(this->feedback);
return offset;
}
const char * getType(){ return "actionlib/TestFeedback"; };
const char * getMD5(){ return "49ceb5b32ea3af22073ede4a0328249e"; };
};
}
#endif
| 1,670 | C | 25.523809 | 76 | 0.561677 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestResult.h | #ifndef _ROS_actionlib_TestRequestResult_h
#define _ROS_actionlib_TestRequestResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestRequestResult : public ros::Msg
{
public:
typedef int32_t _the_result_type;
_the_result_type the_result;
typedef bool _is_simple_server_type;
_is_simple_server_type is_simple_server;
TestRequestResult():
the_result(0),
is_simple_server(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.real = this->the_result;
*(outbuffer + offset + 0) = (u_the_result.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_the_result.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_the_result.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_the_result.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_server;
u_is_simple_server.real = this->is_simple_server;
*(outbuffer + offset + 0) = (u_is_simple_server.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_simple_server);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.base = 0;
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->the_result = u_the_result.real;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_server;
u_is_simple_server.base = 0;
u_is_simple_server.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_simple_server = u_is_simple_server.real;
offset += sizeof(this->is_simple_server);
return offset;
}
const char * getType(){ return "actionlib/TestRequestResult"; };
const char * getMD5(){ return "61c2364524499c7c5017e2f3fce7ba06"; };
};
}
#endif
| 2,426 | C | 28.962963 | 83 | 0.565952 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestAction.h | #ifndef _ROS_actionlib_TestRequestAction_h
#define _ROS_actionlib_TestRequestAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib/TestRequestActionGoal.h"
#include "actionlib/TestRequestActionResult.h"
#include "actionlib/TestRequestActionFeedback.h"
namespace actionlib
{
class TestRequestAction : public ros::Msg
{
public:
typedef actionlib::TestRequestActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib::TestRequestActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib::TestRequestActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
TestRequestAction():
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/TestRequestAction"; };
const char * getMD5(){ return "dc44b1f4045dbf0d1db54423b3b86b30"; };
};
}
#endif
| 1,618 | C | 27.403508 | 73 | 0.694067 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsResult.h | #ifndef _ROS_actionlib_TwoIntsResult_h
#define _ROS_actionlib_TwoIntsResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TwoIntsResult : public ros::Msg
{
public:
typedef int64_t _sum_type;
_sum_type sum;
TwoIntsResult():
sum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.real = this->sum;
*(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sum.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sum.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sum.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sum.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.base = 0;
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sum = u_sum.real;
offset += sizeof(this->sum);
return offset;
}
const char * getType(){ return "actionlib/TwoIntsResult"; };
const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
};
}
#endif
| 2,122 | C | 28.901408 | 72 | 0.511781 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ContactSensor/ContactSensor.cpp | #include "ContactSensor.hpp"
#include <Arduino.h>
void ContactSensor::Initialize(const int & in_sensor_pin, const int & in_led_pin) {
sensor_pin = in_sensor_pin;
led_pin = in_led_pin;
// pinMode(led_pin, OUTPUT);
double av = 0;
for(int i=0; i < numSamples; i++) {
av += analogRead(sensor_pin);
delay(5);
}
center = av / static_cast<double>(numSamples);
thresh = center;
}
void ContactSensor::update_clk() {
val = alpha * prev_val + (1 - alpha) * abs(analogRead(sensor_pin) - center); // read the input pin
prev_val = val;
// if(val > thresh) {
// digitalWrite(led_pin, HIGH);
// } else {
// digitalWrite(led_pin, LOW);
// }
}
bool ContactSensor::isTriggered() {
if(val > thresh) {
return true;
}
return false;
}
double ContactSensor::ReturnVal()
{
return val;
}
| 823 | C++ | 19.6 | 101 | 0.619684 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ContactSensor/ContactSensor.hpp | #ifndef CONTACTSENSOR_INCLUDE_GUARD_HPP
#define CONTACTSENSOR_INCLUDE_GUARD_HPP
/// \file
/// \brief Contact Sensor Library. Adapted from https://github.com/adham-elarabawy/OpenQuadruped
class ContactSensor {
private:
int led_pin;
int sensor_pin;
double center = 0;
double prev_val = 0;
double val = 0;
int numSamples = 200;
double thresh = 2.5;
double alpha = 0.999;
public:
void Initialize(const int & in_sensor_pin, const int & in_led_pin);
bool isTriggered();
void update_clk();
double ReturnVal();
};
#endif
| 543 | C++ | 21.666666 | 96 | 0.699816 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/SpotServo/SpotServo.hpp | #ifndef SPOTSERVO_INCLUDE_GUARD_HPP
#define SPOTSERVO_INCLUDE_GUARD_HPP
/// \file
/// \brief Servo Speed Control Library
#include <Servo.h>
#include <Arduino.h>
#include <math.h>
// #include <cmath>
enum LegType {FL, FR, BL, BR};
enum JointType {Shoulder, Elbow, Wrist};
/// \brief SpotServo class responsible servo control
class SpotServo
{
public:
// using default constructor
/// \brief Initialize parameters
/// \param servo_pin: pin number on Teensy 4.0 (see dataseet)
/// \param home_angle_: default joint angle
/// \param offset_: motor position offset (due to mechanical fit issues)
/// \param leg_type_: Front Left, Front Right, Back Left, or Back Right leg (see enum)
/// \param joint_type_: Shoulder, Elbow or Wrist (see enum)
void Initialize(const int & servo_pin, const double & stand_angle_, const double & home_angle_, const double & offset_, const LegType & leg_type_, const JointType & joint_type_,
const int & min_pwm_ = 500, const int & max_pwm_ = 2500, const double & ang_min_pwm = 0.0, const double & ang_max_pwm = 270.0);
/// \brief Commands a motor to move to a certain goal instantly when stepping, and slowly when viewing
/// \param goal_pose_: the desired motor position in degrees
/// \param desired_speed_: the desired motor speed (deg/sec) while reaching this goal
/// \param step_or_view_: operation mode, stepping or viewing.
void SetGoal(const double & goal_pose_, const double & desired_speed_, const bool & step_or_view_ = true);
/// \brief returns joint_type
/// \returns: joint_type
JointType return_joint_type();
/// \brief returns leg_type
/// \returns: leg_type
LegType return_legtype();
/// \brief returns this servo's home angle
/// \returns: home_angle
double return_home();
/// \brief Return the interpolated position (time-step is small enough that this is mostly accurate)
/// \returns: motor_pose_est
double GetPoseEstimate();
/// \brief Perform one motor update, potentially sending a new motor command, and updating the time-step.
void update_clk();
/// \brief Check if goal position reached
bool GoalReached();
/// \biref Actuate motors
void actuate();
/// \brief directly write pulse width in us
/// \param pulse: pulse width to write
void writePulse(const int & pulse);
/// \brief Attach servo
/// \param servo_pin: pin number on Teensy 4.0 (see dataseet)
/// \param min_pwm: minimum us value
/// \param max_pwm: maximum us value
void AssemblyInit(const int & servo_pin, const int & min_pwm_, const int & max_pwm_);
private:
// Intrinsic Parameters
Servo servo;
// time elapsed since last servo update
double last_actuated = 0.0;
// error threshold for servo position
double error_threshold = 0.5;
// maximum servo angle (minimum is 0)
double control_range = 270.0;
// loop period (milisec)
double wait_time = 1.0;
// motor position offset (due to mechanical fit issues)
int offset = 0;
// Leg Type (see enum)
LegType leg_type;
// Joint Type (see enum)
JointType joint_type;
// default angle
double home_angle = 0.0;
double stand_angle = 0.0;
// Changeable Parameters
double goal_pose = -999; // deg
double current_pose = 0.0; // deg
double desired_speed = 0.0; // deg/sec
// Servo's PWM range (usec)
// NOTE: This is unique to your servos, VERY IMPORTANT
int min_pwm = 500;
int max_pwm = 2500;
// Interpolation to convert from deg to usec
double conv_slope = 0.0;
double conv_intcpt = 0.0;
// False is step, True is view
bool step_or_view = false;
// indicated servo mode
bool calibrating = false;
};
#endif | 3,799 | C++ | 32.043478 | 181 | 0.653856 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/SpotServo/SpotServo.cpp | #include "SpotServo.hpp"
using namespace std;
// Spot Full Constructor
void SpotServo::Initialize(const int & servo_pin, const double & stand_angle_, const double & home_angle_, const double & offset_, const LegType & leg_type_, const JointType & joint_type_,
const int & min_pwm_, const int & max_pwm_, const double & ang_min_pwm, const double & ang_max_pwm)
{
// use defaults for servo attach
AssemblyInit(servo_pin, min_pwm, max_pwm);
// these are not really min and max, just used for interpolation
min_pwm = min_pwm_;
max_pwm = max_pwm_;
conv_slope = (double)(max_pwm - min_pwm) / (ang_max_pwm - ang_min_pwm);
conv_intcpt = max_pwm - conv_slope * ang_max_pwm;
offset = offset_;
home_angle = home_angle_;
leg_type = leg_type_;
joint_type = joint_type;
stand_angle = stand_angle_;
goal_pose = stand_angle + offset;
current_pose = stand_angle + offset;
int pwm = round((goal_pose) * conv_slope + conv_intcpt);
servo.writeMicroseconds(pwm);
last_actuated = millis();
}
void SpotServo::SetGoal(const double & goal_pose_, const double & desired_speed_, const bool & step_or_view_)
{
// remove calibrating flag
calibrating = false;
// Update Move Type
step_or_view = step_or_view_;
// Catch for invalid command (used by calibration node to single out motors)
// Only update if valid command
if (goal_pose_ > -998)
{
goal_pose = goal_pose_;
// Add Offset
goal_pose += offset;
// TODO: ADD JOINT LIM
desired_speed = desired_speed_;
}
}
JointType SpotServo::return_joint_type()
{
return joint_type;
}
LegType SpotServo::return_legtype()
{
return leg_type;
}
double SpotServo::return_home()
{
return home_angle;
}
double SpotServo::GetPoseEstimate()
{
return current_pose - offset;
}
void SpotServo::actuate()
{
if (goal_pose > -998)
{
// Only update position if not within threshold
if(!GoalReached())
{
// returns 1.0 * sign of goal_pose - current_pose
double direction = 1.0;
if (goal_pose - current_pose < 0.0)
{
direction = -1.0;
}
current_pose += direction * (wait_time / 1000.0) * desired_speed;
int pwm = round((current_pose) * conv_slope + conv_intcpt);
servo.writeMicroseconds(pwm);
last_actuated = millis();
} else
// if we are at small error thresh, actuate directly
{
int pwm = round((goal_pose) * conv_slope + conv_intcpt);
current_pose = goal_pose;
servo.writeMicroseconds(pwm);
last_actuated = millis();
}
}
}
void SpotServo::update_clk()
{
if (!calibrating)
{
// Only perform update if loop rate is met - or instantly if walking
if ((millis() - last_actuated > wait_time ) or !step_or_view)
{
actuate();
}
}
}
bool SpotServo::GoalReached()
{
return (abs(current_pose - goal_pose) < error_threshold);
}
void SpotServo::writePulse(const int & pulse)
{
servo.writeMicroseconds(pulse);
calibrating = true;
}
void SpotServo::AssemblyInit(const int & servo_pin, const int & min_pwm_, const int & max_pwm_)
{
// use defaults for servo attach
servo.attach(servo_pin, min_pwm, max_pwm);
} | 3,038 | C++ | 23.119047 | 188 | 0.671824 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/servo_model.py | #!/usr/bin/env python
import numpy as np
import busio
import digitalio
import board
import adafruit_mcp3xxx.mcp3008 as MCP
from adafruit_mcp3xxx.analog_in import AnalogIn
import time
from adafruit_servokit import ServoKit
class ServoJoint:
def __init__(self,
name,
effort=0.15,
speed=8.76,
gpio=22,
fb_chan=0,
pwm_chan=0,
pwm_min=600,
pwm_max=2800,
servo_horn_bias=0,
actuation_range=270):
self.name = name
self.effort = effort # Nm
self.speed = speed # rad/s
# offset in mechanical design
self.servo_horn_bias = servo_horn_bias
# create the spi bus
self.spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)
# create the cs (chip select)
if gpio == 22:
self.cs = digitalio.DigitalInOut(board.D22)
elif gpio == 27:
self.cs = digitalio.DigitalInOut(board.D27)
# create the mcp object
self.mcp = MCP.MCP3008(self.spi, self.cs)
# fb_chan from 0 to 7 for each MCP ADC
if fb_chan == 0:
self.chan = AnalogIn(self.mcp, MCP.P0)
elif fb_chan == 1:
self.chan = AnalogIn(self.mcp, MCP.P1)
elif fb_chan == 2:
self.chan = AnalogIn(self.mcp, MCP.P2)
elif fb_chan == 3:
self.chan = AnalogIn(self.mcp, MCP.P3)
elif fb_chan == 4:
self.chan = AnalogIn(self.mcp, MCP.P4)
elif fb_chan == 5:
self.chan = AnalogIn(self.mcp, MCP.P5)
elif fb_chan == 6:
self.chan = AnalogIn(self.mcp, MCP.P6)
elif fb_chan == 7:
self.chan = AnalogIn(self.mcp, MCP.P7)
self.kit = ServoKit(channels=16)
self.pwm_chan = pwm_chan
self.kit.servo[self.pwm_chan].set_pulse_width_range(pwm_min, pwm_max)
self.kit.servo[self.pwm_chan].actuation_range = actuation_range
self.bias = self.rad2deg(self.servo_horn_bias) # degrees
def forward_propagate(self, current_pos, desired_pos, dt):
""" Predict the new position of the actuated servo
motor joint
"""
pos_change = desired_pos - current_pos
percent_of_pos_reached = (self.speed * dt) / np.abs(pos_change)
# Cap at 100%
if percent_of_pos_reached > 100.0:
percent_of_pos_reached = 100.0
return current_pos + (pos_change * percent_of_pos_reached)
def calibrate(self, min_val, max_val, num_iters=22):
# Send to min value and record digital sig
# Send to max value and record digital sig
# OR INCREMENT TO GET MORE DATA
commands = np.array([])
measurements = np.array([])
# Number of data points to collect
num_iters = num_iters
for i in range(num_iters):
# commanded_value = (-np.pi / 2.0) + (i *
# (np.pi) / float(num_iters - 1))
range_val = max_val - min_val
commanded_value = (min_val) + (i *
(range_val) / float(num_iters - 1))
commands = np.append(commands, commanded_value)
self.actuate(commanded_value)
time.sleep(.5) # according to rated speed 0.1sec/60deg
measurements = np.append(measurements, self.chan.value)
time.sleep(1.0) # according to rated speed 0.1sec/60deg
# Perform fit
print("COMMANDS: {}".format(commands))
print("MEASUREMENTS: {}".format(measurements))
polynomial = 4
# We want to input measurements and receive equivalent commanded angles in radians
self.fit = np.poly1d(np.polyfit(measurements, commands, polynomial))
# Test Fit
print("TESTING FIT: 90 DEG; RESULT IS {}".format(
self.fit(self.chan.value)))
print("RETURNING TO -90")
self.actuate(-np.pi / 2)
# Save fit
np.save(self.name + "_fit", self.fit)
def load_calibration(self):
# Load fit
self.fit = np.load(self.name + "_fit.npy")
def remap(self, value):
# Use calibraton value to remap from Digital Sig to Angle
p = np.poly1d(self.fit)
return p(value)
def measure(self):
return self.remap(self.chan.value)
def rad2deg(self, rad):
deg = rad * 180.0 / np.pi
if deg > 90:
deg = 90
elif deg < -90:
deg = -90
return deg
def deg2rad(self, deg):
return deg * np.pi / 180.0
def actuate(self, desired_pos):
self.kit.servo[
self.pwm_chan].angle = self.bias + self.rad2deg(desired_pos)
def actuate_deg(self, desired_pos):
self.kit.servo[
self.pwm_chan].angle = desired_pos
| 4,877 | Python | 31.092105 | 90 | 0.555464 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/serial_test.py | import time
from Teensy_Interface import TeensyInterface
ti = TeensyInterface()
while True:
s = input("Send? [y/n]")
if s == "y":
ti.add_to_buffer(4, 0, 135, 60)
ti.send_buffer()
r = input("Read? [y/n]")
if r == "y":
print(ti.read_buffer())
| 284 | Python | 17.999999 | 44 | 0.552817 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/motor_calibrate.py | #!/usr/bin/env python
import time
import numpy as np
from servo_model import ServoJoint
joint_names = [
'rb_servo_r_hip', 'r_hip_r_thigh', 'r_thigh_r_knee', 'r_knee_r_shin',
'r_shin_r_ankle', 'r_ankle_r_foot', 'lb_servo_l_hip', 'l_hip_l_thigh',
'l_thigh_l_knee', 'l_knee_l_shin', 'l_shin_l_ankle', 'l_ankle_l_foot',
'torso_r_shoulder', 'r_shoulder_rs_servo', 're_servo_r_elbow',
'torso_l_shoulder', 'l_shoulder_ls_servo', 'le_servo_l_elbow'
]
loop = True
pwm_min = int(input("Enter Min PWM: ")) # 500
pwm_max = int(input("Enter Max PWM: ")) # 2400
actuation_range = int(input("Enter Actuation Range: "))
while loop:
channel = int(
input("Which channel is your servo connected to? [0-11]: "))
servo = ServoJoint(name=joint_names[channel],
pwm_chan=channel,
pwm_min=pwm_min,
pwm_max=pwm_max,
actuation_range=actuation_range)
inner_loop = True
while inner_loop:
val = float(input("Select an angle value (deg): [q to quit]"))
if val == "q" or val == "Q":
inner_loop = False
else:
servo.actuate_deg(val)
cont = input("Test another motor [y] or quit [n]? ")
if cont == "n":
loop = False
| 1,292 | Python | 29.069767 | 74 | 0.563467 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/Teensy_Interface.py | import serial
class TeensyInterface:
def __init__(self, port='/dev/ttyS0', baud=500000, timeout=0.2):
self.ser = serial.Serial(port, baud)
self.ser.flush()
self.buffer = []
def __construct_string(self, i, x, y, z):
return "{},{},{},{}\n".format(i, x, y, z)
def add_to_buffer(self, i, x, y, z):
self.buffer.append(self.__construct_string(i, x, y, z))
def add_raw(self, val):
self.buffer.append("{}\n".format(val))
def send_buffer(self):
for message in self.buffer:
self.ser.write(message.encode('utf-8'))
self.buffer = []
def read_buffer(self):
return self.ser.read_until(b'\n')
| 694 | Python | 24.74074 | 68 | 0.559078 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/imu.py | import time
import board
import busio
import adafruit_lsm9ds1
import numpy as np
import math
# i2c permission: sudo usermod -a -G i2c <user>
# https://www.raspberrypi.org/forums/viewtopic.php?t=58782
# use ROS with python3: https://medium.com/@beta_b0t/how-to-setup-ros-with-python-3-44a69ca36674
class IMU:
def __init__(self, rp_flip=True, r_neg=False, p_neg=True, y_neg=True):
# I2C connection:
# SPI connection:
# from digitalio import DigitalInOut, Direction
# spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
# csag = DigitalInOut(board.D5)
# csag.direction = Direction.OUTPUT
# csag.value = True
# csm = DigitalInOut(board.D6)
# csm.direction = Direction.OUTPUT
# csm.value = True
# sensor = adafruit_lsm9ds1.LSM9DS1_SPI(spi, csag, csm)
self.i2c = busio.I2C(board.SCL, board.SDA)
self.sensor = adafruit_lsm9ds1.LSM9DS1_I2C(self.i2c)
# Calibration Parameters
self.x_gyro_calibration = 0
self.y_gyro_calibration = 0
self.z_gyro_calibration = 0
self.roll_calibration = 0
self.pitch_calibration = 0
self.yaw_calibration = 0
# IMU Parameters: acc (x,y,z), gyro(x,y,z)
self.imu_data = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
# Time in seconds
self.prev_time = time.time()
# IMU timer
self.imu_diff = 0
# Gyroscope integrals for filtering
self.roll_int = 0
self.pitch_int = 0
self.yaw_int = 0
# Complementary Filter Coefficient
self.comp_filter = 0.02
# Filtered RPY
self.roll = 0
self.pitch = 0
self.yaw = 0
# Used to turn the IMU into right-hand coordinate system
self.rp_flip = rp_flip
self.r_neg = r_neg
self.p_neg = p_neg
self.y_neg = y_neg
# Magnemometer Calibration Values
self.scale_x = 1
self.scale_y = 1
self.scale_z = 1
self.mag_x_bias = 0
self.mag_y_bias = 0
self.mag_z_bias = 0
self.yaw_bias = 0
# CALIBRATE
self.calibrate_imu()
print("IMU Calibrated!\n")
def calibrate_imu(self):
"""
"""
# Reset calibration params
self.x_gyro_calibration = 0
self.y_gyro_calibration = 0
self.z_gyro_calibration = 0
self.roll_calibration = 0
self.pitch_calibration = 0
self.yaw_calibration = 0
sum_xg = 0
sum_yg = 0
sum_zg = 0
sum_xa = 0
sum_ya = 0
sum_za = 0
sum_roll = 0
sum_pitch = 0
sum_yaw = 0
num_calibrations = 1000
print("Calibrating Gyroscope and Accelerometer...\n")
for i in range(num_calibrations):
""" GYRO/ACC CALIBRATION
"""
self.read_imu()
sum_xg += self.imu_data[0]
sum_yg += self.imu_data[1]
sum_zg += self.imu_data[2]
sum_xa += self.imu_data[3]
sum_ya += self.imu_data[4]
sum_za += self.imu_data[5]
# Y,Z accelerations make up roll
sum_roll += (math.atan2(self.imu_data[3],
self.imu_data[5])) * 180.0 / np.pi
# X,Z accelerations make up pitch
sum_pitch += (math.atan2(self.imu_data[4],
self.imu_data[5])) * 180.0 / np.pi
# # Y, X accelerations make up yaw
# sum_yaw += (math.atan2(self.imu_data[7], self.imu_data[6]) *
# 180.0 / np.pi)
# Average values for calibration
self.x_gyro_calibration = sum_xg / float(num_calibrations)
self.y_gyro_calibration = sum_yg / float(num_calibrations)
self.z_gyro_calibration = sum_zg / float(num_calibrations)
self.roll_calibration = sum_roll / float(num_calibrations)
self.pitch_calibration = sum_pitch / float(num_calibrations)
# self.yaw_calibration = sum_yaw / float(num_calibrations)
print("Gyroscope and Accelerometer calibrated!\n")
# magne_cal = input(
# "Calibrate Magnemometer [c] or Load Existing Calibration [l] ?")
# if magne_cal == "c":
# print("Calibrating Magnetometer...")
# self.calibrate_magnemometer()
# else:
# print("Loading Magnetometer Calibration...")
# self.load_magnemometer_calibration()
# input(
# "Put the robot at its zero-yaw position and press Enter to calibrate Yaw"
# )
# self.read_imu()
# self.yaw_bias = (math.atan2(self.imu_data[7], self.imu_data[6]) *
# 180.0 / np.pi)
# print("Recorded Bias: {}".format(self.yaw_bias))
# input("Enter To Start")
def load_magnemometer_calibration(self):
return True
def calibrate_magnemometer(self):
# Get 10 seconds of magnemometer data
collection_time = 10.0
# Hard Iron Offset
mag_x_max = -32767
mag_x_min = 32767
mag_y_max = -32767
mag_y_min = 32767
mag_z_max = -32767
mag_z_min = 32767
input("Press Enter to start data collection for " +
str(collection_time) + " seconds:")
start_time = time.time()
elapsed_time = time.time() - start_time
while elapsed_time < collection_time:
elapsed_time = time.time() - start_time
self.read_imu()
# Set Max/Min for x
if self.imu_data[6] > mag_x_max:
mag_x_max = self.imu_data[6]
if self.imu_data[6] < mag_x_min:
mag_x_min = self.imu_data[6]
# Set Max/Min for y
if self.imu_data[7] > mag_y_max:
mag_y_max = self.imu_data[7]
if self.imu_data[7] < mag_y_min:
mag_y_min = self.imu_data[6]
# Set Max/Min for z
if self.imu_data[8] > mag_z_max:
mag_z_max = self.imu_data[8]
if self.imu_data[8] < mag_z_min:
mag_z_min = self.imu_data[8]
# Get Hard Iron Correction
self.mag_x_bias = (mag_x_max + mag_x_min) / 2.0
self.mag_y_bias = (mag_y_max + mag_y_min) / 2.0
self.mag_z_bias = (mag_z_max + mag_z_min) / 2.0
# Soft Iron Distortion - SCALE BIASES METHOD
# https://appelsiini.net/2018/calibrate-magnetometer/
# NOTE: Can also do Matrix Method
mag_x_delta = (mag_x_max - mag_x_min) / 2.0
mag_y_delta = (mag_y_max - mag_y_min) / 2.0
mag_z_delta = (mag_z_max - mag_z_min) / 2.0
avg_delta = (mag_x_delta + mag_y_delta + mag_z_delta) / 3.0
self.scale_x = avg_delta / mag_x_delta
self.scale_y = avg_delta / mag_y_delta
self.scale_y = avg_delta / mag_z_delta
# NOW, FOR EACH AXIS: corrected_reading = (reading - bias) * scale
input("Press Enter to save results")
def read_imu(self):
"""
"""
accel_x, accel_y, accel_z = self.sensor.acceleration
mag_x, mag_y, mag_z = self.sensor.magnetic
gyro_x, gyro_y, gyro_z = self.sensor.gyro
# temp = self.sensor.temperature
# Populate imu data list
# Gyroscope Values (Degrees/sec)
self.imu_data[0] = gyro_x - self.x_gyro_calibration
self.imu_data[1] = gyro_y - self.y_gyro_calibration
self.imu_data[2] = gyro_z - self.z_gyro_calibration
# Accelerometer Values (m/s^2)
self.imu_data[3] = accel_x
self.imu_data[4] = accel_y
self.imu_data[5] = accel_z
# Magnemometer Values
self.imu_data[6] = (mag_x - self.mag_x_bias) * self.scale_x
self.imu_data[7] = (mag_y - self.mag_y_bias) * self.scale_y
self.imu_data[8] = (mag_z - self.mag_z_bias) * self.scale_z
def filter_rpy(self):
"""
"""
# Get Readings
self.read_imu()
# Get Current Time in seconds
current_time = time.time()
self.imu_diff = current_time - self.prev_time
# Set new previous time
self.prev_time = current_time
# Catch rollovers
if self.imu_diff < 0:
self.imu_diff = 0
# Complementary filter for RPY
# TODO: DOUBLE CHECK THIS!!!!!!!
roll_gyro_delta = self.imu_data[1] * self.imu_diff
pitch_gyro_delta = self.imu_data[0] * self.imu_diff
yaw_gyro_delta = self.imu_data[2] * self.imu_diff
self.roll_int += roll_gyro_delta
self.pitch_int += pitch_gyro_delta
self.yaw_int += yaw_gyro_delta
# RPY from Accelerometer
# Y,Z accelerations make up roll
roll_a = (math.atan2(self.imu_data[3], self.imu_data[5])
) * 180.0 / np.pi - self.roll_calibration
# X,Z accelerations make up pitch
pitch_a = (math.atan2(self.imu_data[4], self.imu_data[5])
) * 180.0 / np.pi - self.pitch_calibration
# Y, X Magnetometer data makes up yaw
yaw_m = (math.atan2(self.imu_data[7], self.imu_data[6]) * 180.0 /
np.pi)
# Calculate Filtered RPY
self.roll = roll_a * self.comp_filter + (1 - self.comp_filter) * (
roll_gyro_delta + self.roll)
self.pitch = pitch_a * self.comp_filter + (1 - self.comp_filter) * (
pitch_gyro_delta + self.pitch)
self.yaw = math.atan2(self.imu_data[7],
self.imu_data[6]) * 180.0 / np.pi
self.yaw = yaw_m - self.yaw_bias
# Wrap from -PI to PI
self.yaw -= 360.0 * math.floor((self.yaw + 180) / 360.0)
# self.yaw = yaw_m * self.comp_filter + (1 - self.comp_filter) * (
# pitch_gyro_delta + self.yaw)
# self.roll = roll_a
# self.pitch = pitch_a
# self.yaw = yaw_a
# Recenter Roll and Pitch for Right Handed Frame
self.recenter_rp()
def recenter_rp(self):
""" LSM9DS1 IMU does not adhere to right hand rule.
this function allows the user to specify which coordinate
frame standards to use by deciding when to flip and/or negate
Roll and Pitch in the class constructor.
"""
if self.rp_flip:
if self.r_neg:
self.true_roll = -self.pitch
else:
self.true_roll = self.pitch
if self.p_neg:
self.true_pitch = -self.roll
else:
self.true_pitch = self.roll
else:
if self.r_neg:
self.true_roll = -self.roll
else:
self.true_roll = self.roll
if self.p_neg:
self.true_pitch = -self.pitch
else:
self.true_pitch = self.pitch
if self.y_neg:
self.yaw = -self.yaw
if __name__ == "__main__":
imu = IMU()
while True:
imu.filter_rpy()
print("ROLL: {} \t PICH: {} \t YAW: {} \n".format(
imu.true_roll, imu.true_pitch, imu.yaw)) | 11,139 | Python | 33.596273 | 96 | 0.534429 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/setup.py | ## ! DO NOT MANUALLY INVOKE THIS setup.py, USE CATKIN INSTEAD
## Copies from http://docs.ros.org/melodic/api/catkin/html/howto/format2/installing_python.html and edited for our package
from distutils.core import setup
from catkin_pkg.python_setup import generate_distutils_setup
# fetch values from package.xml
setup_args = generate_distutils_setup(
packages=['mini_bullet', 'ars_lib'],
package_dir={'../mini_bullet/src': ''})
setup(**setup_args)
| 457 | Python | 37.166664 | 122 | 0.746171 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/src/spot_sm.cpp | /// \file
/// \brief Draws Each Obstacle in RViz using MarkerArrays
///
/// PARAMETERS:
/// PUBLISHES:
/// SUBSCRIBES:
/// FUNCTIONS:
#include <ros/ros.h>
#include <math.h>
#include <string>
#include <vector>
#include <mini_ros/spot.hpp>
#include <mini_ros/teleop.hpp>
#include "mini_ros/MiniCmd.h"
#include "std_srvs/Empty.h"
#include "std_msgs/Bool.h"
// Global Vars
spot::Spot spot_mini = spot::Spot();
bool teleop_flag = false;
bool motion_flag = false;
bool ESTOP = false;
// Init Time
ros::Time current_time;
ros::Time last_time;
void teleop_callback(const geometry_msgs::Twist &tw)
{
/// \brief cmd_vel subscriber callback. Records commanded twist
///
/// \param tw (geometry_msgs::Twist): the commanded linear and angular velocity
/**
* This function runs every time we get a geometry_msgs::Twist message on the "cmd_vel" topic.
* We generally use the const <message>ConstPtr &msg syntax to prevent our node from accidentally
* changing the message, in the case that another node is also listening to it.
*/
spot_mini.update_command(tw.linear.x, tw.linear.y, tw.linear.z, tw.angular.z, tw.angular.x, tw.angular.y);
}
void estop_callback(const std_msgs::Bool &estop)
{
if (estop.data)
{
spot_mini.update_command(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
motion_flag = true;
if (!ESTOP)
{
ROS_ERROR("ENGAGING MANUAL E-STOP!");
ESTOP = true;
} else
{
ROS_WARN("DIS-ENGAGING MANUAL E-STOP!");
ESTOP = false;
}
}
last_time = ros::Time::now();
}
bool swm_callback(std_srvs::Empty::Request&, std_srvs::Empty::Response&)
/// Switches the Movement mode from FB (Forward/Backward) to LR (Left/Right)
/// and vice versa
{
spot_mini.switch_movement();
motion_flag = true;
return true;
}
int main(int argc, char** argv)
/// The Main Function ///
{
ROS_INFO("STARTING NODE: spot_mini State Machine");
// Vars
double frequency = 5;
// Seconds for timeout
double timeout = 1.0;
ros::init(argc, argv, "mini_sm_node"); // register the node on ROS
ros::NodeHandle nh; // get a handle to ROS
ros::NodeHandle nh_("~"); // get a handle to ROS
// Parameters
nh_.getParam("frequency", frequency);
// Init Subscriber
ros::Subscriber teleop_sub = nh.subscribe("teleop", 1, teleop_callback);
ros::Subscriber estop_sub = nh.subscribe("estop", 1, estop_callback);
// Init Command Publisher
ros::Publisher mini_pub = nh.advertise<mini_ros::MiniCmd>("mini_cmd", 1);
// Init Switch Movement Service Server
ros::ServiceServer switch_movement_server = nh.advertiseService("switch_movement", swm_callback);
// Init MiniCmd
mini_ros::MiniCmd mini_cmd;
// Placeholder
mini_cmd.x_velocity = 0.0;
mini_cmd.y_velocity = 0.0;
mini_cmd.rate = 0.0;
mini_cmd.roll = 0.0;
mini_cmd.pitch = 0.0;
mini_cmd.yaw = 0.0;
mini_cmd.z = 0.0;
mini_cmd.faster = 0.0;
mini_cmd.slower = 0.0;
mini_cmd.motion = "Stop";
mini_cmd.movement = "Stepping";
ros::Rate rate(frequency);
current_time = ros::Time::now();
last_time = ros::Time::now();
// Main While
while (ros::ok())
{
ros::spinOnce();
current_time = ros::Time::now();
spot::SpotCommand cmd = spot_mini.return_command();
// Condition for sending non-stop command
if (!motion_flag and !(current_time.toSec() - last_time.toSec() > timeout) and !ESTOP)
{
mini_cmd.x_velocity = cmd.x_velocity;
mini_cmd.y_velocity = cmd.y_velocity;
mini_cmd.rate = cmd.rate;
mini_cmd.roll = cmd.roll;
mini_cmd.pitch = cmd.pitch;
mini_cmd.yaw = cmd.yaw;
mini_cmd.z = cmd.z;
mini_cmd.faster = cmd.faster;
mini_cmd.slower = cmd.slower;
// Now convert enum to string
// Motion
if (cmd.motion == spot::Go)
{
mini_cmd.motion = "Go";
} else
{
mini_cmd.motion = "Stop";
}
// Movement
if (cmd.movement == spot::Stepping)
{
mini_cmd.movement = "Stepping";
} else
{
mini_cmd.movement = "Viewing";
}
} else
{
mini_cmd.x_velocity = 0.0;
mini_cmd.y_velocity = 0.0;
mini_cmd.rate = 0.0;
mini_cmd.roll = 0.0;
mini_cmd.pitch = 0.0;
mini_cmd.yaw = 0.0;
mini_cmd.z = 0.0;
mini_cmd.faster = 0.0;
mini_cmd.slower = 0.0;
mini_cmd.motion = "Stop";
}
if (current_time.toSec() - last_time.toSec() > timeout)
{
ROS_ERROR("TIMEOUT...ENGAGING E-STOP!");
}
// Now publish
mini_pub.publish(mini_cmd);
motion_flag = false;
rate.sleep();
}
return 0;
} | 4,882 | C++ | 25.538043 | 108 | 0.579271 |