Datasets:

pe-nlp

/

ov-kit-code-files-v3-filtered-dedup

like 0

Follow

PE-NLP 14

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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

C

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; }

C++

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

C++

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

C++

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); }

C++

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

Python

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())

Python

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

Python

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')

Python

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))

Python

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)

Python

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; }

C++