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/mini_ros/JoyButtons.h

#ifndef _ROS_mini_ros_JoyButtons_h #define _ROS_mini_ros_JoyButtons_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace mini_ros { class JoyButtons : public ros::Msg { public: typedef int8_t _updown_type; _updown_type updown; typedef int8_t _leftright_type; _leftright_type leftright; typedef int8_t _left_bump_type; _left_bump_type left_bump; typedef int8_t _right_bump_type; _right_bump_type right_bump; JoyButtons(): updown(0), leftright(0), left_bump(0), right_bump(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int8_t real; uint8_t base; } u_updown; u_updown.real = this->updown; *(outbuffer + offset + 0) = (u_updown.base >> (8 * 0)) & 0xFF; offset += sizeof(this->updown); union { int8_t real; uint8_t base; } u_leftright; u_leftright.real = this->leftright; *(outbuffer + offset + 0) = (u_leftright.base >> (8 * 0)) & 0xFF; offset += sizeof(this->leftright); union { int8_t real; uint8_t base; } u_left_bump; u_left_bump.real = this->left_bump; *(outbuffer + offset + 0) = (u_left_bump.base >> (8 * 0)) & 0xFF; offset += sizeof(this->left_bump); union { int8_t real; uint8_t base; } u_right_bump; u_right_bump.real = this->right_bump; *(outbuffer + offset + 0) = (u_right_bump.base >> (8 * 0)) & 0xFF; offset += sizeof(this->right_bump); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int8_t real; uint8_t base; } u_updown; u_updown.base = 0; u_updown.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->updown = u_updown.real; offset += sizeof(this->updown); union { int8_t real; uint8_t base; } u_leftright; u_leftright.base = 0; u_leftright.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->leftright = u_leftright.real; offset += sizeof(this->leftright); union { int8_t real; uint8_t base; } u_left_bump; u_left_bump.base = 0; u_left_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->left_bump = u_left_bump.real; offset += sizeof(this->left_bump); union { int8_t real; uint8_t base; } u_right_bump; u_right_bump.base = 0; u_right_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->right_bump = u_right_bump.real; offset += sizeof(this->right_bump); return offset; } const char * getType(){ return "mini_ros/JoyButtons"; }; const char * getMD5(){ return "be1de48c3b52ec87587be0e78c2cb8cd"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/MiniCmd.h

#ifndef _ROS_mini_ros_MiniCmd_h #define _ROS_mini_ros_MiniCmd_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace mini_ros { class MiniCmd : public ros::Msg { public: typedef const char* _motion_type; _motion_type motion; typedef const char* _movement_type; _movement_type movement; typedef float _x_velocity_type; _x_velocity_type x_velocity; typedef float _y_velocity_type; _y_velocity_type y_velocity; typedef float _rate_type; _rate_type rate; typedef float _roll_type; _roll_type roll; typedef float _pitch_type; _pitch_type pitch; typedef float _yaw_type; _yaw_type yaw; typedef float _z_type; _z_type z; typedef float _faster_type; _faster_type faster; typedef float _slower_type; _slower_type slower; MiniCmd(): motion(""), movement(""), x_velocity(0), y_velocity(0), rate(0), roll(0), pitch(0), yaw(0), z(0), faster(0), slower(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_motion = strlen(this->motion); varToArr(outbuffer + offset, length_motion); offset += 4; memcpy(outbuffer + offset, this->motion, length_motion); offset += length_motion; uint32_t length_movement = strlen(this->movement); varToArr(outbuffer + offset, length_movement); offset += 4; memcpy(outbuffer + offset, this->movement, length_movement); offset += length_movement; union { float real; uint32_t base; } u_x_velocity; u_x_velocity.real = this->x_velocity; *(outbuffer + offset + 0) = (u_x_velocity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_x_velocity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_x_velocity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_x_velocity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->x_velocity); union { float real; uint32_t base; } u_y_velocity; u_y_velocity.real = this->y_velocity; *(outbuffer + offset + 0) = (u_y_velocity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_y_velocity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_y_velocity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_y_velocity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->y_velocity); union { float real; uint32_t base; } u_rate; u_rate.real = this->rate; *(outbuffer + offset + 0) = (u_rate.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_rate.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_rate.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_rate.base >> (8 * 3)) & 0xFF; offset += sizeof(this->rate); union { float real; uint32_t base; } u_roll; u_roll.real = this->roll; *(outbuffer + offset + 0) = (u_roll.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_roll.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_roll.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_roll.base >> (8 * 3)) & 0xFF; offset += sizeof(this->roll); union { float real; uint32_t base; } u_pitch; u_pitch.real = this->pitch; *(outbuffer + offset + 0) = (u_pitch.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_pitch.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_pitch.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_pitch.base >> (8 * 3)) & 0xFF; offset += sizeof(this->pitch); union { float real; uint32_t base; } u_yaw; u_yaw.real = this->yaw; *(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF; offset += sizeof(this->yaw); union { float real; uint32_t base; } u_z; u_z.real = this->z; *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF; offset += sizeof(this->z); union { float real; uint32_t base; } u_faster; u_faster.real = this->faster; *(outbuffer + offset + 0) = (u_faster.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_faster.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_faster.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_faster.base >> (8 * 3)) & 0xFF; offset += sizeof(this->faster); union { float real; uint32_t base; } u_slower; u_slower.real = this->slower; *(outbuffer + offset + 0) = (u_slower.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_slower.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_slower.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_slower.base >> (8 * 3)) & 0xFF; offset += sizeof(this->slower); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_motion; arrToVar(length_motion, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_motion; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_motion-1]=0; this->motion = (char *)(inbuffer + offset-1); offset += length_motion; uint32_t length_movement; arrToVar(length_movement, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_movement; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_movement-1]=0; this->movement = (char *)(inbuffer + offset-1); offset += length_movement; union { float real; uint32_t base; } u_x_velocity; u_x_velocity.base = 0; u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->x_velocity = u_x_velocity.real; offset += sizeof(this->x_velocity); union { float real; uint32_t base; } u_y_velocity; u_y_velocity.base = 0; u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->y_velocity = u_y_velocity.real; offset += sizeof(this->y_velocity); union { float real; uint32_t base; } u_rate; u_rate.base = 0; u_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->rate = u_rate.real; offset += sizeof(this->rate); union { float real; uint32_t base; } u_roll; u_roll.base = 0; u_roll.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_roll.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_roll.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_roll.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->roll = u_roll.real; offset += sizeof(this->roll); union { float real; uint32_t base; } u_pitch; u_pitch.base = 0; u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->pitch = u_pitch.real; offset += sizeof(this->pitch); union { float real; uint32_t base; } u_yaw; u_yaw.base = 0; u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->yaw = u_yaw.real; offset += sizeof(this->yaw); union { float real; uint32_t base; } u_z; u_z.base = 0; u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->z = u_z.real; offset += sizeof(this->z); union { float real; uint32_t base; } u_faster; u_faster.base = 0; u_faster.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_faster.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_faster.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_faster.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->faster = u_faster.real; offset += sizeof(this->faster); union { float real; uint32_t base; } u_slower; u_slower.base = 0; u_slower.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_slower.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_slower.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_slower.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->slower = u_slower.real; offset += sizeof(this->slower); return offset; } const char * getType(){ return "mini_ros/MiniCmd"; }; const char * getMD5(){ return "83510b9a5f454bd3ceb898b52e349406"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JointAngles.h

#ifndef _ROS_mini_ros_JointAngles_h #define _ROS_mini_ros_JointAngles_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace mini_ros { class JointAngles : public ros::Msg { public: typedef float _fls_type; _fls_type fls; typedef float _fle_type; _fle_type fle; typedef float _flw_type; _flw_type flw; typedef float _frs_type; _frs_type frs; typedef float _fre_type; _fre_type fre; typedef float _frw_type; _frw_type frw; typedef float _bls_type; _bls_type bls; typedef float _ble_type; _ble_type ble; typedef float _blw_type; _blw_type blw; typedef float _brs_type; _brs_type brs; typedef float _bre_type; _bre_type bre; typedef float _brw_type; _brw_type brw; typedef bool _step_or_view_type; _step_or_view_type step_or_view; JointAngles(): fls(0), fle(0), flw(0), frs(0), fre(0), frw(0), bls(0), ble(0), blw(0), brs(0), bre(0), brw(0), step_or_view(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { float real; uint32_t base; } u_fls; u_fls.real = this->fls; *(outbuffer + offset + 0) = (u_fls.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_fls.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_fls.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_fls.base >> (8 * 3)) & 0xFF; offset += sizeof(this->fls); union { float real; uint32_t base; } u_fle; u_fle.real = this->fle; *(outbuffer + offset + 0) = (u_fle.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_fle.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_fle.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_fle.base >> (8 * 3)) & 0xFF; offset += sizeof(this->fle); union { float real; uint32_t base; } u_flw; u_flw.real = this->flw; *(outbuffer + offset + 0) = (u_flw.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_flw.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_flw.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_flw.base >> (8 * 3)) & 0xFF; offset += sizeof(this->flw); union { float real; uint32_t base; } u_frs; u_frs.real = this->frs; *(outbuffer + offset + 0) = (u_frs.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_frs.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_frs.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_frs.base >> (8 * 3)) & 0xFF; offset += sizeof(this->frs); union { float real; uint32_t base; } u_fre; u_fre.real = this->fre; *(outbuffer + offset + 0) = (u_fre.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_fre.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_fre.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_fre.base >> (8 * 3)) & 0xFF; offset += sizeof(this->fre); union { float real; uint32_t base; } u_frw; u_frw.real = this->frw; *(outbuffer + offset + 0) = (u_frw.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_frw.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_frw.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_frw.base >> (8 * 3)) & 0xFF; offset += sizeof(this->frw); union { float real; uint32_t base; } u_bls; u_bls.real = this->bls; *(outbuffer + offset + 0) = (u_bls.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_bls.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_bls.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_bls.base >> (8 * 3)) & 0xFF; offset += sizeof(this->bls); union { float real; uint32_t base; } u_ble; u_ble.real = this->ble; *(outbuffer + offset + 0) = (u_ble.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_ble.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_ble.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_ble.base >> (8 * 3)) & 0xFF; offset += sizeof(this->ble); union { float real; uint32_t base; } u_blw; u_blw.real = this->blw; *(outbuffer + offset + 0) = (u_blw.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_blw.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_blw.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_blw.base >> (8 * 3)) & 0xFF; offset += sizeof(this->blw); union { float real; uint32_t base; } u_brs; u_brs.real = this->brs; *(outbuffer + offset + 0) = (u_brs.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_brs.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_brs.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_brs.base >> (8 * 3)) & 0xFF; offset += sizeof(this->brs); union { float real; uint32_t base; } u_bre; u_bre.real = this->bre; *(outbuffer + offset + 0) = (u_bre.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_bre.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_bre.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_bre.base >> (8 * 3)) & 0xFF; offset += sizeof(this->bre); union { float real; uint32_t base; } u_brw; u_brw.real = this->brw; *(outbuffer + offset + 0) = (u_brw.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_brw.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_brw.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_brw.base >> (8 * 3)) & 0xFF; offset += sizeof(this->brw); union { bool real; uint8_t base; } u_step_or_view; u_step_or_view.real = this->step_or_view; *(outbuffer + offset + 0) = (u_step_or_view.base >> (8 * 0)) & 0xFF; offset += sizeof(this->step_or_view); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { float real; uint32_t base; } u_fls; u_fls.base = 0; u_fls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_fls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_fls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_fls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->fls = u_fls.real; offset += sizeof(this->fls); union { float real; uint32_t base; } u_fle; u_fle.base = 0; u_fle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_fle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_fle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_fle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->fle = u_fle.real; offset += sizeof(this->fle); union { float real; uint32_t base; } u_flw; u_flw.base = 0; u_flw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_flw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_flw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_flw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->flw = u_flw.real; offset += sizeof(this->flw); union { float real; uint32_t base; } u_frs; u_frs.base = 0; u_frs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_frs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_frs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_frs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->frs = u_frs.real; offset += sizeof(this->frs); union { float real; uint32_t base; } u_fre; u_fre.base = 0; u_fre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_fre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_fre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_fre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->fre = u_fre.real; offset += sizeof(this->fre); union { float real; uint32_t base; } u_frw; u_frw.base = 0; u_frw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_frw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_frw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_frw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->frw = u_frw.real; offset += sizeof(this->frw); union { float real; uint32_t base; } u_bls; u_bls.base = 0; u_bls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_bls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_bls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_bls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->bls = u_bls.real; offset += sizeof(this->bls); union { float real; uint32_t base; } u_ble; u_ble.base = 0; u_ble.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_ble.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_ble.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_ble.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->ble = u_ble.real; offset += sizeof(this->ble); union { float real; uint32_t base; } u_blw; u_blw.base = 0; u_blw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_blw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_blw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_blw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->blw = u_blw.real; offset += sizeof(this->blw); union { float real; uint32_t base; } u_brs; u_brs.base = 0; u_brs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_brs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_brs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_brs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->brs = u_brs.real; offset += sizeof(this->brs); union { float real; uint32_t base; } u_bre; u_bre.base = 0; u_bre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_bre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_bre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_bre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->bre = u_bre.real; offset += sizeof(this->bre); union { float real; uint32_t base; } u_brw; u_brw.base = 0; u_brw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_brw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_brw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_brw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->brw = u_brw.real; offset += sizeof(this->brw); union { bool real; uint8_t base; } u_step_or_view; u_step_or_view.base = 0; u_step_or_view.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->step_or_view = u_step_or_view.real; offset += sizeof(this->step_or_view); return offset; } const char * getType(){ return "mini_ros/JointAngles"; }; const char * getMD5(){ return "54bfcd55046a61d9df3827d322506389"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/stereo_msgs/DisparityImage.h

#ifndef _ROS_stereo_msgs_DisparityImage_h #define _ROS_stereo_msgs_DisparityImage_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "sensor_msgs/Image.h" #include "sensor_msgs/RegionOfInterest.h" namespace stereo_msgs { class DisparityImage : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef sensor_msgs::Image _image_type; _image_type image; typedef float _f_type; _f_type f; typedef float _T_type; _T_type T; typedef sensor_msgs::RegionOfInterest _valid_window_type; _valid_window_type valid_window; typedef float _min_disparity_type; _min_disparity_type min_disparity; typedef float _max_disparity_type; _max_disparity_type max_disparity; typedef float _delta_d_type; _delta_d_type delta_d; DisparityImage(): header(), image(), f(0), T(0), valid_window(), min_disparity(0), max_disparity(0), delta_d(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->image.serialize(outbuffer + offset); union { float real; uint32_t base; } u_f; u_f.real = this->f; *(outbuffer + offset + 0) = (u_f.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_f.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_f.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_f.base >> (8 * 3)) & 0xFF; offset += sizeof(this->f); union { float real; uint32_t base; } u_T; u_T.real = this->T; *(outbuffer + offset + 0) = (u_T.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_T.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_T.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_T.base >> (8 * 3)) & 0xFF; offset += sizeof(this->T); offset += this->valid_window.serialize(outbuffer + offset); union { float real; uint32_t base; } u_min_disparity; u_min_disparity.real = this->min_disparity; *(outbuffer + offset + 0) = (u_min_disparity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_min_disparity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_min_disparity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_min_disparity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->min_disparity); union { float real; uint32_t base; } u_max_disparity; u_max_disparity.real = this->max_disparity; *(outbuffer + offset + 0) = (u_max_disparity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_disparity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_disparity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_disparity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->max_disparity); union { float real; uint32_t base; } u_delta_d; u_delta_d.real = this->delta_d; *(outbuffer + offset + 0) = (u_delta_d.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_delta_d.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_delta_d.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_delta_d.base >> (8 * 3)) & 0xFF; offset += sizeof(this->delta_d); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->image.deserialize(inbuffer + offset); union { float real; uint32_t base; } u_f; u_f.base = 0; u_f.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_f.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_f.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_f.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->f = u_f.real; offset += sizeof(this->f); union { float real; uint32_t base; } u_T; u_T.base = 0; u_T.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_T.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_T.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_T.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->T = u_T.real; offset += sizeof(this->T); offset += this->valid_window.deserialize(inbuffer + offset); union { float real; uint32_t base; } u_min_disparity; u_min_disparity.base = 0; u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->min_disparity = u_min_disparity.real; offset += sizeof(this->min_disparity); union { float real; uint32_t base; } u_max_disparity; u_max_disparity.base = 0; u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->max_disparity = u_max_disparity.real; offset += sizeof(this->max_disparity); union { float real; uint32_t base; } u_delta_d; u_delta_d.base = 0; u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->delta_d = u_delta_d.real; offset += sizeof(this->delta_d); return offset; } const char * getType(){ return "stereo_msgs/DisparityImage"; }; const char * getMD5(){ return "04a177815f75271039fa21f16acad8c9"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/RobustControllerStatus.h

#ifndef _ROS_baxter_core_msgs_RobustControllerStatus_h #define _ROS_baxter_core_msgs_RobustControllerStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { class RobustControllerStatus : public ros::Msg { public: typedef bool _isEnabled_type; _isEnabled_type isEnabled; typedef int32_t _complete_type; _complete_type complete; typedef const char* _controlUid_type; _controlUid_type controlUid; typedef bool _timedOut_type; _timedOut_type timedOut; uint32_t errorCodes_length; typedef char* _errorCodes_type; _errorCodes_type st_errorCodes; _errorCodes_type * errorCodes; uint32_t labels_length; typedef char* _labels_type; _labels_type st_labels; _labels_type * labels; enum { NOT_COMPLETE = 0 }; enum { COMPLETE_W_FAILURE = 1 }; enum { COMPLETE_W_SUCCESS = 2 }; RobustControllerStatus(): isEnabled(0), complete(0), controlUid(""), timedOut(0), errorCodes_length(0), errorCodes(NULL), labels_length(0), labels(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_isEnabled; u_isEnabled.real = this->isEnabled; *(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isEnabled); union { int32_t real; uint32_t base; } u_complete; u_complete.real = this->complete; *(outbuffer + offset + 0) = (u_complete.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_complete.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_complete.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_complete.base >> (8 * 3)) & 0xFF; offset += sizeof(this->complete); uint32_t length_controlUid = strlen(this->controlUid); varToArr(outbuffer + offset, length_controlUid); offset += 4; memcpy(outbuffer + offset, this->controlUid, length_controlUid); offset += length_controlUid; union { bool real; uint8_t base; } u_timedOut; u_timedOut.real = this->timedOut; *(outbuffer + offset + 0) = (u_timedOut.base >> (8 * 0)) & 0xFF; offset += sizeof(this->timedOut); *(outbuffer + offset + 0) = (this->errorCodes_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->errorCodes_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->errorCodes_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->errorCodes_length >> (8 * 3)) & 0xFF; offset += sizeof(this->errorCodes_length); for( uint32_t i = 0; i < errorCodes_length; i++){ uint32_t length_errorCodesi = strlen(this->errorCodes[i]); varToArr(outbuffer + offset, length_errorCodesi); offset += 4; memcpy(outbuffer + offset, this->errorCodes[i], length_errorCodesi); offset += length_errorCodesi; } *(outbuffer + offset + 0) = (this->labels_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->labels_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->labels_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->labels_length >> (8 * 3)) & 0xFF; offset += sizeof(this->labels_length); for( uint32_t i = 0; i < labels_length; i++){ uint32_t length_labelsi = strlen(this->labels[i]); varToArr(outbuffer + offset, length_labelsi); offset += 4; memcpy(outbuffer + offset, this->labels[i], length_labelsi); offset += length_labelsi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_isEnabled; u_isEnabled.base = 0; u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isEnabled = u_isEnabled.real; offset += sizeof(this->isEnabled); union { int32_t real; uint32_t base; } u_complete; u_complete.base = 0; u_complete.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_complete.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_complete.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_complete.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->complete = u_complete.real; offset += sizeof(this->complete); uint32_t length_controlUid; arrToVar(length_controlUid, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_controlUid; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_controlUid-1]=0; this->controlUid = (char *)(inbuffer + offset-1); offset += length_controlUid; union { bool real; uint8_t base; } u_timedOut; u_timedOut.base = 0; u_timedOut.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->timedOut = u_timedOut.real; offset += sizeof(this->timedOut); uint32_t errorCodes_lengthT = ((uint32_t) (*(inbuffer + offset))); errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->errorCodes_length); if(errorCodes_lengthT > errorCodes_length) this->errorCodes = (char**)realloc(this->errorCodes, errorCodes_lengthT * sizeof(char*)); errorCodes_length = errorCodes_lengthT; for( uint32_t i = 0; i < errorCodes_length; i++){ uint32_t length_st_errorCodes; arrToVar(length_st_errorCodes, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_errorCodes; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_errorCodes-1]=0; this->st_errorCodes = (char *)(inbuffer + offset-1); offset += length_st_errorCodes; memcpy( &(this->errorCodes[i]), &(this->st_errorCodes), sizeof(char*)); } uint32_t labels_lengthT = ((uint32_t) (*(inbuffer + offset))); labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->labels_length); if(labels_lengthT > labels_length) this->labels = (char**)realloc(this->labels, labels_lengthT * sizeof(char*)); labels_length = labels_lengthT; for( uint32_t i = 0; i < labels_length; i++){ uint32_t length_st_labels; arrToVar(length_st_labels, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_labels; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_labels-1]=0; this->st_labels = (char *)(inbuffer + offset-1); offset += length_st_labels; memcpy( &(this->labels[i]), &(this->st_labels), sizeof(char*)); } return offset; } const char * getType(){ return "baxter_core_msgs/RobustControllerStatus"; }; const char * getMD5(){ return "2f15441b7285d915e7e59d3618e173f2"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CloseCamera.h

#ifndef _ROS_SERVICE_CloseCamera_h #define _ROS_SERVICE_CloseCamera_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { static const char CLOSECAMERA[] = "baxter_core_msgs/CloseCamera"; class CloseCameraRequest : public ros::Msg { public: typedef const char* _name_type; _name_type name; CloseCameraRequest(): name("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; return offset; } const char * getType(){ return CLOSECAMERA; }; const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; }; }; class CloseCameraResponse : public ros::Msg { public: typedef int32_t _err_type; _err_type err; CloseCameraResponse(): err(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int32_t real; uint32_t base; } u_err; u_err.real = this->err; *(outbuffer + offset + 0) = (u_err.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_err.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_err.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_err.base >> (8 * 3)) & 0xFF; offset += sizeof(this->err); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int32_t real; uint32_t base; } u_err; u_err.base = 0; u_err.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_err.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_err.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_err.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->err = u_err.real; offset += sizeof(this->err); return offset; } const char * getType(){ return CLOSECAMERA; }; const char * getMD5(){ return "b6e094011a4dfaee5eddf447220446cf"; }; }; class CloseCamera { public: typedef CloseCameraRequest Request; typedef CloseCameraResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorProperties.h

#ifndef _ROS_baxter_core_msgs_EndEffectorProperties_h #define _ROS_baxter_core_msgs_EndEffectorProperties_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { class EndEffectorProperties : public ros::Msg { public: typedef uint32_t _id_type; _id_type id; typedef uint8_t _ui_type_type; _ui_type_type ui_type; typedef const char* _manufacturer_type; _manufacturer_type manufacturer; typedef const char* _product_type; _product_type product; typedef const char* _serial_number_type; _serial_number_type serial_number; typedef const char* _hardware_rev_type; _hardware_rev_type hardware_rev; typedef const char* _firmware_rev_type; _firmware_rev_type firmware_rev; typedef const char* _firmware_date_type; _firmware_date_type firmware_date; typedef bool _has_calibration_type; _has_calibration_type has_calibration; typedef bool _controls_grip_type; _controls_grip_type controls_grip; typedef bool _senses_grip_type; _senses_grip_type senses_grip; typedef bool _reverses_grip_type; _reverses_grip_type reverses_grip; typedef bool _controls_force_type; _controls_force_type controls_force; typedef bool _senses_force_type; _senses_force_type senses_force; typedef bool _controls_position_type; _controls_position_type controls_position; typedef bool _senses_position_type; _senses_position_type senses_position; typedef const char* _properties_type; _properties_type properties; enum { NO_GRIPPER = 0 }; enum { SUCTION_CUP_GRIPPER = 1 }; enum { ELECTRIC_GRIPPER = 2 }; enum { PASSIVE_GRIPPER = 3 }; EndEffectorProperties(): id(0), ui_type(0), manufacturer(""), product(""), serial_number(""), hardware_rev(""), firmware_rev(""), firmware_date(""), has_calibration(0), controls_grip(0), senses_grip(0), reverses_grip(0), controls_force(0), senses_force(0), controls_position(0), senses_position(0), properties("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF; offset += sizeof(this->id); *(outbuffer + offset + 0) = (this->ui_type >> (8 * 0)) & 0xFF; offset += sizeof(this->ui_type); uint32_t length_manufacturer = strlen(this->manufacturer); varToArr(outbuffer + offset, length_manufacturer); offset += 4; memcpy(outbuffer + offset, this->manufacturer, length_manufacturer); offset += length_manufacturer; uint32_t length_product = strlen(this->product); varToArr(outbuffer + offset, length_product); offset += 4; memcpy(outbuffer + offset, this->product, length_product); offset += length_product; uint32_t length_serial_number = strlen(this->serial_number); varToArr(outbuffer + offset, length_serial_number); offset += 4; memcpy(outbuffer + offset, this->serial_number, length_serial_number); offset += length_serial_number; uint32_t length_hardware_rev = strlen(this->hardware_rev); varToArr(outbuffer + offset, length_hardware_rev); offset += 4; memcpy(outbuffer + offset, this->hardware_rev, length_hardware_rev); offset += length_hardware_rev; uint32_t length_firmware_rev = strlen(this->firmware_rev); varToArr(outbuffer + offset, length_firmware_rev); offset += 4; memcpy(outbuffer + offset, this->firmware_rev, length_firmware_rev); offset += length_firmware_rev; uint32_t length_firmware_date = strlen(this->firmware_date); varToArr(outbuffer + offset, length_firmware_date); offset += 4; memcpy(outbuffer + offset, this->firmware_date, length_firmware_date); offset += length_firmware_date; union { bool real; uint8_t base; } u_has_calibration; u_has_calibration.real = this->has_calibration; *(outbuffer + offset + 0) = (u_has_calibration.base >> (8 * 0)) & 0xFF; offset += sizeof(this->has_calibration); union { bool real; uint8_t base; } u_controls_grip; u_controls_grip.real = this->controls_grip; *(outbuffer + offset + 0) = (u_controls_grip.base >> (8 * 0)) & 0xFF; offset += sizeof(this->controls_grip); union { bool real; uint8_t base; } u_senses_grip; u_senses_grip.real = this->senses_grip; *(outbuffer + offset + 0) = (u_senses_grip.base >> (8 * 0)) & 0xFF; offset += sizeof(this->senses_grip); union { bool real; uint8_t base; } u_reverses_grip; u_reverses_grip.real = this->reverses_grip; *(outbuffer + offset + 0) = (u_reverses_grip.base >> (8 * 0)) & 0xFF; offset += sizeof(this->reverses_grip); union { bool real; uint8_t base; } u_controls_force; u_controls_force.real = this->controls_force; *(outbuffer + offset + 0) = (u_controls_force.base >> (8 * 0)) & 0xFF; offset += sizeof(this->controls_force); union { bool real; uint8_t base; } u_senses_force; u_senses_force.real = this->senses_force; *(outbuffer + offset + 0) = (u_senses_force.base >> (8 * 0)) & 0xFF; offset += sizeof(this->senses_force); union { bool real; uint8_t base; } u_controls_position; u_controls_position.real = this->controls_position; *(outbuffer + offset + 0) = (u_controls_position.base >> (8 * 0)) & 0xFF; offset += sizeof(this->controls_position); union { bool real; uint8_t base; } u_senses_position; u_senses_position.real = this->senses_position; *(outbuffer + offset + 0) = (u_senses_position.base >> (8 * 0)) & 0xFF; offset += sizeof(this->senses_position); uint32_t length_properties = strlen(this->properties); varToArr(outbuffer + offset, length_properties); offset += 4; memcpy(outbuffer + offset, this->properties, length_properties); offset += length_properties; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->id = ((uint32_t) (*(inbuffer + offset))); this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->id); this->ui_type = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->ui_type); uint32_t length_manufacturer; arrToVar(length_manufacturer, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_manufacturer; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_manufacturer-1]=0; this->manufacturer = (char *)(inbuffer + offset-1); offset += length_manufacturer; uint32_t length_product; arrToVar(length_product, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_product; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_product-1]=0; this->product = (char *)(inbuffer + offset-1); offset += length_product; uint32_t length_serial_number; arrToVar(length_serial_number, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_serial_number; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_serial_number-1]=0; this->serial_number = (char *)(inbuffer + offset-1); offset += length_serial_number; uint32_t length_hardware_rev; arrToVar(length_hardware_rev, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_hardware_rev; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_hardware_rev-1]=0; this->hardware_rev = (char *)(inbuffer + offset-1); offset += length_hardware_rev; uint32_t length_firmware_rev; arrToVar(length_firmware_rev, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_firmware_rev; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_firmware_rev-1]=0; this->firmware_rev = (char *)(inbuffer + offset-1); offset += length_firmware_rev; uint32_t length_firmware_date; arrToVar(length_firmware_date, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_firmware_date; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_firmware_date-1]=0; this->firmware_date = (char *)(inbuffer + offset-1); offset += length_firmware_date; union { bool real; uint8_t base; } u_has_calibration; u_has_calibration.base = 0; u_has_calibration.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->has_calibration = u_has_calibration.real; offset += sizeof(this->has_calibration); union { bool real; uint8_t base; } u_controls_grip; u_controls_grip.base = 0; u_controls_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->controls_grip = u_controls_grip.real; offset += sizeof(this->controls_grip); union { bool real; uint8_t base; } u_senses_grip; u_senses_grip.base = 0; u_senses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->senses_grip = u_senses_grip.real; offset += sizeof(this->senses_grip); union { bool real; uint8_t base; } u_reverses_grip; u_reverses_grip.base = 0; u_reverses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->reverses_grip = u_reverses_grip.real; offset += sizeof(this->reverses_grip); union { bool real; uint8_t base; } u_controls_force; u_controls_force.base = 0; u_controls_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->controls_force = u_controls_force.real; offset += sizeof(this->controls_force); union { bool real; uint8_t base; } u_senses_force; u_senses_force.base = 0; u_senses_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->senses_force = u_senses_force.real; offset += sizeof(this->senses_force); union { bool real; uint8_t base; } u_controls_position; u_controls_position.base = 0; u_controls_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->controls_position = u_controls_position.real; offset += sizeof(this->controls_position); union { bool real; uint8_t base; } u_senses_position; u_senses_position.base = 0; u_senses_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->senses_position = u_senses_position.real; offset += sizeof(this->senses_position); uint32_t length_properties; arrToVar(length_properties, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_properties; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_properties-1]=0; this->properties = (char *)(inbuffer + offset-1); offset += length_properties; return offset; } const char * getType(){ return "baxter_core_msgs/EndEffectorProperties"; }; const char * getMD5(){ return "21b83773ab9a35216d11e427573c76cc"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/SolvePositionIK.h

#ifndef _ROS_SERVICE_SolvePositionIK_h #define _ROS_SERVICE_SolvePositionIK_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "geometry_msgs/PoseStamped.h" #include "sensor_msgs/JointState.h" namespace baxter_core_msgs { static const char SOLVEPOSITIONIK[] = "baxter_core_msgs/SolvePositionIK"; class SolvePositionIKRequest : public ros::Msg { public: uint32_t pose_stamp_length; typedef geometry_msgs::PoseStamped _pose_stamp_type; _pose_stamp_type st_pose_stamp; _pose_stamp_type * pose_stamp; uint32_t seed_angles_length; typedef sensor_msgs::JointState _seed_angles_type; _seed_angles_type st_seed_angles; _seed_angles_type * seed_angles; typedef uint8_t _seed_mode_type; _seed_mode_type seed_mode; enum { SEED_AUTO = 0 }; enum { SEED_USER = 1 }; enum { SEED_CURRENT = 2 }; enum { SEED_NS_MAP = 3 }; SolvePositionIKRequest(): pose_stamp_length(0), pose_stamp(NULL), seed_angles_length(0), seed_angles(NULL), seed_mode(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->pose_stamp_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->pose_stamp_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->pose_stamp_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->pose_stamp_length >> (8 * 3)) & 0xFF; offset += sizeof(this->pose_stamp_length); for( uint32_t i = 0; i < pose_stamp_length; i++){ offset += this->pose_stamp[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->seed_angles_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->seed_angles_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->seed_angles_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->seed_angles_length >> (8 * 3)) & 0xFF; offset += sizeof(this->seed_angles_length); for( uint32_t i = 0; i < seed_angles_length; i++){ offset += this->seed_angles[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->seed_mode >> (8 * 0)) & 0xFF; offset += sizeof(this->seed_mode); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t pose_stamp_lengthT = ((uint32_t) (*(inbuffer + offset))); pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->pose_stamp_length); if(pose_stamp_lengthT > pose_stamp_length) this->pose_stamp = (geometry_msgs::PoseStamped*)realloc(this->pose_stamp, pose_stamp_lengthT * sizeof(geometry_msgs::PoseStamped)); pose_stamp_length = pose_stamp_lengthT; for( uint32_t i = 0; i < pose_stamp_length; i++){ offset += this->st_pose_stamp.deserialize(inbuffer + offset); memcpy( &(this->pose_stamp[i]), &(this->st_pose_stamp), sizeof(geometry_msgs::PoseStamped)); } uint32_t seed_angles_lengthT = ((uint32_t) (*(inbuffer + offset))); seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->seed_angles_length); if(seed_angles_lengthT > seed_angles_length) this->seed_angles = (sensor_msgs::JointState*)realloc(this->seed_angles, seed_angles_lengthT * sizeof(sensor_msgs::JointState)); seed_angles_length = seed_angles_lengthT; for( uint32_t i = 0; i < seed_angles_length; i++){ offset += this->st_seed_angles.deserialize(inbuffer + offset); memcpy( &(this->seed_angles[i]), &(this->st_seed_angles), sizeof(sensor_msgs::JointState)); } this->seed_mode = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->seed_mode); return offset; } const char * getType(){ return SOLVEPOSITIONIK; }; const char * getMD5(){ return "2587e42983d0081d0a2288230991073b"; }; }; class SolvePositionIKResponse : public ros::Msg { public: uint32_t joints_length; typedef sensor_msgs::JointState _joints_type; _joints_type st_joints; _joints_type * joints; uint32_t isValid_length; typedef bool _isValid_type; _isValid_type st_isValid; _isValid_type * isValid; uint32_t result_type_length; typedef uint8_t _result_type_type; _result_type_type st_result_type; _result_type_type * result_type; enum { RESULT_INVALID = 0 }; SolvePositionIKResponse(): joints_length(0), joints(NULL), isValid_length(0), isValid(NULL), result_type_length(0), result_type(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->joints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->joints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->joints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->joints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->joints_length); for( uint32_t i = 0; i < joints_length; i++){ offset += this->joints[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->isValid_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->isValid_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->isValid_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->isValid_length >> (8 * 3)) & 0xFF; offset += sizeof(this->isValid_length); for( uint32_t i = 0; i < isValid_length; i++){ union { bool real; uint8_t base; } u_isValidi; u_isValidi.real = this->isValid[i]; *(outbuffer + offset + 0) = (u_isValidi.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isValid[i]); } *(outbuffer + offset + 0) = (this->result_type_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->result_type_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->result_type_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->result_type_length >> (8 * 3)) & 0xFF; offset += sizeof(this->result_type_length); for( uint32_t i = 0; i < result_type_length; i++){ *(outbuffer + offset + 0) = (this->result_type[i] >> (8 * 0)) & 0xFF; offset += sizeof(this->result_type[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t joints_lengthT = ((uint32_t) (*(inbuffer + offset))); joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->joints_length); if(joints_lengthT > joints_length) this->joints = (sensor_msgs::JointState*)realloc(this->joints, joints_lengthT * sizeof(sensor_msgs::JointState)); joints_length = joints_lengthT; for( uint32_t i = 0; i < joints_length; i++){ offset += this->st_joints.deserialize(inbuffer + offset); memcpy( &(this->joints[i]), &(this->st_joints), sizeof(sensor_msgs::JointState)); } uint32_t isValid_lengthT = ((uint32_t) (*(inbuffer + offset))); isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->isValid_length); if(isValid_lengthT > isValid_length) this->isValid = (bool*)realloc(this->isValid, isValid_lengthT * sizeof(bool)); isValid_length = isValid_lengthT; for( uint32_t i = 0; i < isValid_length; i++){ union { bool real; uint8_t base; } u_st_isValid; u_st_isValid.base = 0; u_st_isValid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_isValid = u_st_isValid.real; offset += sizeof(this->st_isValid); memcpy( &(this->isValid[i]), &(this->st_isValid), sizeof(bool)); } uint32_t result_type_lengthT = ((uint32_t) (*(inbuffer + offset))); result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->result_type_length); if(result_type_lengthT > result_type_length) this->result_type = (uint8_t*)realloc(this->result_type, result_type_lengthT * sizeof(uint8_t)); result_type_length = result_type_lengthT; for( uint32_t i = 0; i < result_type_length; i++){ this->st_result_type = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->st_result_type); memcpy( &(this->result_type[i]), &(this->st_result_type), sizeof(uint8_t)); } return offset; } const char * getType(){ return SOLVEPOSITIONIK; }; const char * getMD5(){ return "d9b0c2b3932e08421f5094cf62743b9f"; }; }; class SolvePositionIK { public: typedef SolvePositionIKRequest Request; typedef SolvePositionIKResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/HeadState.h

#ifndef _ROS_baxter_core_msgs_HeadState_h #define _ROS_baxter_core_msgs_HeadState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { class HeadState : public ros::Msg { public: typedef float _pan_type; _pan_type pan; typedef bool _isTurning_type; _isTurning_type isTurning; typedef bool _isNodding_type; _isNodding_type isNodding; typedef bool _isPanEnabled_type; _isPanEnabled_type isPanEnabled; HeadState(): pan(0), isTurning(0), isNodding(0), isPanEnabled(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { float real; uint32_t base; } u_pan; u_pan.real = this->pan; *(outbuffer + offset + 0) = (u_pan.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_pan.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_pan.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_pan.base >> (8 * 3)) & 0xFF; offset += sizeof(this->pan); union { bool real; uint8_t base; } u_isTurning; u_isTurning.real = this->isTurning; *(outbuffer + offset + 0) = (u_isTurning.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isTurning); union { bool real; uint8_t base; } u_isNodding; u_isNodding.real = this->isNodding; *(outbuffer + offset + 0) = (u_isNodding.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isNodding); union { bool real; uint8_t base; } u_isPanEnabled; u_isPanEnabled.real = this->isPanEnabled; *(outbuffer + offset + 0) = (u_isPanEnabled.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isPanEnabled); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { float real; uint32_t base; } u_pan; u_pan.base = 0; u_pan.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_pan.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_pan.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_pan.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->pan = u_pan.real; offset += sizeof(this->pan); union { bool real; uint8_t base; } u_isTurning; u_isTurning.base = 0; u_isTurning.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isTurning = u_isTurning.real; offset += sizeof(this->isTurning); union { bool real; uint8_t base; } u_isNodding; u_isNodding.base = 0; u_isNodding.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isNodding = u_isNodding.real; offset += sizeof(this->isNodding); union { bool real; uint8_t base; } u_isPanEnabled; u_isPanEnabled.base = 0; u_isPanEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isPanEnabled = u_isPanEnabled.real; offset += sizeof(this->isPanEnabled); return offset; } const char * getType(){ return "baxter_core_msgs/HeadState"; }; const char * getMD5(){ return "71c43b264307205358e7e49be5601348"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/ListCameras.h

#ifndef _ROS_SERVICE_ListCameras_h #define _ROS_SERVICE_ListCameras_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { static const char LISTCAMERAS[] = "baxter_core_msgs/ListCameras"; class ListCamerasRequest : public ros::Msg { public: ListCamerasRequest() { } 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 LISTCAMERAS; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class ListCamerasResponse : public ros::Msg { public: uint32_t cameras_length; typedef char* _cameras_type; _cameras_type st_cameras; _cameras_type * cameras; ListCamerasResponse(): cameras_length(0), cameras(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->cameras_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->cameras_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->cameras_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->cameras_length >> (8 * 3)) & 0xFF; offset += sizeof(this->cameras_length); for( uint32_t i = 0; i < cameras_length; i++){ uint32_t length_camerasi = strlen(this->cameras[i]); varToArr(outbuffer + offset, length_camerasi); offset += 4; memcpy(outbuffer + offset, this->cameras[i], length_camerasi); offset += length_camerasi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t cameras_lengthT = ((uint32_t) (*(inbuffer + offset))); cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->cameras_length); if(cameras_lengthT > cameras_length) this->cameras = (char**)realloc(this->cameras, cameras_lengthT * sizeof(char*)); cameras_length = cameras_lengthT; for( uint32_t i = 0; i < cameras_length; i++){ uint32_t length_st_cameras; arrToVar(length_st_cameras, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_cameras; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_cameras-1]=0; this->st_cameras = (char *)(inbuffer + offset-1); offset += length_st_cameras; memcpy( &(this->cameras[i]), &(this->st_cameras), sizeof(char*)); } return offset; } const char * getType(){ return LISTCAMERAS; }; const char * getMD5(){ return "855b31192ab61744e7deb992d94db7ff"; }; }; class ListCameras { public: typedef ListCamerasRequest Request; typedef ListCamerasResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorState.h

#ifndef _ROS_baxter_core_msgs_EndEffectorState_h #define _ROS_baxter_core_msgs_EndEffectorState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" namespace baxter_core_msgs { class EndEffectorState : public ros::Msg { public: typedef ros::Time _timestamp_type; _timestamp_type timestamp; typedef uint32_t _id_type; _id_type id; typedef uint8_t _enabled_type; _enabled_type enabled; typedef uint8_t _calibrated_type; _calibrated_type calibrated; typedef uint8_t _ready_type; _ready_type ready; typedef uint8_t _moving_type; _moving_type moving; typedef uint8_t _gripping_type; _gripping_type gripping; typedef uint8_t _missed_type; _missed_type missed; typedef uint8_t _error_type; _error_type error; typedef uint8_t _reverse_type; _reverse_type reverse; typedef float _position_type; _position_type position; typedef float _force_type; _force_type force; typedef const char* _state_type; _state_type state; typedef const char* _command_type; _command_type command; typedef const char* _command_sender_type; _command_sender_type command_sender; typedef uint32_t _command_sequence_type; _command_sequence_type command_sequence; enum { STATE_FALSE = 0 }; enum { STATE_TRUE = 1 }; enum { STATE_UNKNOWN = 2 }; enum { POSITION_CLOSED = 0.0 }; enum { POSITION_OPEN = 100.0 }; enum { FORCE_MIN = 0.0 }; enum { FORCE_MAX = 100.0 }; EndEffectorState(): timestamp(), id(0), enabled(0), calibrated(0), ready(0), moving(0), gripping(0), missed(0), error(0), reverse(0), position(0), force(0), state(""), command(""), command_sender(""), command_sequence(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->timestamp.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->timestamp.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->timestamp.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->timestamp.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->timestamp.sec); *(outbuffer + offset + 0) = (this->timestamp.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->timestamp.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->timestamp.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->timestamp.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->timestamp.nsec); *(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->enabled >> (8 * 0)) & 0xFF; offset += sizeof(this->enabled); *(outbuffer + offset + 0) = (this->calibrated >> (8 * 0)) & 0xFF; offset += sizeof(this->calibrated); *(outbuffer + offset + 0) = (this->ready >> (8 * 0)) & 0xFF; offset += sizeof(this->ready); *(outbuffer + offset + 0) = (this->moving >> (8 * 0)) & 0xFF; offset += sizeof(this->moving); *(outbuffer + offset + 0) = (this->gripping >> (8 * 0)) & 0xFF; offset += sizeof(this->gripping); *(outbuffer + offset + 0) = (this->missed >> (8 * 0)) & 0xFF; offset += sizeof(this->missed); *(outbuffer + offset + 0) = (this->error >> (8 * 0)) & 0xFF; offset += sizeof(this->error); *(outbuffer + offset + 0) = (this->reverse >> (8 * 0)) & 0xFF; offset += sizeof(this->reverse); union { float real; uint32_t base; } u_position; u_position.real = this->position; *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF; offset += sizeof(this->position); union { float real; uint32_t base; } u_force; u_force.real = this->force; *(outbuffer + offset + 0) = (u_force.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_force.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_force.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_force.base >> (8 * 3)) & 0xFF; offset += sizeof(this->force); uint32_t length_state = strlen(this->state); varToArr(outbuffer + offset, length_state); offset += 4; memcpy(outbuffer + offset, this->state, length_state); offset += length_state; uint32_t length_command = strlen(this->command); varToArr(outbuffer + offset, length_command); offset += 4; memcpy(outbuffer + offset, this->command, length_command); offset += length_command; uint32_t length_command_sender = strlen(this->command_sender); varToArr(outbuffer + offset, length_command_sender); offset += 4; memcpy(outbuffer + offset, this->command_sender, length_command_sender); offset += length_command_sender; *(outbuffer + offset + 0) = (this->command_sequence >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->command_sequence >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->command_sequence >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->command_sequence >> (8 * 3)) & 0xFF; offset += sizeof(this->command_sequence); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->timestamp.sec = ((uint32_t) (*(inbuffer + offset))); this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->timestamp.sec); this->timestamp.nsec = ((uint32_t) (*(inbuffer + offset))); this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->timestamp.nsec); 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->enabled = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->enabled); this->calibrated = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->calibrated); this->ready = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->ready); this->moving = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->moving); this->gripping = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->gripping); this->missed = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->missed); this->error = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->error); this->reverse = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->reverse); union { float real; uint32_t base; } u_position; u_position.base = 0; u_position.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_position.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_position.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_position.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->position = u_position.real; offset += sizeof(this->position); union { float real; uint32_t base; } u_force; u_force.base = 0; u_force.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_force.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_force.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_force.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->force = u_force.real; offset += sizeof(this->force); uint32_t length_state; arrToVar(length_state, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_state; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_state-1]=0; this->state = (char *)(inbuffer + offset-1); offset += length_state; 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; uint32_t length_command_sender; arrToVar(length_command_sender, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_command_sender; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_command_sender-1]=0; this->command_sender = (char *)(inbuffer + offset-1); offset += length_command_sender; this->command_sequence = ((uint32_t) (*(inbuffer + offset))); this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->command_sequence); return offset; } const char * getType(){ return "baxter_core_msgs/EndEffectorState"; }; const char * getMD5(){ return "ade777f069d738595bc19e246b8ec7a0"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorCommand.h

#ifndef _ROS_baxter_core_msgs_EndEffectorCommand_h #define _ROS_baxter_core_msgs_EndEffectorCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { class EndEffectorCommand : public ros::Msg { public: typedef uint32_t _id_type; _id_type id; typedef const char* _command_type; _command_type command; typedef const char* _args_type; _args_type args; typedef const char* _sender_type; _sender_type sender; typedef uint32_t _sequence_type; _sequence_type sequence; enum { CMD_NO_OP = no_op }; enum { CMD_SET = set }; enum { CMD_CONFIGURE = configure }; enum { CMD_REBOOT = reboot }; enum { CMD_RESET = reset }; enum { CMD_CALIBRATE = calibrate }; enum { CMD_CLEAR_CALIBRATION = clear_calibration }; enum { CMD_PREPARE_TO_GRIP = prepare_to_grip }; enum { CMD_GRIP = grip }; enum { CMD_RELEASE = release }; enum { CMD_GO = go }; enum { CMD_STOP = stop }; EndEffectorCommand(): id(0), command(""), args(""), sender(""), sequence(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); uint32_t length_command = strlen(this->command); varToArr(outbuffer + offset, length_command); offset += 4; memcpy(outbuffer + offset, this->command, length_command); offset += length_command; uint32_t length_args = strlen(this->args); varToArr(outbuffer + offset, length_args); offset += 4; memcpy(outbuffer + offset, this->args, length_args); offset += length_args; uint32_t length_sender = strlen(this->sender); varToArr(outbuffer + offset, length_sender); offset += 4; memcpy(outbuffer + offset, this->sender, length_sender); offset += length_sender; *(outbuffer + offset + 0) = (this->sequence >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->sequence >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->sequence >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->sequence >> (8 * 3)) & 0xFF; offset += sizeof(this->sequence); 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); 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; uint32_t length_args; arrToVar(length_args, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_args; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_args-1]=0; this->args = (char *)(inbuffer + offset-1); offset += length_args; uint32_t length_sender; arrToVar(length_sender, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_sender; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_sender-1]=0; this->sender = (char *)(inbuffer + offset-1); offset += length_sender; this->sequence = ((uint32_t) (*(inbuffer + offset))); this->sequence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->sequence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->sequence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->sequence); return offset; } const char * getType(){ return "baxter_core_msgs/EndEffectorCommand"; }; const char * getMD5(){ return "c003234e90416f2ca02ac7837c42cbb7"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/HeadPanCommand.h

#ifndef _ROS_baxter_core_msgs_HeadPanCommand_h #define _ROS_baxter_core_msgs_HeadPanCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { class HeadPanCommand : public ros::Msg { public: typedef float _target_type; _target_type target; typedef float _speed_ratio_type; _speed_ratio_type speed_ratio; typedef uint8_t _enable_pan_request_type; _enable_pan_request_type enable_pan_request; enum { MAX_SPEED_RATIO = 1.0 }; enum { MIN_SPEED_RATIO = 0.0 }; enum { REQUEST_PAN_DISABLE = 0 }; enum { REQUEST_PAN_ENABLE = 1 }; enum { REQUEST_PAN_VOID = 2 }; HeadPanCommand(): target(0), speed_ratio(0), enable_pan_request(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { float real; uint32_t base; } u_target; u_target.real = this->target; *(outbuffer + offset + 0) = (u_target.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_target.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_target.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_target.base >> (8 * 3)) & 0xFF; offset += sizeof(this->target); union { float real; uint32_t base; } u_speed_ratio; u_speed_ratio.real = this->speed_ratio; *(outbuffer + offset + 0) = (u_speed_ratio.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_speed_ratio.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_speed_ratio.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_speed_ratio.base >> (8 * 3)) & 0xFF; offset += sizeof(this->speed_ratio); *(outbuffer + offset + 0) = (this->enable_pan_request >> (8 * 0)) & 0xFF; offset += sizeof(this->enable_pan_request); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { float real; uint32_t base; } u_target; u_target.base = 0; u_target.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_target.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_target.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_target.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->target = u_target.real; offset += sizeof(this->target); union { float real; uint32_t base; } u_speed_ratio; u_speed_ratio.base = 0; u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->speed_ratio = u_speed_ratio.real; offset += sizeof(this->speed_ratio); this->enable_pan_request = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->enable_pan_request); return offset; } const char * getType(){ return "baxter_core_msgs/HeadPanCommand"; }; const char * getMD5(){ return "23b8a3f4b7ee9de7099d029e57660a8c"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AssemblyState.h

#ifndef _ROS_baxter_core_msgs_AssemblyState_h #define _ROS_baxter_core_msgs_AssemblyState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { class AssemblyState : public ros::Msg { public: typedef bool _ready_type; _ready_type ready; typedef bool _enabled_type; _enabled_type enabled; typedef bool _stopped_type; _stopped_type stopped; typedef bool _error_type; _error_type error; typedef uint8_t _estop_button_type; _estop_button_type estop_button; typedef uint8_t _estop_source_type; _estop_source_type estop_source; enum { ESTOP_BUTTON_UNPRESSED = 0 }; enum { ESTOP_BUTTON_PRESSED = 1 }; enum { ESTOP_BUTTON_UNKNOWN = 2 }; enum { ESTOP_BUTTON_RELEASED = 3 }; enum { ESTOP_SOURCE_NONE = 0 }; enum { ESTOP_SOURCE_USER = 1 }; enum { ESTOP_SOURCE_UNKNOWN = 2 }; enum { ESTOP_SOURCE_FAULT = 3 }; enum { ESTOP_SOURCE_BRAIN = 4 }; AssemblyState(): ready(0), enabled(0), stopped(0), error(0), estop_button(0), estop_source(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_ready; u_ready.real = this->ready; *(outbuffer + offset + 0) = (u_ready.base >> (8 * 0)) & 0xFF; offset += sizeof(this->ready); union { bool real; uint8_t base; } u_enabled; u_enabled.real = this->enabled; *(outbuffer + offset + 0) = (u_enabled.base >> (8 * 0)) & 0xFF; offset += sizeof(this->enabled); union { bool real; uint8_t base; } u_stopped; u_stopped.real = this->stopped; *(outbuffer + offset + 0) = (u_stopped.base >> (8 * 0)) & 0xFF; offset += sizeof(this->stopped); union { bool real; uint8_t base; } u_error; u_error.real = this->error; *(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF; offset += sizeof(this->error); *(outbuffer + offset + 0) = (this->estop_button >> (8 * 0)) & 0xFF; offset += sizeof(this->estop_button); *(outbuffer + offset + 0) = (this->estop_source >> (8 * 0)) & 0xFF; offset += sizeof(this->estop_source); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_ready; u_ready.base = 0; u_ready.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->ready = u_ready.real; offset += sizeof(this->ready); union { bool real; uint8_t base; } u_enabled; u_enabled.base = 0; u_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->enabled = u_enabled.real; offset += sizeof(this->enabled); union { bool real; uint8_t base; } u_stopped; u_stopped.base = 0; u_stopped.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->stopped = u_stopped.real; offset += sizeof(this->stopped); union { bool real; uint8_t base; } u_error; u_error.base = 0; u_error.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->error = u_error.real; offset += sizeof(this->error); this->estop_button = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->estop_button); this->estop_source = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->estop_source); return offset; } const char * getType(){ return "baxter_core_msgs/AssemblyState"; }; const char * getMD5(){ return "356d9dd237ce73b2667da9235f541933"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/JointCommand.h

#ifndef _ROS_baxter_core_msgs_JointCommand_h #define _ROS_baxter_core_msgs_JointCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_core_msgs { class JointCommand : public ros::Msg { public: typedef int32_t _mode_type; _mode_type mode; uint32_t command_length; typedef double _command_type; _command_type st_command; _command_type * command; uint32_t names_length; typedef char* _names_type; _names_type st_names; _names_type * names; enum { POSITION_MODE = 1 }; enum { VELOCITY_MODE = 2 }; enum { TORQUE_MODE = 3 }; enum { RAW_POSITION_MODE = 4 }; JointCommand(): mode(0), command_length(0), command(NULL), names_length(0), names(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int32_t real; uint32_t base; } u_mode; u_mode.real = this->mode; *(outbuffer + offset + 0) = (u_mode.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_mode.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_mode.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_mode.base >> (8 * 3)) & 0xFF; offset += sizeof(this->mode); *(outbuffer + offset + 0) = (this->command_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->command_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->command_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->command_length >> (8 * 3)) & 0xFF; offset += sizeof(this->command_length); for( uint32_t i = 0; i < command_length; i++){ union { double real; uint64_t base; } u_commandi; u_commandi.real = this->command[i]; *(outbuffer + offset + 0) = (u_commandi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_commandi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_commandi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_commandi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_commandi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_commandi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_commandi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_commandi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->command[i]); } *(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->names_length); for( uint32_t i = 0; i < names_length; i++){ uint32_t length_namesi = strlen(this->names[i]); varToArr(outbuffer + offset, length_namesi); offset += 4; memcpy(outbuffer + offset, this->names[i], length_namesi); offset += length_namesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int32_t real; uint32_t base; } u_mode; u_mode.base = 0; u_mode.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_mode.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_mode.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_mode.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->mode = u_mode.real; offset += sizeof(this->mode); uint32_t command_lengthT = ((uint32_t) (*(inbuffer + offset))); command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->command_length); if(command_lengthT > command_length) this->command = (double*)realloc(this->command, command_lengthT * sizeof(double)); command_length = command_lengthT; for( uint32_t i = 0; i < command_length; i++){ union { double real; uint64_t base; } u_st_command; u_st_command.base = 0; u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_command = u_st_command.real; offset += sizeof(this->st_command); memcpy( &(this->command[i]), &(this->st_command), sizeof(double)); } uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset))); names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->names_length); if(names_lengthT > names_length) this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*)); names_length = names_lengthT; for( uint32_t i = 0; i < names_length; i++){ uint32_t length_st_names; arrToVar(length_st_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_names-1]=0; this->st_names = (char *)(inbuffer + offset-1); offset += length_st_names; memcpy( &(this->names[i]), &(this->st_names), sizeof(char*)); } return offset; } const char * getType(){ return "baxter_core_msgs/JointCommand"; }; const char * getMD5(){ return "19bfec8434dd568ab3c633d187c36f2e"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/OpenCamera.h

#ifndef _ROS_SERVICE_OpenCamera_h #define _ROS_SERVICE_OpenCamera_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "baxter_core_msgs/CameraSettings.h" namespace baxter_core_msgs { static const char OPENCAMERA[] = "baxter_core_msgs/OpenCamera"; class OpenCameraRequest : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef baxter_core_msgs::CameraSettings _settings_type; _settings_type settings; OpenCameraRequest(): name(""), settings() { } 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->settings.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; offset += this->settings.deserialize(inbuffer + offset); return offset; } const char * getType(){ return OPENCAMERA; }; const char * getMD5(){ return "c4194eee32741c5a98ef8da9666fa6c9"; }; }; class OpenCameraResponse : public ros::Msg { public: typedef int32_t _err_type; _err_type err; OpenCameraResponse(): err(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int32_t real; uint32_t base; } u_err; u_err.real = this->err; *(outbuffer + offset + 0) = (u_err.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_err.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_err.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_err.base >> (8 * 3)) & 0xFF; offset += sizeof(this->err); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int32_t real; uint32_t base; } u_err; u_err.base = 0; u_err.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_err.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_err.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_err.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->err = u_err.real; offset += sizeof(this->err); return offset; } const char * getType(){ return OPENCAMERA; }; const char * getMD5(){ return "b6e094011a4dfaee5eddf447220446cf"; }; }; class OpenCamera { public: typedef OpenCameraRequest Request; typedef OpenCameraResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/bond/Status.h

#ifndef _ROS_bond_Status_h #define _ROS_bond_Status_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace bond { class Status : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef const char* _id_type; _id_type id; typedef const char* _instance_id_type; _instance_id_type instance_id; typedef bool _active_type; _active_type active; typedef float _heartbeat_timeout_type; _heartbeat_timeout_type heartbeat_timeout; typedef float _heartbeat_period_type; _heartbeat_period_type heartbeat_period; Status(): header(), id(""), instance_id(""), active(0), heartbeat_timeout(0), heartbeat_period(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); uint32_t length_id = strlen(this->id); varToArr(outbuffer + offset, length_id); offset += 4; memcpy(outbuffer + offset, this->id, length_id); offset += length_id; uint32_t length_instance_id = strlen(this->instance_id); varToArr(outbuffer + offset, length_instance_id); offset += 4; memcpy(outbuffer + offset, this->instance_id, length_instance_id); offset += length_instance_id; union { bool real; uint8_t base; } u_active; u_active.real = this->active; *(outbuffer + offset + 0) = (u_active.base >> (8 * 0)) & 0xFF; offset += sizeof(this->active); union { float real; uint32_t base; } u_heartbeat_timeout; u_heartbeat_timeout.real = this->heartbeat_timeout; *(outbuffer + offset + 0) = (u_heartbeat_timeout.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_heartbeat_timeout.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_heartbeat_timeout.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_heartbeat_timeout.base >> (8 * 3)) & 0xFF; offset += sizeof(this->heartbeat_timeout); union { float real; uint32_t base; } u_heartbeat_period; u_heartbeat_period.real = this->heartbeat_period; *(outbuffer + offset + 0) = (u_heartbeat_period.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_heartbeat_period.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_heartbeat_period.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_heartbeat_period.base >> (8 * 3)) & 0xFF; offset += sizeof(this->heartbeat_period); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t length_id; arrToVar(length_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_id-1]=0; this->id = (char *)(inbuffer + offset-1); offset += length_id; uint32_t length_instance_id; arrToVar(length_instance_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_instance_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_instance_id-1]=0; this->instance_id = (char *)(inbuffer + offset-1); offset += length_instance_id; union { bool real; uint8_t base; } u_active; u_active.base = 0; u_active.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->active = u_active.real; offset += sizeof(this->active); union { float real; uint32_t base; } u_heartbeat_timeout; u_heartbeat_timeout.base = 0; u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->heartbeat_timeout = u_heartbeat_timeout.real; offset += sizeof(this->heartbeat_timeout); union { float real; uint32_t base; } u_heartbeat_period; u_heartbeat_period.base = 0; u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->heartbeat_period = u_heartbeat_period.real; offset += sizeof(this->heartbeat_period); return offset; } const char * getType(){ return "bond/Status"; }; const char * getMD5(){ return "eacc84bf5d65b6777d4c50f463dfb9c8"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/bond/Constants.h

#ifndef _ROS_bond_Constants_h #define _ROS_bond_Constants_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace bond { class Constants : public ros::Msg { public: enum { DEAD_PUBLISH_PERIOD = 0.05 }; enum { DEFAULT_CONNECT_TIMEOUT = 10.0 }; enum { DEFAULT_HEARTBEAT_TIMEOUT = 4.0 }; enum { DEFAULT_DISCONNECT_TIMEOUT = 2.0 }; enum { DEFAULT_HEARTBEAT_PERIOD = 1.0 }; enum { DISABLE_HEARTBEAT_TIMEOUT_PARAM = /bond_disable_heartbeat_timeout }; Constants() { } 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 "bond/Constants"; }; const char * getMD5(){ return "6fc594dc1d7bd7919077042712f8c8b0"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Color.h

#ifndef _ROS_turtlesim_Color_h #define _ROS_turtlesim_Color_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlesim { class Color : public ros::Msg { public: typedef uint8_t _r_type; _r_type r; typedef uint8_t _g_type; _g_type g; typedef uint8_t _b_type; _b_type b; Color(): r(0), g(0), b(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF; offset += sizeof(this->r); *(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF; offset += sizeof(this->g); *(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF; offset += sizeof(this->b); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->r = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->r); this->g = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->g); this->b = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->b); return offset; } const char * getType(){ return "turtlesim/Color"; }; const char * getMD5(){ return "353891e354491c51aabe32df673fb446"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/SetPen.h

#ifndef _ROS_SERVICE_SetPen_h #define _ROS_SERVICE_SetPen_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlesim { static const char SETPEN[] = "turtlesim/SetPen"; class SetPenRequest : public ros::Msg { public: typedef uint8_t _r_type; _r_type r; typedef uint8_t _g_type; _g_type g; typedef uint8_t _b_type; _b_type b; typedef uint8_t _width_type; _width_type width; typedef uint8_t _off_type; _off_type off; SetPenRequest(): r(0), g(0), b(0), width(0), off(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF; offset += sizeof(this->r); *(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF; offset += sizeof(this->g); *(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF; offset += sizeof(this->b); *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF; offset += sizeof(this->width); *(outbuffer + offset + 0) = (this->off >> (8 * 0)) & 0xFF; offset += sizeof(this->off); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->r = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->r); this->g = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->g); this->b = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->b); this->width = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->width); this->off = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->off); return offset; } const char * getType(){ return SETPEN; }; const char * getMD5(){ return "9f452acce566bf0c0954594f69a8e41b"; }; }; class SetPenResponse : public ros::Msg { public: SetPenResponse() { } 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 SETPEN; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class SetPen { public: typedef SetPenRequest Request; typedef SetPenResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Pose.h

#ifndef _ROS_turtlesim_Pose_h #define _ROS_turtlesim_Pose_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlesim { class Pose : public ros::Msg { public: typedef float _x_type; _x_type x; typedef float _y_type; _y_type y; typedef float _theta_type; _theta_type theta; typedef float _linear_velocity_type; _linear_velocity_type linear_velocity; typedef float _angular_velocity_type; _angular_velocity_type angular_velocity; Pose(): x(0), y(0), theta(0), linear_velocity(0), angular_velocity(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { float real; uint32_t base; } u_x; u_x.real = this->x; *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF; offset += sizeof(this->x); union { float real; uint32_t base; } u_y; u_y.real = this->y; *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF; offset += sizeof(this->y); union { float real; uint32_t base; } u_theta; u_theta.real = this->theta; *(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF; offset += sizeof(this->theta); union { float real; uint32_t base; } u_linear_velocity; u_linear_velocity.real = this->linear_velocity; *(outbuffer + offset + 0) = (u_linear_velocity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_linear_velocity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_linear_velocity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_linear_velocity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->linear_velocity); union { float real; uint32_t base; } u_angular_velocity; u_angular_velocity.real = this->angular_velocity; *(outbuffer + offset + 0) = (u_angular_velocity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_angular_velocity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_angular_velocity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_angular_velocity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->angular_velocity); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { float real; uint32_t base; } u_x; u_x.base = 0; u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->x = u_x.real; offset += sizeof(this->x); union { float real; uint32_t base; } u_y; u_y.base = 0; u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->y = u_y.real; offset += sizeof(this->y); union { float real; uint32_t base; } u_theta; u_theta.base = 0; u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->theta = u_theta.real; offset += sizeof(this->theta); union { float real; uint32_t base; } u_linear_velocity; u_linear_velocity.base = 0; u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->linear_velocity = u_linear_velocity.real; offset += sizeof(this->linear_velocity); union { float real; uint32_t base; } u_angular_velocity; u_angular_velocity.base = 0; u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->angular_velocity = u_angular_velocity.real; offset += sizeof(this->angular_velocity); return offset; } const char * getType(){ return "turtlesim/Pose"; }; const char * getMD5(){ return "863b248d5016ca62ea2e895ae5265cf9"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_toolbox/SetPidGains.h

#ifndef _ROS_SERVICE_SetPidGains_h #define _ROS_SERVICE_SetPidGains_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace control_toolbox { static const char SETPIDGAINS[] = "control_toolbox/SetPidGains"; class SetPidGainsRequest : public ros::Msg { public: typedef double _p_type; _p_type p; typedef double _i_type; _i_type i; typedef double _d_type; _d_type d; typedef double _i_clamp_type; _i_clamp_type i_clamp; typedef bool _antiwindup_type; _antiwindup_type antiwindup; SetPidGainsRequest(): p(0), i(0), d(0), i_clamp(0), antiwindup(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { double real; uint64_t base; } u_p; u_p.real = this->p; *(outbuffer + offset + 0) = (u_p.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_p.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_p.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_p.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_p.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_p.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_p.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_p.base >> (8 * 7)) & 0xFF; offset += sizeof(this->p); union { double real; uint64_t base; } u_i; u_i.real = this->i; *(outbuffer + offset + 0) = (u_i.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_i.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_i.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_i.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_i.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_i.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_i.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_i.base >> (8 * 7)) & 0xFF; offset += sizeof(this->i); union { double real; uint64_t base; } u_d; u_d.real = this->d; *(outbuffer + offset + 0) = (u_d.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_d.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_d.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_d.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_d.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_d.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_d.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_d.base >> (8 * 7)) & 0xFF; offset += sizeof(this->d); union { double real; uint64_t base; } u_i_clamp; u_i_clamp.real = this->i_clamp; *(outbuffer + offset + 0) = (u_i_clamp.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_i_clamp.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_i_clamp.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_i_clamp.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_i_clamp.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_i_clamp.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_i_clamp.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_i_clamp.base >> (8 * 7)) & 0xFF; offset += sizeof(this->i_clamp); union { bool real; uint8_t base; } u_antiwindup; u_antiwindup.real = this->antiwindup; *(outbuffer + offset + 0) = (u_antiwindup.base >> (8 * 0)) & 0xFF; offset += sizeof(this->antiwindup); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { double real; uint64_t base; } u_p; u_p.base = 0; u_p.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_p.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_p.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_p.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_p.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_p.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_p.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_p.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->p = u_p.real; offset += sizeof(this->p); union { double real; uint64_t base; } u_i; u_i.base = 0; u_i.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_i.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_i.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_i.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_i.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_i.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_i.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_i.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->i = u_i.real; offset += sizeof(this->i); union { double real; uint64_t base; } u_d; u_d.base = 0; u_d.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_d.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_d.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_d.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_d.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_d.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_d.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_d.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->d = u_d.real; offset += sizeof(this->d); union { double real; uint64_t base; } u_i_clamp; u_i_clamp.base = 0; u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->i_clamp = u_i_clamp.real; offset += sizeof(this->i_clamp); union { bool real; uint8_t base; } u_antiwindup; u_antiwindup.base = 0; u_antiwindup.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->antiwindup = u_antiwindup.real; offset += sizeof(this->antiwindup); return offset; } const char * getType(){ return SETPIDGAINS; }; const char * getMD5(){ return "4a43159879643e60937bf2893b633607"; }; }; class SetPidGainsResponse : public ros::Msg { public: SetPidGainsResponse() { } 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 SETPIDGAINS; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class SetPidGains { public: typedef SetPidGainsRequest Request; typedef SetPidGainsResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/GetOctomap.h

#ifndef _ROS_SERVICE_GetOctomap_h #define _ROS_SERVICE_GetOctomap_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "octomap_msgs/Octomap.h" namespace octomap_msgs { static const char GETOCTOMAP[] = "octomap_msgs/GetOctomap"; class GetOctomapRequest : public ros::Msg { public: GetOctomapRequest() { } 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 GETOCTOMAP; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class GetOctomapResponse : public ros::Msg { public: typedef octomap_msgs::Octomap _map_type; _map_type map; GetOctomapResponse(): 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 GETOCTOMAP; }; const char * getMD5(){ return "be9d2869d24fe40d6bc21ac21f6bb2c5"; }; }; class GetOctomap { public: typedef GetOctomapRequest Request; typedef GetOctomapResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/OctomapWithPose.h

#ifndef _ROS_octomap_msgs_OctomapWithPose_h #define _ROS_octomap_msgs_OctomapWithPose_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 "octomap_msgs/Octomap.h" namespace octomap_msgs { class OctomapWithPose : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef geometry_msgs::Pose _origin_type; _origin_type origin; typedef octomap_msgs::Octomap _octomap_type; _octomap_type octomap; OctomapWithPose(): header(), origin(), octomap() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->origin.serialize(outbuffer + offset); offset += this->octomap.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->origin.deserialize(inbuffer + offset); offset += this->octomap.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "octomap_msgs/OctomapWithPose"; }; const char * getMD5(){ return "20b380aca6a508a657e95526cddaf618"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/BoundingBoxQuery.h

#ifndef _ROS_SERVICE_BoundingBoxQuery_h #define _ROS_SERVICE_BoundingBoxQuery_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "geometry_msgs/Point.h" namespace octomap_msgs { static const char BOUNDINGBOXQUERY[] = "octomap_msgs/BoundingBoxQuery"; class BoundingBoxQueryRequest : public ros::Msg { public: typedef geometry_msgs::Point _min_type; _min_type min; typedef geometry_msgs::Point _max_type; _max_type max; BoundingBoxQueryRequest(): min(), max() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->min.serialize(outbuffer + offset); offset += this->max.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->min.deserialize(inbuffer + offset); offset += this->max.deserialize(inbuffer + offset); return offset; } const char * getType(){ return BOUNDINGBOXQUERY; }; const char * getMD5(){ return "93aa3d73b866f04880927745f4aab303"; }; }; class BoundingBoxQueryResponse : public ros::Msg { public: BoundingBoxQueryResponse() { } 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 BOUNDINGBOXQUERY; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class BoundingBoxQuery { public: typedef BoundingBoxQueryRequest Request; typedef BoundingBoxQueryResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/Octomap.h

#ifndef _ROS_octomap_msgs_Octomap_h #define _ROS_octomap_msgs_Octomap_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace octomap_msgs { class Octomap : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef bool _binary_type; _binary_type binary; typedef const char* _id_type; _id_type id; typedef double _resolution_type; _resolution_type resolution; uint32_t data_length; typedef int8_t _data_type; _data_type st_data; _data_type * data; Octomap(): header(), binary(0), id(""), resolution(0), data_length(0), data(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_binary; u_binary.real = this->binary; *(outbuffer + offset + 0) = (u_binary.base >> (8 * 0)) & 0xFF; offset += sizeof(this->binary); uint32_t length_id = strlen(this->id); varToArr(outbuffer + offset, length_id); offset += 4; memcpy(outbuffer + offset, this->id, length_id); offset += length_id; union { double real; uint64_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; *(outbuffer + offset + 4) = (u_resolution.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_resolution.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_resolution.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_resolution.base >> (8 * 7)) & 0xFF; offset += sizeof(this->resolution); *(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++){ union { int8_t real; uint8_t base; } u_datai; u_datai.real = this->data[i]; *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF; offset += sizeof(this->data[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_binary; u_binary.base = 0; u_binary.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->binary = u_binary.real; offset += sizeof(this->binary); uint32_t length_id; arrToVar(length_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_id-1]=0; this->id = (char *)(inbuffer + offset-1); offset += length_id; union { double real; uint64_t base; } u_resolution; u_resolution.base = 0; u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->resolution = u_resolution.real; offset += sizeof(this->resolution); 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 = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t)); data_length = data_lengthT; for( uint32_t i = 0; i < data_length; i++){ union { int8_t real; uint8_t base; } u_st_data; u_st_data.base = 0; u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_data = u_st_data.real; offset += sizeof(this->st_data); memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t)); } return offset; } const char * getType(){ return "octomap_msgs/Octomap"; }; const char * getMD5(){ return "9a45536b45c5e409cd49f04bb2d9999f"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/transform_broadcaster.h

/* * Software License Agreement (BSD License) * * Copyright (c) 2011, Willow Garage, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * Neither the name of Willow Garage, Inc. nor the names of its * contributors may be used to endorse or promote prducts derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #ifndef ROS_TRANSFORM_BROADCASTER_H_ #define ROS_TRANSFORM_BROADCASTER_H_ #include "ros.h" #include "tfMessage.h" namespace tf { class TransformBroadcaster { public: TransformBroadcaster() : publisher_("/tf", &internal_msg) {} void init(ros::NodeHandle &nh) { nh.advertise(publisher_); } void sendTransform(geometry_msgs::TransformStamped &transform) { internal_msg.transforms_length = 1; internal_msg.transforms = &transform; publisher_.publish(&internal_msg); } private: tf::tfMessage internal_msg; ros::Publisher publisher_; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateStatus.h

#ifndef _ROS_baxter_maintenance_msgs_UpdateStatus_h #define _ROS_baxter_maintenance_msgs_UpdateStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_maintenance_msgs { class UpdateStatus : public ros::Msg { public: typedef uint16_t _status_type; _status_type status; typedef float _progress_type; _progress_type progress; typedef const char* _long_description_type; _long_description_type long_description; enum { STS_IDLE = 0 }; enum { STS_INVALID = 1 }; enum { STS_BUSY = 2 }; enum { STS_CANCELLED = 3 }; enum { STS_ERR = 4 }; enum { STS_MOUNT_UPDATE = 5 }; enum { STS_VERIFY_UPDATE = 6 }; enum { STS_PREP_STAGING = 7 }; enum { STS_MOUNT_STAGING = 8 }; enum { STS_EXTRACT_UPDATE = 9 }; enum { STS_LOAD_KEXEC = 10 }; UpdateStatus(): status(0), progress(0), long_description("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->status >> (8 * 1)) & 0xFF; offset += sizeof(this->status); union { float real; uint32_t base; } u_progress; u_progress.real = this->progress; *(outbuffer + offset + 0) = (u_progress.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_progress.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_progress.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_progress.base >> (8 * 3)) & 0xFF; offset += sizeof(this->progress); uint32_t length_long_description = strlen(this->long_description); varToArr(outbuffer + offset, length_long_description); offset += 4; memcpy(outbuffer + offset, this->long_description, length_long_description); offset += length_long_description; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->status = ((uint16_t) (*(inbuffer + offset))); this->status |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->status); union { float real; uint32_t base; } u_progress; u_progress.base = 0; u_progress.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_progress.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_progress.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_progress.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->progress = u_progress.real; offset += sizeof(this->progress); uint32_t length_long_description; arrToVar(length_long_description, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_long_description; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_long_description-1]=0; this->long_description = (char *)(inbuffer + offset-1); offset += length_long_description; return offset; } const char * getType(){ return "baxter_maintenance_msgs/UpdateStatus"; }; const char * getMD5(){ return "74e246350421569590252c39e8aa7b85"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/CalibrateArmData.h

#ifndef _ROS_baxter_maintenance_msgs_CalibrateArmData_h #define _ROS_baxter_maintenance_msgs_CalibrateArmData_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_maintenance_msgs { class CalibrateArmData : public ros::Msg { public: typedef bool _suppressWriteToFile_type; _suppressWriteToFile_type suppressWriteToFile; CalibrateArmData(): suppressWriteToFile(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_suppressWriteToFile; u_suppressWriteToFile.real = this->suppressWriteToFile; *(outbuffer + offset + 0) = (u_suppressWriteToFile.base >> (8 * 0)) & 0xFF; offset += sizeof(this->suppressWriteToFile); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_suppressWriteToFile; u_suppressWriteToFile.base = 0; u_suppressWriteToFile.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->suppressWriteToFile = u_suppressWriteToFile.real; offset += sizeof(this->suppressWriteToFile); return offset; } const char * getType(){ return "baxter_maintenance_msgs/CalibrateArmData"; }; const char * getMD5(){ return "ba9ee949ea363f7bcfc8cc74e0bcb69d"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/CalibrateArmEnable.h

#ifndef _ROS_baxter_maintenance_msgs_CalibrateArmEnable_h #define _ROS_baxter_maintenance_msgs_CalibrateArmEnable_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "baxter_maintenance_msgs/CalibrateArmData.h" namespace baxter_maintenance_msgs { class CalibrateArmEnable : public ros::Msg { public: typedef bool _isEnabled_type; _isEnabled_type isEnabled; typedef const char* _uid_type; _uid_type uid; typedef baxter_maintenance_msgs::CalibrateArmData _data_type; _data_type data; CalibrateArmEnable(): isEnabled(0), uid(""), data() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_isEnabled; u_isEnabled.real = this->isEnabled; *(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isEnabled); uint32_t length_uid = strlen(this->uid); varToArr(outbuffer + offset, length_uid); offset += 4; memcpy(outbuffer + offset, this->uid, length_uid); offset += length_uid; offset += this->data.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_isEnabled; u_isEnabled.base = 0; u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isEnabled = u_isEnabled.real; offset += sizeof(this->isEnabled); uint32_t length_uid; arrToVar(length_uid, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_uid; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_uid-1]=0; this->uid = (char *)(inbuffer + offset-1); offset += length_uid; offset += this->data.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "baxter_maintenance_msgs/CalibrateArmEnable"; }; const char * getMD5(){ return "d7ff300fd410d4ac849664ab8143da39"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateSources.h

#ifndef _ROS_baxter_maintenance_msgs_UpdateSources_h #define _ROS_baxter_maintenance_msgs_UpdateSources_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "baxter_maintenance_msgs/UpdateSource.h" namespace baxter_maintenance_msgs { class UpdateSources : public ros::Msg { public: typedef const char* _uuid_type; _uuid_type uuid; uint32_t sources_length; typedef baxter_maintenance_msgs::UpdateSource _sources_type; _sources_type st_sources; _sources_type * sources; UpdateSources(): uuid(""), sources_length(0), sources(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_uuid = strlen(this->uuid); varToArr(outbuffer + offset, length_uuid); offset += 4; memcpy(outbuffer + offset, this->uuid, length_uuid); offset += length_uuid; *(outbuffer + offset + 0) = (this->sources_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->sources_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->sources_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->sources_length >> (8 * 3)) & 0xFF; offset += sizeof(this->sources_length); for( uint32_t i = 0; i < sources_length; i++){ offset += this->sources[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_uuid; arrToVar(length_uuid, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_uuid; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_uuid-1]=0; this->uuid = (char *)(inbuffer + offset-1); offset += length_uuid; uint32_t sources_lengthT = ((uint32_t) (*(inbuffer + offset))); sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->sources_length); if(sources_lengthT > sources_length) this->sources = (baxter_maintenance_msgs::UpdateSource*)realloc(this->sources, sources_lengthT * sizeof(baxter_maintenance_msgs::UpdateSource)); sources_length = sources_lengthT; for( uint32_t i = 0; i < sources_length; i++){ offset += this->st_sources.deserialize(inbuffer + offset); memcpy( &(this->sources[i]), &(this->st_sources), sizeof(baxter_maintenance_msgs::UpdateSource)); } return offset; } const char * getType(){ return "baxter_maintenance_msgs/UpdateSources"; }; const char * getMD5(){ return "b3b428bf55e80e83d378830c33b3405b"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateSource.h

#ifndef _ROS_baxter_maintenance_msgs_UpdateSource_h #define _ROS_baxter_maintenance_msgs_UpdateSource_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_maintenance_msgs { class UpdateSource : public ros::Msg { public: typedef const char* _devname_type; _devname_type devname; typedef const char* _filename_type; _filename_type filename; typedef const char* _version_type; _version_type version; typedef const char* _uuid_type; _uuid_type uuid; UpdateSource(): devname(""), filename(""), version(""), uuid("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_devname = strlen(this->devname); varToArr(outbuffer + offset, length_devname); offset += 4; memcpy(outbuffer + offset, this->devname, length_devname); offset += length_devname; uint32_t length_filename = strlen(this->filename); varToArr(outbuffer + offset, length_filename); offset += 4; memcpy(outbuffer + offset, this->filename, length_filename); offset += length_filename; uint32_t length_version = strlen(this->version); varToArr(outbuffer + offset, length_version); offset += 4; memcpy(outbuffer + offset, this->version, length_version); offset += length_version; uint32_t length_uuid = strlen(this->uuid); varToArr(outbuffer + offset, length_uuid); offset += 4; memcpy(outbuffer + offset, this->uuid, length_uuid); offset += length_uuid; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_devname; arrToVar(length_devname, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_devname; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_devname-1]=0; this->devname = (char *)(inbuffer + offset-1); offset += length_devname; uint32_t length_filename; arrToVar(length_filename, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_filename; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_filename-1]=0; this->filename = (char *)(inbuffer + offset-1); offset += length_filename; uint32_t length_version; arrToVar(length_version, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_version; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_version-1]=0; this->version = (char *)(inbuffer + offset-1); offset += length_version; uint32_t length_uuid; arrToVar(length_uuid, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_uuid; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_uuid-1]=0; this->uuid = (char *)(inbuffer + offset-1); offset += length_uuid; return offset; } const char * getType(){ return "baxter_maintenance_msgs/UpdateSource"; }; const char * getMD5(){ return "88ad69e3ed4d619e167c9d83e6d9310f"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/TareData.h

#ifndef _ROS_baxter_maintenance_msgs_TareData_h #define _ROS_baxter_maintenance_msgs_TareData_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace baxter_maintenance_msgs { class TareData : public ros::Msg { public: typedef bool _tuneGravitySpring_type; _tuneGravitySpring_type tuneGravitySpring; TareData(): tuneGravitySpring(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_tuneGravitySpring; u_tuneGravitySpring.real = this->tuneGravitySpring; *(outbuffer + offset + 0) = (u_tuneGravitySpring.base >> (8 * 0)) & 0xFF; offset += sizeof(this->tuneGravitySpring); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_tuneGravitySpring; u_tuneGravitySpring.base = 0; u_tuneGravitySpring.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->tuneGravitySpring = u_tuneGravitySpring.real; offset += sizeof(this->tuneGravitySpring); return offset; } const char * getType(){ return "baxter_maintenance_msgs/TareData"; }; const char * getMD5(){ return "241e9c2ceee7da9db50693da0b3f2741"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/navfn/MakeNavPlan.h

#ifndef _ROS_SERVICE_MakeNavPlan_h #define _ROS_SERVICE_MakeNavPlan_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "geometry_msgs/PoseStamped.h" namespace navfn { static const char MAKENAVPLAN[] = "navfn/MakeNavPlan"; class MakeNavPlanRequest : public ros::Msg { public: typedef geometry_msgs::PoseStamped _start_type; _start_type start; typedef geometry_msgs::PoseStamped _goal_type; _goal_type goal; MakeNavPlanRequest(): start(), goal() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->start.serialize(outbuffer + offset); offset += this->goal.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->start.deserialize(inbuffer + offset); offset += this->goal.deserialize(inbuffer + offset); return offset; } const char * getType(){ return MAKENAVPLAN; }; const char * getMD5(){ return "2fe3126bd5b2d56edd5005220333d4fd"; }; }; class MakeNavPlanResponse : public ros::Msg { public: typedef uint8_t _plan_found_type; _plan_found_type plan_found; typedef const char* _error_message_type; _error_message_type error_message; uint32_t path_length; typedef geometry_msgs::PoseStamped _path_type; _path_type st_path; _path_type * path; MakeNavPlanResponse(): plan_found(0), error_message(""), path_length(0), path(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->plan_found >> (8 * 0)) & 0xFF; offset += sizeof(this->plan_found); uint32_t length_error_message = strlen(this->error_message); varToArr(outbuffer + offset, length_error_message); offset += 4; memcpy(outbuffer + offset, this->error_message, length_error_message); offset += length_error_message; *(outbuffer + offset + 0) = (this->path_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->path_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->path_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->path_length >> (8 * 3)) & 0xFF; offset += sizeof(this->path_length); for( uint32_t i = 0; i < path_length; i++){ offset += this->path[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->plan_found = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->plan_found); uint32_t length_error_message; arrToVar(length_error_message, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_error_message; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_error_message-1]=0; this->error_message = (char *)(inbuffer + offset-1); offset += length_error_message; uint32_t path_lengthT = ((uint32_t) (*(inbuffer + offset))); path_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); path_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); path_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->path_length); if(path_lengthT > path_length) this->path = (geometry_msgs::PoseStamped*)realloc(this->path, path_lengthT * sizeof(geometry_msgs::PoseStamped)); path_length = path_lengthT; for( uint32_t i = 0; i < path_length; i++){ offset += this->st_path.deserialize(inbuffer + offset); memcpy( &(this->path[i]), &(this->st_path), sizeof(geometry_msgs::PoseStamped)); } return offset; } const char * getType(){ return MAKENAVPLAN; }; const char * getMD5(){ return "8b8ed7edf1b237dc9ddda8c8ffed5d3a"; }; }; class MakeNavPlan { public: typedef MakeNavPlanRequest Request; typedef MakeNavPlanResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/navfn/SetCostmap.h

#ifndef _ROS_SERVICE_SetCostmap_h #define _ROS_SERVICE_SetCostmap_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace navfn { static const char SETCOSTMAP[] = "navfn/SetCostmap"; class SetCostmapRequest : public ros::Msg { public: uint32_t costs_length; typedef uint8_t _costs_type; _costs_type st_costs; _costs_type * costs; typedef uint16_t _height_type; _height_type height; typedef uint16_t _width_type; _width_type width; SetCostmapRequest(): costs_length(0), costs(NULL), height(0), width(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->costs_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->costs_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->costs_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->costs_length >> (8 * 3)) & 0xFF; offset += sizeof(this->costs_length); for( uint32_t i = 0; i < costs_length; i++){ *(outbuffer + offset + 0) = (this->costs[i] >> (8 * 0)) & 0xFF; offset += sizeof(this->costs[i]); } *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF; offset += sizeof(this->height); *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF; offset += sizeof(this->width); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t costs_lengthT = ((uint32_t) (*(inbuffer + offset))); costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->costs_length); if(costs_lengthT > costs_length) this->costs = (uint8_t*)realloc(this->costs, costs_lengthT * sizeof(uint8_t)); costs_length = costs_lengthT; for( uint32_t i = 0; i < costs_length; i++){ this->st_costs = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->st_costs); memcpy( &(this->costs[i]), &(this->st_costs), sizeof(uint8_t)); } this->height = ((uint16_t) (*(inbuffer + offset))); this->height |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->height); this->width = ((uint16_t) (*(inbuffer + offset))); this->width |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->width); return offset; } const char * getType(){ return SETCOSTMAP; }; const char * getMD5(){ return "370ec969cdb71f9cde7c7cbe0d752308"; }; }; class SetCostmapResponse : public ros::Msg { public: SetCostmapResponse() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; return offset; } const char * getType(){ return SETCOSTMAP; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class SetCostmap { public: typedef SetCostmapRequest Request; typedef SetCostmapResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/OrientationConstraint.h

#ifndef _ROS_moveit_msgs_OrientationConstraint_h #define _ROS_moveit_msgs_OrientationConstraint_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Quaternion.h" namespace moveit_msgs { class OrientationConstraint : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef geometry_msgs::Quaternion _orientation_type; _orientation_type orientation; typedef const char* _link_name_type; _link_name_type link_name; typedef double _absolute_x_axis_tolerance_type; _absolute_x_axis_tolerance_type absolute_x_axis_tolerance; typedef double _absolute_y_axis_tolerance_type; _absolute_y_axis_tolerance_type absolute_y_axis_tolerance; typedef double _absolute_z_axis_tolerance_type; _absolute_z_axis_tolerance_type absolute_z_axis_tolerance; typedef double _weight_type; _weight_type weight; OrientationConstraint(): header(), orientation(), link_name(""), absolute_x_axis_tolerance(0), absolute_y_axis_tolerance(0), absolute_z_axis_tolerance(0), weight(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->orientation.serialize(outbuffer + offset); uint32_t length_link_name = strlen(this->link_name); varToArr(outbuffer + offset, length_link_name); offset += 4; memcpy(outbuffer + offset, this->link_name, length_link_name); offset += length_link_name; union { double real; uint64_t base; } u_absolute_x_axis_tolerance; u_absolute_x_axis_tolerance.real = this->absolute_x_axis_tolerance; *(outbuffer + offset + 0) = (u_absolute_x_axis_tolerance.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_absolute_x_axis_tolerance.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_absolute_x_axis_tolerance.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_absolute_x_axis_tolerance.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_absolute_x_axis_tolerance.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_absolute_x_axis_tolerance.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_absolute_x_axis_tolerance.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_absolute_x_axis_tolerance.base >> (8 * 7)) & 0xFF; offset += sizeof(this->absolute_x_axis_tolerance); union { double real; uint64_t base; } u_absolute_y_axis_tolerance; u_absolute_y_axis_tolerance.real = this->absolute_y_axis_tolerance; *(outbuffer + offset + 0) = (u_absolute_y_axis_tolerance.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_absolute_y_axis_tolerance.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_absolute_y_axis_tolerance.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_absolute_y_axis_tolerance.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_absolute_y_axis_tolerance.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_absolute_y_axis_tolerance.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_absolute_y_axis_tolerance.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_absolute_y_axis_tolerance.base >> (8 * 7)) & 0xFF; offset += sizeof(this->absolute_y_axis_tolerance); union { double real; uint64_t base; } u_absolute_z_axis_tolerance; u_absolute_z_axis_tolerance.real = this->absolute_z_axis_tolerance; *(outbuffer + offset + 0) = (u_absolute_z_axis_tolerance.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_absolute_z_axis_tolerance.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_absolute_z_axis_tolerance.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_absolute_z_axis_tolerance.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_absolute_z_axis_tolerance.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_absolute_z_axis_tolerance.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_absolute_z_axis_tolerance.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_absolute_z_axis_tolerance.base >> (8 * 7)) & 0xFF; offset += sizeof(this->absolute_z_axis_tolerance); union { double real; uint64_t base; } u_weight; u_weight.real = this->weight; *(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF; offset += sizeof(this->weight); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->orientation.deserialize(inbuffer + offset); uint32_t length_link_name; arrToVar(length_link_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_link_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_link_name-1]=0; this->link_name = (char *)(inbuffer + offset-1); offset += length_link_name; union { double real; uint64_t base; } u_absolute_x_axis_tolerance; u_absolute_x_axis_tolerance.base = 0; u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->absolute_x_axis_tolerance = u_absolute_x_axis_tolerance.real; offset += sizeof(this->absolute_x_axis_tolerance); union { double real; uint64_t base; } u_absolute_y_axis_tolerance; u_absolute_y_axis_tolerance.base = 0; u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->absolute_y_axis_tolerance = u_absolute_y_axis_tolerance.real; offset += sizeof(this->absolute_y_axis_tolerance); union { double real; uint64_t base; } u_absolute_z_axis_tolerance; u_absolute_z_axis_tolerance.base = 0; u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->absolute_z_axis_tolerance = u_absolute_z_axis_tolerance.real; offset += sizeof(this->absolute_z_axis_tolerance); union { double real; uint64_t base; } u_weight; u_weight.base = 0; u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->weight = u_weight.real; offset += sizeof(this->weight); return offset; } const char * getType(){ return "moveit_msgs/OrientationConstraint"; }; const char * getMD5(){ return "ab5cefb9bc4c0089620f5eb4caf4e59a"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetMotionSequence.h

#ifndef _ROS_SERVICE_GetMotionSequence_h #define _ROS_SERVICE_GetMotionSequence_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MotionSequenceRequest.h" #include "moveit_msgs/MotionSequenceResponse.h" namespace moveit_msgs { static const char GETMOTIONSEQUENCE[] = "moveit_msgs/GetMotionSequence"; class GetMotionSequenceRequest : public ros::Msg { public: typedef moveit_msgs::MotionSequenceRequest _request_type; _request_type request; GetMotionSequenceRequest(): request() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->request.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->request.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETMOTIONSEQUENCE; }; const char * getMD5(){ return "bae3996834a2cd1013b32c29e6a79b4e"; }; }; class GetMotionSequenceResponse : public ros::Msg { public: typedef moveit_msgs::MotionSequenceResponse _response_type; _response_type response; GetMotionSequenceResponse(): response() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->response.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->response.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETMOTIONSEQUENCE; }; const char * getMD5(){ return "039cee462ada3f0feb5f4e2e12baefae"; }; }; class GetMotionSequence { public: typedef GetMotionSequenceRequest Request; typedef GetMotionSequenceResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceResponse.h

#ifndef _ROS_moveit_msgs_MotionSequenceResponse_h #define _ROS_moveit_msgs_MotionSequenceResponse_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/RobotTrajectory.h" namespace moveit_msgs { class MotionSequenceResponse : public ros::Msg { public: typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; typedef moveit_msgs::RobotState _sequence_start_type; _sequence_start_type sequence_start; uint32_t planned_trajectories_length; typedef moveit_msgs::RobotTrajectory _planned_trajectories_type; _planned_trajectories_type st_planned_trajectories; _planned_trajectories_type * planned_trajectories; typedef double _planning_time_type; _planning_time_type planning_time; MotionSequenceResponse(): error_code(), sequence_start(), planned_trajectories_length(0), planned_trajectories(NULL), planning_time(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->error_code.serialize(outbuffer + offset); offset += this->sequence_start.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->planned_trajectories_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->planned_trajectories_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->planned_trajectories_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->planned_trajectories_length >> (8 * 3)) & 0xFF; offset += sizeof(this->planned_trajectories_length); for( uint32_t i = 0; i < planned_trajectories_length; i++){ offset += this->planned_trajectories[i].serialize(outbuffer + offset); } union { double real; uint64_t base; } u_planning_time; u_planning_time.real = this->planning_time; *(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF; offset += sizeof(this->planning_time); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->error_code.deserialize(inbuffer + offset); offset += this->sequence_start.deserialize(inbuffer + offset); uint32_t planned_trajectories_lengthT = ((uint32_t) (*(inbuffer + offset))); planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->planned_trajectories_length); if(planned_trajectories_lengthT > planned_trajectories_length) this->planned_trajectories = (moveit_msgs::RobotTrajectory*)realloc(this->planned_trajectories, planned_trajectories_lengthT * sizeof(moveit_msgs::RobotTrajectory)); planned_trajectories_length = planned_trajectories_lengthT; for( uint32_t i = 0; i < planned_trajectories_length; i++){ offset += this->st_planned_trajectories.deserialize(inbuffer + offset); memcpy( &(this->planned_trajectories[i]), &(this->st_planned_trajectories), sizeof(moveit_msgs::RobotTrajectory)); } union { double real; uint64_t base; } u_planning_time; u_planning_time.base = 0; u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->planning_time = u_planning_time.real; offset += sizeof(this->planning_time); return offset; } const char * getType(){ return "moveit_msgs/MotionSequenceResponse"; }; const char * getMD5(){ return "3b9d4e8079db4576e4829d30617a3d1d"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ChangeControlDimensions.h

#ifndef _ROS_SERVICE_ChangeControlDimensions_h #define _ROS_SERVICE_ChangeControlDimensions_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { static const char CHANGECONTROLDIMENSIONS[] = "moveit_msgs/ChangeControlDimensions"; class ChangeControlDimensionsRequest : public ros::Msg { public: typedef bool _control_x_translation_type; _control_x_translation_type control_x_translation; typedef bool _control_y_translation_type; _control_y_translation_type control_y_translation; typedef bool _control_z_translation_type; _control_z_translation_type control_z_translation; typedef bool _control_x_rotation_type; _control_x_rotation_type control_x_rotation; typedef bool _control_y_rotation_type; _control_y_rotation_type control_y_rotation; typedef bool _control_z_rotation_type; _control_z_rotation_type control_z_rotation; ChangeControlDimensionsRequest(): control_x_translation(0), control_y_translation(0), control_z_translation(0), control_x_rotation(0), control_y_rotation(0), control_z_rotation(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_control_x_translation; u_control_x_translation.real = this->control_x_translation; *(outbuffer + offset + 0) = (u_control_x_translation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->control_x_translation); union { bool real; uint8_t base; } u_control_y_translation; u_control_y_translation.real = this->control_y_translation; *(outbuffer + offset + 0) = (u_control_y_translation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->control_y_translation); union { bool real; uint8_t base; } u_control_z_translation; u_control_z_translation.real = this->control_z_translation; *(outbuffer + offset + 0) = (u_control_z_translation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->control_z_translation); union { bool real; uint8_t base; } u_control_x_rotation; u_control_x_rotation.real = this->control_x_rotation; *(outbuffer + offset + 0) = (u_control_x_rotation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->control_x_rotation); union { bool real; uint8_t base; } u_control_y_rotation; u_control_y_rotation.real = this->control_y_rotation; *(outbuffer + offset + 0) = (u_control_y_rotation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->control_y_rotation); union { bool real; uint8_t base; } u_control_z_rotation; u_control_z_rotation.real = this->control_z_rotation; *(outbuffer + offset + 0) = (u_control_z_rotation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->control_z_rotation); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_control_x_translation; u_control_x_translation.base = 0; u_control_x_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->control_x_translation = u_control_x_translation.real; offset += sizeof(this->control_x_translation); union { bool real; uint8_t base; } u_control_y_translation; u_control_y_translation.base = 0; u_control_y_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->control_y_translation = u_control_y_translation.real; offset += sizeof(this->control_y_translation); union { bool real; uint8_t base; } u_control_z_translation; u_control_z_translation.base = 0; u_control_z_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->control_z_translation = u_control_z_translation.real; offset += sizeof(this->control_z_translation); union { bool real; uint8_t base; } u_control_x_rotation; u_control_x_rotation.base = 0; u_control_x_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->control_x_rotation = u_control_x_rotation.real; offset += sizeof(this->control_x_rotation); union { bool real; uint8_t base; } u_control_y_rotation; u_control_y_rotation.base = 0; u_control_y_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->control_y_rotation = u_control_y_rotation.real; offset += sizeof(this->control_y_rotation); union { bool real; uint8_t base; } u_control_z_rotation; u_control_z_rotation.base = 0; u_control_z_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->control_z_rotation = u_control_z_rotation.real; offset += sizeof(this->control_z_rotation); return offset; } const char * getType(){ return CHANGECONTROLDIMENSIONS; }; const char * getMD5(){ return "64c0dd6d519e78f5ce2626b06dab34c1"; }; }; class ChangeControlDimensionsResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; ChangeControlDimensionsResponse(): success(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.real = this->success; *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; offset += sizeof(this->success); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.base = 0; u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->success = u_success.real; offset += sizeof(this->success); return offset; } const char * getType(){ return CHANGECONTROLDIMENSIONS; }; const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; }; class ChangeControlDimensions { public: typedef ChangeControlDimensionsRequest Request; typedef ChangeControlDimensionsResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GraspPlanning.h

#ifndef _ROS_SERVICE_GraspPlanning_h #define _ROS_SERVICE_GraspPlanning_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/Grasp.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "moveit_msgs/CollisionObject.h" namespace moveit_msgs { static const char GRASPPLANNING[] = "moveit_msgs/GraspPlanning"; class GraspPlanningRequest : public ros::Msg { public: typedef const char* _group_name_type; _group_name_type group_name; typedef moveit_msgs::CollisionObject _target_type; _target_type target; uint32_t support_surfaces_length; typedef char* _support_surfaces_type; _support_surfaces_type st_support_surfaces; _support_surfaces_type * support_surfaces; uint32_t candidate_grasps_length; typedef moveit_msgs::Grasp _candidate_grasps_type; _candidate_grasps_type st_candidate_grasps; _candidate_grasps_type * candidate_grasps; uint32_t movable_obstacles_length; typedef moveit_msgs::CollisionObject _movable_obstacles_type; _movable_obstacles_type st_movable_obstacles; _movable_obstacles_type * movable_obstacles; GraspPlanningRequest(): group_name(""), target(), support_surfaces_length(0), support_surfaces(NULL), candidate_grasps_length(0), candidate_grasps(NULL), movable_obstacles_length(0), movable_obstacles(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; offset += this->target.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->support_surfaces_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->support_surfaces_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->support_surfaces_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->support_surfaces_length >> (8 * 3)) & 0xFF; offset += sizeof(this->support_surfaces_length); for( uint32_t i = 0; i < support_surfaces_length; i++){ uint32_t length_support_surfacesi = strlen(this->support_surfaces[i]); varToArr(outbuffer + offset, length_support_surfacesi); offset += 4; memcpy(outbuffer + offset, this->support_surfaces[i], length_support_surfacesi); offset += length_support_surfacesi; } *(outbuffer + offset + 0) = (this->candidate_grasps_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->candidate_grasps_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->candidate_grasps_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->candidate_grasps_length >> (8 * 3)) & 0xFF; offset += sizeof(this->candidate_grasps_length); for( uint32_t i = 0; i < candidate_grasps_length; i++){ offset += this->candidate_grasps[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->movable_obstacles_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->movable_obstacles_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->movable_obstacles_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->movable_obstacles_length >> (8 * 3)) & 0xFF; offset += sizeof(this->movable_obstacles_length); for( uint32_t i = 0; i < movable_obstacles_length; i++){ offset += this->movable_obstacles[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; offset += this->target.deserialize(inbuffer + offset); uint32_t support_surfaces_lengthT = ((uint32_t) (*(inbuffer + offset))); support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->support_surfaces_length); if(support_surfaces_lengthT > support_surfaces_length) this->support_surfaces = (char**)realloc(this->support_surfaces, support_surfaces_lengthT * sizeof(char*)); support_surfaces_length = support_surfaces_lengthT; for( uint32_t i = 0; i < support_surfaces_length; i++){ uint32_t length_st_support_surfaces; arrToVar(length_st_support_surfaces, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_support_surfaces; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_support_surfaces-1]=0; this->st_support_surfaces = (char *)(inbuffer + offset-1); offset += length_st_support_surfaces; memcpy( &(this->support_surfaces[i]), &(this->st_support_surfaces), sizeof(char*)); } uint32_t candidate_grasps_lengthT = ((uint32_t) (*(inbuffer + offset))); candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->candidate_grasps_length); if(candidate_grasps_lengthT > candidate_grasps_length) this->candidate_grasps = (moveit_msgs::Grasp*)realloc(this->candidate_grasps, candidate_grasps_lengthT * sizeof(moveit_msgs::Grasp)); candidate_grasps_length = candidate_grasps_lengthT; for( uint32_t i = 0; i < candidate_grasps_length; i++){ offset += this->st_candidate_grasps.deserialize(inbuffer + offset); memcpy( &(this->candidate_grasps[i]), &(this->st_candidate_grasps), sizeof(moveit_msgs::Grasp)); } uint32_t movable_obstacles_lengthT = ((uint32_t) (*(inbuffer + offset))); movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->movable_obstacles_length); if(movable_obstacles_lengthT > movable_obstacles_length) this->movable_obstacles = (moveit_msgs::CollisionObject*)realloc(this->movable_obstacles, movable_obstacles_lengthT * sizeof(moveit_msgs::CollisionObject)); movable_obstacles_length = movable_obstacles_lengthT; for( uint32_t i = 0; i < movable_obstacles_length; i++){ offset += this->st_movable_obstacles.deserialize(inbuffer + offset); memcpy( &(this->movable_obstacles[i]), &(this->st_movable_obstacles), sizeof(moveit_msgs::CollisionObject)); } return offset; } const char * getType(){ return GRASPPLANNING; }; const char * getMD5(){ return "c234e9a645708cc86b57a43999746ae6"; }; }; class GraspPlanningResponse : public ros::Msg { public: uint32_t grasps_length; typedef moveit_msgs::Grasp _grasps_type; _grasps_type st_grasps; _grasps_type * grasps; typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; GraspPlanningResponse(): grasps_length(0), grasps(NULL), error_code() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->grasps_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->grasps_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->grasps_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->grasps_length >> (8 * 3)) & 0xFF; offset += sizeof(this->grasps_length); for( uint32_t i = 0; i < grasps_length; i++){ offset += this->grasps[i].serialize(outbuffer + offset); } offset += this->error_code.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t grasps_lengthT = ((uint32_t) (*(inbuffer + offset))); grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->grasps_length); if(grasps_lengthT > grasps_length) this->grasps = (moveit_msgs::Grasp*)realloc(this->grasps, grasps_lengthT * sizeof(moveit_msgs::Grasp)); grasps_length = grasps_lengthT; for( uint32_t i = 0; i < grasps_length; i++){ offset += this->st_grasps.deserialize(inbuffer + offset); memcpy( &(this->grasps[i]), &(this->st_grasps), sizeof(moveit_msgs::Grasp)); } offset += this->error_code.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GRASPPLANNING; }; const char * getMD5(){ return "bb8169d403b6e9f96bf61e22a50d13ae"; }; }; class GraspPlanning { public: typedef GraspPlanningRequest Request; typedef GraspPlanningResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupResult.h

#ifndef _ROS_moveit_msgs_PickupResult_h #define _ROS_moveit_msgs_PickupResult_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/RobotTrajectory.h" #include "moveit_msgs/Grasp.h" namespace moveit_msgs { class PickupResult : public ros::Msg { public: typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; typedef moveit_msgs::RobotState _trajectory_start_type; _trajectory_start_type trajectory_start; uint32_t trajectory_stages_length; typedef moveit_msgs::RobotTrajectory _trajectory_stages_type; _trajectory_stages_type st_trajectory_stages; _trajectory_stages_type * trajectory_stages; uint32_t trajectory_descriptions_length; typedef char* _trajectory_descriptions_type; _trajectory_descriptions_type st_trajectory_descriptions; _trajectory_descriptions_type * trajectory_descriptions; typedef moveit_msgs::Grasp _grasp_type; _grasp_type grasp; typedef double _planning_time_type; _planning_time_type planning_time; PickupResult(): error_code(), trajectory_start(), trajectory_stages_length(0), trajectory_stages(NULL), trajectory_descriptions_length(0), trajectory_descriptions(NULL), grasp(), planning_time(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->error_code.serialize(outbuffer + offset); offset += this->trajectory_start.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->trajectory_stages_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->trajectory_stages_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->trajectory_stages_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->trajectory_stages_length >> (8 * 3)) & 0xFF; offset += sizeof(this->trajectory_stages_length); for( uint32_t i = 0; i < trajectory_stages_length; i++){ offset += this->trajectory_stages[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->trajectory_descriptions_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->trajectory_descriptions_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->trajectory_descriptions_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->trajectory_descriptions_length >> (8 * 3)) & 0xFF; offset += sizeof(this->trajectory_descriptions_length); for( uint32_t i = 0; i < trajectory_descriptions_length; i++){ uint32_t length_trajectory_descriptionsi = strlen(this->trajectory_descriptions[i]); varToArr(outbuffer + offset, length_trajectory_descriptionsi); offset += 4; memcpy(outbuffer + offset, this->trajectory_descriptions[i], length_trajectory_descriptionsi); offset += length_trajectory_descriptionsi; } offset += this->grasp.serialize(outbuffer + offset); union { double real; uint64_t base; } u_planning_time; u_planning_time.real = this->planning_time; *(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF; offset += sizeof(this->planning_time); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->error_code.deserialize(inbuffer + offset); offset += this->trajectory_start.deserialize(inbuffer + offset); uint32_t trajectory_stages_lengthT = ((uint32_t) (*(inbuffer + offset))); trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->trajectory_stages_length); if(trajectory_stages_lengthT > trajectory_stages_length) this->trajectory_stages = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory_stages, trajectory_stages_lengthT * sizeof(moveit_msgs::RobotTrajectory)); trajectory_stages_length = trajectory_stages_lengthT; for( uint32_t i = 0; i < trajectory_stages_length; i++){ offset += this->st_trajectory_stages.deserialize(inbuffer + offset); memcpy( &(this->trajectory_stages[i]), &(this->st_trajectory_stages), sizeof(moveit_msgs::RobotTrajectory)); } uint32_t trajectory_descriptions_lengthT = ((uint32_t) (*(inbuffer + offset))); trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->trajectory_descriptions_length); if(trajectory_descriptions_lengthT > trajectory_descriptions_length) this->trajectory_descriptions = (char**)realloc(this->trajectory_descriptions, trajectory_descriptions_lengthT * sizeof(char*)); trajectory_descriptions_length = trajectory_descriptions_lengthT; for( uint32_t i = 0; i < trajectory_descriptions_length; i++){ uint32_t length_st_trajectory_descriptions; arrToVar(length_st_trajectory_descriptions, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_trajectory_descriptions; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_trajectory_descriptions-1]=0; this->st_trajectory_descriptions = (char *)(inbuffer + offset-1); offset += length_st_trajectory_descriptions; memcpy( &(this->trajectory_descriptions[i]), &(this->st_trajectory_descriptions), sizeof(char*)); } offset += this->grasp.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_planning_time; u_planning_time.base = 0; u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->planning_time = u_planning_time.real; offset += sizeof(this->planning_time); return offset; } const char * getType(){ return "moveit_msgs/PickupResult"; }; const char * getMD5(){ return "c1e72234397d9de0761966243e264774"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanRequest.h

#ifndef _ROS_moveit_msgs_MotionPlanRequest_h #define _ROS_moveit_msgs_MotionPlanRequest_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/WorkspaceParameters.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/Constraints.h" #include "moveit_msgs/TrajectoryConstraints.h" namespace moveit_msgs { class MotionPlanRequest : public ros::Msg { public: typedef moveit_msgs::WorkspaceParameters _workspace_parameters_type; _workspace_parameters_type workspace_parameters; typedef moveit_msgs::RobotState _start_state_type; _start_state_type start_state; uint32_t goal_constraints_length; typedef moveit_msgs::Constraints _goal_constraints_type; _goal_constraints_type st_goal_constraints; _goal_constraints_type * goal_constraints; typedef moveit_msgs::Constraints _path_constraints_type; _path_constraints_type path_constraints; typedef moveit_msgs::TrajectoryConstraints _trajectory_constraints_type; _trajectory_constraints_type trajectory_constraints; typedef const char* _planner_id_type; _planner_id_type planner_id; typedef const char* _group_name_type; _group_name_type group_name; typedef int32_t _num_planning_attempts_type; _num_planning_attempts_type num_planning_attempts; typedef double _allowed_planning_time_type; _allowed_planning_time_type allowed_planning_time; typedef double _max_velocity_scaling_factor_type; _max_velocity_scaling_factor_type max_velocity_scaling_factor; typedef double _max_acceleration_scaling_factor_type; _max_acceleration_scaling_factor_type max_acceleration_scaling_factor; MotionPlanRequest(): workspace_parameters(), start_state(), goal_constraints_length(0), goal_constraints(NULL), path_constraints(), trajectory_constraints(), planner_id(""), group_name(""), num_planning_attempts(0), allowed_planning_time(0), max_velocity_scaling_factor(0), max_acceleration_scaling_factor(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->workspace_parameters.serialize(outbuffer + offset); offset += this->start_state.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->goal_constraints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->goal_constraints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->goal_constraints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->goal_constraints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->goal_constraints_length); for( uint32_t i = 0; i < goal_constraints_length; i++){ offset += this->goal_constraints[i].serialize(outbuffer + offset); } offset += this->path_constraints.serialize(outbuffer + offset); offset += this->trajectory_constraints.serialize(outbuffer + offset); uint32_t length_planner_id = strlen(this->planner_id); varToArr(outbuffer + offset, length_planner_id); offset += 4; memcpy(outbuffer + offset, this->planner_id, length_planner_id); offset += length_planner_id; uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; union { int32_t real; uint32_t base; } u_num_planning_attempts; u_num_planning_attempts.real = this->num_planning_attempts; *(outbuffer + offset + 0) = (u_num_planning_attempts.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_num_planning_attempts.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_num_planning_attempts.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_num_planning_attempts.base >> (8 * 3)) & 0xFF; offset += sizeof(this->num_planning_attempts); union { double real; uint64_t base; } u_allowed_planning_time; u_allowed_planning_time.real = this->allowed_planning_time; *(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF; offset += sizeof(this->allowed_planning_time); union { double real; uint64_t base; } u_max_velocity_scaling_factor; u_max_velocity_scaling_factor.real = this->max_velocity_scaling_factor; *(outbuffer + offset + 0) = (u_max_velocity_scaling_factor.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_velocity_scaling_factor.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_velocity_scaling_factor.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_velocity_scaling_factor.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_velocity_scaling_factor.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_velocity_scaling_factor.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_velocity_scaling_factor.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_velocity_scaling_factor.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_velocity_scaling_factor); union { double real; uint64_t base; } u_max_acceleration_scaling_factor; u_max_acceleration_scaling_factor.real = this->max_acceleration_scaling_factor; *(outbuffer + offset + 0) = (u_max_acceleration_scaling_factor.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_acceleration_scaling_factor.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_acceleration_scaling_factor.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_acceleration_scaling_factor.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_acceleration_scaling_factor.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_acceleration_scaling_factor.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_acceleration_scaling_factor.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_acceleration_scaling_factor.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_acceleration_scaling_factor); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->workspace_parameters.deserialize(inbuffer + offset); offset += this->start_state.deserialize(inbuffer + offset); uint32_t goal_constraints_lengthT = ((uint32_t) (*(inbuffer + offset))); goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->goal_constraints_length); if(goal_constraints_lengthT > goal_constraints_length) this->goal_constraints = (moveit_msgs::Constraints*)realloc(this->goal_constraints, goal_constraints_lengthT * sizeof(moveit_msgs::Constraints)); goal_constraints_length = goal_constraints_lengthT; for( uint32_t i = 0; i < goal_constraints_length; i++){ offset += this->st_goal_constraints.deserialize(inbuffer + offset); memcpy( &(this->goal_constraints[i]), &(this->st_goal_constraints), sizeof(moveit_msgs::Constraints)); } offset += this->path_constraints.deserialize(inbuffer + offset); offset += this->trajectory_constraints.deserialize(inbuffer + offset); uint32_t length_planner_id; arrToVar(length_planner_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_planner_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_planner_id-1]=0; this->planner_id = (char *)(inbuffer + offset-1); offset += length_planner_id; uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; union { int32_t real; uint32_t base; } u_num_planning_attempts; u_num_planning_attempts.base = 0; u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->num_planning_attempts = u_num_planning_attempts.real; offset += sizeof(this->num_planning_attempts); union { double real; uint64_t base; } u_allowed_planning_time; u_allowed_planning_time.base = 0; u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->allowed_planning_time = u_allowed_planning_time.real; offset += sizeof(this->allowed_planning_time); union { double real; uint64_t base; } u_max_velocity_scaling_factor; u_max_velocity_scaling_factor.base = 0; u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_velocity_scaling_factor = u_max_velocity_scaling_factor.real; offset += sizeof(this->max_velocity_scaling_factor); union { double real; uint64_t base; } u_max_acceleration_scaling_factor; u_max_acceleration_scaling_factor.base = 0; u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_acceleration_scaling_factor = u_max_acceleration_scaling_factor.real; offset += sizeof(this->max_acceleration_scaling_factor); return offset; } const char * getType(){ return "moveit_msgs/MotionPlanRequest"; }; const char * getMD5(){ return "c3bec13a525a6ae66e0fc57b768fdca6"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/Grasp.h

#ifndef _ROS_moveit_msgs_Grasp_h #define _ROS_moveit_msgs_Grasp_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "trajectory_msgs/JointTrajectory.h" #include "geometry_msgs/PoseStamped.h" #include "moveit_msgs/GripperTranslation.h" namespace moveit_msgs { class Grasp : public ros::Msg { public: typedef const char* _id_type; _id_type id; typedef trajectory_msgs::JointTrajectory _pre_grasp_posture_type; _pre_grasp_posture_type pre_grasp_posture; typedef trajectory_msgs::JointTrajectory _grasp_posture_type; _grasp_posture_type grasp_posture; typedef geometry_msgs::PoseStamped _grasp_pose_type; _grasp_pose_type grasp_pose; typedef double _grasp_quality_type; _grasp_quality_type grasp_quality; typedef moveit_msgs::GripperTranslation _pre_grasp_approach_type; _pre_grasp_approach_type pre_grasp_approach; typedef moveit_msgs::GripperTranslation _post_grasp_retreat_type; _post_grasp_retreat_type post_grasp_retreat; typedef moveit_msgs::GripperTranslation _post_place_retreat_type; _post_place_retreat_type post_place_retreat; typedef float _max_contact_force_type; _max_contact_force_type max_contact_force; uint32_t allowed_touch_objects_length; typedef char* _allowed_touch_objects_type; _allowed_touch_objects_type st_allowed_touch_objects; _allowed_touch_objects_type * allowed_touch_objects; Grasp(): id(""), pre_grasp_posture(), grasp_posture(), grasp_pose(), grasp_quality(0), pre_grasp_approach(), post_grasp_retreat(), post_place_retreat(), max_contact_force(0), allowed_touch_objects_length(0), allowed_touch_objects(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_id = strlen(this->id); varToArr(outbuffer + offset, length_id); offset += 4; memcpy(outbuffer + offset, this->id, length_id); offset += length_id; offset += this->pre_grasp_posture.serialize(outbuffer + offset); offset += this->grasp_posture.serialize(outbuffer + offset); offset += this->grasp_pose.serialize(outbuffer + offset); union { double real; uint64_t base; } u_grasp_quality; u_grasp_quality.real = this->grasp_quality; *(outbuffer + offset + 0) = (u_grasp_quality.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_grasp_quality.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_grasp_quality.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_grasp_quality.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_grasp_quality.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_grasp_quality.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_grasp_quality.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_grasp_quality.base >> (8 * 7)) & 0xFF; offset += sizeof(this->grasp_quality); offset += this->pre_grasp_approach.serialize(outbuffer + offset); offset += this->post_grasp_retreat.serialize(outbuffer + offset); offset += this->post_place_retreat.serialize(outbuffer + offset); union { float real; uint32_t base; } u_max_contact_force; u_max_contact_force.real = this->max_contact_force; *(outbuffer + offset + 0) = (u_max_contact_force.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_contact_force.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_contact_force.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_contact_force.base >> (8 * 3)) & 0xFF; offset += sizeof(this->max_contact_force); *(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF; offset += sizeof(this->allowed_touch_objects_length); for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]); varToArr(outbuffer + offset, length_allowed_touch_objectsi); offset += 4; memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi); offset += length_allowed_touch_objectsi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_id; arrToVar(length_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_id-1]=0; this->id = (char *)(inbuffer + offset-1); offset += length_id; offset += this->pre_grasp_posture.deserialize(inbuffer + offset); offset += this->grasp_posture.deserialize(inbuffer + offset); offset += this->grasp_pose.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_grasp_quality; u_grasp_quality.base = 0; u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->grasp_quality = u_grasp_quality.real; offset += sizeof(this->grasp_quality); offset += this->pre_grasp_approach.deserialize(inbuffer + offset); offset += this->post_grasp_retreat.deserialize(inbuffer + offset); offset += this->post_place_retreat.deserialize(inbuffer + offset); union { float real; uint32_t base; } u_max_contact_force; u_max_contact_force.base = 0; u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->max_contact_force = u_max_contact_force.real; offset += sizeof(this->max_contact_force); uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset))); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->allowed_touch_objects_length); if(allowed_touch_objects_lengthT > allowed_touch_objects_length) this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*)); allowed_touch_objects_length = allowed_touch_objects_lengthT; for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_st_allowed_touch_objects; arrToVar(length_st_allowed_touch_objects, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_allowed_touch_objects-1]=0; this->st_allowed_touch_objects = (char *)(inbuffer + offset-1); offset += length_st_allowed_touch_objects; memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*)); } return offset; } const char * getType(){ return "moveit_msgs/Grasp"; }; const char * getMD5(){ return "e26c8fb64f589c33c5d5e54bd7b5e4cb"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ContactInformation.h

#ifndef _ROS_moveit_msgs_ContactInformation_h #define _ROS_moveit_msgs_ContactInformation_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Point.h" #include "geometry_msgs/Vector3.h" namespace moveit_msgs { class ContactInformation : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef geometry_msgs::Point _position_type; _position_type position; typedef geometry_msgs::Vector3 _normal_type; _normal_type normal; typedef double _depth_type; _depth_type depth; typedef const char* _contact_body_1_type; _contact_body_1_type contact_body_1; typedef uint32_t _body_type_1_type; _body_type_1_type body_type_1; typedef const char* _contact_body_2_type; _contact_body_2_type contact_body_2; typedef uint32_t _body_type_2_type; _body_type_2_type body_type_2; enum { ROBOT_LINK = 0 }; enum { WORLD_OBJECT = 1 }; enum { ROBOT_ATTACHED = 2 }; ContactInformation(): header(), position(), normal(), depth(0), contact_body_1(""), body_type_1(0), contact_body_2(""), body_type_2(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->position.serialize(outbuffer + offset); offset += this->normal.serialize(outbuffer + offset); union { double real; uint64_t base; } u_depth; u_depth.real = this->depth; *(outbuffer + offset + 0) = (u_depth.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_depth.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_depth.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_depth.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_depth.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_depth.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_depth.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_depth.base >> (8 * 7)) & 0xFF; offset += sizeof(this->depth); uint32_t length_contact_body_1 = strlen(this->contact_body_1); varToArr(outbuffer + offset, length_contact_body_1); offset += 4; memcpy(outbuffer + offset, this->contact_body_1, length_contact_body_1); offset += length_contact_body_1; *(outbuffer + offset + 0) = (this->body_type_1 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->body_type_1 >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->body_type_1 >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->body_type_1 >> (8 * 3)) & 0xFF; offset += sizeof(this->body_type_1); uint32_t length_contact_body_2 = strlen(this->contact_body_2); varToArr(outbuffer + offset, length_contact_body_2); offset += 4; memcpy(outbuffer + offset, this->contact_body_2, length_contact_body_2); offset += length_contact_body_2; *(outbuffer + offset + 0) = (this->body_type_2 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->body_type_2 >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->body_type_2 >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->body_type_2 >> (8 * 3)) & 0xFF; offset += sizeof(this->body_type_2); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->position.deserialize(inbuffer + offset); offset += this->normal.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_depth; u_depth.base = 0; u_depth.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_depth.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_depth.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_depth.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_depth.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_depth.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_depth.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_depth.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->depth = u_depth.real; offset += sizeof(this->depth); uint32_t length_contact_body_1; arrToVar(length_contact_body_1, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_contact_body_1; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_contact_body_1-1]=0; this->contact_body_1 = (char *)(inbuffer + offset-1); offset += length_contact_body_1; this->body_type_1 = ((uint32_t) (*(inbuffer + offset))); this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->body_type_1); uint32_t length_contact_body_2; arrToVar(length_contact_body_2, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_contact_body_2; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_contact_body_2-1]=0; this->contact_body_2 = (char *)(inbuffer + offset-1); offset += length_contact_body_2; this->body_type_2 = ((uint32_t) (*(inbuffer + offset))); this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->body_type_2); return offset; } const char * getType(){ return "moveit_msgs/ContactInformation"; }; const char * getMD5(){ return "116228ca08b0c286ec5ca32a50fdc17b"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningSceneComponents.h

#ifndef _ROS_moveit_msgs_PlanningSceneComponents_h #define _ROS_moveit_msgs_PlanningSceneComponents_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class PlanningSceneComponents : public ros::Msg { public: typedef uint32_t _components_type; _components_type components; enum { SCENE_SETTINGS = 1 }; enum { ROBOT_STATE = 2 }; enum { ROBOT_STATE_ATTACHED_OBJECTS = 4 }; enum { WORLD_OBJECT_NAMES = 8 }; enum { WORLD_OBJECT_GEOMETRY = 16 }; enum { OCTOMAP = 32 }; enum { TRANSFORMS = 64 }; enum { ALLOWED_COLLISION_MATRIX = 128 }; enum { LINK_PADDING_AND_SCALING = 256 }; enum { OBJECT_COLORS = 512 }; PlanningSceneComponents(): components(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->components >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->components >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->components >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->components >> (8 * 3)) & 0xFF; offset += sizeof(this->components); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->components = ((uint32_t) (*(inbuffer + offset))); this->components |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->components |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->components |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->components); return offset; } const char * getType(){ return "moveit_msgs/PlanningSceneComponents"; }; const char * getMD5(){ return "bc993e784476960b918b6e7ad5bb58ce"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ChangeDriftDimensions.h

#ifndef _ROS_SERVICE_ChangeDriftDimensions_h #define _ROS_SERVICE_ChangeDriftDimensions_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "geometry_msgs/Transform.h" namespace moveit_msgs { static const char CHANGEDRIFTDIMENSIONS[] = "moveit_msgs/ChangeDriftDimensions"; class ChangeDriftDimensionsRequest : public ros::Msg { public: typedef bool _drift_x_translation_type; _drift_x_translation_type drift_x_translation; typedef bool _drift_y_translation_type; _drift_y_translation_type drift_y_translation; typedef bool _drift_z_translation_type; _drift_z_translation_type drift_z_translation; typedef bool _drift_x_rotation_type; _drift_x_rotation_type drift_x_rotation; typedef bool _drift_y_rotation_type; _drift_y_rotation_type drift_y_rotation; typedef bool _drift_z_rotation_type; _drift_z_rotation_type drift_z_rotation; typedef geometry_msgs::Transform _transform_jog_frame_to_drift_frame_type; _transform_jog_frame_to_drift_frame_type transform_jog_frame_to_drift_frame; ChangeDriftDimensionsRequest(): drift_x_translation(0), drift_y_translation(0), drift_z_translation(0), drift_x_rotation(0), drift_y_rotation(0), drift_z_rotation(0), transform_jog_frame_to_drift_frame() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_drift_x_translation; u_drift_x_translation.real = this->drift_x_translation; *(outbuffer + offset + 0) = (u_drift_x_translation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->drift_x_translation); union { bool real; uint8_t base; } u_drift_y_translation; u_drift_y_translation.real = this->drift_y_translation; *(outbuffer + offset + 0) = (u_drift_y_translation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->drift_y_translation); union { bool real; uint8_t base; } u_drift_z_translation; u_drift_z_translation.real = this->drift_z_translation; *(outbuffer + offset + 0) = (u_drift_z_translation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->drift_z_translation); union { bool real; uint8_t base; } u_drift_x_rotation; u_drift_x_rotation.real = this->drift_x_rotation; *(outbuffer + offset + 0) = (u_drift_x_rotation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->drift_x_rotation); union { bool real; uint8_t base; } u_drift_y_rotation; u_drift_y_rotation.real = this->drift_y_rotation; *(outbuffer + offset + 0) = (u_drift_y_rotation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->drift_y_rotation); union { bool real; uint8_t base; } u_drift_z_rotation; u_drift_z_rotation.real = this->drift_z_rotation; *(outbuffer + offset + 0) = (u_drift_z_rotation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->drift_z_rotation); offset += this->transform_jog_frame_to_drift_frame.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_drift_x_translation; u_drift_x_translation.base = 0; u_drift_x_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->drift_x_translation = u_drift_x_translation.real; offset += sizeof(this->drift_x_translation); union { bool real; uint8_t base; } u_drift_y_translation; u_drift_y_translation.base = 0; u_drift_y_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->drift_y_translation = u_drift_y_translation.real; offset += sizeof(this->drift_y_translation); union { bool real; uint8_t base; } u_drift_z_translation; u_drift_z_translation.base = 0; u_drift_z_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->drift_z_translation = u_drift_z_translation.real; offset += sizeof(this->drift_z_translation); union { bool real; uint8_t base; } u_drift_x_rotation; u_drift_x_rotation.base = 0; u_drift_x_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->drift_x_rotation = u_drift_x_rotation.real; offset += sizeof(this->drift_x_rotation); union { bool real; uint8_t base; } u_drift_y_rotation; u_drift_y_rotation.base = 0; u_drift_y_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->drift_y_rotation = u_drift_y_rotation.real; offset += sizeof(this->drift_y_rotation); union { bool real; uint8_t base; } u_drift_z_rotation; u_drift_z_rotation.base = 0; u_drift_z_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->drift_z_rotation = u_drift_z_rotation.real; offset += sizeof(this->drift_z_rotation); offset += this->transform_jog_frame_to_drift_frame.deserialize(inbuffer + offset); return offset; } const char * getType(){ return CHANGEDRIFTDIMENSIONS; }; const char * getMD5(){ return "4a5ce44f94cdee672e699df89b1ebaf1"; }; }; class ChangeDriftDimensionsResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; ChangeDriftDimensionsResponse(): success(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.real = this->success; *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; offset += sizeof(this->success); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.base = 0; u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->success = u_success.real; offset += sizeof(this->success); return offset; } const char * getType(){ return CHANGEDRIFTDIMENSIONS; }; const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; }; class ChangeDriftDimensions { public: typedef ChangeDriftDimensionsRequest Request; typedef ChangeDriftDimensionsResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPositionFK.h

#ifndef _ROS_SERVICE_GetPositionFK_h #define _ROS_SERVICE_GetPositionFK_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "geometry_msgs/PoseStamped.h" #include "std_msgs/Header.h" #include "moveit_msgs/RobotState.h" namespace moveit_msgs { static const char GETPOSITIONFK[] = "moveit_msgs/GetPositionFK"; class GetPositionFKRequest : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t fk_link_names_length; typedef char* _fk_link_names_type; _fk_link_names_type st_fk_link_names; _fk_link_names_type * fk_link_names; typedef moveit_msgs::RobotState _robot_state_type; _robot_state_type robot_state; GetPositionFKRequest(): header(), fk_link_names_length(0), fk_link_names(NULL), robot_state() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->fk_link_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->fk_link_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->fk_link_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->fk_link_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->fk_link_names_length); for( uint32_t i = 0; i < fk_link_names_length; i++){ uint32_t length_fk_link_namesi = strlen(this->fk_link_names[i]); varToArr(outbuffer + offset, length_fk_link_namesi); offset += 4; memcpy(outbuffer + offset, this->fk_link_names[i], length_fk_link_namesi); offset += length_fk_link_namesi; } offset += this->robot_state.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t fk_link_names_lengthT = ((uint32_t) (*(inbuffer + offset))); fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->fk_link_names_length); if(fk_link_names_lengthT > fk_link_names_length) this->fk_link_names = (char**)realloc(this->fk_link_names, fk_link_names_lengthT * sizeof(char*)); fk_link_names_length = fk_link_names_lengthT; for( uint32_t i = 0; i < fk_link_names_length; i++){ uint32_t length_st_fk_link_names; arrToVar(length_st_fk_link_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_fk_link_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_fk_link_names-1]=0; this->st_fk_link_names = (char *)(inbuffer + offset-1); offset += length_st_fk_link_names; memcpy( &(this->fk_link_names[i]), &(this->st_fk_link_names), sizeof(char*)); } offset += this->robot_state.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPOSITIONFK; }; const char * getMD5(){ return "1d1ed72044ed56f6246c31b522781797"; }; }; class GetPositionFKResponse : public ros::Msg { public: uint32_t pose_stamped_length; typedef geometry_msgs::PoseStamped _pose_stamped_type; _pose_stamped_type st_pose_stamped; _pose_stamped_type * pose_stamped; uint32_t fk_link_names_length; typedef char* _fk_link_names_type; _fk_link_names_type st_fk_link_names; _fk_link_names_type * fk_link_names; typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; GetPositionFKResponse(): pose_stamped_length(0), pose_stamped(NULL), fk_link_names_length(0), fk_link_names(NULL), error_code() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->pose_stamped_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->pose_stamped_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->pose_stamped_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->pose_stamped_length >> (8 * 3)) & 0xFF; offset += sizeof(this->pose_stamped_length); for( uint32_t i = 0; i < pose_stamped_length; i++){ offset += this->pose_stamped[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->fk_link_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->fk_link_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->fk_link_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->fk_link_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->fk_link_names_length); for( uint32_t i = 0; i < fk_link_names_length; i++){ uint32_t length_fk_link_namesi = strlen(this->fk_link_names[i]); varToArr(outbuffer + offset, length_fk_link_namesi); offset += 4; memcpy(outbuffer + offset, this->fk_link_names[i], length_fk_link_namesi); offset += length_fk_link_namesi; } offset += this->error_code.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t pose_stamped_lengthT = ((uint32_t) (*(inbuffer + offset))); pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->pose_stamped_length); if(pose_stamped_lengthT > pose_stamped_length) this->pose_stamped = (geometry_msgs::PoseStamped*)realloc(this->pose_stamped, pose_stamped_lengthT * sizeof(geometry_msgs::PoseStamped)); pose_stamped_length = pose_stamped_lengthT; for( uint32_t i = 0; i < pose_stamped_length; i++){ offset += this->st_pose_stamped.deserialize(inbuffer + offset); memcpy( &(this->pose_stamped[i]), &(this->st_pose_stamped), sizeof(geometry_msgs::PoseStamped)); } uint32_t fk_link_names_lengthT = ((uint32_t) (*(inbuffer + offset))); fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->fk_link_names_length); if(fk_link_names_lengthT > fk_link_names_length) this->fk_link_names = (char**)realloc(this->fk_link_names, fk_link_names_lengthT * sizeof(char*)); fk_link_names_length = fk_link_names_lengthT; for( uint32_t i = 0; i < fk_link_names_length; i++){ uint32_t length_st_fk_link_names; arrToVar(length_st_fk_link_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_fk_link_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_fk_link_names-1]=0; this->st_fk_link_names = (char *)(inbuffer + offset-1); offset += length_st_fk_link_names; memcpy( &(this->fk_link_names[i]), &(this->st_fk_link_names), sizeof(char*)); } offset += this->error_code.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPOSITIONFK; }; const char * getMD5(){ return "297215cf4fdfe0008356995ae621dae6"; }; }; class GetPositionFK { public: typedef GetPositionFKRequest Request; typedef GetPositionFKResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CheckIfRobotStateExistsInWarehouse.h

#ifndef _ROS_SERVICE_CheckIfRobotStateExistsInWarehouse_h #define _ROS_SERVICE_CheckIfRobotStateExistsInWarehouse_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { static const char CHECKIFROBOTSTATEEXISTSINWAREHOUSE[] = "moveit_msgs/CheckIfRobotStateExistsInWarehouse"; class CheckIfRobotStateExistsInWarehouseRequest : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef const char* _robot_type; _robot_type robot; CheckIfRobotStateExistsInWarehouseRequest(): name(""), robot("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; uint32_t length_robot = strlen(this->robot); varToArr(outbuffer + offset, length_robot); offset += 4; memcpy(outbuffer + offset, this->robot, length_robot); offset += length_robot; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; uint32_t length_robot; arrToVar(length_robot, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_robot; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_robot-1]=0; this->robot = (char *)(inbuffer + offset-1); offset += length_robot; return offset; } const char * getType(){ return CHECKIFROBOTSTATEEXISTSINWAREHOUSE; }; const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; }; }; class CheckIfRobotStateExistsInWarehouseResponse : public ros::Msg { public: typedef bool _exists_type; _exists_type exists; CheckIfRobotStateExistsInWarehouseResponse(): exists(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_exists; u_exists.real = this->exists; *(outbuffer + offset + 0) = (u_exists.base >> (8 * 0)) & 0xFF; offset += sizeof(this->exists); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_exists; u_exists.base = 0; u_exists.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->exists = u_exists.real; offset += sizeof(this->exists); return offset; } const char * getType(){ return CHECKIFROBOTSTATEEXISTSINWAREHOUSE; }; const char * getMD5(){ return "e8c90de4adc1219c86af9c2874c0c1b5"; }; }; class CheckIfRobotStateExistsInWarehouse { public: typedef CheckIfRobotStateExistsInWarehouseRequest Request; typedef CheckIfRobotStateExistsInWarehouseResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DeleteRobotStateFromWarehouse.h

#ifndef _ROS_SERVICE_DeleteRobotStateFromWarehouse_h #define _ROS_SERVICE_DeleteRobotStateFromWarehouse_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { static const char DELETEROBOTSTATEFROMWAREHOUSE[] = "moveit_msgs/DeleteRobotStateFromWarehouse"; class DeleteRobotStateFromWarehouseRequest : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef const char* _robot_type; _robot_type robot; DeleteRobotStateFromWarehouseRequest(): name(""), robot("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; uint32_t length_robot = strlen(this->robot); varToArr(outbuffer + offset, length_robot); offset += 4; memcpy(outbuffer + offset, this->robot, length_robot); offset += length_robot; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; uint32_t length_robot; arrToVar(length_robot, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_robot; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_robot-1]=0; this->robot = (char *)(inbuffer + offset-1); offset += length_robot; return offset; } const char * getType(){ return DELETEROBOTSTATEFROMWAREHOUSE; }; const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; }; }; class DeleteRobotStateFromWarehouseResponse : public ros::Msg { public: DeleteRobotStateFromWarehouseResponse() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; return offset; } const char * getType(){ return DELETEROBOTSTATEFROMWAREHOUSE; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class DeleteRobotStateFromWarehouse { public: typedef DeleteRobotStateFromWarehouseRequest Request; typedef DeleteRobotStateFromWarehouseResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupGoal.h

#ifndef _ROS_moveit_msgs_PickupGoal_h #define _ROS_moveit_msgs_PickupGoal_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/Grasp.h" #include "moveit_msgs/Constraints.h" #include "moveit_msgs/PlanningOptions.h" namespace moveit_msgs { class PickupGoal : public ros::Msg { public: typedef const char* _target_name_type; _target_name_type target_name; typedef const char* _group_name_type; _group_name_type group_name; typedef const char* _end_effector_type; _end_effector_type end_effector; uint32_t possible_grasps_length; typedef moveit_msgs::Grasp _possible_grasps_type; _possible_grasps_type st_possible_grasps; _possible_grasps_type * possible_grasps; typedef const char* _support_surface_name_type; _support_surface_name_type support_surface_name; typedef bool _allow_gripper_support_collision_type; _allow_gripper_support_collision_type allow_gripper_support_collision; uint32_t attached_object_touch_links_length; typedef char* _attached_object_touch_links_type; _attached_object_touch_links_type st_attached_object_touch_links; _attached_object_touch_links_type * attached_object_touch_links; typedef bool _minimize_object_distance_type; _minimize_object_distance_type minimize_object_distance; typedef moveit_msgs::Constraints _path_constraints_type; _path_constraints_type path_constraints; typedef const char* _planner_id_type; _planner_id_type planner_id; uint32_t allowed_touch_objects_length; typedef char* _allowed_touch_objects_type; _allowed_touch_objects_type st_allowed_touch_objects; _allowed_touch_objects_type * allowed_touch_objects; typedef double _allowed_planning_time_type; _allowed_planning_time_type allowed_planning_time; typedef moveit_msgs::PlanningOptions _planning_options_type; _planning_options_type planning_options; PickupGoal(): target_name(""), group_name(""), end_effector(""), possible_grasps_length(0), possible_grasps(NULL), support_surface_name(""), allow_gripper_support_collision(0), attached_object_touch_links_length(0), attached_object_touch_links(NULL), minimize_object_distance(0), path_constraints(), planner_id(""), allowed_touch_objects_length(0), allowed_touch_objects(NULL), allowed_planning_time(0), planning_options() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_target_name = strlen(this->target_name); varToArr(outbuffer + offset, length_target_name); offset += 4; memcpy(outbuffer + offset, this->target_name, length_target_name); offset += length_target_name; uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; uint32_t length_end_effector = strlen(this->end_effector); varToArr(outbuffer + offset, length_end_effector); offset += 4; memcpy(outbuffer + offset, this->end_effector, length_end_effector); offset += length_end_effector; *(outbuffer + offset + 0) = (this->possible_grasps_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->possible_grasps_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->possible_grasps_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->possible_grasps_length >> (8 * 3)) & 0xFF; offset += sizeof(this->possible_grasps_length); for( uint32_t i = 0; i < possible_grasps_length; i++){ offset += this->possible_grasps[i].serialize(outbuffer + offset); } uint32_t length_support_surface_name = strlen(this->support_surface_name); varToArr(outbuffer + offset, length_support_surface_name); offset += 4; memcpy(outbuffer + offset, this->support_surface_name, length_support_surface_name); offset += length_support_surface_name; union { bool real; uint8_t base; } u_allow_gripper_support_collision; u_allow_gripper_support_collision.real = this->allow_gripper_support_collision; *(outbuffer + offset + 0) = (u_allow_gripper_support_collision.base >> (8 * 0)) & 0xFF; offset += sizeof(this->allow_gripper_support_collision); *(outbuffer + offset + 0) = (this->attached_object_touch_links_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->attached_object_touch_links_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->attached_object_touch_links_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->attached_object_touch_links_length >> (8 * 3)) & 0xFF; offset += sizeof(this->attached_object_touch_links_length); for( uint32_t i = 0; i < attached_object_touch_links_length; i++){ uint32_t length_attached_object_touch_linksi = strlen(this->attached_object_touch_links[i]); varToArr(outbuffer + offset, length_attached_object_touch_linksi); offset += 4; memcpy(outbuffer + offset, this->attached_object_touch_links[i], length_attached_object_touch_linksi); offset += length_attached_object_touch_linksi; } union { bool real; uint8_t base; } u_minimize_object_distance; u_minimize_object_distance.real = this->minimize_object_distance; *(outbuffer + offset + 0) = (u_minimize_object_distance.base >> (8 * 0)) & 0xFF; offset += sizeof(this->minimize_object_distance); offset += this->path_constraints.serialize(outbuffer + offset); uint32_t length_planner_id = strlen(this->planner_id); varToArr(outbuffer + offset, length_planner_id); offset += 4; memcpy(outbuffer + offset, this->planner_id, length_planner_id); offset += length_planner_id; *(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF; offset += sizeof(this->allowed_touch_objects_length); for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]); varToArr(outbuffer + offset, length_allowed_touch_objectsi); offset += 4; memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi); offset += length_allowed_touch_objectsi; } union { double real; uint64_t base; } u_allowed_planning_time; u_allowed_planning_time.real = this->allowed_planning_time; *(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF; offset += sizeof(this->allowed_planning_time); offset += this->planning_options.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_target_name; arrToVar(length_target_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_target_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_target_name-1]=0; this->target_name = (char *)(inbuffer + offset-1); offset += length_target_name; uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; uint32_t length_end_effector; arrToVar(length_end_effector, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_end_effector; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_end_effector-1]=0; this->end_effector = (char *)(inbuffer + offset-1); offset += length_end_effector; uint32_t possible_grasps_lengthT = ((uint32_t) (*(inbuffer + offset))); possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->possible_grasps_length); if(possible_grasps_lengthT > possible_grasps_length) this->possible_grasps = (moveit_msgs::Grasp*)realloc(this->possible_grasps, possible_grasps_lengthT * sizeof(moveit_msgs::Grasp)); possible_grasps_length = possible_grasps_lengthT; for( uint32_t i = 0; i < possible_grasps_length; i++){ offset += this->st_possible_grasps.deserialize(inbuffer + offset); memcpy( &(this->possible_grasps[i]), &(this->st_possible_grasps), sizeof(moveit_msgs::Grasp)); } uint32_t length_support_surface_name; arrToVar(length_support_surface_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_support_surface_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_support_surface_name-1]=0; this->support_surface_name = (char *)(inbuffer + offset-1); offset += length_support_surface_name; union { bool real; uint8_t base; } u_allow_gripper_support_collision; u_allow_gripper_support_collision.base = 0; u_allow_gripper_support_collision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->allow_gripper_support_collision = u_allow_gripper_support_collision.real; offset += sizeof(this->allow_gripper_support_collision); uint32_t attached_object_touch_links_lengthT = ((uint32_t) (*(inbuffer + offset))); attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->attached_object_touch_links_length); if(attached_object_touch_links_lengthT > attached_object_touch_links_length) this->attached_object_touch_links = (char**)realloc(this->attached_object_touch_links, attached_object_touch_links_lengthT * sizeof(char*)); attached_object_touch_links_length = attached_object_touch_links_lengthT; for( uint32_t i = 0; i < attached_object_touch_links_length; i++){ uint32_t length_st_attached_object_touch_links; arrToVar(length_st_attached_object_touch_links, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_attached_object_touch_links; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_attached_object_touch_links-1]=0; this->st_attached_object_touch_links = (char *)(inbuffer + offset-1); offset += length_st_attached_object_touch_links; memcpy( &(this->attached_object_touch_links[i]), &(this->st_attached_object_touch_links), sizeof(char*)); } union { bool real; uint8_t base; } u_minimize_object_distance; u_minimize_object_distance.base = 0; u_minimize_object_distance.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->minimize_object_distance = u_minimize_object_distance.real; offset += sizeof(this->minimize_object_distance); offset += this->path_constraints.deserialize(inbuffer + offset); uint32_t length_planner_id; arrToVar(length_planner_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_planner_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_planner_id-1]=0; this->planner_id = (char *)(inbuffer + offset-1); offset += length_planner_id; uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset))); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->allowed_touch_objects_length); if(allowed_touch_objects_lengthT > allowed_touch_objects_length) this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*)); allowed_touch_objects_length = allowed_touch_objects_lengthT; for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_st_allowed_touch_objects; arrToVar(length_st_allowed_touch_objects, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_allowed_touch_objects-1]=0; this->st_allowed_touch_objects = (char *)(inbuffer + offset-1); offset += length_st_allowed_touch_objects; memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*)); } union { double real; uint64_t base; } u_allowed_planning_time; u_allowed_planning_time.base = 0; u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->allowed_planning_time = u_allowed_planning_time.real; offset += sizeof(this->allowed_planning_time); offset += this->planning_options.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/PickupGoal"; }; const char * getMD5(){ return "458c6ab3761d73e99b070063f7b74c2a"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RobotState.h

#ifndef _ROS_moveit_msgs_RobotState_h #define _ROS_moveit_msgs_RobotState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "sensor_msgs/JointState.h" #include "sensor_msgs/MultiDOFJointState.h" #include "moveit_msgs/AttachedCollisionObject.h" namespace moveit_msgs { class RobotState : public ros::Msg { public: typedef sensor_msgs::JointState _joint_state_type; _joint_state_type joint_state; typedef sensor_msgs::MultiDOFJointState _multi_dof_joint_state_type; _multi_dof_joint_state_type multi_dof_joint_state; uint32_t attached_collision_objects_length; typedef moveit_msgs::AttachedCollisionObject _attached_collision_objects_type; _attached_collision_objects_type st_attached_collision_objects; _attached_collision_objects_type * attached_collision_objects; typedef bool _is_diff_type; _is_diff_type is_diff; RobotState(): joint_state(), multi_dof_joint_state(), attached_collision_objects_length(0), attached_collision_objects(NULL), is_diff(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->joint_state.serialize(outbuffer + offset); offset += this->multi_dof_joint_state.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->attached_collision_objects_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->attached_collision_objects_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->attached_collision_objects_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->attached_collision_objects_length >> (8 * 3)) & 0xFF; offset += sizeof(this->attached_collision_objects_length); for( uint32_t i = 0; i < attached_collision_objects_length; i++){ offset += this->attached_collision_objects[i].serialize(outbuffer + offset); } union { bool real; uint8_t base; } u_is_diff; u_is_diff.real = this->is_diff; *(outbuffer + offset + 0) = (u_is_diff.base >> (8 * 0)) & 0xFF; offset += sizeof(this->is_diff); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->joint_state.deserialize(inbuffer + offset); offset += this->multi_dof_joint_state.deserialize(inbuffer + offset); uint32_t attached_collision_objects_lengthT = ((uint32_t) (*(inbuffer + offset))); attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->attached_collision_objects_length); if(attached_collision_objects_lengthT > attached_collision_objects_length) this->attached_collision_objects = (moveit_msgs::AttachedCollisionObject*)realloc(this->attached_collision_objects, attached_collision_objects_lengthT * sizeof(moveit_msgs::AttachedCollisionObject)); attached_collision_objects_length = attached_collision_objects_lengthT; for( uint32_t i = 0; i < attached_collision_objects_length; i++){ offset += this->st_attached_collision_objects.deserialize(inbuffer + offset); memcpy( &(this->attached_collision_objects[i]), &(this->st_attached_collision_objects), sizeof(moveit_msgs::AttachedCollisionObject)); } union { bool real; uint8_t base; } u_is_diff; u_is_diff.base = 0; u_is_diff.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->is_diff = u_is_diff.real; offset += sizeof(this->is_diff); return offset; } const char * getType(){ return "moveit_msgs/RobotState"; }; const char * getMD5(){ return "217a2e8e5547f4162b13a37db9cb4da4"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupResult.h

#ifndef _ROS_moveit_msgs_MoveGroupResult_h #define _ROS_moveit_msgs_MoveGroupResult_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/RobotTrajectory.h" namespace moveit_msgs { class MoveGroupResult : public ros::Msg { public: typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; typedef moveit_msgs::RobotState _trajectory_start_type; _trajectory_start_type trajectory_start; typedef moveit_msgs::RobotTrajectory _planned_trajectory_type; _planned_trajectory_type planned_trajectory; typedef moveit_msgs::RobotTrajectory _executed_trajectory_type; _executed_trajectory_type executed_trajectory; typedef double _planning_time_type; _planning_time_type planning_time; MoveGroupResult(): error_code(), trajectory_start(), planned_trajectory(), executed_trajectory(), planning_time(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->error_code.serialize(outbuffer + offset); offset += this->trajectory_start.serialize(outbuffer + offset); offset += this->planned_trajectory.serialize(outbuffer + offset); offset += this->executed_trajectory.serialize(outbuffer + offset); union { double real; uint64_t base; } u_planning_time; u_planning_time.real = this->planning_time; *(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF; offset += sizeof(this->planning_time); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->error_code.deserialize(inbuffer + offset); offset += this->trajectory_start.deserialize(inbuffer + offset); offset += this->planned_trajectory.deserialize(inbuffer + offset); offset += this->executed_trajectory.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_planning_time; u_planning_time.base = 0; u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->planning_time = u_planning_time.real; offset += sizeof(this->planning_time); return offset; } const char * getType(){ return "moveit_msgs/MoveGroupResult"; }; const char * getMD5(){ return "34098589d402fee7ae9c3fd413e5a6c6"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceRequest.h

#ifndef _ROS_moveit_msgs_MotionSequenceRequest_h #define _ROS_moveit_msgs_MotionSequenceRequest_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MotionSequenceItem.h" namespace moveit_msgs { class MotionSequenceRequest : public ros::Msg { public: uint32_t items_length; typedef moveit_msgs::MotionSequenceItem _items_type; _items_type st_items; _items_type * items; MotionSequenceRequest(): items_length(0), items(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->items_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->items_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->items_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->items_length >> (8 * 3)) & 0xFF; offset += sizeof(this->items_length); for( uint32_t i = 0; i < items_length; i++){ offset += this->items[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t items_lengthT = ((uint32_t) (*(inbuffer + offset))); items_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); items_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); items_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->items_length); if(items_lengthT > items_length) this->items = (moveit_msgs::MotionSequenceItem*)realloc(this->items, items_lengthT * sizeof(moveit_msgs::MotionSequenceItem)); items_length = items_lengthT; for( uint32_t i = 0; i < items_length; i++){ offset += this->st_items.deserialize(inbuffer + offset); memcpy( &(this->items[i]), &(this->st_items), sizeof(moveit_msgs::MotionSequenceItem)); } return offset; } const char * getType(){ return "moveit_msgs/MotionSequenceRequest"; }; const char * getMD5(){ return "c89266756409bea218f39a7f05ef21a1"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceResult.h

#ifndef _ROS_moveit_msgs_MoveGroupSequenceResult_h #define _ROS_moveit_msgs_MoveGroupSequenceResult_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MotionSequenceResponse.h" namespace moveit_msgs { class MoveGroupSequenceResult : public ros::Msg { public: typedef moveit_msgs::MotionSequenceResponse _response_type; _response_type response; MoveGroupSequenceResult(): response() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->response.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->response.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/MoveGroupSequenceResult"; }; const char * getMD5(){ return "039cee462ada3f0feb5f4e2e12baefae"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPlanningScene.h

#ifndef _ROS_SERVICE_GetPlanningScene_h #define _ROS_SERVICE_GetPlanningScene_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PlanningScene.h" #include "moveit_msgs/PlanningSceneComponents.h" namespace moveit_msgs { static const char GETPLANNINGSCENE[] = "moveit_msgs/GetPlanningScene"; class GetPlanningSceneRequest : public ros::Msg { public: typedef moveit_msgs::PlanningSceneComponents _components_type; _components_type components; GetPlanningSceneRequest(): components() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->components.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->components.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPLANNINGSCENE; }; const char * getMD5(){ return "d81da6c0e5e015646a4efe344f33d7dc"; }; }; class GetPlanningSceneResponse : public ros::Msg { public: typedef moveit_msgs::PlanningScene _scene_type; _scene_type scene; GetPlanningSceneResponse(): scene() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->scene.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->scene.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPLANNINGSCENE; }; const char * getMD5(){ return "7bedc4871b1d0af6ec8b8996db347e7f"; }; }; class GetPlanningScene { public: typedef GetPlanningSceneRequest Request; typedef GetPlanningSceneResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/JointConstraint.h

#ifndef _ROS_moveit_msgs_JointConstraint_h #define _ROS_moveit_msgs_JointConstraint_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class JointConstraint : public ros::Msg { public: typedef const char* _joint_name_type; _joint_name_type joint_name; typedef double _position_type; _position_type position; typedef double _tolerance_above_type; _tolerance_above_type tolerance_above; typedef double _tolerance_below_type; _tolerance_below_type tolerance_below; typedef double _weight_type; _weight_type weight; JointConstraint(): joint_name(""), position(0), tolerance_above(0), tolerance_below(0), weight(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_joint_name = strlen(this->joint_name); varToArr(outbuffer + offset, length_joint_name); offset += 4; memcpy(outbuffer + offset, this->joint_name, length_joint_name); offset += length_joint_name; union { double real; uint64_t base; } u_position; u_position.real = this->position; *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF; offset += sizeof(this->position); union { double real; uint64_t base; } u_tolerance_above; u_tolerance_above.real = this->tolerance_above; *(outbuffer + offset + 0) = (u_tolerance_above.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_tolerance_above.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_tolerance_above.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_tolerance_above.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_tolerance_above.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_tolerance_above.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_tolerance_above.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_tolerance_above.base >> (8 * 7)) & 0xFF; offset += sizeof(this->tolerance_above); union { double real; uint64_t base; } u_tolerance_below; u_tolerance_below.real = this->tolerance_below; *(outbuffer + offset + 0) = (u_tolerance_below.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_tolerance_below.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_tolerance_below.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_tolerance_below.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_tolerance_below.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_tolerance_below.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_tolerance_below.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_tolerance_below.base >> (8 * 7)) & 0xFF; offset += sizeof(this->tolerance_below); union { double real; uint64_t base; } u_weight; u_weight.real = this->weight; *(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF; offset += sizeof(this->weight); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_joint_name; arrToVar(length_joint_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_joint_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_joint_name-1]=0; this->joint_name = (char *)(inbuffer + offset-1); offset += length_joint_name; union { double real; uint64_t base; } u_position; u_position.base = 0; u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->position = u_position.real; offset += sizeof(this->position); union { double real; uint64_t base; } u_tolerance_above; u_tolerance_above.base = 0; u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->tolerance_above = u_tolerance_above.real; offset += sizeof(this->tolerance_above); union { double real; uint64_t base; } u_tolerance_below; u_tolerance_below.base = 0; u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->tolerance_below = u_tolerance_below.real; offset += sizeof(this->tolerance_below); union { double real; uint64_t base; } u_weight; u_weight.base = 0; u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->weight = u_weight.real; offset += sizeof(this->weight); return offset; } const char * getType(){ return "moveit_msgs/JointConstraint"; }; const char * getMD5(){ return "c02a15146bec0ce13564807805b008f0"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetStateValidity.h

#ifndef _ROS_SERVICE_GetStateValidity_h #define _ROS_SERVICE_GetStateValidity_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/ConstraintEvalResult.h" #include "moveit_msgs/CostSource.h" #include "moveit_msgs/ContactInformation.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/Constraints.h" namespace moveit_msgs { static const char GETSTATEVALIDITY[] = "moveit_msgs/GetStateValidity"; class GetStateValidityRequest : public ros::Msg { public: typedef moveit_msgs::RobotState _robot_state_type; _robot_state_type robot_state; typedef const char* _group_name_type; _group_name_type group_name; typedef moveit_msgs::Constraints _constraints_type; _constraints_type constraints; GetStateValidityRequest(): robot_state(), group_name(""), constraints() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->robot_state.serialize(outbuffer + offset); uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; offset += this->constraints.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->robot_state.deserialize(inbuffer + offset); uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; offset += this->constraints.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETSTATEVALIDITY; }; const char * getMD5(){ return "b569c609cafad20ba7d0e46e70e7cab1"; }; }; class GetStateValidityResponse : public ros::Msg { public: typedef bool _valid_type; _valid_type valid; uint32_t contacts_length; typedef moveit_msgs::ContactInformation _contacts_type; _contacts_type st_contacts; _contacts_type * contacts; uint32_t cost_sources_length; typedef moveit_msgs::CostSource _cost_sources_type; _cost_sources_type st_cost_sources; _cost_sources_type * cost_sources; uint32_t constraint_result_length; typedef moveit_msgs::ConstraintEvalResult _constraint_result_type; _constraint_result_type st_constraint_result; _constraint_result_type * constraint_result; GetStateValidityResponse(): valid(0), contacts_length(0), contacts(NULL), cost_sources_length(0), cost_sources(NULL), constraint_result_length(0), constraint_result(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_valid; u_valid.real = this->valid; *(outbuffer + offset + 0) = (u_valid.base >> (8 * 0)) & 0xFF; offset += sizeof(this->valid); *(outbuffer + offset + 0) = (this->contacts_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->contacts_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->contacts_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->contacts_length >> (8 * 3)) & 0xFF; offset += sizeof(this->contacts_length); for( uint32_t i = 0; i < contacts_length; i++){ offset += this->contacts[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->cost_sources_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->cost_sources_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->cost_sources_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->cost_sources_length >> (8 * 3)) & 0xFF; offset += sizeof(this->cost_sources_length); for( uint32_t i = 0; i < cost_sources_length; i++){ offset += this->cost_sources[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->constraint_result_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->constraint_result_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->constraint_result_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->constraint_result_length >> (8 * 3)) & 0xFF; offset += sizeof(this->constraint_result_length); for( uint32_t i = 0; i < constraint_result_length; i++){ offset += this->constraint_result[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_valid; u_valid.base = 0; u_valid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->valid = u_valid.real; offset += sizeof(this->valid); uint32_t contacts_lengthT = ((uint32_t) (*(inbuffer + offset))); contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->contacts_length); if(contacts_lengthT > contacts_length) this->contacts = (moveit_msgs::ContactInformation*)realloc(this->contacts, contacts_lengthT * sizeof(moveit_msgs::ContactInformation)); contacts_length = contacts_lengthT; for( uint32_t i = 0; i < contacts_length; i++){ offset += this->st_contacts.deserialize(inbuffer + offset); memcpy( &(this->contacts[i]), &(this->st_contacts), sizeof(moveit_msgs::ContactInformation)); } uint32_t cost_sources_lengthT = ((uint32_t) (*(inbuffer + offset))); cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->cost_sources_length); if(cost_sources_lengthT > cost_sources_length) this->cost_sources = (moveit_msgs::CostSource*)realloc(this->cost_sources, cost_sources_lengthT * sizeof(moveit_msgs::CostSource)); cost_sources_length = cost_sources_lengthT; for( uint32_t i = 0; i < cost_sources_length; i++){ offset += this->st_cost_sources.deserialize(inbuffer + offset); memcpy( &(this->cost_sources[i]), &(this->st_cost_sources), sizeof(moveit_msgs::CostSource)); } uint32_t constraint_result_lengthT = ((uint32_t) (*(inbuffer + offset))); constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->constraint_result_length); if(constraint_result_lengthT > constraint_result_length) this->constraint_result = (moveit_msgs::ConstraintEvalResult*)realloc(this->constraint_result, constraint_result_lengthT * sizeof(moveit_msgs::ConstraintEvalResult)); constraint_result_length = constraint_result_lengthT; for( uint32_t i = 0; i < constraint_result_length; i++){ offset += this->st_constraint_result.deserialize(inbuffer + offset); memcpy( &(this->constraint_result[i]), &(this->st_constraint_result), sizeof(moveit_msgs::ConstraintEvalResult)); } return offset; } const char * getType(){ return GETSTATEVALIDITY; }; const char * getMD5(){ return "e326fb22b7448f29c0e726d9270d9929"; }; }; class GetStateValidity { public: typedef GetStateValidityRequest Request; typedef GetStateValidityResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/QueryPlannerInterfaces.h

#ifndef _ROS_SERVICE_QueryPlannerInterfaces_h #define _ROS_SERVICE_QueryPlannerInterfaces_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PlannerInterfaceDescription.h" namespace moveit_msgs { static const char QUERYPLANNERINTERFACES[] = "moveit_msgs/QueryPlannerInterfaces"; class QueryPlannerInterfacesRequest : public ros::Msg { public: QueryPlannerInterfacesRequest() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; return offset; } const char * getType(){ return QUERYPLANNERINTERFACES; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class QueryPlannerInterfacesResponse : public ros::Msg { public: uint32_t planner_interfaces_length; typedef moveit_msgs::PlannerInterfaceDescription _planner_interfaces_type; _planner_interfaces_type st_planner_interfaces; _planner_interfaces_type * planner_interfaces; QueryPlannerInterfacesResponse(): planner_interfaces_length(0), planner_interfaces(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->planner_interfaces_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->planner_interfaces_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->planner_interfaces_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->planner_interfaces_length >> (8 * 3)) & 0xFF; offset += sizeof(this->planner_interfaces_length); for( uint32_t i = 0; i < planner_interfaces_length; i++){ offset += this->planner_interfaces[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t planner_interfaces_lengthT = ((uint32_t) (*(inbuffer + offset))); planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->planner_interfaces_length); if(planner_interfaces_lengthT > planner_interfaces_length) this->planner_interfaces = (moveit_msgs::PlannerInterfaceDescription*)realloc(this->planner_interfaces, planner_interfaces_lengthT * sizeof(moveit_msgs::PlannerInterfaceDescription)); planner_interfaces_length = planner_interfaces_lengthT; for( uint32_t i = 0; i < planner_interfaces_length; i++){ offset += this->st_planner_interfaces.deserialize(inbuffer + offset); memcpy( &(this->planner_interfaces[i]), &(this->st_planner_interfaces), sizeof(moveit_msgs::PlannerInterfaceDescription)); } return offset; } const char * getType(){ return QUERYPLANNERINTERFACES; }; const char * getMD5(){ return "acd3317a4c5631f33127fb428209db05"; }; }; class QueryPlannerInterfaces { public: typedef QueryPlannerInterfacesRequest Request; typedef QueryPlannerInterfacesResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SetPlannerParams.h

#ifndef _ROS_SERVICE_SetPlannerParams_h #define _ROS_SERVICE_SetPlannerParams_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PlannerParams.h" namespace moveit_msgs { static const char SETPLANNERPARAMS[] = "moveit_msgs/SetPlannerParams"; class SetPlannerParamsRequest : public ros::Msg { public: typedef const char* _planner_config_type; _planner_config_type planner_config; typedef const char* _group_type; _group_type group; typedef moveit_msgs::PlannerParams _params_type; _params_type params; typedef bool _replace_type; _replace_type replace; SetPlannerParamsRequest(): planner_config(""), group(""), params(), replace(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_planner_config = strlen(this->planner_config); varToArr(outbuffer + offset, length_planner_config); offset += 4; memcpy(outbuffer + offset, this->planner_config, length_planner_config); offset += length_planner_config; uint32_t length_group = strlen(this->group); varToArr(outbuffer + offset, length_group); offset += 4; memcpy(outbuffer + offset, this->group, length_group); offset += length_group; offset += this->params.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_replace; u_replace.real = this->replace; *(outbuffer + offset + 0) = (u_replace.base >> (8 * 0)) & 0xFF; offset += sizeof(this->replace); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_planner_config; arrToVar(length_planner_config, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_planner_config; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_planner_config-1]=0; this->planner_config = (char *)(inbuffer + offset-1); offset += length_planner_config; uint32_t length_group; arrToVar(length_group, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group-1]=0; this->group = (char *)(inbuffer + offset-1); offset += length_group; offset += this->params.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_replace; u_replace.base = 0; u_replace.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->replace = u_replace.real; offset += sizeof(this->replace); return offset; } const char * getType(){ return SETPLANNERPARAMS; }; const char * getMD5(){ return "86762d89189c5f52cda7680fdbceb1db"; }; }; class SetPlannerParamsResponse : public ros::Msg { public: SetPlannerParamsResponse() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; return offset; } const char * getType(){ return SETPLANNERPARAMS; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class SetPlannerParams { public: typedef SetPlannerParamsRequest Request; typedef SetPlannerParamsResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceLocation.h

#ifndef _ROS_moveit_msgs_PlaceLocation_h #define _ROS_moveit_msgs_PlaceLocation_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "trajectory_msgs/JointTrajectory.h" #include "geometry_msgs/PoseStamped.h" #include "moveit_msgs/GripperTranslation.h" namespace moveit_msgs { class PlaceLocation : public ros::Msg { public: typedef const char* _id_type; _id_type id; typedef trajectory_msgs::JointTrajectory _post_place_posture_type; _post_place_posture_type post_place_posture; typedef geometry_msgs::PoseStamped _place_pose_type; _place_pose_type place_pose; typedef moveit_msgs::GripperTranslation _pre_place_approach_type; _pre_place_approach_type pre_place_approach; typedef moveit_msgs::GripperTranslation _post_place_retreat_type; _post_place_retreat_type post_place_retreat; uint32_t allowed_touch_objects_length; typedef char* _allowed_touch_objects_type; _allowed_touch_objects_type st_allowed_touch_objects; _allowed_touch_objects_type * allowed_touch_objects; PlaceLocation(): id(""), post_place_posture(), place_pose(), pre_place_approach(), post_place_retreat(), allowed_touch_objects_length(0), allowed_touch_objects(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_id = strlen(this->id); varToArr(outbuffer + offset, length_id); offset += 4; memcpy(outbuffer + offset, this->id, length_id); offset += length_id; offset += this->post_place_posture.serialize(outbuffer + offset); offset += this->place_pose.serialize(outbuffer + offset); offset += this->pre_place_approach.serialize(outbuffer + offset); offset += this->post_place_retreat.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF; offset += sizeof(this->allowed_touch_objects_length); for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]); varToArr(outbuffer + offset, length_allowed_touch_objectsi); offset += 4; memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi); offset += length_allowed_touch_objectsi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_id; arrToVar(length_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_id-1]=0; this->id = (char *)(inbuffer + offset-1); offset += length_id; offset += this->post_place_posture.deserialize(inbuffer + offset); offset += this->place_pose.deserialize(inbuffer + offset); offset += this->pre_place_approach.deserialize(inbuffer + offset); offset += this->post_place_retreat.deserialize(inbuffer + offset); uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset))); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->allowed_touch_objects_length); if(allowed_touch_objects_lengthT > allowed_touch_objects_length) this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*)); allowed_touch_objects_length = allowed_touch_objects_lengthT; for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_st_allowed_touch_objects; arrToVar(length_st_allowed_touch_objects, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_allowed_touch_objects-1]=0; this->st_allowed_touch_objects = (char *)(inbuffer + offset-1); offset += length_st_allowed_touch_objects; memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*)); } return offset; } const char * getType(){ return "moveit_msgs/PlaceLocation"; }; const char * getMD5(){ return "f3dbcaca40fb29ede2af78b3e1831128"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/Constraints.h

#ifndef _ROS_moveit_msgs_Constraints_h #define _ROS_moveit_msgs_Constraints_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/JointConstraint.h" #include "moveit_msgs/PositionConstraint.h" #include "moveit_msgs/OrientationConstraint.h" #include "moveit_msgs/VisibilityConstraint.h" namespace moveit_msgs { class Constraints : public ros::Msg { public: typedef const char* _name_type; _name_type name; uint32_t joint_constraints_length; typedef moveit_msgs::JointConstraint _joint_constraints_type; _joint_constraints_type st_joint_constraints; _joint_constraints_type * joint_constraints; uint32_t position_constraints_length; typedef moveit_msgs::PositionConstraint _position_constraints_type; _position_constraints_type st_position_constraints; _position_constraints_type * position_constraints; uint32_t orientation_constraints_length; typedef moveit_msgs::OrientationConstraint _orientation_constraints_type; _orientation_constraints_type st_orientation_constraints; _orientation_constraints_type * orientation_constraints; uint32_t visibility_constraints_length; typedef moveit_msgs::VisibilityConstraint _visibility_constraints_type; _visibility_constraints_type st_visibility_constraints; _visibility_constraints_type * visibility_constraints; Constraints(): name(""), joint_constraints_length(0), joint_constraints(NULL), position_constraints_length(0), position_constraints(NULL), orientation_constraints_length(0), orientation_constraints(NULL), visibility_constraints_length(0), visibility_constraints(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; *(outbuffer + offset + 0) = (this->joint_constraints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->joint_constraints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->joint_constraints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->joint_constraints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->joint_constraints_length); for( uint32_t i = 0; i < joint_constraints_length; i++){ offset += this->joint_constraints[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->position_constraints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->position_constraints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->position_constraints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->position_constraints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->position_constraints_length); for( uint32_t i = 0; i < position_constraints_length; i++){ offset += this->position_constraints[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->orientation_constraints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->orientation_constraints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->orientation_constraints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->orientation_constraints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->orientation_constraints_length); for( uint32_t i = 0; i < orientation_constraints_length; i++){ offset += this->orientation_constraints[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->visibility_constraints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->visibility_constraints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->visibility_constraints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->visibility_constraints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->visibility_constraints_length); for( uint32_t i = 0; i < visibility_constraints_length; i++){ offset += this->visibility_constraints[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; uint32_t joint_constraints_lengthT = ((uint32_t) (*(inbuffer + offset))); joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->joint_constraints_length); if(joint_constraints_lengthT > joint_constraints_length) this->joint_constraints = (moveit_msgs::JointConstraint*)realloc(this->joint_constraints, joint_constraints_lengthT * sizeof(moveit_msgs::JointConstraint)); joint_constraints_length = joint_constraints_lengthT; for( uint32_t i = 0; i < joint_constraints_length; i++){ offset += this->st_joint_constraints.deserialize(inbuffer + offset); memcpy( &(this->joint_constraints[i]), &(this->st_joint_constraints), sizeof(moveit_msgs::JointConstraint)); } uint32_t position_constraints_lengthT = ((uint32_t) (*(inbuffer + offset))); position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->position_constraints_length); if(position_constraints_lengthT > position_constraints_length) this->position_constraints = (moveit_msgs::PositionConstraint*)realloc(this->position_constraints, position_constraints_lengthT * sizeof(moveit_msgs::PositionConstraint)); position_constraints_length = position_constraints_lengthT; for( uint32_t i = 0; i < position_constraints_length; i++){ offset += this->st_position_constraints.deserialize(inbuffer + offset); memcpy( &(this->position_constraints[i]), &(this->st_position_constraints), sizeof(moveit_msgs::PositionConstraint)); } uint32_t orientation_constraints_lengthT = ((uint32_t) (*(inbuffer + offset))); orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->orientation_constraints_length); if(orientation_constraints_lengthT > orientation_constraints_length) this->orientation_constraints = (moveit_msgs::OrientationConstraint*)realloc(this->orientation_constraints, orientation_constraints_lengthT * sizeof(moveit_msgs::OrientationConstraint)); orientation_constraints_length = orientation_constraints_lengthT; for( uint32_t i = 0; i < orientation_constraints_length; i++){ offset += this->st_orientation_constraints.deserialize(inbuffer + offset); memcpy( &(this->orientation_constraints[i]), &(this->st_orientation_constraints), sizeof(moveit_msgs::OrientationConstraint)); } uint32_t visibility_constraints_lengthT = ((uint32_t) (*(inbuffer + offset))); visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->visibility_constraints_length); if(visibility_constraints_lengthT > visibility_constraints_length) this->visibility_constraints = (moveit_msgs::VisibilityConstraint*)realloc(this->visibility_constraints, visibility_constraints_lengthT * sizeof(moveit_msgs::VisibilityConstraint)); visibility_constraints_length = visibility_constraints_lengthT; for( uint32_t i = 0; i < visibility_constraints_length; i++){ offset += this->st_visibility_constraints.deserialize(inbuffer + offset); memcpy( &(this->visibility_constraints[i]), &(this->st_visibility_constraints), sizeof(moveit_msgs::VisibilityConstraint)); } return offset; } const char * getType(){ return "moveit_msgs/Constraints"; }; const char * getMD5(){ return "8d5ce8d34ef26c65fb5d43c9e99bf6e0"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteKnownTrajectory.h

#ifndef _ROS_SERVICE_ExecuteKnownTrajectory_h #define _ROS_SERVICE_ExecuteKnownTrajectory_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "moveit_msgs/RobotTrajectory.h" namespace moveit_msgs { static const char EXECUTEKNOWNTRAJECTORY[] = "moveit_msgs/ExecuteKnownTrajectory"; class ExecuteKnownTrajectoryRequest : public ros::Msg { public: typedef moveit_msgs::RobotTrajectory _trajectory_type; _trajectory_type trajectory; typedef bool _wait_for_execution_type; _wait_for_execution_type wait_for_execution; ExecuteKnownTrajectoryRequest(): trajectory(), wait_for_execution(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->trajectory.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_wait_for_execution; u_wait_for_execution.real = this->wait_for_execution; *(outbuffer + offset + 0) = (u_wait_for_execution.base >> (8 * 0)) & 0xFF; offset += sizeof(this->wait_for_execution); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->trajectory.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_wait_for_execution; u_wait_for_execution.base = 0; u_wait_for_execution.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->wait_for_execution = u_wait_for_execution.real; offset += sizeof(this->wait_for_execution); return offset; } const char * getType(){ return EXECUTEKNOWNTRAJECTORY; }; const char * getMD5(){ return "2a3d2a0b337c6a27da4468bb351928e5"; }; }; class ExecuteKnownTrajectoryResponse : public ros::Msg { public: typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; ExecuteKnownTrajectoryResponse(): error_code() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->error_code.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->error_code.deserialize(inbuffer + offset); return offset; } const char * getType(){ return EXECUTEKNOWNTRAJECTORY; }; const char * getMD5(){ return "1f7ab918f5d0c5312f25263d3d688122"; }; }; class ExecuteKnownTrajectory { public: typedef ExecuteKnownTrajectoryRequest Request; typedef ExecuteKnownTrajectoryResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveItErrorCodes.h

#ifndef _ROS_moveit_msgs_MoveItErrorCodes_h #define _ROS_moveit_msgs_MoveItErrorCodes_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class MoveItErrorCodes : public ros::Msg { public: typedef int32_t _val_type; _val_type val; enum { SUCCESS = 1 }; enum { FAILURE = 99999 }; enum { PLANNING_FAILED = -1 }; enum { INVALID_MOTION_PLAN = -2 }; enum { MOTION_PLAN_INVALIDATED_BY_ENVIRONMENT_CHANGE = -3 }; enum { CONTROL_FAILED = -4 }; enum { UNABLE_TO_AQUIRE_SENSOR_DATA = -5 }; enum { TIMED_OUT = -6 }; enum { PREEMPTED = -7 }; enum { START_STATE_IN_COLLISION = -10 }; enum { START_STATE_VIOLATES_PATH_CONSTRAINTS = -11 }; enum { GOAL_IN_COLLISION = -12 }; enum { GOAL_VIOLATES_PATH_CONSTRAINTS = -13 }; enum { GOAL_CONSTRAINTS_VIOLATED = -14 }; enum { INVALID_GROUP_NAME = -15 }; enum { INVALID_GOAL_CONSTRAINTS = -16 }; enum { INVALID_ROBOT_STATE = -17 }; enum { INVALID_LINK_NAME = -18 }; enum { INVALID_OBJECT_NAME = -19 }; enum { FRAME_TRANSFORM_FAILURE = -21 }; enum { COLLISION_CHECKING_UNAVAILABLE = -22 }; enum { ROBOT_STATE_STALE = -23 }; enum { SENSOR_INFO_STALE = -24 }; enum { NO_IK_SOLUTION = -31 }; MoveItErrorCodes(): val(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int32_t real; uint32_t base; } u_val; u_val.real = this->val; *(outbuffer + offset + 0) = (u_val.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_val.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_val.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_val.base >> (8 * 3)) & 0xFF; offset += sizeof(this->val); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int32_t real; uint32_t base; } u_val; u_val.base = 0; u_val.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_val.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_val.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_val.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->val = u_val.real; offset += sizeof(this->val); return offset; } const char * getType(){ return "moveit_msgs/MoveItErrorCodes"; }; const char * getMD5(){ return "aa336b18d80531f66439810112c0a43e"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ConstraintEvalResult.h

#ifndef _ROS_moveit_msgs_ConstraintEvalResult_h #define _ROS_moveit_msgs_ConstraintEvalResult_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class ConstraintEvalResult : public ros::Msg { public: typedef bool _result_type; _result_type result; typedef double _distance_type; _distance_type distance; ConstraintEvalResult(): result(0), distance(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_result; u_result.real = this->result; *(outbuffer + offset + 0) = (u_result.base >> (8 * 0)) & 0xFF; offset += sizeof(this->result); union { double real; uint64_t base; } u_distance; u_distance.real = this->distance; *(outbuffer + offset + 0) = (u_distance.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_distance.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_distance.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_distance.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_distance.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_distance.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_distance.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_distance.base >> (8 * 7)) & 0xFF; offset += sizeof(this->distance); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_result; u_result.base = 0; u_result.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->result = u_result.real; offset += sizeof(this->result); union { double real; uint64_t base; } u_distance; u_distance.base = 0; u_distance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_distance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_distance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_distance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_distance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_distance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_distance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_distance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->distance = u_distance.real; offset += sizeof(this->distance); return offset; } const char * getType(){ return "moveit_msgs/ConstraintEvalResult"; }; const char * getMD5(){ return "093643083d24f6488cb5a868bd47c090"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AllowedCollisionEntry.h

#ifndef _ROS_moveit_msgs_AllowedCollisionEntry_h #define _ROS_moveit_msgs_AllowedCollisionEntry_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class AllowedCollisionEntry : public ros::Msg { public: uint32_t enabled_length; typedef bool _enabled_type; _enabled_type st_enabled; _enabled_type * enabled; AllowedCollisionEntry(): enabled_length(0), enabled(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->enabled_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->enabled_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->enabled_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->enabled_length >> (8 * 3)) & 0xFF; offset += sizeof(this->enabled_length); for( uint32_t i = 0; i < enabled_length; i++){ union { bool real; uint8_t base; } u_enabledi; u_enabledi.real = this->enabled[i]; *(outbuffer + offset + 0) = (u_enabledi.base >> (8 * 0)) & 0xFF; offset += sizeof(this->enabled[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t enabled_lengthT = ((uint32_t) (*(inbuffer + offset))); enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->enabled_length); if(enabled_lengthT > enabled_length) this->enabled = (bool*)realloc(this->enabled, enabled_lengthT * sizeof(bool)); enabled_length = enabled_lengthT; for( uint32_t i = 0; i < enabled_length; i++){ union { bool real; uint8_t base; } u_st_enabled; u_st_enabled.base = 0; u_st_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_enabled = u_st_enabled.real; offset += sizeof(this->st_enabled); memcpy( &(this->enabled[i]), &(this->st_enabled), sizeof(bool)); } return offset; } const char * getType(){ return "moveit_msgs/AllowedCollisionEntry"; }; const char * getMD5(){ return "90d1ae1850840724bb043562fe3285fc"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ApplyPlanningScene.h

#ifndef _ROS_SERVICE_ApplyPlanningScene_h #define _ROS_SERVICE_ApplyPlanningScene_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PlanningScene.h" namespace moveit_msgs { static const char APPLYPLANNINGSCENE[] = "moveit_msgs/ApplyPlanningScene"; class ApplyPlanningSceneRequest : public ros::Msg { public: typedef moveit_msgs::PlanningScene _scene_type; _scene_type scene; ApplyPlanningSceneRequest(): scene() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->scene.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->scene.deserialize(inbuffer + offset); return offset; } const char * getType(){ return APPLYPLANNINGSCENE; }; const char * getMD5(){ return "7bedc4871b1d0af6ec8b8996db347e7f"; }; }; class ApplyPlanningSceneResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; ApplyPlanningSceneResponse(): success(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.real = this->success; *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; offset += sizeof(this->success); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.base = 0; u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->success = u_success.real; offset += sizeof(this->success); return offset; } const char * getType(){ return APPLYPLANNINGSCENE; }; const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; }; class ApplyPlanningScene { public: typedef ApplyPlanningSceneRequest Request; typedef ApplyPlanningSceneResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CostSource.h

#ifndef _ROS_moveit_msgs_CostSource_h #define _ROS_moveit_msgs_CostSource_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "geometry_msgs/Vector3.h" namespace moveit_msgs { class CostSource : public ros::Msg { public: typedef double _cost_density_type; _cost_density_type cost_density; typedef geometry_msgs::Vector3 _aabb_min_type; _aabb_min_type aabb_min; typedef geometry_msgs::Vector3 _aabb_max_type; _aabb_max_type aabb_max; CostSource(): cost_density(0), aabb_min(), aabb_max() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { double real; uint64_t base; } u_cost_density; u_cost_density.real = this->cost_density; *(outbuffer + offset + 0) = (u_cost_density.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_cost_density.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_cost_density.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_cost_density.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_cost_density.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_cost_density.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_cost_density.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_cost_density.base >> (8 * 7)) & 0xFF; offset += sizeof(this->cost_density); offset += this->aabb_min.serialize(outbuffer + offset); offset += this->aabb_max.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { double real; uint64_t base; } u_cost_density; u_cost_density.base = 0; u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->cost_density = u_cost_density.real; offset += sizeof(this->cost_density); offset += this->aabb_min.deserialize(inbuffer + offset); offset += this->aabb_max.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/CostSource"; }; const char * getMD5(){ return "abb7e013237dacaaa8b97e704102f908"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LinkPadding.h

#ifndef _ROS_moveit_msgs_LinkPadding_h #define _ROS_moveit_msgs_LinkPadding_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class LinkPadding : public ros::Msg { public: typedef const char* _link_name_type; _link_name_type link_name; typedef double _padding_type; _padding_type padding; LinkPadding(): link_name(""), padding(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_link_name = strlen(this->link_name); varToArr(outbuffer + offset, length_link_name); offset += 4; memcpy(outbuffer + offset, this->link_name, length_link_name); offset += length_link_name; union { double real; uint64_t base; } u_padding; u_padding.real = this->padding; *(outbuffer + offset + 0) = (u_padding.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_padding.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_padding.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_padding.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_padding.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_padding.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_padding.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_padding.base >> (8 * 7)) & 0xFF; offset += sizeof(this->padding); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_link_name; arrToVar(length_link_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_link_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_link_name-1]=0; this->link_name = (char *)(inbuffer + offset-1); offset += length_link_name; union { double real; uint64_t base; } u_padding; u_padding.base = 0; u_padding.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_padding.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_padding.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_padding.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_padding.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_padding.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_padding.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_padding.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->padding = u_padding.real; offset += sizeof(this->padding); return offset; } const char * getType(){ return "moveit_msgs/LinkPadding"; }; const char * getMD5(){ return "b3ea75670df55c696fedee97774d5947"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ObjectColor.h

#ifndef _ROS_moveit_msgs_ObjectColor_h #define _ROS_moveit_msgs_ObjectColor_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/ColorRGBA.h" namespace moveit_msgs { class ObjectColor : public ros::Msg { public: typedef const char* _id_type; _id_type id; typedef std_msgs::ColorRGBA _color_type; _color_type color; ObjectColor(): id(""), color() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_id = strlen(this->id); varToArr(outbuffer + offset, length_id); offset += 4; memcpy(outbuffer + offset, this->id, length_id); offset += length_id; offset += this->color.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_id; arrToVar(length_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_id-1]=0; this->id = (char *)(inbuffer + offset-1); offset += length_id; offset += this->color.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/ObjectColor"; }; const char * getMD5(){ return "ec3bd6f103430e64b2ae706a67d8488e"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceGoal.h

#ifndef _ROS_moveit_msgs_PlaceGoal_h #define _ROS_moveit_msgs_PlaceGoal_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PlaceLocation.h" #include "moveit_msgs/Constraints.h" #include "moveit_msgs/PlanningOptions.h" namespace moveit_msgs { class PlaceGoal : public ros::Msg { public: typedef const char* _group_name_type; _group_name_type group_name; typedef const char* _attached_object_name_type; _attached_object_name_type attached_object_name; uint32_t place_locations_length; typedef moveit_msgs::PlaceLocation _place_locations_type; _place_locations_type st_place_locations; _place_locations_type * place_locations; typedef bool _place_eef_type; _place_eef_type place_eef; typedef const char* _support_surface_name_type; _support_surface_name_type support_surface_name; typedef bool _allow_gripper_support_collision_type; _allow_gripper_support_collision_type allow_gripper_support_collision; typedef moveit_msgs::Constraints _path_constraints_type; _path_constraints_type path_constraints; typedef const char* _planner_id_type; _planner_id_type planner_id; uint32_t allowed_touch_objects_length; typedef char* _allowed_touch_objects_type; _allowed_touch_objects_type st_allowed_touch_objects; _allowed_touch_objects_type * allowed_touch_objects; typedef double _allowed_planning_time_type; _allowed_planning_time_type allowed_planning_time; typedef moveit_msgs::PlanningOptions _planning_options_type; _planning_options_type planning_options; PlaceGoal(): group_name(""), attached_object_name(""), place_locations_length(0), place_locations(NULL), place_eef(0), support_surface_name(""), allow_gripper_support_collision(0), path_constraints(), planner_id(""), allowed_touch_objects_length(0), allowed_touch_objects(NULL), allowed_planning_time(0), planning_options() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; uint32_t length_attached_object_name = strlen(this->attached_object_name); varToArr(outbuffer + offset, length_attached_object_name); offset += 4; memcpy(outbuffer + offset, this->attached_object_name, length_attached_object_name); offset += length_attached_object_name; *(outbuffer + offset + 0) = (this->place_locations_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->place_locations_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->place_locations_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->place_locations_length >> (8 * 3)) & 0xFF; offset += sizeof(this->place_locations_length); for( uint32_t i = 0; i < place_locations_length; i++){ offset += this->place_locations[i].serialize(outbuffer + offset); } union { bool real; uint8_t base; } u_place_eef; u_place_eef.real = this->place_eef; *(outbuffer + offset + 0) = (u_place_eef.base >> (8 * 0)) & 0xFF; offset += sizeof(this->place_eef); uint32_t length_support_surface_name = strlen(this->support_surface_name); varToArr(outbuffer + offset, length_support_surface_name); offset += 4; memcpy(outbuffer + offset, this->support_surface_name, length_support_surface_name); offset += length_support_surface_name; union { bool real; uint8_t base; } u_allow_gripper_support_collision; u_allow_gripper_support_collision.real = this->allow_gripper_support_collision; *(outbuffer + offset + 0) = (u_allow_gripper_support_collision.base >> (8 * 0)) & 0xFF; offset += sizeof(this->allow_gripper_support_collision); offset += this->path_constraints.serialize(outbuffer + offset); uint32_t length_planner_id = strlen(this->planner_id); varToArr(outbuffer + offset, length_planner_id); offset += 4; memcpy(outbuffer + offset, this->planner_id, length_planner_id); offset += length_planner_id; *(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF; offset += sizeof(this->allowed_touch_objects_length); for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]); varToArr(outbuffer + offset, length_allowed_touch_objectsi); offset += 4; memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi); offset += length_allowed_touch_objectsi; } union { double real; uint64_t base; } u_allowed_planning_time; u_allowed_planning_time.real = this->allowed_planning_time; *(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF; offset += sizeof(this->allowed_planning_time); offset += this->planning_options.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; uint32_t length_attached_object_name; arrToVar(length_attached_object_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_attached_object_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_attached_object_name-1]=0; this->attached_object_name = (char *)(inbuffer + offset-1); offset += length_attached_object_name; uint32_t place_locations_lengthT = ((uint32_t) (*(inbuffer + offset))); place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->place_locations_length); if(place_locations_lengthT > place_locations_length) this->place_locations = (moveit_msgs::PlaceLocation*)realloc(this->place_locations, place_locations_lengthT * sizeof(moveit_msgs::PlaceLocation)); place_locations_length = place_locations_lengthT; for( uint32_t i = 0; i < place_locations_length; i++){ offset += this->st_place_locations.deserialize(inbuffer + offset); memcpy( &(this->place_locations[i]), &(this->st_place_locations), sizeof(moveit_msgs::PlaceLocation)); } union { bool real; uint8_t base; } u_place_eef; u_place_eef.base = 0; u_place_eef.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->place_eef = u_place_eef.real; offset += sizeof(this->place_eef); uint32_t length_support_surface_name; arrToVar(length_support_surface_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_support_surface_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_support_surface_name-1]=0; this->support_surface_name = (char *)(inbuffer + offset-1); offset += length_support_surface_name; union { bool real; uint8_t base; } u_allow_gripper_support_collision; u_allow_gripper_support_collision.base = 0; u_allow_gripper_support_collision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->allow_gripper_support_collision = u_allow_gripper_support_collision.real; offset += sizeof(this->allow_gripper_support_collision); offset += this->path_constraints.deserialize(inbuffer + offset); uint32_t length_planner_id; arrToVar(length_planner_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_planner_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_planner_id-1]=0; this->planner_id = (char *)(inbuffer + offset-1); offset += length_planner_id; uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset))); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->allowed_touch_objects_length); if(allowed_touch_objects_lengthT > allowed_touch_objects_length) this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*)); allowed_touch_objects_length = allowed_touch_objects_lengthT; for( uint32_t i = 0; i < allowed_touch_objects_length; i++){ uint32_t length_st_allowed_touch_objects; arrToVar(length_st_allowed_touch_objects, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_allowed_touch_objects-1]=0; this->st_allowed_touch_objects = (char *)(inbuffer + offset-1); offset += length_st_allowed_touch_objects; memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*)); } union { double real; uint64_t base; } u_allowed_planning_time; u_allowed_planning_time.base = 0; u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->allowed_planning_time = u_allowed_planning_time.real; offset += sizeof(this->allowed_planning_time); offset += this->planning_options.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/PlaceGoal"; }; const char * getMD5(){ return "e3f3e956e536ccd313fd8f23023f0a94"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/JointLimits.h

#ifndef _ROS_moveit_msgs_JointLimits_h #define _ROS_moveit_msgs_JointLimits_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class JointLimits : public ros::Msg { public: typedef const char* _joint_name_type; _joint_name_type joint_name; typedef bool _has_position_limits_type; _has_position_limits_type has_position_limits; typedef double _min_position_type; _min_position_type min_position; typedef double _max_position_type; _max_position_type max_position; typedef bool _has_velocity_limits_type; _has_velocity_limits_type has_velocity_limits; typedef double _max_velocity_type; _max_velocity_type max_velocity; typedef bool _has_acceleration_limits_type; _has_acceleration_limits_type has_acceleration_limits; typedef double _max_acceleration_type; _max_acceleration_type max_acceleration; JointLimits(): joint_name(""), has_position_limits(0), min_position(0), max_position(0), has_velocity_limits(0), max_velocity(0), has_acceleration_limits(0), max_acceleration(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_joint_name = strlen(this->joint_name); varToArr(outbuffer + offset, length_joint_name); offset += 4; memcpy(outbuffer + offset, this->joint_name, length_joint_name); offset += length_joint_name; union { bool real; uint8_t base; } u_has_position_limits; u_has_position_limits.real = this->has_position_limits; *(outbuffer + offset + 0) = (u_has_position_limits.base >> (8 * 0)) & 0xFF; offset += sizeof(this->has_position_limits); union { double real; uint64_t base; } u_min_position; u_min_position.real = this->min_position; *(outbuffer + offset + 0) = (u_min_position.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_min_position.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_min_position.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_min_position.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_min_position.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_min_position.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_min_position.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_min_position.base >> (8 * 7)) & 0xFF; offset += sizeof(this->min_position); union { double real; uint64_t base; } u_max_position; u_max_position.real = this->max_position; *(outbuffer + offset + 0) = (u_max_position.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_position.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_position.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_position.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_position.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_position.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_position.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_position.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_position); union { bool real; uint8_t base; } u_has_velocity_limits; u_has_velocity_limits.real = this->has_velocity_limits; *(outbuffer + offset + 0) = (u_has_velocity_limits.base >> (8 * 0)) & 0xFF; offset += sizeof(this->has_velocity_limits); union { double real; uint64_t base; } u_max_velocity; u_max_velocity.real = this->max_velocity; *(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_velocity); union { bool real; uint8_t base; } u_has_acceleration_limits; u_has_acceleration_limits.real = this->has_acceleration_limits; *(outbuffer + offset + 0) = (u_has_acceleration_limits.base >> (8 * 0)) & 0xFF; offset += sizeof(this->has_acceleration_limits); union { double real; uint64_t base; } u_max_acceleration; u_max_acceleration.real = this->max_acceleration; *(outbuffer + offset + 0) = (u_max_acceleration.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_acceleration.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_acceleration.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_acceleration.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_acceleration.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_acceleration.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_acceleration.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_acceleration.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_acceleration); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_joint_name; arrToVar(length_joint_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_joint_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_joint_name-1]=0; this->joint_name = (char *)(inbuffer + offset-1); offset += length_joint_name; union { bool real; uint8_t base; } u_has_position_limits; u_has_position_limits.base = 0; u_has_position_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->has_position_limits = u_has_position_limits.real; offset += sizeof(this->has_position_limits); union { double real; uint64_t base; } u_min_position; u_min_position.base = 0; u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->min_position = u_min_position.real; offset += sizeof(this->min_position); union { double real; uint64_t base; } u_max_position; u_max_position.base = 0; u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_position = u_max_position.real; offset += sizeof(this->max_position); union { bool real; uint8_t base; } u_has_velocity_limits; u_has_velocity_limits.base = 0; u_has_velocity_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->has_velocity_limits = u_has_velocity_limits.real; offset += sizeof(this->has_velocity_limits); union { double real; uint64_t base; } u_max_velocity; u_max_velocity.base = 0; u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_velocity = u_max_velocity.real; offset += sizeof(this->max_velocity); union { bool real; uint8_t base; } u_has_acceleration_limits; u_has_acceleration_limits.base = 0; u_has_acceleration_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->has_acceleration_limits = u_has_acceleration_limits.real; offset += sizeof(this->has_acceleration_limits); union { double real; uint64_t base; } u_max_acceleration; u_max_acceleration.base = 0; u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_acceleration = u_max_acceleration.real; offset += sizeof(this->max_acceleration); return offset; } const char * getType(){ return "moveit_msgs/JointLimits"; }; const char * getMD5(){ return "8ca618c7329ea46142cbc864a2efe856"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningOptions.h

#ifndef _ROS_moveit_msgs_PlanningOptions_h #define _ROS_moveit_msgs_PlanningOptions_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PlanningScene.h" namespace moveit_msgs { class PlanningOptions : public ros::Msg { public: typedef moveit_msgs::PlanningScene _planning_scene_diff_type; _planning_scene_diff_type planning_scene_diff; typedef bool _plan_only_type; _plan_only_type plan_only; typedef bool _look_around_type; _look_around_type look_around; typedef int32_t _look_around_attempts_type; _look_around_attempts_type look_around_attempts; typedef double _max_safe_execution_cost_type; _max_safe_execution_cost_type max_safe_execution_cost; typedef bool _replan_type; _replan_type replan; typedef int32_t _replan_attempts_type; _replan_attempts_type replan_attempts; typedef double _replan_delay_type; _replan_delay_type replan_delay; PlanningOptions(): planning_scene_diff(), plan_only(0), look_around(0), look_around_attempts(0), max_safe_execution_cost(0), replan(0), replan_attempts(0), replan_delay(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->planning_scene_diff.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_plan_only; u_plan_only.real = this->plan_only; *(outbuffer + offset + 0) = (u_plan_only.base >> (8 * 0)) & 0xFF; offset += sizeof(this->plan_only); union { bool real; uint8_t base; } u_look_around; u_look_around.real = this->look_around; *(outbuffer + offset + 0) = (u_look_around.base >> (8 * 0)) & 0xFF; offset += sizeof(this->look_around); union { int32_t real; uint32_t base; } u_look_around_attempts; u_look_around_attempts.real = this->look_around_attempts; *(outbuffer + offset + 0) = (u_look_around_attempts.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_look_around_attempts.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_look_around_attempts.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_look_around_attempts.base >> (8 * 3)) & 0xFF; offset += sizeof(this->look_around_attempts); union { double real; uint64_t base; } u_max_safe_execution_cost; u_max_safe_execution_cost.real = this->max_safe_execution_cost; *(outbuffer + offset + 0) = (u_max_safe_execution_cost.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_safe_execution_cost.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_safe_execution_cost.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_safe_execution_cost.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_safe_execution_cost.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_safe_execution_cost.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_safe_execution_cost.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_safe_execution_cost.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_safe_execution_cost); union { bool real; uint8_t base; } u_replan; u_replan.real = this->replan; *(outbuffer + offset + 0) = (u_replan.base >> (8 * 0)) & 0xFF; offset += sizeof(this->replan); union { int32_t real; uint32_t base; } u_replan_attempts; u_replan_attempts.real = this->replan_attempts; *(outbuffer + offset + 0) = (u_replan_attempts.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_replan_attempts.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_replan_attempts.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_replan_attempts.base >> (8 * 3)) & 0xFF; offset += sizeof(this->replan_attempts); union { double real; uint64_t base; } u_replan_delay; u_replan_delay.real = this->replan_delay; *(outbuffer + offset + 0) = (u_replan_delay.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_replan_delay.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_replan_delay.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_replan_delay.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_replan_delay.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_replan_delay.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_replan_delay.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_replan_delay.base >> (8 * 7)) & 0xFF; offset += sizeof(this->replan_delay); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->planning_scene_diff.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_plan_only; u_plan_only.base = 0; u_plan_only.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->plan_only = u_plan_only.real; offset += sizeof(this->plan_only); union { bool real; uint8_t base; } u_look_around; u_look_around.base = 0; u_look_around.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->look_around = u_look_around.real; offset += sizeof(this->look_around); union { int32_t real; uint32_t base; } u_look_around_attempts; u_look_around_attempts.base = 0; u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->look_around_attempts = u_look_around_attempts.real; offset += sizeof(this->look_around_attempts); union { double real; uint64_t base; } u_max_safe_execution_cost; u_max_safe_execution_cost.base = 0; u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_safe_execution_cost = u_max_safe_execution_cost.real; offset += sizeof(this->max_safe_execution_cost); union { bool real; uint8_t base; } u_replan; u_replan.base = 0; u_replan.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->replan = u_replan.real; offset += sizeof(this->replan); union { int32_t real; uint32_t base; } u_replan_attempts; u_replan_attempts.base = 0; u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->replan_attempts = u_replan_attempts.real; offset += sizeof(this->replan_attempts); union { double real; uint64_t base; } u_replan_delay; u_replan_delay.base = 0; u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->replan_delay = u_replan_delay.real; offset += sizeof(this->replan_delay); return offset; } const char * getType(){ return "moveit_msgs/PlanningOptions"; }; const char * getMD5(){ return "3934e50ede2ecea03e532aade900ab50"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/VisibilityConstraint.h

#ifndef _ROS_moveit_msgs_VisibilityConstraint_h #define _ROS_moveit_msgs_VisibilityConstraint_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "geometry_msgs/PoseStamped.h" namespace moveit_msgs { class VisibilityConstraint : public ros::Msg { public: typedef double _target_radius_type; _target_radius_type target_radius; typedef geometry_msgs::PoseStamped _target_pose_type; _target_pose_type target_pose; typedef int32_t _cone_sides_type; _cone_sides_type cone_sides; typedef geometry_msgs::PoseStamped _sensor_pose_type; _sensor_pose_type sensor_pose; typedef double _max_view_angle_type; _max_view_angle_type max_view_angle; typedef double _max_range_angle_type; _max_range_angle_type max_range_angle; typedef uint8_t _sensor_view_direction_type; _sensor_view_direction_type sensor_view_direction; typedef double _weight_type; _weight_type weight; enum { SENSOR_Z = 0 }; enum { SENSOR_Y = 1 }; enum { SENSOR_X = 2 }; VisibilityConstraint(): target_radius(0), target_pose(), cone_sides(0), sensor_pose(), max_view_angle(0), max_range_angle(0), sensor_view_direction(0), weight(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { double real; uint64_t base; } u_target_radius; u_target_radius.real = this->target_radius; *(outbuffer + offset + 0) = (u_target_radius.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_target_radius.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_target_radius.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_target_radius.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_target_radius.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_target_radius.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_target_radius.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_target_radius.base >> (8 * 7)) & 0xFF; offset += sizeof(this->target_radius); offset += this->target_pose.serialize(outbuffer + offset); union { int32_t real; uint32_t base; } u_cone_sides; u_cone_sides.real = this->cone_sides; *(outbuffer + offset + 0) = (u_cone_sides.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_cone_sides.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_cone_sides.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_cone_sides.base >> (8 * 3)) & 0xFF; offset += sizeof(this->cone_sides); offset += this->sensor_pose.serialize(outbuffer + offset); union { double real; uint64_t base; } u_max_view_angle; u_max_view_angle.real = this->max_view_angle; *(outbuffer + offset + 0) = (u_max_view_angle.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_view_angle.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_view_angle.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_view_angle.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_view_angle.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_view_angle.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_view_angle.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_view_angle.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_view_angle); union { double real; uint64_t base; } u_max_range_angle; u_max_range_angle.real = this->max_range_angle; *(outbuffer + offset + 0) = (u_max_range_angle.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_range_angle.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_range_angle.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_range_angle.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_range_angle.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_range_angle.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_range_angle.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_range_angle.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_range_angle); *(outbuffer + offset + 0) = (this->sensor_view_direction >> (8 * 0)) & 0xFF; offset += sizeof(this->sensor_view_direction); union { double real; uint64_t base; } u_weight; u_weight.real = this->weight; *(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF; offset += sizeof(this->weight); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { double real; uint64_t base; } u_target_radius; u_target_radius.base = 0; u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->target_radius = u_target_radius.real; offset += sizeof(this->target_radius); offset += this->target_pose.deserialize(inbuffer + offset); union { int32_t real; uint32_t base; } u_cone_sides; u_cone_sides.base = 0; u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->cone_sides = u_cone_sides.real; offset += sizeof(this->cone_sides); offset += this->sensor_pose.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_max_view_angle; u_max_view_angle.base = 0; u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_view_angle = u_max_view_angle.real; offset += sizeof(this->max_view_angle); union { double real; uint64_t base; } u_max_range_angle; u_max_range_angle.base = 0; u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_range_angle = u_max_range_angle.real; offset += sizeof(this->max_range_angle); this->sensor_view_direction = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->sensor_view_direction); union { double real; uint64_t base; } u_weight; u_weight.base = 0; u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->weight = u_weight.real; offset += sizeof(this->weight); return offset; } const char * getType(){ return "moveit_msgs/VisibilityConstraint"; }; const char * getMD5(){ return "62cda903bfe31ff2e5fcdc3810d577ad"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PositionConstraint.h

#ifndef _ROS_moveit_msgs_PositionConstraint_h #define _ROS_moveit_msgs_PositionConstraint_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Vector3.h" #include "moveit_msgs/BoundingVolume.h" namespace moveit_msgs { class PositionConstraint : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef const char* _link_name_type; _link_name_type link_name; typedef geometry_msgs::Vector3 _target_point_offset_type; _target_point_offset_type target_point_offset; typedef moveit_msgs::BoundingVolume _constraint_region_type; _constraint_region_type constraint_region; typedef double _weight_type; _weight_type weight; PositionConstraint(): header(), link_name(""), target_point_offset(), constraint_region(), weight(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); uint32_t length_link_name = strlen(this->link_name); varToArr(outbuffer + offset, length_link_name); offset += 4; memcpy(outbuffer + offset, this->link_name, length_link_name); offset += length_link_name; offset += this->target_point_offset.serialize(outbuffer + offset); offset += this->constraint_region.serialize(outbuffer + offset); union { double real; uint64_t base; } u_weight; u_weight.real = this->weight; *(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF; offset += sizeof(this->weight); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t length_link_name; arrToVar(length_link_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_link_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_link_name-1]=0; this->link_name = (char *)(inbuffer + offset-1); offset += length_link_name; offset += this->target_point_offset.deserialize(inbuffer + offset); offset += this->constraint_region.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_weight; u_weight.base = 0; u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->weight = u_weight.real; offset += sizeof(this->weight); return offset; } const char * getType(){ return "moveit_msgs/PositionConstraint"; }; const char * getMD5(){ return "c83edf208d87d3aa3169f47775a58e6a"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningSceneWorld.h

#ifndef _ROS_moveit_msgs_PlanningSceneWorld_h #define _ROS_moveit_msgs_PlanningSceneWorld_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/CollisionObject.h" #include "octomap_msgs/OctomapWithPose.h" namespace moveit_msgs { class PlanningSceneWorld : public ros::Msg { public: uint32_t collision_objects_length; typedef moveit_msgs::CollisionObject _collision_objects_type; _collision_objects_type st_collision_objects; _collision_objects_type * collision_objects; typedef octomap_msgs::OctomapWithPose _octomap_type; _octomap_type octomap; PlanningSceneWorld(): collision_objects_length(0), collision_objects(NULL), octomap() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->collision_objects_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->collision_objects_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->collision_objects_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->collision_objects_length >> (8 * 3)) & 0xFF; offset += sizeof(this->collision_objects_length); for( uint32_t i = 0; i < collision_objects_length; i++){ offset += this->collision_objects[i].serialize(outbuffer + offset); } offset += this->octomap.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t collision_objects_lengthT = ((uint32_t) (*(inbuffer + offset))); collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->collision_objects_length); if(collision_objects_lengthT > collision_objects_length) this->collision_objects = (moveit_msgs::CollisionObject*)realloc(this->collision_objects, collision_objects_lengthT * sizeof(moveit_msgs::CollisionObject)); collision_objects_length = collision_objects_lengthT; for( uint32_t i = 0; i < collision_objects_length; i++){ offset += this->st_collision_objects.deserialize(inbuffer + offset); memcpy( &(this->collision_objects[i]), &(this->st_collision_objects), sizeof(moveit_msgs::CollisionObject)); } offset += this->octomap.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/PlanningSceneWorld"; }; const char * getMD5(){ return "373d88390d1db385335639f687723ee6"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AttachedCollisionObject.h

#ifndef _ROS_moveit_msgs_AttachedCollisionObject_h #define _ROS_moveit_msgs_AttachedCollisionObject_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/CollisionObject.h" #include "trajectory_msgs/JointTrajectory.h" namespace moveit_msgs { class AttachedCollisionObject : public ros::Msg { public: typedef const char* _link_name_type; _link_name_type link_name; typedef moveit_msgs::CollisionObject _object_type; _object_type object; uint32_t touch_links_length; typedef char* _touch_links_type; _touch_links_type st_touch_links; _touch_links_type * touch_links; typedef trajectory_msgs::JointTrajectory _detach_posture_type; _detach_posture_type detach_posture; typedef double _weight_type; _weight_type weight; AttachedCollisionObject(): link_name(""), object(), touch_links_length(0), touch_links(NULL), detach_posture(), weight(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_link_name = strlen(this->link_name); varToArr(outbuffer + offset, length_link_name); offset += 4; memcpy(outbuffer + offset, this->link_name, length_link_name); offset += length_link_name; offset += this->object.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->touch_links_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->touch_links_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->touch_links_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->touch_links_length >> (8 * 3)) & 0xFF; offset += sizeof(this->touch_links_length); for( uint32_t i = 0; i < touch_links_length; i++){ uint32_t length_touch_linksi = strlen(this->touch_links[i]); varToArr(outbuffer + offset, length_touch_linksi); offset += 4; memcpy(outbuffer + offset, this->touch_links[i], length_touch_linksi); offset += length_touch_linksi; } offset += this->detach_posture.serialize(outbuffer + offset); union { double real; uint64_t base; } u_weight; u_weight.real = this->weight; *(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF; offset += sizeof(this->weight); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_link_name; arrToVar(length_link_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_link_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_link_name-1]=0; this->link_name = (char *)(inbuffer + offset-1); offset += length_link_name; offset += this->object.deserialize(inbuffer + offset); uint32_t touch_links_lengthT = ((uint32_t) (*(inbuffer + offset))); touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->touch_links_length); if(touch_links_lengthT > touch_links_length) this->touch_links = (char**)realloc(this->touch_links, touch_links_lengthT * sizeof(char*)); touch_links_length = touch_links_lengthT; for( uint32_t i = 0; i < touch_links_length; i++){ uint32_t length_st_touch_links; arrToVar(length_st_touch_links, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_touch_links; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_touch_links-1]=0; this->st_touch_links = (char *)(inbuffer + offset-1); offset += length_st_touch_links; memcpy( &(this->touch_links[i]), &(this->st_touch_links), sizeof(char*)); } offset += this->detach_posture.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_weight; u_weight.base = 0; u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->weight = u_weight.real; offset += sizeof(this->weight); return offset; } const char * getType(){ return "moveit_msgs/AttachedCollisionObject"; }; const char * getMD5(){ return "3ceac60b21e85bbd6c5b0ab9d476b752"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AllowedCollisionMatrix.h

#ifndef _ROS_moveit_msgs_AllowedCollisionMatrix_h #define _ROS_moveit_msgs_AllowedCollisionMatrix_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/AllowedCollisionEntry.h" namespace moveit_msgs { class AllowedCollisionMatrix : public ros::Msg { public: uint32_t entry_names_length; typedef char* _entry_names_type; _entry_names_type st_entry_names; _entry_names_type * entry_names; uint32_t entry_values_length; typedef moveit_msgs::AllowedCollisionEntry _entry_values_type; _entry_values_type st_entry_values; _entry_values_type * entry_values; uint32_t default_entry_names_length; typedef char* _default_entry_names_type; _default_entry_names_type st_default_entry_names; _default_entry_names_type * default_entry_names; uint32_t default_entry_values_length; typedef bool _default_entry_values_type; _default_entry_values_type st_default_entry_values; _default_entry_values_type * default_entry_values; AllowedCollisionMatrix(): entry_names_length(0), entry_names(NULL), entry_values_length(0), entry_values(NULL), default_entry_names_length(0), default_entry_names(NULL), default_entry_values_length(0), default_entry_values(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->entry_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->entry_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->entry_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->entry_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->entry_names_length); for( uint32_t i = 0; i < entry_names_length; i++){ uint32_t length_entry_namesi = strlen(this->entry_names[i]); varToArr(outbuffer + offset, length_entry_namesi); offset += 4; memcpy(outbuffer + offset, this->entry_names[i], length_entry_namesi); offset += length_entry_namesi; } *(outbuffer + offset + 0) = (this->entry_values_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->entry_values_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->entry_values_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->entry_values_length >> (8 * 3)) & 0xFF; offset += sizeof(this->entry_values_length); for( uint32_t i = 0; i < entry_values_length; i++){ offset += this->entry_values[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->default_entry_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->default_entry_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->default_entry_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->default_entry_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->default_entry_names_length); for( uint32_t i = 0; i < default_entry_names_length; i++){ uint32_t length_default_entry_namesi = strlen(this->default_entry_names[i]); varToArr(outbuffer + offset, length_default_entry_namesi); offset += 4; memcpy(outbuffer + offset, this->default_entry_names[i], length_default_entry_namesi); offset += length_default_entry_namesi; } *(outbuffer + offset + 0) = (this->default_entry_values_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->default_entry_values_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->default_entry_values_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->default_entry_values_length >> (8 * 3)) & 0xFF; offset += sizeof(this->default_entry_values_length); for( uint32_t i = 0; i < default_entry_values_length; i++){ union { bool real; uint8_t base; } u_default_entry_valuesi; u_default_entry_valuesi.real = this->default_entry_values[i]; *(outbuffer + offset + 0) = (u_default_entry_valuesi.base >> (8 * 0)) & 0xFF; offset += sizeof(this->default_entry_values[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t entry_names_lengthT = ((uint32_t) (*(inbuffer + offset))); entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->entry_names_length); if(entry_names_lengthT > entry_names_length) this->entry_names = (char**)realloc(this->entry_names, entry_names_lengthT * sizeof(char*)); entry_names_length = entry_names_lengthT; for( uint32_t i = 0; i < entry_names_length; i++){ uint32_t length_st_entry_names; arrToVar(length_st_entry_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_entry_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_entry_names-1]=0; this->st_entry_names = (char *)(inbuffer + offset-1); offset += length_st_entry_names; memcpy( &(this->entry_names[i]), &(this->st_entry_names), sizeof(char*)); } uint32_t entry_values_lengthT = ((uint32_t) (*(inbuffer + offset))); entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->entry_values_length); if(entry_values_lengthT > entry_values_length) this->entry_values = (moveit_msgs::AllowedCollisionEntry*)realloc(this->entry_values, entry_values_lengthT * sizeof(moveit_msgs::AllowedCollisionEntry)); entry_values_length = entry_values_lengthT; for( uint32_t i = 0; i < entry_values_length; i++){ offset += this->st_entry_values.deserialize(inbuffer + offset); memcpy( &(this->entry_values[i]), &(this->st_entry_values), sizeof(moveit_msgs::AllowedCollisionEntry)); } uint32_t default_entry_names_lengthT = ((uint32_t) (*(inbuffer + offset))); default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->default_entry_names_length); if(default_entry_names_lengthT > default_entry_names_length) this->default_entry_names = (char**)realloc(this->default_entry_names, default_entry_names_lengthT * sizeof(char*)); default_entry_names_length = default_entry_names_lengthT; for( uint32_t i = 0; i < default_entry_names_length; i++){ uint32_t length_st_default_entry_names; arrToVar(length_st_default_entry_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_default_entry_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_default_entry_names-1]=0; this->st_default_entry_names = (char *)(inbuffer + offset-1); offset += length_st_default_entry_names; memcpy( &(this->default_entry_names[i]), &(this->st_default_entry_names), sizeof(char*)); } uint32_t default_entry_values_lengthT = ((uint32_t) (*(inbuffer + offset))); default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->default_entry_values_length); if(default_entry_values_lengthT > default_entry_values_length) this->default_entry_values = (bool*)realloc(this->default_entry_values, default_entry_values_lengthT * sizeof(bool)); default_entry_values_length = default_entry_values_lengthT; for( uint32_t i = 0; i < default_entry_values_length; i++){ union { bool real; uint8_t base; } u_st_default_entry_values; u_st_default_entry_values.base = 0; u_st_default_entry_values.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_default_entry_values = u_st_default_entry_values.real; offset += sizeof(this->st_default_entry_values); memcpy( &(this->default_entry_values[i]), &(this->st_default_entry_values), sizeof(bool)); } return offset; } const char * getType(){ return "moveit_msgs/AllowedCollisionMatrix"; }; const char * getMD5(){ return "aedce13587eef0d79165a075659c1879"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayTrajectory.h

#ifndef _ROS_moveit_msgs_DisplayTrajectory_h #define _ROS_moveit_msgs_DisplayTrajectory_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/RobotTrajectory.h" #include "moveit_msgs/RobotState.h" namespace moveit_msgs { class DisplayTrajectory : public ros::Msg { public: typedef const char* _model_id_type; _model_id_type model_id; uint32_t trajectory_length; typedef moveit_msgs::RobotTrajectory _trajectory_type; _trajectory_type st_trajectory; _trajectory_type * trajectory; typedef moveit_msgs::RobotState _trajectory_start_type; _trajectory_start_type trajectory_start; DisplayTrajectory(): model_id(""), trajectory_length(0), trajectory(NULL), trajectory_start() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_model_id = strlen(this->model_id); varToArr(outbuffer + offset, length_model_id); offset += 4; memcpy(outbuffer + offset, this->model_id, length_model_id); offset += length_model_id; *(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF; offset += sizeof(this->trajectory_length); for( uint32_t i = 0; i < trajectory_length; i++){ offset += this->trajectory[i].serialize(outbuffer + offset); } offset += this->trajectory_start.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_model_id; arrToVar(length_model_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_model_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_model_id-1]=0; this->model_id = (char *)(inbuffer + offset-1); offset += length_model_id; uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset))); trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->trajectory_length); if(trajectory_lengthT > trajectory_length) this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory)); trajectory_length = trajectory_lengthT; for( uint32_t i = 0; i < trajectory_length; i++){ offset += this->st_trajectory.deserialize(inbuffer + offset); memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory)); } offset += this->trajectory_start.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/DisplayTrajectory"; }; const char * getMD5(){ return "c3c039261ab9e8a11457dac56b6316c8"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LinkScale.h

#ifndef _ROS_moveit_msgs_LinkScale_h #define _ROS_moveit_msgs_LinkScale_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class LinkScale : public ros::Msg { public: typedef const char* _link_name_type; _link_name_type link_name; typedef double _scale_type; _scale_type scale; LinkScale(): link_name(""), scale(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_link_name = strlen(this->link_name); varToArr(outbuffer + offset, length_link_name); offset += 4; memcpy(outbuffer + offset, this->link_name, length_link_name); offset += length_link_name; union { double real; uint64_t base; } u_scale; u_scale.real = this->scale; *(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_scale.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_scale.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_scale.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_scale.base >> (8 * 7)) & 0xFF; offset += sizeof(this->scale); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_link_name; arrToVar(length_link_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_link_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_link_name-1]=0; this->link_name = (char *)(inbuffer + offset-1); offset += length_link_name; union { double real; uint64_t base; } u_scale; u_scale.base = 0; u_scale.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_scale.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_scale.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_scale.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_scale.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_scale.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_scale.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_scale.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->scale = u_scale.real; offset += sizeof(this->scale); return offset; } const char * getType(){ return "moveit_msgs/LinkScale"; }; const char * getMD5(){ return "19faf226446bfb2f645a4da6f2a56166"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPositionIK.h

#ifndef _ROS_SERVICE_GetPositionIK_h #define _ROS_SERVICE_GetPositionIK_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "moveit_msgs/PositionIKRequest.h" #include "moveit_msgs/RobotState.h" namespace moveit_msgs { static const char GETPOSITIONIK[] = "moveit_msgs/GetPositionIK"; class GetPositionIKRequest : public ros::Msg { public: typedef moveit_msgs::PositionIKRequest _ik_request_type; _ik_request_type ik_request; GetPositionIKRequest(): ik_request() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->ik_request.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->ik_request.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPOSITIONIK; }; const char * getMD5(){ return "a67dc7e99d15c1dca32a77c22bc2d93b"; }; }; class GetPositionIKResponse : public ros::Msg { public: typedef moveit_msgs::RobotState _solution_type; _solution_type solution; typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; GetPositionIKResponse(): solution(), error_code() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->solution.serialize(outbuffer + offset); offset += this->error_code.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->solution.deserialize(inbuffer + offset); offset += this->error_code.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPOSITIONIK; }; const char * getMD5(){ return "ad50fe5fa0ddb482909be313121ea148"; }; }; class GetPositionIK { public: typedef GetPositionIKRequest Request; typedef GetPositionIKResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LoadMap.h

#ifndef _ROS_SERVICE_LoadMap_h #define _ROS_SERVICE_LoadMap_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { static const char LOADMAP[] = "moveit_msgs/LoadMap"; class LoadMapRequest : public ros::Msg { public: typedef const char* _filename_type; _filename_type filename; LoadMapRequest(): filename("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_filename = strlen(this->filename); varToArr(outbuffer + offset, length_filename); offset += 4; memcpy(outbuffer + offset, this->filename, length_filename); offset += length_filename; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_filename; arrToVar(length_filename, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_filename; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_filename-1]=0; this->filename = (char *)(inbuffer + offset-1); offset += length_filename; return offset; } const char * getType(){ return LOADMAP; }; const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; }; }; class LoadMapResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; LoadMapResponse(): success(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.real = this->success; *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; offset += sizeof(this->success); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.base = 0; u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->success = u_success.real; offset += sizeof(this->success); return offset; } const char * getType(){ return LOADMAP; }; const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; }; class LoadMap { public: typedef LoadMapRequest Request; typedef LoadMapResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceGoal.h

#ifndef _ROS_moveit_msgs_MoveGroupSequenceGoal_h #define _ROS_moveit_msgs_MoveGroupSequenceGoal_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MotionSequenceRequest.h" #include "moveit_msgs/PlanningOptions.h" namespace moveit_msgs { class MoveGroupSequenceGoal : public ros::Msg { public: typedef moveit_msgs::MotionSequenceRequest _request_type; _request_type request; typedef moveit_msgs::PlanningOptions _planning_options_type; _planning_options_type planning_options; MoveGroupSequenceGoal(): request(), planning_options() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->request.serialize(outbuffer + offset); offset += this->planning_options.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->request.deserialize(inbuffer + offset); offset += this->planning_options.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/MoveGroupSequenceGoal"; }; const char * getMD5(){ return "12fc6281edcaf031de4783a58087ebf1"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetCartesianPath.h

#ifndef _ROS_SERVICE_GetCartesianPath_h #define _ROS_SERVICE_GetCartesianPath_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "moveit_msgs/RobotTrajectory.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/MoveItErrorCodes.h" #include "geometry_msgs/Pose.h" #include "moveit_msgs/Constraints.h" namespace moveit_msgs { static const char GETCARTESIANPATH[] = "moveit_msgs/GetCartesianPath"; class GetCartesianPathRequest : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef moveit_msgs::RobotState _start_state_type; _start_state_type start_state; typedef const char* _group_name_type; _group_name_type group_name; typedef const char* _link_name_type; _link_name_type link_name; uint32_t waypoints_length; typedef geometry_msgs::Pose _waypoints_type; _waypoints_type st_waypoints; _waypoints_type * waypoints; typedef double _max_step_type; _max_step_type max_step; typedef double _jump_threshold_type; _jump_threshold_type jump_threshold; typedef bool _avoid_collisions_type; _avoid_collisions_type avoid_collisions; typedef moveit_msgs::Constraints _path_constraints_type; _path_constraints_type path_constraints; GetCartesianPathRequest(): header(), start_state(), group_name(""), link_name(""), waypoints_length(0), waypoints(NULL), max_step(0), jump_threshold(0), avoid_collisions(0), path_constraints() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->start_state.serialize(outbuffer + offset); uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; uint32_t length_link_name = strlen(this->link_name); varToArr(outbuffer + offset, length_link_name); offset += 4; memcpy(outbuffer + offset, this->link_name, length_link_name); offset += length_link_name; *(outbuffer + offset + 0) = (this->waypoints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->waypoints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->waypoints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->waypoints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->waypoints_length); for( uint32_t i = 0; i < waypoints_length; i++){ offset += this->waypoints[i].serialize(outbuffer + offset); } union { double real; uint64_t base; } u_max_step; u_max_step.real = this->max_step; *(outbuffer + offset + 0) = (u_max_step.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_step.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_step.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_step.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_max_step.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_max_step.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_max_step.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_max_step.base >> (8 * 7)) & 0xFF; offset += sizeof(this->max_step); union { double real; uint64_t base; } u_jump_threshold; u_jump_threshold.real = this->jump_threshold; *(outbuffer + offset + 0) = (u_jump_threshold.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_jump_threshold.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_jump_threshold.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_jump_threshold.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_jump_threshold.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_jump_threshold.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_jump_threshold.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_jump_threshold.base >> (8 * 7)) & 0xFF; offset += sizeof(this->jump_threshold); union { bool real; uint8_t base; } u_avoid_collisions; u_avoid_collisions.real = this->avoid_collisions; *(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF; offset += sizeof(this->avoid_collisions); offset += this->path_constraints.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->start_state.deserialize(inbuffer + offset); uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; uint32_t length_link_name; arrToVar(length_link_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_link_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_link_name-1]=0; this->link_name = (char *)(inbuffer + offset-1); offset += length_link_name; uint32_t waypoints_lengthT = ((uint32_t) (*(inbuffer + offset))); waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->waypoints_length); if(waypoints_lengthT > waypoints_length) this->waypoints = (geometry_msgs::Pose*)realloc(this->waypoints, waypoints_lengthT * sizeof(geometry_msgs::Pose)); waypoints_length = waypoints_lengthT; for( uint32_t i = 0; i < waypoints_length; i++){ offset += this->st_waypoints.deserialize(inbuffer + offset); memcpy( &(this->waypoints[i]), &(this->st_waypoints), sizeof(geometry_msgs::Pose)); } union { double real; uint64_t base; } u_max_step; u_max_step.base = 0; u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->max_step = u_max_step.real; offset += sizeof(this->max_step); union { double real; uint64_t base; } u_jump_threshold; u_jump_threshold.base = 0; u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->jump_threshold = u_jump_threshold.real; offset += sizeof(this->jump_threshold); union { bool real; uint8_t base; } u_avoid_collisions; u_avoid_collisions.base = 0; u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->avoid_collisions = u_avoid_collisions.real; offset += sizeof(this->avoid_collisions); offset += this->path_constraints.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETCARTESIANPATH; }; const char * getMD5(){ return "b37c16ad7ed838d811a270a8054276b6"; }; }; class GetCartesianPathResponse : public ros::Msg { public: typedef moveit_msgs::RobotState _start_state_type; _start_state_type start_state; typedef moveit_msgs::RobotTrajectory _solution_type; _solution_type solution; typedef double _fraction_type; _fraction_type fraction; typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; GetCartesianPathResponse(): start_state(), solution(), fraction(0), error_code() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->start_state.serialize(outbuffer + offset); offset += this->solution.serialize(outbuffer + offset); union { double real; uint64_t base; } u_fraction; u_fraction.real = this->fraction; *(outbuffer + offset + 0) = (u_fraction.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_fraction.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_fraction.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_fraction.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_fraction.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_fraction.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_fraction.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_fraction.base >> (8 * 7)) & 0xFF; offset += sizeof(this->fraction); offset += this->error_code.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->start_state.deserialize(inbuffer + offset); offset += this->solution.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_fraction; u_fraction.base = 0; u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->fraction = u_fraction.real; offset += sizeof(this->fraction); offset += this->error_code.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETCARTESIANPATH; }; const char * getMD5(){ return "45414110461a45eb0e273e013924ce59"; }; }; class GetCartesianPath { public: typedef GetCartesianPathRequest Request; typedef GetCartesianPathResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ListRobotStatesInWarehouse.h

#ifndef _ROS_SERVICE_ListRobotStatesInWarehouse_h #define _ROS_SERVICE_ListRobotStatesInWarehouse_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { static const char LISTROBOTSTATESINWAREHOUSE[] = "moveit_msgs/ListRobotStatesInWarehouse"; class ListRobotStatesInWarehouseRequest : public ros::Msg { public: typedef const char* _regex_type; _regex_type regex; typedef const char* _robot_type; _robot_type robot; ListRobotStatesInWarehouseRequest(): regex(""), robot("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_regex = strlen(this->regex); varToArr(outbuffer + offset, length_regex); offset += 4; memcpy(outbuffer + offset, this->regex, length_regex); offset += length_regex; uint32_t length_robot = strlen(this->robot); varToArr(outbuffer + offset, length_robot); offset += 4; memcpy(outbuffer + offset, this->robot, length_robot); offset += length_robot; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_regex; arrToVar(length_regex, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_regex; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_regex-1]=0; this->regex = (char *)(inbuffer + offset-1); offset += length_regex; uint32_t length_robot; arrToVar(length_robot, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_robot; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_robot-1]=0; this->robot = (char *)(inbuffer + offset-1); offset += length_robot; return offset; } const char * getType(){ return LISTROBOTSTATESINWAREHOUSE; }; const char * getMD5(){ return "6f0970a3ca837e2fc3ed63e314b44b42"; }; }; class ListRobotStatesInWarehouseResponse : public ros::Msg { public: uint32_t states_length; typedef char* _states_type; _states_type st_states; _states_type * states; ListRobotStatesInWarehouseResponse(): states_length(0), states(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF; offset += sizeof(this->states_length); for( uint32_t i = 0; i < states_length; i++){ uint32_t length_statesi = strlen(this->states[i]); varToArr(outbuffer + offset, length_statesi); offset += 4; memcpy(outbuffer + offset, this->states[i], length_statesi); offset += length_statesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset))); states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->states_length); if(states_lengthT > states_length) this->states = (char**)realloc(this->states, states_lengthT * sizeof(char*)); states_length = states_lengthT; for( uint32_t i = 0; i < states_length; i++){ uint32_t length_st_states; arrToVar(length_st_states, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_states; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_states-1]=0; this->st_states = (char *)(inbuffer + offset-1); offset += length_st_states; memcpy( &(this->states[i]), &(this->st_states), sizeof(char*)); } return offset; } const char * getType(){ return LISTROBOTSTATESINWAREHOUSE; }; const char * getMD5(){ return "a8656b247c0429bb79afe0ddb88eb2f5"; }; }; class ListRobotStatesInWarehouse { public: typedef ListRobotStatesInWarehouseRequest Request; typedef ListRobotStatesInWarehouseResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayRobotState.h

#ifndef _ROS_moveit_msgs_DisplayRobotState_h #define _ROS_moveit_msgs_DisplayRobotState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/ObjectColor.h" namespace moveit_msgs { class DisplayRobotState : public ros::Msg { public: typedef moveit_msgs::RobotState _state_type; _state_type state; uint32_t highlight_links_length; typedef moveit_msgs::ObjectColor _highlight_links_type; _highlight_links_type st_highlight_links; _highlight_links_type * highlight_links; DisplayRobotState(): state(), highlight_links_length(0), highlight_links(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->state.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->highlight_links_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->highlight_links_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->highlight_links_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->highlight_links_length >> (8 * 3)) & 0xFF; offset += sizeof(this->highlight_links_length); for( uint32_t i = 0; i < highlight_links_length; i++){ offset += this->highlight_links[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->state.deserialize(inbuffer + offset); uint32_t highlight_links_lengthT = ((uint32_t) (*(inbuffer + offset))); highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->highlight_links_length); if(highlight_links_lengthT > highlight_links_length) this->highlight_links = (moveit_msgs::ObjectColor*)realloc(this->highlight_links, highlight_links_lengthT * sizeof(moveit_msgs::ObjectColor)); highlight_links_length = highlight_links_lengthT; for( uint32_t i = 0; i < highlight_links_length; i++){ offset += this->st_highlight_links.deserialize(inbuffer + offset); memcpy( &(this->highlight_links[i]), &(this->st_highlight_links), sizeof(moveit_msgs::ObjectColor)); } return offset; } const char * getType(){ return "moveit_msgs/DisplayRobotState"; }; const char * getMD5(){ return "6a3bab3a33a8c47aee24481a455a21aa"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceItem.h

#ifndef _ROS_moveit_msgs_MotionSequenceItem_h #define _ROS_moveit_msgs_MotionSequenceItem_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MotionPlanRequest.h" namespace moveit_msgs { class MotionSequenceItem : public ros::Msg { public: typedef moveit_msgs::MotionPlanRequest _req_type; _req_type req; typedef double _blend_radius_type; _blend_radius_type blend_radius; MotionSequenceItem(): req(), blend_radius(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->req.serialize(outbuffer + offset); union { double real; uint64_t base; } u_blend_radius; u_blend_radius.real = this->blend_radius; *(outbuffer + offset + 0) = (u_blend_radius.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_blend_radius.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_blend_radius.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_blend_radius.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_blend_radius.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_blend_radius.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_blend_radius.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_blend_radius.base >> (8 * 7)) & 0xFF; offset += sizeof(this->blend_radius); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->req.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_blend_radius; u_blend_radius.base = 0; u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->blend_radius = u_blend_radius.real; offset += sizeof(this->blend_radius); return offset; } const char * getType(){ return "moveit_msgs/MotionSequenceItem"; }; const char * getMD5(){ return "932aef4280f479e42c693b8b285624bf"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CollisionObject.h

#ifndef _ROS_moveit_msgs_CollisionObject_h #define _ROS_moveit_msgs_CollisionObject_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "object_recognition_msgs/ObjectType.h" #include "shape_msgs/SolidPrimitive.h" #include "geometry_msgs/Pose.h" #include "shape_msgs/Mesh.h" #include "shape_msgs/Plane.h" namespace moveit_msgs { class CollisionObject : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef const char* _id_type; _id_type id; typedef object_recognition_msgs::ObjectType _type_type; _type_type type; uint32_t primitives_length; typedef shape_msgs::SolidPrimitive _primitives_type; _primitives_type st_primitives; _primitives_type * primitives; uint32_t primitive_poses_length; typedef geometry_msgs::Pose _primitive_poses_type; _primitive_poses_type st_primitive_poses; _primitive_poses_type * primitive_poses; uint32_t meshes_length; typedef shape_msgs::Mesh _meshes_type; _meshes_type st_meshes; _meshes_type * meshes; uint32_t mesh_poses_length; typedef geometry_msgs::Pose _mesh_poses_type; _mesh_poses_type st_mesh_poses; _mesh_poses_type * mesh_poses; uint32_t planes_length; typedef shape_msgs::Plane _planes_type; _planes_type st_planes; _planes_type * planes; uint32_t plane_poses_length; typedef geometry_msgs::Pose _plane_poses_type; _plane_poses_type st_plane_poses; _plane_poses_type * plane_poses; typedef int8_t _operation_type; _operation_type operation; enum { ADD = 0 }; enum { REMOVE = 1 }; enum { APPEND = 2 }; enum { MOVE = 3 }; CollisionObject(): header(), id(""), type(), primitives_length(0), primitives(NULL), primitive_poses_length(0), primitive_poses(NULL), meshes_length(0), meshes(NULL), mesh_poses_length(0), mesh_poses(NULL), planes_length(0), planes(NULL), plane_poses_length(0), plane_poses(NULL), operation(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); uint32_t length_id = strlen(this->id); varToArr(outbuffer + offset, length_id); offset += 4; memcpy(outbuffer + offset, this->id, length_id); offset += length_id; offset += this->type.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF; offset += sizeof(this->primitives_length); for( uint32_t i = 0; i < primitives_length; i++){ offset += this->primitives[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF; offset += sizeof(this->primitive_poses_length); for( uint32_t i = 0; i < primitive_poses_length; i++){ offset += this->primitive_poses[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF; offset += sizeof(this->meshes_length); for( uint32_t i = 0; i < meshes_length; i++){ offset += this->meshes[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF; offset += sizeof(this->mesh_poses_length); for( uint32_t i = 0; i < mesh_poses_length; i++){ offset += this->mesh_poses[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->planes_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->planes_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->planes_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->planes_length >> (8 * 3)) & 0xFF; offset += sizeof(this->planes_length); for( uint32_t i = 0; i < planes_length; i++){ offset += this->planes[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->plane_poses_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->plane_poses_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->plane_poses_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->plane_poses_length >> (8 * 3)) & 0xFF; offset += sizeof(this->plane_poses_length); for( uint32_t i = 0; i < plane_poses_length; i++){ offset += this->plane_poses[i].serialize(outbuffer + offset); } union { int8_t real; uint8_t base; } u_operation; u_operation.real = this->operation; *(outbuffer + offset + 0) = (u_operation.base >> (8 * 0)) & 0xFF; offset += sizeof(this->operation); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t length_id; arrToVar(length_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_id-1]=0; this->id = (char *)(inbuffer + offset-1); offset += length_id; offset += this->type.deserialize(inbuffer + offset); uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset))); primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->primitives_length); if(primitives_lengthT > primitives_length) this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive)); primitives_length = primitives_lengthT; for( uint32_t i = 0; i < primitives_length; i++){ offset += this->st_primitives.deserialize(inbuffer + offset); memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive)); } uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset))); primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->primitive_poses_length); if(primitive_poses_lengthT > primitive_poses_length) this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose)); primitive_poses_length = primitive_poses_lengthT; for( uint32_t i = 0; i < primitive_poses_length; i++){ offset += this->st_primitive_poses.deserialize(inbuffer + offset); memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose)); } uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset))); meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->meshes_length); if(meshes_lengthT > meshes_length) this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh)); meshes_length = meshes_lengthT; for( uint32_t i = 0; i < meshes_length; i++){ offset += this->st_meshes.deserialize(inbuffer + offset); memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh)); } uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset))); mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->mesh_poses_length); if(mesh_poses_lengthT > mesh_poses_length) this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose)); mesh_poses_length = mesh_poses_lengthT; for( uint32_t i = 0; i < mesh_poses_length; i++){ offset += this->st_mesh_poses.deserialize(inbuffer + offset); memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose)); } uint32_t planes_lengthT = ((uint32_t) (*(inbuffer + offset))); planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->planes_length); if(planes_lengthT > planes_length) this->planes = (shape_msgs::Plane*)realloc(this->planes, planes_lengthT * sizeof(shape_msgs::Plane)); planes_length = planes_lengthT; for( uint32_t i = 0; i < planes_length; i++){ offset += this->st_planes.deserialize(inbuffer + offset); memcpy( &(this->planes[i]), &(this->st_planes), sizeof(shape_msgs::Plane)); } uint32_t plane_poses_lengthT = ((uint32_t) (*(inbuffer + offset))); plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->plane_poses_length); if(plane_poses_lengthT > plane_poses_length) this->plane_poses = (geometry_msgs::Pose*)realloc(this->plane_poses, plane_poses_lengthT * sizeof(geometry_msgs::Pose)); plane_poses_length = plane_poses_lengthT; for( uint32_t i = 0; i < plane_poses_length; i++){ offset += this->st_plane_poses.deserialize(inbuffer + offset); memcpy( &(this->plane_poses[i]), &(this->st_plane_poses), sizeof(geometry_msgs::Pose)); } union { int8_t real; uint8_t base; } u_operation; u_operation.base = 0; u_operation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->operation = u_operation.real; offset += sizeof(this->operation); return offset; } const char * getType(){ return "moveit_msgs/CollisionObject"; }; const char * getMD5(){ return "568a161b26dc46c54a5a07621ce82cf3"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPlannerParams.h

#ifndef _ROS_SERVICE_GetPlannerParams_h #define _ROS_SERVICE_GetPlannerParams_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PlannerParams.h" namespace moveit_msgs { static const char GETPLANNERPARAMS[] = "moveit_msgs/GetPlannerParams"; class GetPlannerParamsRequest : public ros::Msg { public: typedef const char* _planner_config_type; _planner_config_type planner_config; typedef const char* _group_type; _group_type group; GetPlannerParamsRequest(): planner_config(""), group("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_planner_config = strlen(this->planner_config); varToArr(outbuffer + offset, length_planner_config); offset += 4; memcpy(outbuffer + offset, this->planner_config, length_planner_config); offset += length_planner_config; uint32_t length_group = strlen(this->group); varToArr(outbuffer + offset, length_group); offset += 4; memcpy(outbuffer + offset, this->group, length_group); offset += length_group; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_planner_config; arrToVar(length_planner_config, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_planner_config; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_planner_config-1]=0; this->planner_config = (char *)(inbuffer + offset-1); offset += length_planner_config; uint32_t length_group; arrToVar(length_group, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group-1]=0; this->group = (char *)(inbuffer + offset-1); offset += length_group; return offset; } const char * getType(){ return GETPLANNERPARAMS; }; const char * getMD5(){ return "f548a13784550d510d791867af53ef40"; }; }; class GetPlannerParamsResponse : public ros::Msg { public: typedef moveit_msgs::PlannerParams _params_type; _params_type params; GetPlannerParamsResponse(): params() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->params.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->params.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPLANNERPARAMS; }; const char * getMD5(){ return "462b1bd59976ece800f6a48f2b0bf1a2"; }; }; class GetPlannerParams { public: typedef GetPlannerParamsRequest Request; typedef GetPlannerParamsResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningScene.h

#ifndef _ROS_moveit_msgs_PlanningScene_h #define _ROS_moveit_msgs_PlanningScene_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/RobotState.h" #include "geometry_msgs/TransformStamped.h" #include "moveit_msgs/AllowedCollisionMatrix.h" #include "moveit_msgs/LinkPadding.h" #include "moveit_msgs/LinkScale.h" #include "moveit_msgs/ObjectColor.h" #include "moveit_msgs/PlanningSceneWorld.h" namespace moveit_msgs { class PlanningScene : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef moveit_msgs::RobotState _robot_state_type; _robot_state_type robot_state; typedef const char* _robot_model_name_type; _robot_model_name_type robot_model_name; uint32_t fixed_frame_transforms_length; typedef geometry_msgs::TransformStamped _fixed_frame_transforms_type; _fixed_frame_transforms_type st_fixed_frame_transforms; _fixed_frame_transforms_type * fixed_frame_transforms; typedef moveit_msgs::AllowedCollisionMatrix _allowed_collision_matrix_type; _allowed_collision_matrix_type allowed_collision_matrix; uint32_t link_padding_length; typedef moveit_msgs::LinkPadding _link_padding_type; _link_padding_type st_link_padding; _link_padding_type * link_padding; uint32_t link_scale_length; typedef moveit_msgs::LinkScale _link_scale_type; _link_scale_type st_link_scale; _link_scale_type * link_scale; uint32_t object_colors_length; typedef moveit_msgs::ObjectColor _object_colors_type; _object_colors_type st_object_colors; _object_colors_type * object_colors; typedef moveit_msgs::PlanningSceneWorld _world_type; _world_type world; typedef bool _is_diff_type; _is_diff_type is_diff; PlanningScene(): name(""), robot_state(), robot_model_name(""), fixed_frame_transforms_length(0), fixed_frame_transforms(NULL), allowed_collision_matrix(), link_padding_length(0), link_padding(NULL), link_scale_length(0), link_scale(NULL), object_colors_length(0), object_colors(NULL), world(), is_diff(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; offset += this->robot_state.serialize(outbuffer + offset); uint32_t length_robot_model_name = strlen(this->robot_model_name); varToArr(outbuffer + offset, length_robot_model_name); offset += 4; memcpy(outbuffer + offset, this->robot_model_name, length_robot_model_name); offset += length_robot_model_name; *(outbuffer + offset + 0) = (this->fixed_frame_transforms_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->fixed_frame_transforms_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->fixed_frame_transforms_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->fixed_frame_transforms_length >> (8 * 3)) & 0xFF; offset += sizeof(this->fixed_frame_transforms_length); for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){ offset += this->fixed_frame_transforms[i].serialize(outbuffer + offset); } offset += this->allowed_collision_matrix.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->link_padding_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->link_padding_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->link_padding_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->link_padding_length >> (8 * 3)) & 0xFF; offset += sizeof(this->link_padding_length); for( uint32_t i = 0; i < link_padding_length; i++){ offset += this->link_padding[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->link_scale_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->link_scale_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->link_scale_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->link_scale_length >> (8 * 3)) & 0xFF; offset += sizeof(this->link_scale_length); for( uint32_t i = 0; i < link_scale_length; i++){ offset += this->link_scale[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->object_colors_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->object_colors_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->object_colors_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->object_colors_length >> (8 * 3)) & 0xFF; offset += sizeof(this->object_colors_length); for( uint32_t i = 0; i < object_colors_length; i++){ offset += this->object_colors[i].serialize(outbuffer + offset); } offset += this->world.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_is_diff; u_is_diff.real = this->is_diff; *(outbuffer + offset + 0) = (u_is_diff.base >> (8 * 0)) & 0xFF; offset += sizeof(this->is_diff); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; offset += this->robot_state.deserialize(inbuffer + offset); uint32_t length_robot_model_name; arrToVar(length_robot_model_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_robot_model_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_robot_model_name-1]=0; this->robot_model_name = (char *)(inbuffer + offset-1); offset += length_robot_model_name; uint32_t fixed_frame_transforms_lengthT = ((uint32_t) (*(inbuffer + offset))); fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->fixed_frame_transforms_length); if(fixed_frame_transforms_lengthT > fixed_frame_transforms_length) this->fixed_frame_transforms = (geometry_msgs::TransformStamped*)realloc(this->fixed_frame_transforms, fixed_frame_transforms_lengthT * sizeof(geometry_msgs::TransformStamped)); fixed_frame_transforms_length = fixed_frame_transforms_lengthT; for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){ offset += this->st_fixed_frame_transforms.deserialize(inbuffer + offset); memcpy( &(this->fixed_frame_transforms[i]), &(this->st_fixed_frame_transforms), sizeof(geometry_msgs::TransformStamped)); } offset += this->allowed_collision_matrix.deserialize(inbuffer + offset); uint32_t link_padding_lengthT = ((uint32_t) (*(inbuffer + offset))); link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->link_padding_length); if(link_padding_lengthT > link_padding_length) this->link_padding = (moveit_msgs::LinkPadding*)realloc(this->link_padding, link_padding_lengthT * sizeof(moveit_msgs::LinkPadding)); link_padding_length = link_padding_lengthT; for( uint32_t i = 0; i < link_padding_length; i++){ offset += this->st_link_padding.deserialize(inbuffer + offset); memcpy( &(this->link_padding[i]), &(this->st_link_padding), sizeof(moveit_msgs::LinkPadding)); } uint32_t link_scale_lengthT = ((uint32_t) (*(inbuffer + offset))); link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->link_scale_length); if(link_scale_lengthT > link_scale_length) this->link_scale = (moveit_msgs::LinkScale*)realloc(this->link_scale, link_scale_lengthT * sizeof(moveit_msgs::LinkScale)); link_scale_length = link_scale_lengthT; for( uint32_t i = 0; i < link_scale_length; i++){ offset += this->st_link_scale.deserialize(inbuffer + offset); memcpy( &(this->link_scale[i]), &(this->st_link_scale), sizeof(moveit_msgs::LinkScale)); } uint32_t object_colors_lengthT = ((uint32_t) (*(inbuffer + offset))); object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->object_colors_length); if(object_colors_lengthT > object_colors_length) this->object_colors = (moveit_msgs::ObjectColor*)realloc(this->object_colors, object_colors_lengthT * sizeof(moveit_msgs::ObjectColor)); object_colors_length = object_colors_lengthT; for( uint32_t i = 0; i < object_colors_length; i++){ offset += this->st_object_colors.deserialize(inbuffer + offset); memcpy( &(this->object_colors[i]), &(this->st_object_colors), sizeof(moveit_msgs::ObjectColor)); } offset += this->world.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_is_diff; u_is_diff.base = 0; u_is_diff.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->is_diff = u_is_diff.real; offset += sizeof(this->is_diff); return offset; } const char * getType(){ return "moveit_msgs/PlanningScene"; }; const char * getMD5(){ return "89aac6d20db967ba716cba5a86b1b9d5"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupGoal.h

#ifndef _ROS_moveit_msgs_MoveGroupGoal_h #define _ROS_moveit_msgs_MoveGroupGoal_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MotionPlanRequest.h" #include "moveit_msgs/PlanningOptions.h" namespace moveit_msgs { class MoveGroupGoal : public ros::Msg { public: typedef moveit_msgs::MotionPlanRequest _request_type; _request_type request; typedef moveit_msgs::PlanningOptions _planning_options_type; _planning_options_type planning_options; MoveGroupGoal(): request(), planning_options() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->request.serialize(outbuffer + offset); offset += this->planning_options.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->request.deserialize(inbuffer + offset); offset += this->planning_options.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/MoveGroupGoal"; }; const char * getMD5(){ return "a6de2db49c561a49babce1a8172e8906"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RenameRobotStateInWarehouse.h

#ifndef _ROS_SERVICE_RenameRobotStateInWarehouse_h #define _ROS_SERVICE_RenameRobotStateInWarehouse_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { static const char RENAMEROBOTSTATEINWAREHOUSE[] = "moveit_msgs/RenameRobotStateInWarehouse"; class RenameRobotStateInWarehouseRequest : public ros::Msg { public: typedef const char* _old_name_type; _old_name_type old_name; typedef const char* _new_name_type; _new_name_type new_name; typedef const char* _robot_type; _robot_type robot; RenameRobotStateInWarehouseRequest(): old_name(""), new_name(""), robot("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_old_name = strlen(this->old_name); varToArr(outbuffer + offset, length_old_name); offset += 4; memcpy(outbuffer + offset, this->old_name, length_old_name); offset += length_old_name; uint32_t length_new_name = strlen(this->new_name); varToArr(outbuffer + offset, length_new_name); offset += 4; memcpy(outbuffer + offset, this->new_name, length_new_name); offset += length_new_name; uint32_t length_robot = strlen(this->robot); varToArr(outbuffer + offset, length_robot); offset += 4; memcpy(outbuffer + offset, this->robot, length_robot); offset += length_robot; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_old_name; arrToVar(length_old_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_old_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_old_name-1]=0; this->old_name = (char *)(inbuffer + offset-1); offset += length_old_name; uint32_t length_new_name; arrToVar(length_new_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_new_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_new_name-1]=0; this->new_name = (char *)(inbuffer + offset-1); offset += length_new_name; uint32_t length_robot; arrToVar(length_robot, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_robot; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_robot-1]=0; this->robot = (char *)(inbuffer + offset-1); offset += length_robot; return offset; } const char * getType(){ return RENAMEROBOTSTATEINWAREHOUSE; }; const char * getMD5(){ return "073dc05c3fd313b947cea483c25c46b0"; }; }; class RenameRobotStateInWarehouseResponse : public ros::Msg { public: RenameRobotStateInWarehouseResponse() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; return offset; } const char * getType(){ return RENAMEROBOTSTATEINWAREHOUSE; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class RenameRobotStateInWarehouse { public: typedef RenameRobotStateInWarehouseRequest Request; typedef RenameRobotStateInWarehouseResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/KinematicSolverInfo.h

#ifndef _ROS_moveit_msgs_KinematicSolverInfo_h #define _ROS_moveit_msgs_KinematicSolverInfo_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/JointLimits.h" namespace moveit_msgs { class KinematicSolverInfo : public ros::Msg { public: uint32_t joint_names_length; typedef char* _joint_names_type; _joint_names_type st_joint_names; _joint_names_type * joint_names; uint32_t limits_length; typedef moveit_msgs::JointLimits _limits_type; _limits_type st_limits; _limits_type * limits; uint32_t link_names_length; typedef char* _link_names_type; _link_names_type st_link_names; _link_names_type * link_names; KinematicSolverInfo(): joint_names_length(0), joint_names(NULL), limits_length(0), limits(NULL), link_names_length(0), link_names(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->joint_names_length); for( uint32_t i = 0; i < joint_names_length; i++){ uint32_t length_joint_namesi = strlen(this->joint_names[i]); varToArr(outbuffer + offset, length_joint_namesi); offset += 4; memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi); offset += length_joint_namesi; } *(outbuffer + offset + 0) = (this->limits_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->limits_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->limits_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->limits_length >> (8 * 3)) & 0xFF; offset += sizeof(this->limits_length); for( uint32_t i = 0; i < limits_length; i++){ offset += this->limits[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->link_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->link_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->link_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->link_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->link_names_length); for( uint32_t i = 0; i < link_names_length; i++){ uint32_t length_link_namesi = strlen(this->link_names[i]); varToArr(outbuffer + offset, length_link_namesi); offset += 4; memcpy(outbuffer + offset, this->link_names[i], length_link_namesi); offset += length_link_namesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset))); joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->joint_names_length); if(joint_names_lengthT > joint_names_length) this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*)); joint_names_length = joint_names_lengthT; for( uint32_t i = 0; i < joint_names_length; i++){ uint32_t length_st_joint_names; arrToVar(length_st_joint_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_joint_names-1]=0; this->st_joint_names = (char *)(inbuffer + offset-1); offset += length_st_joint_names; memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*)); } uint32_t limits_lengthT = ((uint32_t) (*(inbuffer + offset))); limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->limits_length); if(limits_lengthT > limits_length) this->limits = (moveit_msgs::JointLimits*)realloc(this->limits, limits_lengthT * sizeof(moveit_msgs::JointLimits)); limits_length = limits_lengthT; for( uint32_t i = 0; i < limits_length; i++){ offset += this->st_limits.deserialize(inbuffer + offset); memcpy( &(this->limits[i]), &(this->st_limits), sizeof(moveit_msgs::JointLimits)); } uint32_t link_names_lengthT = ((uint32_t) (*(inbuffer + offset))); link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->link_names_length); if(link_names_lengthT > link_names_length) this->link_names = (char**)realloc(this->link_names, link_names_lengthT * sizeof(char*)); link_names_length = link_names_lengthT; for( uint32_t i = 0; i < link_names_length; i++){ uint32_t length_st_link_names; arrToVar(length_st_link_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_link_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_link_names-1]=0; this->st_link_names = (char *)(inbuffer + offset-1); offset += length_st_link_names; memcpy( &(this->link_names[i]), &(this->st_link_names), sizeof(char*)); } return offset; } const char * getType(){ return "moveit_msgs/KinematicSolverInfo"; }; const char * getMD5(){ return "cc048557c0f9795c392dd80f8bb00489"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PositionIKRequest.h

#ifndef _ROS_moveit_msgs_PositionIKRequest_h #define _ROS_moveit_msgs_PositionIKRequest_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/Constraints.h" #include "geometry_msgs/PoseStamped.h" #include "ros/duration.h" namespace moveit_msgs { class PositionIKRequest : public ros::Msg { public: typedef const char* _group_name_type; _group_name_type group_name; typedef moveit_msgs::RobotState _robot_state_type; _robot_state_type robot_state; typedef moveit_msgs::Constraints _constraints_type; _constraints_type constraints; typedef bool _avoid_collisions_type; _avoid_collisions_type avoid_collisions; typedef const char* _ik_link_name_type; _ik_link_name_type ik_link_name; typedef geometry_msgs::PoseStamped _pose_stamped_type; _pose_stamped_type pose_stamped; uint32_t ik_link_names_length; typedef char* _ik_link_names_type; _ik_link_names_type st_ik_link_names; _ik_link_names_type * ik_link_names; uint32_t pose_stamped_vector_length; typedef geometry_msgs::PoseStamped _pose_stamped_vector_type; _pose_stamped_vector_type st_pose_stamped_vector; _pose_stamped_vector_type * pose_stamped_vector; typedef ros::Duration _timeout_type; _timeout_type timeout; typedef int32_t _attempts_type; _attempts_type attempts; PositionIKRequest(): group_name(""), robot_state(), constraints(), avoid_collisions(0), ik_link_name(""), pose_stamped(), ik_link_names_length(0), ik_link_names(NULL), pose_stamped_vector_length(0), pose_stamped_vector(NULL), timeout(), attempts(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; offset += this->robot_state.serialize(outbuffer + offset); offset += this->constraints.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_avoid_collisions; u_avoid_collisions.real = this->avoid_collisions; *(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF; offset += sizeof(this->avoid_collisions); uint32_t length_ik_link_name = strlen(this->ik_link_name); varToArr(outbuffer + offset, length_ik_link_name); offset += 4; memcpy(outbuffer + offset, this->ik_link_name, length_ik_link_name); offset += length_ik_link_name; offset += this->pose_stamped.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->ik_link_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->ik_link_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->ik_link_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->ik_link_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->ik_link_names_length); for( uint32_t i = 0; i < ik_link_names_length; i++){ uint32_t length_ik_link_namesi = strlen(this->ik_link_names[i]); varToArr(outbuffer + offset, length_ik_link_namesi); offset += 4; memcpy(outbuffer + offset, this->ik_link_names[i], length_ik_link_namesi); offset += length_ik_link_namesi; } *(outbuffer + offset + 0) = (this->pose_stamped_vector_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->pose_stamped_vector_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->pose_stamped_vector_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->pose_stamped_vector_length >> (8 * 3)) & 0xFF; offset += sizeof(this->pose_stamped_vector_length); for( uint32_t i = 0; i < pose_stamped_vector_length; i++){ offset += this->pose_stamped_vector[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->timeout.sec); *(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->timeout.nsec); union { int32_t real; uint32_t base; } u_attempts; u_attempts.real = this->attempts; *(outbuffer + offset + 0) = (u_attempts.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_attempts.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_attempts.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_attempts.base >> (8 * 3)) & 0xFF; offset += sizeof(this->attempts); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; offset += this->robot_state.deserialize(inbuffer + offset); offset += this->constraints.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_avoid_collisions; u_avoid_collisions.base = 0; u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->avoid_collisions = u_avoid_collisions.real; offset += sizeof(this->avoid_collisions); uint32_t length_ik_link_name; arrToVar(length_ik_link_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_ik_link_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_ik_link_name-1]=0; this->ik_link_name = (char *)(inbuffer + offset-1); offset += length_ik_link_name; offset += this->pose_stamped.deserialize(inbuffer + offset); uint32_t ik_link_names_lengthT = ((uint32_t) (*(inbuffer + offset))); ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->ik_link_names_length); if(ik_link_names_lengthT > ik_link_names_length) this->ik_link_names = (char**)realloc(this->ik_link_names, ik_link_names_lengthT * sizeof(char*)); ik_link_names_length = ik_link_names_lengthT; for( uint32_t i = 0; i < ik_link_names_length; i++){ uint32_t length_st_ik_link_names; arrToVar(length_st_ik_link_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_ik_link_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_ik_link_names-1]=0; this->st_ik_link_names = (char *)(inbuffer + offset-1); offset += length_st_ik_link_names; memcpy( &(this->ik_link_names[i]), &(this->st_ik_link_names), sizeof(char*)); } uint32_t pose_stamped_vector_lengthT = ((uint32_t) (*(inbuffer + offset))); pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->pose_stamped_vector_length); if(pose_stamped_vector_lengthT > pose_stamped_vector_length) this->pose_stamped_vector = (geometry_msgs::PoseStamped*)realloc(this->pose_stamped_vector, pose_stamped_vector_lengthT * sizeof(geometry_msgs::PoseStamped)); pose_stamped_vector_length = pose_stamped_vector_lengthT; for( uint32_t i = 0; i < pose_stamped_vector_length; i++){ offset += this->st_pose_stamped_vector.deserialize(inbuffer + offset); memcpy( &(this->pose_stamped_vector[i]), &(this->st_pose_stamped_vector), sizeof(geometry_msgs::PoseStamped)); } this->timeout.sec = ((uint32_t) (*(inbuffer + offset))); this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->timeout.sec); this->timeout.nsec = ((uint32_t) (*(inbuffer + offset))); this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->timeout.nsec); union { int32_t real; uint32_t base; } u_attempts; u_attempts.base = 0; u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->attempts = u_attempts.real; offset += sizeof(this->attempts); return offset; } const char * getType(){ return "moveit_msgs/PositionIKRequest"; }; const char * getMD5(){ return "9936dc239c90af180ec94a51596c96f2"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetMotionPlan.h

#ifndef _ROS_SERVICE_GetMotionPlan_h #define _ROS_SERVICE_GetMotionPlan_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/MotionPlanRequest.h" #include "moveit_msgs/MotionPlanResponse.h" namespace moveit_msgs { static const char GETMOTIONPLAN[] = "moveit_msgs/GetMotionPlan"; class GetMotionPlanRequest : public ros::Msg { public: typedef moveit_msgs::MotionPlanRequest _motion_plan_request_type; _motion_plan_request_type motion_plan_request; GetMotionPlanRequest(): motion_plan_request() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->motion_plan_request.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->motion_plan_request.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETMOTIONPLAN; }; const char * getMD5(){ return "9dcb82c5daeb2ff8a7ab1a98b642871d"; }; }; class GetMotionPlanResponse : public ros::Msg { public: typedef moveit_msgs::MotionPlanResponse _motion_plan_response_type; _motion_plan_response_type motion_plan_response; GetMotionPlanResponse(): motion_plan_response() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->motion_plan_response.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->motion_plan_response.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETMOTIONPLAN; }; const char * getMD5(){ return "37fe7e8f0d4dfa55ccfa53d63c86ae15"; }; }; class GetMotionPlan { public: typedef GetMotionPlanRequest Request; typedef GetMotionPlanResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SaveMap.h

#ifndef _ROS_SERVICE_SaveMap_h #define _ROS_SERVICE_SaveMap_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { static const char SAVEMAP[] = "moveit_msgs/SaveMap"; class SaveMapRequest : public ros::Msg { public: typedef const char* _filename_type; _filename_type filename; SaveMapRequest(): filename("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_filename = strlen(this->filename); varToArr(outbuffer + offset, length_filename); offset += 4; memcpy(outbuffer + offset, this->filename, length_filename); offset += length_filename; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_filename; arrToVar(length_filename, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_filename; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_filename-1]=0; this->filename = (char *)(inbuffer + offset-1); offset += length_filename; return offset; } const char * getType(){ return SAVEMAP; }; const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; }; }; class SaveMapResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; SaveMapResponse(): success(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.real = this->success; *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; offset += sizeof(this->success); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.base = 0; u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->success = u_success.real; offset += sizeof(this->success); return offset; } const char * getType(){ return SAVEMAP; }; const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; }; class SaveMap { public: typedef SaveMapRequest Request; typedef SaveMapResponse Response; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanResponse.h

#ifndef _ROS_moveit_msgs_MotionPlanResponse_h #define _ROS_moveit_msgs_MotionPlanResponse_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/RobotTrajectory.h" #include "moveit_msgs/MoveItErrorCodes.h" namespace moveit_msgs { class MotionPlanResponse : public ros::Msg { public: typedef moveit_msgs::RobotState _trajectory_start_type; _trajectory_start_type trajectory_start; typedef const char* _group_name_type; _group_name_type group_name; typedef moveit_msgs::RobotTrajectory _trajectory_type; _trajectory_type trajectory; typedef double _planning_time_type; _planning_time_type planning_time; typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; MotionPlanResponse(): trajectory_start(), group_name(""), trajectory(), planning_time(0), error_code() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->trajectory_start.serialize(outbuffer + offset); uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; offset += this->trajectory.serialize(outbuffer + offset); union { double real; uint64_t base; } u_planning_time; u_planning_time.real = this->planning_time; *(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF; offset += sizeof(this->planning_time); offset += this->error_code.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->trajectory_start.deserialize(inbuffer + offset); uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; offset += this->trajectory.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_planning_time; u_planning_time.base = 0; u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->planning_time = u_planning_time.real; offset += sizeof(this->planning_time); offset += this->error_code.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/MotionPlanResponse"; }; const char * getMD5(){ return "e493d20ab41424c48f671e152c70fc74"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanDetailedResponse.h

#ifndef _ROS_moveit_msgs_MotionPlanDetailedResponse_h #define _ROS_moveit_msgs_MotionPlanDetailedResponse_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/RobotState.h" #include "moveit_msgs/RobotTrajectory.h" #include "moveit_msgs/MoveItErrorCodes.h" namespace moveit_msgs { class MotionPlanDetailedResponse : public ros::Msg { public: typedef moveit_msgs::RobotState _trajectory_start_type; _trajectory_start_type trajectory_start; typedef const char* _group_name_type; _group_name_type group_name; uint32_t trajectory_length; typedef moveit_msgs::RobotTrajectory _trajectory_type; _trajectory_type st_trajectory; _trajectory_type * trajectory; uint32_t description_length; typedef char* _description_type; _description_type st_description; _description_type * description; uint32_t processing_time_length; typedef double _processing_time_type; _processing_time_type st_processing_time; _processing_time_type * processing_time; typedef moveit_msgs::MoveItErrorCodes _error_code_type; _error_code_type error_code; MotionPlanDetailedResponse(): trajectory_start(), group_name(""), trajectory_length(0), trajectory(NULL), description_length(0), description(NULL), processing_time_length(0), processing_time(NULL), error_code() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->trajectory_start.serialize(outbuffer + offset); uint32_t length_group_name = strlen(this->group_name); varToArr(outbuffer + offset, length_group_name); offset += 4; memcpy(outbuffer + offset, this->group_name, length_group_name); offset += length_group_name; *(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF; offset += sizeof(this->trajectory_length); for( uint32_t i = 0; i < trajectory_length; i++){ offset += this->trajectory[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->description_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->description_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->description_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->description_length >> (8 * 3)) & 0xFF; offset += sizeof(this->description_length); for( uint32_t i = 0; i < description_length; i++){ uint32_t length_descriptioni = strlen(this->description[i]); varToArr(outbuffer + offset, length_descriptioni); offset += 4; memcpy(outbuffer + offset, this->description[i], length_descriptioni); offset += length_descriptioni; } *(outbuffer + offset + 0) = (this->processing_time_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->processing_time_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->processing_time_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->processing_time_length >> (8 * 3)) & 0xFF; offset += sizeof(this->processing_time_length); for( uint32_t i = 0; i < processing_time_length; i++){ union { double real; uint64_t base; } u_processing_timei; u_processing_timei.real = this->processing_time[i]; *(outbuffer + offset + 0) = (u_processing_timei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_processing_timei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_processing_timei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_processing_timei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_processing_timei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_processing_timei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_processing_timei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_processing_timei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->processing_time[i]); } offset += this->error_code.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->trajectory_start.deserialize(inbuffer + offset); uint32_t length_group_name; arrToVar(length_group_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_group_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_group_name-1]=0; this->group_name = (char *)(inbuffer + offset-1); offset += length_group_name; uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset))); trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->trajectory_length); if(trajectory_lengthT > trajectory_length) this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory)); trajectory_length = trajectory_lengthT; for( uint32_t i = 0; i < trajectory_length; i++){ offset += this->st_trajectory.deserialize(inbuffer + offset); memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory)); } uint32_t description_lengthT = ((uint32_t) (*(inbuffer + offset))); description_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); description_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); description_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->description_length); if(description_lengthT > description_length) this->description = (char**)realloc(this->description, description_lengthT * sizeof(char*)); description_length = description_lengthT; for( uint32_t i = 0; i < description_length; i++){ uint32_t length_st_description; arrToVar(length_st_description, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_description; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_description-1]=0; this->st_description = (char *)(inbuffer + offset-1); offset += length_st_description; memcpy( &(this->description[i]), &(this->st_description), sizeof(char*)); } uint32_t processing_time_lengthT = ((uint32_t) (*(inbuffer + offset))); processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->processing_time_length); if(processing_time_lengthT > processing_time_length) this->processing_time = (double*)realloc(this->processing_time, processing_time_lengthT * sizeof(double)); processing_time_length = processing_time_lengthT; for( uint32_t i = 0; i < processing_time_length; i++){ union { double real; uint64_t base; } u_st_processing_time; u_st_processing_time.base = 0; u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_processing_time = u_st_processing_time.real; offset += sizeof(this->st_processing_time); memcpy( &(this->processing_time[i]), &(this->st_processing_time), sizeof(double)); } offset += this->error_code.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/MotionPlanDetailedResponse"; }; const char * getMD5(){ return "7b84c374bb2e37bdc0eba664f7636a8f"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/TrajectoryConstraints.h

#ifndef _ROS_moveit_msgs_TrajectoryConstraints_h #define _ROS_moveit_msgs_TrajectoryConstraints_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/Constraints.h" namespace moveit_msgs { class TrajectoryConstraints : public ros::Msg { public: uint32_t constraints_length; typedef moveit_msgs::Constraints _constraints_type; _constraints_type st_constraints; _constraints_type * constraints; TrajectoryConstraints(): constraints_length(0), constraints(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->constraints_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->constraints_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->constraints_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->constraints_length >> (8 * 3)) & 0xFF; offset += sizeof(this->constraints_length); for( uint32_t i = 0; i < constraints_length; i++){ offset += this->constraints[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t constraints_lengthT = ((uint32_t) (*(inbuffer + offset))); constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->constraints_length); if(constraints_lengthT > constraints_length) this->constraints = (moveit_msgs::Constraints*)realloc(this->constraints, constraints_lengthT * sizeof(moveit_msgs::Constraints)); constraints_length = constraints_lengthT; for( uint32_t i = 0; i < constraints_length; i++){ offset += this->st_constraints.deserialize(inbuffer + offset); memcpy( &(this->constraints[i]), &(this->st_constraints), sizeof(moveit_msgs::Constraints)); } return offset; } const char * getType(){ return "moveit_msgs/TrajectoryConstraints"; }; const char * getMD5(){ return "461e1a732dfebb01e7d6c75d51a51eac"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupAction.h

#ifndef _ROS_moveit_msgs_PickupAction_h #define _ROS_moveit_msgs_PickupAction_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "moveit_msgs/PickupActionGoal.h" #include "moveit_msgs/PickupActionResult.h" #include "moveit_msgs/PickupActionFeedback.h" namespace moveit_msgs { class PickupAction : public ros::Msg { public: typedef moveit_msgs::PickupActionGoal _action_goal_type; _action_goal_type action_goal; typedef moveit_msgs::PickupActionResult _action_result_type; _action_result_type action_result; typedef moveit_msgs::PickupActionFeedback _action_feedback_type; _action_feedback_type action_feedback; PickupAction(): action_goal(), action_result(), action_feedback() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->action_goal.serialize(outbuffer + offset); offset += this->action_result.serialize(outbuffer + offset); offset += this->action_feedback.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->action_goal.deserialize(inbuffer + offset); offset += this->action_result.deserialize(inbuffer + offset); offset += this->action_feedback.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/PickupAction"; }; const char * getMD5(){ return "966c9238fcaad4ba8d20e116b676ccc1"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlannerInterfaceDescription.h

#ifndef _ROS_moveit_msgs_PlannerInterfaceDescription_h #define _ROS_moveit_msgs_PlannerInterfaceDescription_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace moveit_msgs { class PlannerInterfaceDescription : public ros::Msg { public: typedef const char* _name_type; _name_type name; uint32_t planner_ids_length; typedef char* _planner_ids_type; _planner_ids_type st_planner_ids; _planner_ids_type * planner_ids; PlannerInterfaceDescription(): name(""), planner_ids_length(0), planner_ids(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; *(outbuffer + offset + 0) = (this->planner_ids_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->planner_ids_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->planner_ids_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->planner_ids_length >> (8 * 3)) & 0xFF; offset += sizeof(this->planner_ids_length); for( uint32_t i = 0; i < planner_ids_length; i++){ uint32_t length_planner_idsi = strlen(this->planner_ids[i]); varToArr(outbuffer + offset, length_planner_idsi); offset += 4; memcpy(outbuffer + offset, this->planner_ids[i], length_planner_idsi); offset += length_planner_idsi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; uint32_t planner_ids_lengthT = ((uint32_t) (*(inbuffer + offset))); planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->planner_ids_length); if(planner_ids_lengthT > planner_ids_length) this->planner_ids = (char**)realloc(this->planner_ids, planner_ids_lengthT * sizeof(char*)); planner_ids_length = planner_ids_lengthT; for( uint32_t i = 0; i < planner_ids_length; i++){ uint32_t length_st_planner_ids; arrToVar(length_st_planner_ids, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_planner_ids; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_planner_ids-1]=0; this->st_planner_ids = (char *)(inbuffer + offset-1); offset += length_st_planner_ids; memcpy( &(this->planner_ids[i]), &(this->st_planner_ids), sizeof(char*)); } return offset; } const char * getType(){ return "moveit_msgs/PlannerInterfaceDescription"; }; const char * getMD5(){ return "ea5f6e6129aa1b110ccda9900d2bf25e"; }; }; } #endif

C