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/ros/service_server.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_SERVICE_SERVER_H_ #define _ROS_SERVICE_SERVER_H_ #include "rosserial_msgs/TopicInfo.h" #include "ros/publisher.h" #include "ros/subscriber.h" namespace ros { template<typename MReq , typename MRes, typename ObjT = void> class ServiceServer : public Subscriber_ { public: typedef void(ObjT::*CallbackT)(const MReq&, MRes&); ServiceServer(const char* topic_name, CallbackT cb, ObjT* obj) : pub(topic_name, &resp, rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_PUBLISHER), obj_(obj) { this->topic_ = topic_name; this->cb_ = cb; } // these refer to the subscriber virtual void callback(unsigned char *data) { req.deserialize(data); (obj_->*cb_)(req, resp); pub.publish(&resp); } virtual const char * getMsgType() { return this->req.getType(); } virtual const char * getMsgMD5() { return this->req.getMD5(); } virtual int getEndpointType() { return rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_SUBSCRIBER; } MReq req; MRes resp; Publisher pub; private: CallbackT cb_; ObjT* obj_; }; template<typename MReq , typename MRes> class ServiceServer<MReq, MRes, void> : public Subscriber_ { public: typedef void(*CallbackT)(const MReq&, MRes&); ServiceServer(const char* topic_name, CallbackT cb) : pub(topic_name, &resp, rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_PUBLISHER) { this->topic_ = topic_name; this->cb_ = cb; } // these refer to the subscriber virtual void callback(unsigned char *data) { req.deserialize(data); cb_(req, resp); pub.publish(&resp); } virtual const char * getMsgType() { return this->req.getType(); } virtual const char * getMsgMD5() { return this->req.getMD5(); } virtual int getEndpointType() { return rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_SUBSCRIBER; } MReq req; MRes resp; Publisher pub; private: CallbackT cb_; }; } #endif

C

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

#ifndef _ROS_turtlebot3_msgs_VersionInfo_h #define _ROS_turtlebot3_msgs_VersionInfo_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlebot3_msgs { class VersionInfo : public ros::Msg { public: typedef const char* _hardware_type; _hardware_type hardware; typedef const char* _firmware_type; _firmware_type firmware; typedef const char* _software_type; _software_type software; VersionInfo(): hardware(""), firmware(""), software("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_hardware = strlen(this->hardware); varToArr(outbuffer + offset, length_hardware); offset += 4; memcpy(outbuffer + offset, this->hardware, length_hardware); offset += length_hardware; uint32_t length_firmware = strlen(this->firmware); varToArr(outbuffer + offset, length_firmware); offset += 4; memcpy(outbuffer + offset, this->firmware, length_firmware); offset += length_firmware; uint32_t length_software = strlen(this->software); varToArr(outbuffer + offset, length_software); offset += 4; memcpy(outbuffer + offset, this->software, length_software); offset += length_software; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_hardware; arrToVar(length_hardware, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_hardware; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_hardware-1]=0; this->hardware = (char *)(inbuffer + offset-1); offset += length_hardware; uint32_t length_firmware; arrToVar(length_firmware, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_firmware; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_firmware-1]=0; this->firmware = (char *)(inbuffer + offset-1); offset += length_firmware; uint32_t length_software; arrToVar(length_software, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_software; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_software-1]=0; this->software = (char *)(inbuffer + offset-1); offset += length_software; return offset; } const char * getType(){ return "turtlebot3_msgs/VersionInfo"; }; const char * getMD5(){ return "43e0361461af2970a33107409403ef3c"; }; }; } #endif

C

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

#ifndef _ROS_turtlebot3_msgs_SensorState_h #define _ROS_turtlebot3_msgs_SensorState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace turtlebot3_msgs { class SensorState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef uint8_t _bumper_type; _bumper_type bumper; typedef float _cliff_type; _cliff_type cliff; typedef float _sonar_type; _sonar_type sonar; typedef float _illumination_type; _illumination_type illumination; typedef uint8_t _led_type; _led_type led; typedef uint8_t _button_type; _button_type button; typedef bool _torque_type; _torque_type torque; typedef int32_t _left_encoder_type; _left_encoder_type left_encoder; typedef int32_t _right_encoder_type; _right_encoder_type right_encoder; typedef float _battery_type; _battery_type battery; enum { BUMPER_FORWARD = 1 }; enum { BUMPER_BACKWARD = 2 }; enum { CLIFF = 1 }; enum { SONAR = 1 }; enum { ILLUMINATION = 1 }; enum { BUTTON0 = 1 }; enum { BUTTON1 = 2 }; enum { ERROR_LEFT_MOTOR = 1 }; enum { ERROR_RIGHT_MOTOR = 2 }; enum { TORQUE_ON = 1 }; enum { TORQUE_OFF = 2 }; SensorState(): header(), bumper(0), cliff(0), sonar(0), illumination(0), led(0), button(0), torque(0), left_encoder(0), right_encoder(0), battery(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->bumper >> (8 * 0)) & 0xFF; offset += sizeof(this->bumper); union { float real; uint32_t base; } u_cliff; u_cliff.real = this->cliff; *(outbuffer + offset + 0) = (u_cliff.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_cliff.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_cliff.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_cliff.base >> (8 * 3)) & 0xFF; offset += sizeof(this->cliff); union { float real; uint32_t base; } u_sonar; u_sonar.real = this->sonar; *(outbuffer + offset + 0) = (u_sonar.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_sonar.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_sonar.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_sonar.base >> (8 * 3)) & 0xFF; offset += sizeof(this->sonar); union { float real; uint32_t base; } u_illumination; u_illumination.real = this->illumination; *(outbuffer + offset + 0) = (u_illumination.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_illumination.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_illumination.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_illumination.base >> (8 * 3)) & 0xFF; offset += sizeof(this->illumination); *(outbuffer + offset + 0) = (this->led >> (8 * 0)) & 0xFF; offset += sizeof(this->led); *(outbuffer + offset + 0) = (this->button >> (8 * 0)) & 0xFF; offset += sizeof(this->button); union { bool real; uint8_t base; } u_torque; u_torque.real = this->torque; *(outbuffer + offset + 0) = (u_torque.base >> (8 * 0)) & 0xFF; offset += sizeof(this->torque); union { int32_t real; uint32_t base; } u_left_encoder; u_left_encoder.real = this->left_encoder; *(outbuffer + offset + 0) = (u_left_encoder.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_left_encoder.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_left_encoder.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_left_encoder.base >> (8 * 3)) & 0xFF; offset += sizeof(this->left_encoder); union { int32_t real; uint32_t base; } u_right_encoder; u_right_encoder.real = this->right_encoder; *(outbuffer + offset + 0) = (u_right_encoder.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_right_encoder.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_right_encoder.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_right_encoder.base >> (8 * 3)) & 0xFF; offset += sizeof(this->right_encoder); union { float real; uint32_t base; } u_battery; u_battery.real = this->battery; *(outbuffer + offset + 0) = (u_battery.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_battery.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_battery.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_battery.base >> (8 * 3)) & 0xFF; offset += sizeof(this->battery); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); this->bumper = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->bumper); union { float real; uint32_t base; } u_cliff; u_cliff.base = 0; u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->cliff = u_cliff.real; offset += sizeof(this->cliff); union { float real; uint32_t base; } u_sonar; u_sonar.base = 0; u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->sonar = u_sonar.real; offset += sizeof(this->sonar); union { float real; uint32_t base; } u_illumination; u_illumination.base = 0; u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->illumination = u_illumination.real; offset += sizeof(this->illumination); this->led = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->led); this->button = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->button); union { bool real; uint8_t base; } u_torque; u_torque.base = 0; u_torque.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->torque = u_torque.real; offset += sizeof(this->torque); union { int32_t real; uint32_t base; } u_left_encoder; u_left_encoder.base = 0; u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->left_encoder = u_left_encoder.real; offset += sizeof(this->left_encoder); union { int32_t real; uint32_t base; } u_right_encoder; u_right_encoder.base = 0; u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->right_encoder = u_right_encoder.real; offset += sizeof(this->right_encoder); union { float real; uint32_t base; } u_battery; u_battery.base = 0; u_battery.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_battery.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_battery.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_battery.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->battery = u_battery.real; offset += sizeof(this->battery); return offset; } const char * getType(){ return "turtlebot3_msgs/SensorState"; }; const char * getMD5(){ return "7250c1dc0b61c4190e78f528f599285f"; }; }; } #endif

C

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

#ifndef _ROS_turtlebot3_msgs_Sound_h #define _ROS_turtlebot3_msgs_Sound_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlebot3_msgs { class Sound : public ros::Msg { public: typedef uint8_t _value_type; _value_type value; enum { OFF = 0 }; enum { ON = 1 }; enum { LOW_BATTERY = 2 }; enum { ERROR = 3 }; enum { BUTTON1 = 4 }; enum { BUTTON2 = 5 }; Sound(): value(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF; offset += sizeof(this->value); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->value = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->value); return offset; } const char * getType(){ return "turtlebot3_msgs/Sound"; }; const char * getMD5(){ return "e1f8c7f8a9a61383b5734fbdeca2f99a"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_JoyFeedback_h #define _ROS_sensor_msgs_JoyFeedback_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace sensor_msgs { class JoyFeedback : public ros::Msg { public: typedef uint8_t _type_type; _type_type type; typedef uint8_t _id_type; _id_type id; typedef float _intensity_type; _intensity_type intensity; enum { TYPE_LED = 0 }; enum { TYPE_RUMBLE = 1 }; enum { TYPE_BUZZER = 2 }; JoyFeedback(): type(0), id(0), intensity(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF; offset += sizeof(this->type); *(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF; offset += sizeof(this->id); union { float real; uint32_t base; } u_intensity; u_intensity.real = this->intensity; *(outbuffer + offset + 0) = (u_intensity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_intensity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_intensity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_intensity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->intensity); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->type = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->type); this->id = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->id); union { float real; uint32_t base; } u_intensity; u_intensity.base = 0; u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->intensity = u_intensity.real; offset += sizeof(this->intensity); return offset; } const char * getType(){ return "sensor_msgs/JoyFeedback"; }; const char * getMD5(){ return "f4dcd73460360d98f36e55ee7f2e46f1"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_MultiDOFJointState_h #define _ROS_sensor_msgs_MultiDOFJointState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Transform.h" #include "geometry_msgs/Twist.h" #include "geometry_msgs/Wrench.h" namespace sensor_msgs { class MultiDOFJointState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t joint_names_length; typedef char* _joint_names_type; _joint_names_type st_joint_names; _joint_names_type * joint_names; uint32_t transforms_length; typedef geometry_msgs::Transform _transforms_type; _transforms_type st_transforms; _transforms_type * transforms; uint32_t twist_length; typedef geometry_msgs::Twist _twist_type; _twist_type st_twist; _twist_type * twist; uint32_t wrench_length; typedef geometry_msgs::Wrench _wrench_type; _wrench_type st_wrench; _wrench_type * wrench; MultiDOFJointState(): header(), joint_names_length(0), joint_names(NULL), transforms_length(0), transforms(NULL), twist_length(0), twist(NULL), wrench_length(0), wrench(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->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->transforms_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF; offset += sizeof(this->transforms_length); for( uint32_t i = 0; i < transforms_length; i++){ offset += this->transforms[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF; offset += sizeof(this->twist_length); for( uint32_t i = 0; i < twist_length; i++){ offset += this->twist[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->wrench_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->wrench_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->wrench_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->wrench_length >> (8 * 3)) & 0xFF; offset += sizeof(this->wrench_length); for( uint32_t i = 0; i < wrench_length; i++){ offset += this->wrench[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t 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 transforms_lengthT = ((uint32_t) (*(inbuffer + offset))); transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->transforms_length); if(transforms_lengthT > transforms_length) this->transforms = (geometry_msgs::Transform*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::Transform)); transforms_length = transforms_lengthT; for( uint32_t i = 0; i < transforms_length; i++){ offset += this->st_transforms.deserialize(inbuffer + offset); memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::Transform)); } uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset))); twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->twist_length); if(twist_lengthT > twist_length) this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist)); twist_length = twist_lengthT; for( uint32_t i = 0; i < twist_length; i++){ offset += this->st_twist.deserialize(inbuffer + offset); memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist)); } uint32_t wrench_lengthT = ((uint32_t) (*(inbuffer + offset))); wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->wrench_length); if(wrench_lengthT > wrench_length) this->wrench = (geometry_msgs::Wrench*)realloc(this->wrench, wrench_lengthT * sizeof(geometry_msgs::Wrench)); wrench_length = wrench_lengthT; for( uint32_t i = 0; i < wrench_length; i++){ offset += this->st_wrench.deserialize(inbuffer + offset); memcpy( &(this->wrench[i]), &(this->st_wrench), sizeof(geometry_msgs::Wrench)); } return offset; } const char * getType(){ return "sensor_msgs/MultiDOFJointState"; }; const char * getMD5(){ return "690f272f0640d2631c305eeb8301e59d"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_JointState_h #define _ROS_sensor_msgs_JointState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace sensor_msgs { class JointState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t name_length; typedef char* _name_type; _name_type st_name; _name_type * name; uint32_t position_length; typedef double _position_type; _position_type st_position; _position_type * position; uint32_t velocity_length; typedef double _velocity_type; _velocity_type st_velocity; _velocity_type * velocity; uint32_t effort_length; typedef double _effort_type; _effort_type st_effort; _effort_type * effort; JointState(): header(), name_length(0), name(NULL), position_length(0), position(NULL), velocity_length(0), velocity(NULL), effort_length(0), effort(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF; offset += sizeof(this->name_length); for( uint32_t i = 0; i < name_length; i++){ uint32_t length_namei = strlen(this->name[i]); varToArr(outbuffer + offset, length_namei); offset += 4; memcpy(outbuffer + offset, this->name[i], length_namei); offset += length_namei; } *(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF; offset += sizeof(this->position_length); for( uint32_t i = 0; i < position_length; i++){ union { double real; uint64_t base; } u_positioni; u_positioni.real = this->position[i]; *(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF; offset += sizeof(this->position[i]); } *(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF; offset += sizeof(this->velocity_length); for( uint32_t i = 0; i < velocity_length; i++){ union { double real; uint64_t base; } u_velocityi; u_velocityi.real = this->velocity[i]; *(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->velocity[i]); } *(outbuffer + offset + 0) = (this->effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->effort_length); for( uint32_t i = 0; i < effort_length; i++){ union { double real; uint64_t base; } u_efforti; u_efforti.real = this->effort[i]; *(outbuffer + offset + 0) = (u_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->effort[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset))); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->name_length); if(name_lengthT > name_length) this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*)); name_length = name_lengthT; for( uint32_t i = 0; i < name_length; i++){ uint32_t length_st_name; arrToVar(length_st_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_name-1]=0; this->st_name = (char *)(inbuffer + offset-1); offset += length_st_name; memcpy( &(this->name[i]), &(this->st_name), sizeof(char*)); } uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset))); position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->position_length); if(position_lengthT > position_length) this->position = (double*)realloc(this->position, position_lengthT * sizeof(double)); position_length = position_lengthT; for( uint32_t i = 0; i < position_length; i++){ union { double real; uint64_t base; } u_st_position; u_st_position.base = 0; u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_position = u_st_position.real; offset += sizeof(this->st_position); memcpy( &(this->position[i]), &(this->st_position), sizeof(double)); } uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset))); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->velocity_length); if(velocity_lengthT > velocity_length) this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double)); velocity_length = velocity_lengthT; for( uint32_t i = 0; i < velocity_length; i++){ union { double real; uint64_t base; } u_st_velocity; u_st_velocity.base = 0; u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_velocity = u_st_velocity.real; offset += sizeof(this->st_velocity); memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double)); } uint32_t effort_lengthT = ((uint32_t) (*(inbuffer + offset))); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->effort_length); if(effort_lengthT > effort_length) this->effort = (double*)realloc(this->effort, effort_lengthT * sizeof(double)); effort_length = effort_lengthT; for( uint32_t i = 0; i < effort_length; i++){ union { double real; uint64_t base; } u_st_effort; u_st_effort.base = 0; u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_effort = u_st_effort.real; offset += sizeof(this->st_effort); memcpy( &(this->effort[i]), &(this->st_effort), sizeof(double)); } return offset; } const char * getType(){ return "sensor_msgs/JointState"; }; const char * getMD5(){ return "3066dcd76a6cfaef579bd0f34173e9fd"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_Temperature_h #define _ROS_sensor_msgs_Temperature_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace sensor_msgs { class Temperature : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef double _temperature_type; _temperature_type temperature; typedef double _variance_type; _variance_type variance; Temperature(): header(), temperature(0), variance(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { double real; uint64_t base; } u_temperature; u_temperature.real = this->temperature; *(outbuffer + offset + 0) = (u_temperature.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_temperature.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_temperature.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_temperature.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_temperature.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_temperature.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_temperature.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_temperature.base >> (8 * 7)) & 0xFF; offset += sizeof(this->temperature); union { double real; uint64_t base; } u_variance; u_variance.real = this->variance; *(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF; offset += sizeof(this->variance); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_temperature; u_temperature.base = 0; u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->temperature = u_temperature.real; offset += sizeof(this->temperature); union { double real; uint64_t base; } u_variance; u_variance.base = 0; u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->variance = u_variance.real; offset += sizeof(this->variance); return offset; } const char * getType(){ return "sensor_msgs/Temperature"; }; const char * getMD5(){ return "ff71b307acdbe7c871a5a6d7ed359100"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_TimeReference_h #define _ROS_sensor_msgs_TimeReference_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "ros/time.h" namespace sensor_msgs { class TimeReference : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef ros::Time _time_ref_type; _time_ref_type time_ref; typedef const char* _source_type; _source_type source; TimeReference(): header(), time_ref(), source("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->time_ref.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time_ref.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time_ref.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time_ref.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time_ref.sec); *(outbuffer + offset + 0) = (this->time_ref.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time_ref.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time_ref.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time_ref.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time_ref.nsec); uint32_t length_source = strlen(this->source); varToArr(outbuffer + offset, length_source); offset += 4; memcpy(outbuffer + offset, this->source, length_source); offset += length_source; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); this->time_ref.sec = ((uint32_t) (*(inbuffer + offset))); this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time_ref.sec); this->time_ref.nsec = ((uint32_t) (*(inbuffer + offset))); this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time_ref.nsec); uint32_t length_source; arrToVar(length_source, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_source; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_source-1]=0; this->source = (char *)(inbuffer + offset-1); offset += length_source; return offset; } const char * getType(){ return "sensor_msgs/TimeReference"; }; const char * getMD5(){ return "fded64a0265108ba86c3d38fb11c0c16"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_MultiEchoLaserScan_h #define _ROS_sensor_msgs_MultiEchoLaserScan_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "sensor_msgs/LaserEcho.h" namespace sensor_msgs { class MultiEchoLaserScan : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef float _angle_min_type; _angle_min_type angle_min; typedef float _angle_max_type; _angle_max_type angle_max; typedef float _angle_increment_type; _angle_increment_type angle_increment; typedef float _time_increment_type; _time_increment_type time_increment; typedef float _scan_time_type; _scan_time_type scan_time; typedef float _range_min_type; _range_min_type range_min; typedef float _range_max_type; _range_max_type range_max; uint32_t ranges_length; typedef sensor_msgs::LaserEcho _ranges_type; _ranges_type st_ranges; _ranges_type * ranges; uint32_t intensities_length; typedef sensor_msgs::LaserEcho _intensities_type; _intensities_type st_intensities; _intensities_type * intensities; MultiEchoLaserScan(): header(), angle_min(0), angle_max(0), angle_increment(0), time_increment(0), scan_time(0), range_min(0), range_max(0), ranges_length(0), ranges(NULL), intensities_length(0), intensities(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { float real; uint32_t base; } u_angle_min; u_angle_min.real = this->angle_min; *(outbuffer + offset + 0) = (u_angle_min.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_angle_min.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_angle_min.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_angle_min.base >> (8 * 3)) & 0xFF; offset += sizeof(this->angle_min); union { float real; uint32_t base; } u_angle_max; u_angle_max.real = this->angle_max; *(outbuffer + offset + 0) = (u_angle_max.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_angle_max.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_angle_max.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_angle_max.base >> (8 * 3)) & 0xFF; offset += sizeof(this->angle_max); union { float real; uint32_t base; } u_angle_increment; u_angle_increment.real = this->angle_increment; *(outbuffer + offset + 0) = (u_angle_increment.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_angle_increment.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_angle_increment.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_angle_increment.base >> (8 * 3)) & 0xFF; offset += sizeof(this->angle_increment); union { float real; uint32_t base; } u_time_increment; u_time_increment.real = this->time_increment; *(outbuffer + offset + 0) = (u_time_increment.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_time_increment.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_time_increment.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_time_increment.base >> (8 * 3)) & 0xFF; offset += sizeof(this->time_increment); union { float real; uint32_t base; } u_scan_time; u_scan_time.real = this->scan_time; *(outbuffer + offset + 0) = (u_scan_time.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_scan_time.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_scan_time.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_scan_time.base >> (8 * 3)) & 0xFF; offset += sizeof(this->scan_time); union { float real; uint32_t base; } u_range_min; u_range_min.real = this->range_min; *(outbuffer + offset + 0) = (u_range_min.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_range_min.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_range_min.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_range_min.base >> (8 * 3)) & 0xFF; offset += sizeof(this->range_min); union { float real; uint32_t base; } u_range_max; u_range_max.real = this->range_max; *(outbuffer + offset + 0) = (u_range_max.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_range_max.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_range_max.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_range_max.base >> (8 * 3)) & 0xFF; offset += sizeof(this->range_max); *(outbuffer + offset + 0) = (this->ranges_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->ranges_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->ranges_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->ranges_length >> (8 * 3)) & 0xFF; offset += sizeof(this->ranges_length); for( uint32_t i = 0; i < ranges_length; i++){ offset += this->ranges[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->intensities_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->intensities_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->intensities_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->intensities_length >> (8 * 3)) & 0xFF; offset += sizeof(this->intensities_length); for( uint32_t i = 0; i < intensities_length; i++){ offset += this->intensities[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { float real; uint32_t base; } u_angle_min; u_angle_min.base = 0; u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->angle_min = u_angle_min.real; offset += sizeof(this->angle_min); union { float real; uint32_t base; } u_angle_max; u_angle_max.base = 0; u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->angle_max = u_angle_max.real; offset += sizeof(this->angle_max); union { float real; uint32_t base; } u_angle_increment; u_angle_increment.base = 0; u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->angle_increment = u_angle_increment.real; offset += sizeof(this->angle_increment); union { float real; uint32_t base; } u_time_increment; u_time_increment.base = 0; u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->time_increment = u_time_increment.real; offset += sizeof(this->time_increment); union { float real; uint32_t base; } u_scan_time; u_scan_time.base = 0; u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->scan_time = u_scan_time.real; offset += sizeof(this->scan_time); union { float real; uint32_t base; } u_range_min; u_range_min.base = 0; u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->range_min = u_range_min.real; offset += sizeof(this->range_min); union { float real; uint32_t base; } u_range_max; u_range_max.base = 0; u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->range_max = u_range_max.real; offset += sizeof(this->range_max); uint32_t ranges_lengthT = ((uint32_t) (*(inbuffer + offset))); ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->ranges_length); if(ranges_lengthT > ranges_length) this->ranges = (sensor_msgs::LaserEcho*)realloc(this->ranges, ranges_lengthT * sizeof(sensor_msgs::LaserEcho)); ranges_length = ranges_lengthT; for( uint32_t i = 0; i < ranges_length; i++){ offset += this->st_ranges.deserialize(inbuffer + offset); memcpy( &(this->ranges[i]), &(this->st_ranges), sizeof(sensor_msgs::LaserEcho)); } uint32_t intensities_lengthT = ((uint32_t) (*(inbuffer + offset))); intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->intensities_length); if(intensities_lengthT > intensities_length) this->intensities = (sensor_msgs::LaserEcho*)realloc(this->intensities, intensities_lengthT * sizeof(sensor_msgs::LaserEcho)); intensities_length = intensities_lengthT; for( uint32_t i = 0; i < intensities_length; i++){ offset += this->st_intensities.deserialize(inbuffer + offset); memcpy( &(this->intensities[i]), &(this->st_intensities), sizeof(sensor_msgs::LaserEcho)); } return offset; } const char * getType(){ return "sensor_msgs/MultiEchoLaserScan"; }; const char * getMD5(){ return "6fefb0c6da89d7c8abe4b339f5c2f8fb"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_SetCameraInfo_h #define _ROS_SERVICE_SetCameraInfo_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "sensor_msgs/CameraInfo.h" namespace sensor_msgs { static const char SETCAMERAINFO[] = "sensor_msgs/SetCameraInfo"; class SetCameraInfoRequest : public ros::Msg { public: typedef sensor_msgs::CameraInfo _camera_info_type; _camera_info_type camera_info; SetCameraInfoRequest(): camera_info() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->camera_info.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->camera_info.deserialize(inbuffer + offset); return offset; } const char * getType(){ return SETCAMERAINFO; }; const char * getMD5(){ return "ee34be01fdeee563d0d99cd594d5581d"; }; }; class SetCameraInfoResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; typedef const char* _status_message_type; _status_message_type status_message; SetCameraInfoResponse(): success(0), status_message("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.real = this->success; *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; offset += sizeof(this->success); uint32_t length_status_message = strlen(this->status_message); varToArr(outbuffer + offset, length_status_message); offset += 4; memcpy(outbuffer + offset, this->status_message, length_status_message); offset += length_status_message; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.base = 0; u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->success = u_success.real; offset += sizeof(this->success); uint32_t length_status_message; arrToVar(length_status_message, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_status_message; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_status_message-1]=0; this->status_message = (char *)(inbuffer + offset-1); offset += length_status_message; return offset; } const char * getType(){ return SETCAMERAINFO; }; const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; }; }; class SetCameraInfo { public: typedef SetCameraInfoRequest Request; typedef SetCameraInfoResponse Response; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_NavSatFix_h #define _ROS_sensor_msgs_NavSatFix_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "sensor_msgs/NavSatStatus.h" namespace sensor_msgs { class NavSatFix : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef sensor_msgs::NavSatStatus _status_type; _status_type status; typedef double _latitude_type; _latitude_type latitude; typedef double _longitude_type; _longitude_type longitude; typedef double _altitude_type; _altitude_type altitude; double position_covariance[9]; typedef uint8_t _position_covariance_type_type; _position_covariance_type_type position_covariance_type; enum { COVARIANCE_TYPE_UNKNOWN = 0 }; enum { COVARIANCE_TYPE_APPROXIMATED = 1 }; enum { COVARIANCE_TYPE_DIAGONAL_KNOWN = 2 }; enum { COVARIANCE_TYPE_KNOWN = 3 }; NavSatFix(): header(), status(), latitude(0), longitude(0), altitude(0), position_covariance(), position_covariance_type(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->status.serialize(outbuffer + offset); union { double real; uint64_t base; } u_latitude; u_latitude.real = this->latitude; *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF; offset += sizeof(this->latitude); union { double real; uint64_t base; } u_longitude; u_longitude.real = this->longitude; *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF; offset += sizeof(this->longitude); union { double real; uint64_t base; } u_altitude; u_altitude.real = this->altitude; *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_altitude.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_altitude.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_altitude.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_altitude.base >> (8 * 7)) & 0xFF; offset += sizeof(this->altitude); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_position_covariancei; u_position_covariancei.real = this->position_covariance[i]; *(outbuffer + offset + 0) = (u_position_covariancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_position_covariancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_position_covariancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_position_covariancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_position_covariancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_position_covariancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_position_covariancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_position_covariancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->position_covariance[i]); } *(outbuffer + offset + 0) = (this->position_covariance_type >> (8 * 0)) & 0xFF; offset += sizeof(this->position_covariance_type); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->status.deserialize(inbuffer + offset); union { double real; uint64_t base; } u_latitude; u_latitude.base = 0; u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->latitude = u_latitude.real; offset += sizeof(this->latitude); union { double real; uint64_t base; } u_longitude; u_longitude.base = 0; u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->longitude = u_longitude.real; offset += sizeof(this->longitude); union { double real; uint64_t base; } u_altitude; u_altitude.base = 0; u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->altitude = u_altitude.real; offset += sizeof(this->altitude); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_position_covariancei; u_position_covariancei.base = 0; u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->position_covariance[i] = u_position_covariancei.real; offset += sizeof(this->position_covariance[i]); } this->position_covariance_type = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->position_covariance_type); return offset; } const char * getType(){ return "sensor_msgs/NavSatFix"; }; const char * getMD5(){ return "2d3a8cd499b9b4a0249fb98fd05cfa48"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_PointCloud2_h #define _ROS_sensor_msgs_PointCloud2_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "sensor_msgs/PointField.h" namespace sensor_msgs { class PointCloud2 : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef uint32_t _height_type; _height_type height; typedef uint32_t _width_type; _width_type width; uint32_t fields_length; typedef sensor_msgs::PointField _fields_type; _fields_type st_fields; _fields_type * fields; typedef bool _is_bigendian_type; _is_bigendian_type is_bigendian; typedef uint32_t _point_step_type; _point_step_type point_step; typedef uint32_t _row_step_type; _row_step_type row_step; uint32_t data_length; typedef uint8_t _data_type; _data_type st_data; _data_type * data; typedef bool _is_dense_type; _is_dense_type is_dense; PointCloud2(): header(), height(0), width(0), fields_length(0), fields(NULL), is_bigendian(0), point_step(0), row_step(0), data_length(0), data(NULL), is_dense(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF; offset += sizeof(this->height); *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF; offset += sizeof(this->width); *(outbuffer + offset + 0) = (this->fields_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->fields_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->fields_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->fields_length >> (8 * 3)) & 0xFF; offset += sizeof(this->fields_length); for( uint32_t i = 0; i < fields_length; i++){ offset += this->fields[i].serialize(outbuffer + offset); } union { bool real; uint8_t base; } u_is_bigendian; u_is_bigendian.real = this->is_bigendian; *(outbuffer + offset + 0) = (u_is_bigendian.base >> (8 * 0)) & 0xFF; offset += sizeof(this->is_bigendian); *(outbuffer + offset + 0) = (this->point_step >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->point_step >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->point_step >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->point_step >> (8 * 3)) & 0xFF; offset += sizeof(this->point_step); *(outbuffer + offset + 0) = (this->row_step >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->row_step >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->row_step >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->row_step >> (8 * 3)) & 0xFF; offset += sizeof(this->row_step); *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF; offset += sizeof(this->data_length); for( uint32_t i = 0; i < data_length; i++){ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF; offset += sizeof(this->data[i]); } union { bool real; uint8_t base; } u_is_dense; u_is_dense.real = this->is_dense; *(outbuffer + offset + 0) = (u_is_dense.base >> (8 * 0)) & 0xFF; offset += sizeof(this->is_dense); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); this->height = ((uint32_t) (*(inbuffer + offset))); this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->height); this->width = ((uint32_t) (*(inbuffer + offset))); this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->width); uint32_t fields_lengthT = ((uint32_t) (*(inbuffer + offset))); fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->fields_length); if(fields_lengthT > fields_length) this->fields = (sensor_msgs::PointField*)realloc(this->fields, fields_lengthT * sizeof(sensor_msgs::PointField)); fields_length = fields_lengthT; for( uint32_t i = 0; i < fields_length; i++){ offset += this->st_fields.deserialize(inbuffer + offset); memcpy( &(this->fields[i]), &(this->st_fields), sizeof(sensor_msgs::PointField)); } union { bool real; uint8_t base; } u_is_bigendian; u_is_bigendian.base = 0; u_is_bigendian.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->is_bigendian = u_is_bigendian.real; offset += sizeof(this->is_bigendian); this->point_step = ((uint32_t) (*(inbuffer + offset))); this->point_step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->point_step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->point_step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->point_step); this->row_step = ((uint32_t) (*(inbuffer + offset))); this->row_step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->row_step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->row_step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->row_step); uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset))); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data_length); if(data_lengthT > data_length) this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t)); data_length = data_lengthT; for( uint32_t i = 0; i < data_length; i++){ this->st_data = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->st_data); memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t)); } union { bool real; uint8_t base; } u_is_dense; u_is_dense.base = 0; u_is_dense.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->is_dense = u_is_dense.real; offset += sizeof(this->is_dense); return offset; } const char * getType(){ return "sensor_msgs/PointCloud2"; }; const char * getMD5(){ return "1158d486dd51d683ce2f1be655c3c181"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_Imu_h #define _ROS_sensor_msgs_Imu_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Quaternion.h" #include "geometry_msgs/Vector3.h" namespace sensor_msgs { class Imu : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef geometry_msgs::Quaternion _orientation_type; _orientation_type orientation; double orientation_covariance[9]; typedef geometry_msgs::Vector3 _angular_velocity_type; _angular_velocity_type angular_velocity; double angular_velocity_covariance[9]; typedef geometry_msgs::Vector3 _linear_acceleration_type; _linear_acceleration_type linear_acceleration; double linear_acceleration_covariance[9]; Imu(): header(), orientation(), orientation_covariance(), angular_velocity(), angular_velocity_covariance(), linear_acceleration(), linear_acceleration_covariance() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->orientation.serialize(outbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_orientation_covariancei; u_orientation_covariancei.real = this->orientation_covariance[i]; *(outbuffer + offset + 0) = (u_orientation_covariancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_orientation_covariancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_orientation_covariancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_orientation_covariancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_orientation_covariancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_orientation_covariancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_orientation_covariancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_orientation_covariancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->orientation_covariance[i]); } offset += this->angular_velocity.serialize(outbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_angular_velocity_covariancei; u_angular_velocity_covariancei.real = this->angular_velocity_covariance[i]; *(outbuffer + offset + 0) = (u_angular_velocity_covariancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_angular_velocity_covariancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_angular_velocity_covariancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_angular_velocity_covariancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_angular_velocity_covariancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_angular_velocity_covariancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_angular_velocity_covariancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_angular_velocity_covariancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->angular_velocity_covariance[i]); } offset += this->linear_acceleration.serialize(outbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_linear_acceleration_covariancei; u_linear_acceleration_covariancei.real = this->linear_acceleration_covariance[i]; *(outbuffer + offset + 0) = (u_linear_acceleration_covariancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_linear_acceleration_covariancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_linear_acceleration_covariancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_linear_acceleration_covariancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_linear_acceleration_covariancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_linear_acceleration_covariancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_linear_acceleration_covariancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_linear_acceleration_covariancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->linear_acceleration_covariance[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->orientation.deserialize(inbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_orientation_covariancei; u_orientation_covariancei.base = 0; u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->orientation_covariance[i] = u_orientation_covariancei.real; offset += sizeof(this->orientation_covariance[i]); } offset += this->angular_velocity.deserialize(inbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_angular_velocity_covariancei; u_angular_velocity_covariancei.base = 0; u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->angular_velocity_covariance[i] = u_angular_velocity_covariancei.real; offset += sizeof(this->angular_velocity_covariance[i]); } offset += this->linear_acceleration.deserialize(inbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_linear_acceleration_covariancei; u_linear_acceleration_covariancei.base = 0; u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->linear_acceleration_covariance[i] = u_linear_acceleration_covariancei.real; offset += sizeof(this->linear_acceleration_covariance[i]); } return offset; } const char * getType(){ return "sensor_msgs/Imu"; }; const char * getMD5(){ return "6a62c6daae103f4ff57a132d6f95cec2"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_CompressedImage_h #define _ROS_sensor_msgs_CompressedImage_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace sensor_msgs { class CompressedImage : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef const char* _format_type; _format_type format; uint32_t data_length; typedef uint8_t _data_type; _data_type st_data; _data_type * data; CompressedImage(): header(), format(""), data_length(0), data(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); uint32_t length_format = strlen(this->format); varToArr(outbuffer + offset, length_format); offset += 4; memcpy(outbuffer + offset, this->format, length_format); offset += length_format; *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF; offset += sizeof(this->data_length); for( uint32_t i = 0; i < data_length; i++){ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF; offset += sizeof(this->data[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t length_format; arrToVar(length_format, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_format; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_format-1]=0; this->format = (char *)(inbuffer + offset-1); offset += length_format; uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset))); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data_length); if(data_lengthT > data_length) this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t)); data_length = data_lengthT; for( uint32_t i = 0; i < data_length; i++){ this->st_data = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->st_data); memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t)); } return offset; } const char * getType(){ return "sensor_msgs/CompressedImage"; }; const char * getMD5(){ return "8f7a12909da2c9d3332d540a0977563f"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_PointCloud_h #define _ROS_sensor_msgs_PointCloud_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Point32.h" #include "sensor_msgs/ChannelFloat32.h" namespace sensor_msgs { class PointCloud : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t points_length; typedef geometry_msgs::Point32 _points_type; _points_type st_points; _points_type * points; uint32_t channels_length; typedef sensor_msgs::ChannelFloat32 _channels_type; _channels_type st_channels; _channels_type * channels; PointCloud(): header(), points_length(0), points(NULL), channels_length(0), channels(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF; offset += sizeof(this->points_length); for( uint32_t i = 0; i < points_length; i++){ offset += this->points[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->channels_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->channels_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->channels_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->channels_length >> (8 * 3)) & 0xFF; offset += sizeof(this->channels_length); for( uint32_t i = 0; i < channels_length; i++){ offset += this->channels[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset))); points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->points_length); if(points_lengthT > points_length) this->points = (geometry_msgs::Point32*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point32)); points_length = points_lengthT; for( uint32_t i = 0; i < points_length; i++){ offset += this->st_points.deserialize(inbuffer + offset); memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point32)); } uint32_t channels_lengthT = ((uint32_t) (*(inbuffer + offset))); channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->channels_length); if(channels_lengthT > channels_length) this->channels = (sensor_msgs::ChannelFloat32*)realloc(this->channels, channels_lengthT * sizeof(sensor_msgs::ChannelFloat32)); channels_length = channels_lengthT; for( uint32_t i = 0; i < channels_length; i++){ offset += this->st_channels.deserialize(inbuffer + offset); memcpy( &(this->channels[i]), &(this->st_channels), sizeof(sensor_msgs::ChannelFloat32)); } return offset; } const char * getType(){ return "sensor_msgs/PointCloud"; }; const char * getMD5(){ return "d8e9c3f5afbdd8a130fd1d2763945fca"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_Image_h #define _ROS_sensor_msgs_Image_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace sensor_msgs { class Image : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef uint32_t _height_type; _height_type height; typedef uint32_t _width_type; _width_type width; typedef const char* _encoding_type; _encoding_type encoding; typedef uint8_t _is_bigendian_type; _is_bigendian_type is_bigendian; typedef uint32_t _step_type; _step_type step; uint32_t data_length; typedef uint8_t _data_type; _data_type st_data; _data_type * data; Image(): header(), height(0), width(0), encoding(""), is_bigendian(0), step(0), data_length(0), data(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF; offset += sizeof(this->height); *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF; offset += sizeof(this->width); uint32_t length_encoding = strlen(this->encoding); varToArr(outbuffer + offset, length_encoding); offset += 4; memcpy(outbuffer + offset, this->encoding, length_encoding); offset += length_encoding; *(outbuffer + offset + 0) = (this->is_bigendian >> (8 * 0)) & 0xFF; offset += sizeof(this->is_bigendian); *(outbuffer + offset + 0) = (this->step >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->step >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->step >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->step >> (8 * 3)) & 0xFF; offset += sizeof(this->step); *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF; offset += sizeof(this->data_length); for( uint32_t i = 0; i < data_length; i++){ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF; offset += sizeof(this->data[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); this->height = ((uint32_t) (*(inbuffer + offset))); this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->height); this->width = ((uint32_t) (*(inbuffer + offset))); this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->width); uint32_t length_encoding; arrToVar(length_encoding, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_encoding; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_encoding-1]=0; this->encoding = (char *)(inbuffer + offset-1); offset += length_encoding; this->is_bigendian = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->is_bigendian); this->step = ((uint32_t) (*(inbuffer + offset))); this->step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->step); uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset))); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data_length); if(data_lengthT > data_length) this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t)); data_length = data_lengthT; for( uint32_t i = 0; i < data_length; i++){ this->st_data = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->st_data); memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t)); } return offset; } const char * getType(){ return "sensor_msgs/Image"; }; const char * getMD5(){ return "060021388200f6f0f447d0fcd9c64743"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_Range_h #define _ROS_sensor_msgs_Range_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace sensor_msgs { class Range : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef uint8_t _radiation_type_type; _radiation_type_type radiation_type; typedef float _field_of_view_type; _field_of_view_type field_of_view; typedef float _min_range_type; _min_range_type min_range; typedef float _max_range_type; _max_range_type max_range; typedef float _range_type; _range_type range; enum { ULTRASOUND = 0 }; enum { INFRARED = 1 }; Range(): header(), radiation_type(0), field_of_view(0), min_range(0), max_range(0), range(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->radiation_type >> (8 * 0)) & 0xFF; offset += sizeof(this->radiation_type); union { float real; uint32_t base; } u_field_of_view; u_field_of_view.real = this->field_of_view; *(outbuffer + offset + 0) = (u_field_of_view.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_field_of_view.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_field_of_view.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_field_of_view.base >> (8 * 3)) & 0xFF; offset += sizeof(this->field_of_view); union { float real; uint32_t base; } u_min_range; u_min_range.real = this->min_range; *(outbuffer + offset + 0) = (u_min_range.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_min_range.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_min_range.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_min_range.base >> (8 * 3)) & 0xFF; offset += sizeof(this->min_range); union { float real; uint32_t base; } u_max_range; u_max_range.real = this->max_range; *(outbuffer + offset + 0) = (u_max_range.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_max_range.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_max_range.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_max_range.base >> (8 * 3)) & 0xFF; offset += sizeof(this->max_range); union { float real; uint32_t base; } u_range; u_range.real = this->range; *(outbuffer + offset + 0) = (u_range.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_range.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_range.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_range.base >> (8 * 3)) & 0xFF; offset += sizeof(this->range); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); this->radiation_type = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->radiation_type); union { float real; uint32_t base; } u_field_of_view; u_field_of_view.base = 0; u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->field_of_view = u_field_of_view.real; offset += sizeof(this->field_of_view); union { float real; uint32_t base; } u_min_range; u_min_range.base = 0; u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->min_range = u_min_range.real; offset += sizeof(this->min_range); union { float real; uint32_t base; } u_max_range; u_max_range.base = 0; u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->max_range = u_max_range.real; offset += sizeof(this->max_range); union { float real; uint32_t base; } u_range; u_range.base = 0; u_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->range = u_range.real; offset += sizeof(this->range); return offset; } const char * getType(){ return "sensor_msgs/Range"; }; const char * getMD5(){ return "c005c34273dc426c67a020a87bc24148"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_BatteryState_h #define _ROS_sensor_msgs_BatteryState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace sensor_msgs { class BatteryState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef float _voltage_type; _voltage_type voltage; typedef float _current_type; _current_type current; typedef float _charge_type; _charge_type charge; typedef float _capacity_type; _capacity_type capacity; typedef float _design_capacity_type; _design_capacity_type design_capacity; typedef float _percentage_type; _percentage_type percentage; typedef uint8_t _power_supply_status_type; _power_supply_status_type power_supply_status; typedef uint8_t _power_supply_health_type; _power_supply_health_type power_supply_health; typedef uint8_t _power_supply_technology_type; _power_supply_technology_type power_supply_technology; typedef bool _present_type; _present_type present; uint32_t cell_voltage_length; typedef float _cell_voltage_type; _cell_voltage_type st_cell_voltage; _cell_voltage_type * cell_voltage; typedef const char* _location_type; _location_type location; typedef const char* _serial_number_type; _serial_number_type serial_number; enum { POWER_SUPPLY_STATUS_UNKNOWN = 0 }; enum { POWER_SUPPLY_STATUS_CHARGING = 1 }; enum { POWER_SUPPLY_STATUS_DISCHARGING = 2 }; enum { POWER_SUPPLY_STATUS_NOT_CHARGING = 3 }; enum { POWER_SUPPLY_STATUS_FULL = 4 }; enum { POWER_SUPPLY_HEALTH_UNKNOWN = 0 }; enum { POWER_SUPPLY_HEALTH_GOOD = 1 }; enum { POWER_SUPPLY_HEALTH_OVERHEAT = 2 }; enum { POWER_SUPPLY_HEALTH_DEAD = 3 }; enum { POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4 }; enum { POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5 }; enum { POWER_SUPPLY_HEALTH_COLD = 6 }; enum { POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7 }; enum { POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8 }; enum { POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0 }; enum { POWER_SUPPLY_TECHNOLOGY_NIMH = 1 }; enum { POWER_SUPPLY_TECHNOLOGY_LION = 2 }; enum { POWER_SUPPLY_TECHNOLOGY_LIPO = 3 }; enum { POWER_SUPPLY_TECHNOLOGY_LIFE = 4 }; enum { POWER_SUPPLY_TECHNOLOGY_NICD = 5 }; enum { POWER_SUPPLY_TECHNOLOGY_LIMN = 6 }; BatteryState(): header(), voltage(0), current(0), charge(0), capacity(0), design_capacity(0), percentage(0), power_supply_status(0), power_supply_health(0), power_supply_technology(0), present(0), cell_voltage_length(0), cell_voltage(NULL), location(""), serial_number("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { float real; uint32_t base; } u_voltage; u_voltage.real = this->voltage; *(outbuffer + offset + 0) = (u_voltage.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_voltage.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_voltage.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_voltage.base >> (8 * 3)) & 0xFF; offset += sizeof(this->voltage); union { float real; uint32_t base; } u_current; u_current.real = this->current; *(outbuffer + offset + 0) = (u_current.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_current.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_current.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_current.base >> (8 * 3)) & 0xFF; offset += sizeof(this->current); union { float real; uint32_t base; } u_charge; u_charge.real = this->charge; *(outbuffer + offset + 0) = (u_charge.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_charge.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_charge.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_charge.base >> (8 * 3)) & 0xFF; offset += sizeof(this->charge); union { float real; uint32_t base; } u_capacity; u_capacity.real = this->capacity; *(outbuffer + offset + 0) = (u_capacity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_capacity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_capacity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_capacity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->capacity); union { float real; uint32_t base; } u_design_capacity; u_design_capacity.real = this->design_capacity; *(outbuffer + offset + 0) = (u_design_capacity.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_design_capacity.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_design_capacity.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_design_capacity.base >> (8 * 3)) & 0xFF; offset += sizeof(this->design_capacity); union { float real; uint32_t base; } u_percentage; u_percentage.real = this->percentage; *(outbuffer + offset + 0) = (u_percentage.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_percentage.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_percentage.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_percentage.base >> (8 * 3)) & 0xFF; offset += sizeof(this->percentage); *(outbuffer + offset + 0) = (this->power_supply_status >> (8 * 0)) & 0xFF; offset += sizeof(this->power_supply_status); *(outbuffer + offset + 0) = (this->power_supply_health >> (8 * 0)) & 0xFF; offset += sizeof(this->power_supply_health); *(outbuffer + offset + 0) = (this->power_supply_technology >> (8 * 0)) & 0xFF; offset += sizeof(this->power_supply_technology); union { bool real; uint8_t base; } u_present; u_present.real = this->present; *(outbuffer + offset + 0) = (u_present.base >> (8 * 0)) & 0xFF; offset += sizeof(this->present); *(outbuffer + offset + 0) = (this->cell_voltage_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->cell_voltage_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->cell_voltage_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->cell_voltage_length >> (8 * 3)) & 0xFF; offset += sizeof(this->cell_voltage_length); for( uint32_t i = 0; i < cell_voltage_length; i++){ union { float real; uint32_t base; } u_cell_voltagei; u_cell_voltagei.real = this->cell_voltage[i]; *(outbuffer + offset + 0) = (u_cell_voltagei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_cell_voltagei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_cell_voltagei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_cell_voltagei.base >> (8 * 3)) & 0xFF; offset += sizeof(this->cell_voltage[i]); } uint32_t length_location = strlen(this->location); varToArr(outbuffer + offset, length_location); offset += 4; memcpy(outbuffer + offset, this->location, length_location); offset += length_location; 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; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { float real; uint32_t base; } u_voltage; u_voltage.base = 0; u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->voltage = u_voltage.real; offset += sizeof(this->voltage); union { float real; uint32_t base; } u_current; u_current.base = 0; u_current.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_current.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_current.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_current.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->current = u_current.real; offset += sizeof(this->current); union { float real; uint32_t base; } u_charge; u_charge.base = 0; u_charge.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_charge.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_charge.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_charge.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->charge = u_charge.real; offset += sizeof(this->charge); union { float real; uint32_t base; } u_capacity; u_capacity.base = 0; u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->capacity = u_capacity.real; offset += sizeof(this->capacity); union { float real; uint32_t base; } u_design_capacity; u_design_capacity.base = 0; u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->design_capacity = u_design_capacity.real; offset += sizeof(this->design_capacity); union { float real; uint32_t base; } u_percentage; u_percentage.base = 0; u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->percentage = u_percentage.real; offset += sizeof(this->percentage); this->power_supply_status = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->power_supply_status); this->power_supply_health = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->power_supply_health); this->power_supply_technology = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->power_supply_technology); union { bool real; uint8_t base; } u_present; u_present.base = 0; u_present.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->present = u_present.real; offset += sizeof(this->present); uint32_t cell_voltage_lengthT = ((uint32_t) (*(inbuffer + offset))); cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->cell_voltage_length); if(cell_voltage_lengthT > cell_voltage_length) this->cell_voltage = (float*)realloc(this->cell_voltage, cell_voltage_lengthT * sizeof(float)); cell_voltage_length = cell_voltage_lengthT; for( uint32_t i = 0; i < cell_voltage_length; i++){ union { float real; uint32_t base; } u_st_cell_voltage; u_st_cell_voltage.base = 0; u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_cell_voltage = u_st_cell_voltage.real; offset += sizeof(this->st_cell_voltage); memcpy( &(this->cell_voltage[i]), &(this->st_cell_voltage), sizeof(float)); } uint32_t length_location; arrToVar(length_location, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_location; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_location-1]=0; this->location = (char *)(inbuffer + offset-1); offset += length_location; 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; return offset; } const char * getType(){ return "sensor_msgs/BatteryState"; }; const char * getMD5(){ return "476f837fa6771f6e16e3bf4ef96f8770"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_CameraInfo_h #define _ROS_sensor_msgs_CameraInfo_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "sensor_msgs/RegionOfInterest.h" namespace sensor_msgs { class CameraInfo : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef uint32_t _height_type; _height_type height; typedef uint32_t _width_type; _width_type width; typedef const char* _distortion_model_type; _distortion_model_type distortion_model; uint32_t D_length; typedef double _D_type; _D_type st_D; _D_type * D; double K[9]; double R[9]; double P[12]; typedef uint32_t _binning_x_type; _binning_x_type binning_x; typedef uint32_t _binning_y_type; _binning_y_type binning_y; typedef sensor_msgs::RegionOfInterest _roi_type; _roi_type roi; CameraInfo(): header(), height(0), width(0), distortion_model(""), D_length(0), D(NULL), K(), R(), P(), binning_x(0), binning_y(0), roi() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF; offset += sizeof(this->height); *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF; offset += sizeof(this->width); uint32_t length_distortion_model = strlen(this->distortion_model); varToArr(outbuffer + offset, length_distortion_model); offset += 4; memcpy(outbuffer + offset, this->distortion_model, length_distortion_model); offset += length_distortion_model; *(outbuffer + offset + 0) = (this->D_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->D_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->D_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->D_length >> (8 * 3)) & 0xFF; offset += sizeof(this->D_length); for( uint32_t i = 0; i < D_length; i++){ union { double real; uint64_t base; } u_Di; u_Di.real = this->D[i]; *(outbuffer + offset + 0) = (u_Di.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_Di.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_Di.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_Di.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_Di.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_Di.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_Di.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_Di.base >> (8 * 7)) & 0xFF; offset += sizeof(this->D[i]); } for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_Ki; u_Ki.real = this->K[i]; *(outbuffer + offset + 0) = (u_Ki.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_Ki.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_Ki.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_Ki.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_Ki.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_Ki.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_Ki.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_Ki.base >> (8 * 7)) & 0xFF; offset += sizeof(this->K[i]); } for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_Ri; u_Ri.real = this->R[i]; *(outbuffer + offset + 0) = (u_Ri.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_Ri.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_Ri.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_Ri.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_Ri.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_Ri.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_Ri.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_Ri.base >> (8 * 7)) & 0xFF; offset += sizeof(this->R[i]); } for( uint32_t i = 0; i < 12; i++){ union { double real; uint64_t base; } u_Pi; u_Pi.real = this->P[i]; *(outbuffer + offset + 0) = (u_Pi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_Pi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_Pi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_Pi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_Pi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_Pi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_Pi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_Pi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->P[i]); } *(outbuffer + offset + 0) = (this->binning_x >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->binning_x >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->binning_x >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->binning_x >> (8 * 3)) & 0xFF; offset += sizeof(this->binning_x); *(outbuffer + offset + 0) = (this->binning_y >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->binning_y >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->binning_y >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->binning_y >> (8 * 3)) & 0xFF; offset += sizeof(this->binning_y); offset += this->roi.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); this->height = ((uint32_t) (*(inbuffer + offset))); this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->height); this->width = ((uint32_t) (*(inbuffer + offset))); this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->width); uint32_t length_distortion_model; arrToVar(length_distortion_model, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_distortion_model; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_distortion_model-1]=0; this->distortion_model = (char *)(inbuffer + offset-1); offset += length_distortion_model; uint32_t D_lengthT = ((uint32_t) (*(inbuffer + offset))); D_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); D_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); D_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->D_length); if(D_lengthT > D_length) this->D = (double*)realloc(this->D, D_lengthT * sizeof(double)); D_length = D_lengthT; for( uint32_t i = 0; i < D_length; i++){ union { double real; uint64_t base; } u_st_D; u_st_D.base = 0; u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_D = u_st_D.real; offset += sizeof(this->st_D); memcpy( &(this->D[i]), &(this->st_D), sizeof(double)); } for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_Ki; u_Ki.base = 0; u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->K[i] = u_Ki.real; offset += sizeof(this->K[i]); } for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_Ri; u_Ri.base = 0; u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->R[i] = u_Ri.real; offset += sizeof(this->R[i]); } for( uint32_t i = 0; i < 12; i++){ union { double real; uint64_t base; } u_Pi; u_Pi.base = 0; u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->P[i] = u_Pi.real; offset += sizeof(this->P[i]); } this->binning_x = ((uint32_t) (*(inbuffer + offset))); this->binning_x |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->binning_x |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->binning_x |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->binning_x); this->binning_y = ((uint32_t) (*(inbuffer + offset))); this->binning_y |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->binning_y |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->binning_y |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->binning_y); offset += this->roi.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "sensor_msgs/CameraInfo"; }; const char * getMD5(){ return "c9a58c1b0b154e0e6da7578cb991d214"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_Joy_h #define _ROS_sensor_msgs_Joy_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace sensor_msgs { class Joy : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t axes_length; typedef float _axes_type; _axes_type st_axes; _axes_type * axes; uint32_t buttons_length; typedef int32_t _buttons_type; _buttons_type st_buttons; _buttons_type * buttons; Joy(): header(), axes_length(0), axes(NULL), buttons_length(0), buttons(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->axes_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->axes_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->axes_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->axes_length >> (8 * 3)) & 0xFF; offset += sizeof(this->axes_length); for( uint32_t i = 0; i < axes_length; i++){ union { float real; uint32_t base; } u_axesi; u_axesi.real = this->axes[i]; *(outbuffer + offset + 0) = (u_axesi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_axesi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_axesi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_axesi.base >> (8 * 3)) & 0xFF; offset += sizeof(this->axes[i]); } *(outbuffer + offset + 0) = (this->buttons_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->buttons_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->buttons_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->buttons_length >> (8 * 3)) & 0xFF; offset += sizeof(this->buttons_length); for( uint32_t i = 0; i < buttons_length; i++){ union { int32_t real; uint32_t base; } u_buttonsi; u_buttonsi.real = this->buttons[i]; *(outbuffer + offset + 0) = (u_buttonsi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_buttonsi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_buttonsi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_buttonsi.base >> (8 * 3)) & 0xFF; offset += sizeof(this->buttons[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t axes_lengthT = ((uint32_t) (*(inbuffer + offset))); axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->axes_length); if(axes_lengthT > axes_length) this->axes = (float*)realloc(this->axes, axes_lengthT * sizeof(float)); axes_length = axes_lengthT; for( uint32_t i = 0; i < axes_length; i++){ union { float real; uint32_t base; } u_st_axes; u_st_axes.base = 0; u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_axes = u_st_axes.real; offset += sizeof(this->st_axes); memcpy( &(this->axes[i]), &(this->st_axes), sizeof(float)); } uint32_t buttons_lengthT = ((uint32_t) (*(inbuffer + offset))); buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->buttons_length); if(buttons_lengthT > buttons_length) this->buttons = (int32_t*)realloc(this->buttons, buttons_lengthT * sizeof(int32_t)); buttons_length = buttons_lengthT; for( uint32_t i = 0; i < buttons_length; i++){ union { int32_t real; uint32_t base; } u_st_buttons; u_st_buttons.base = 0; u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_buttons = u_st_buttons.real; offset += sizeof(this->st_buttons); memcpy( &(this->buttons[i]), &(this->st_buttons), sizeof(int32_t)); } return offset; } const char * getType(){ return "sensor_msgs/Joy"; }; const char * getMD5(){ return "5a9ea5f83505693b71e785041e67a8bb"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_NavSatStatus_h #define _ROS_sensor_msgs_NavSatStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace sensor_msgs { class NavSatStatus : public ros::Msg { public: typedef int8_t _status_type; _status_type status; typedef uint16_t _service_type; _service_type service; enum { STATUS_NO_FIX = -1 }; enum { STATUS_FIX = 0 }; enum { STATUS_SBAS_FIX = 1 }; enum { STATUS_GBAS_FIX = 2 }; enum { SERVICE_GPS = 1 }; enum { SERVICE_GLONASS = 2 }; enum { SERVICE_COMPASS = 4 }; enum { SERVICE_GALILEO = 8 }; NavSatStatus(): status(0), service(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int8_t real; uint8_t base; } u_status; u_status.real = this->status; *(outbuffer + offset + 0) = (u_status.base >> (8 * 0)) & 0xFF; offset += sizeof(this->status); *(outbuffer + offset + 0) = (this->service >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->service >> (8 * 1)) & 0xFF; offset += sizeof(this->service); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int8_t real; uint8_t base; } u_status; u_status.base = 0; u_status.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->status = u_status.real; offset += sizeof(this->status); this->service = ((uint16_t) (*(inbuffer + offset))); this->service |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->service); return offset; } const char * getType(){ return "sensor_msgs/NavSatStatus"; }; const char * getMD5(){ return "331cdbddfa4bc96ffc3b9ad98900a54c"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_ChannelFloat32_h #define _ROS_sensor_msgs_ChannelFloat32_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace sensor_msgs { class ChannelFloat32 : public ros::Msg { public: typedef const char* _name_type; _name_type name; uint32_t values_length; typedef float _values_type; _values_type st_values; _values_type * values; ChannelFloat32(): name(""), values_length(0), values(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->values_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF; offset += sizeof(this->values_length); for( uint32_t i = 0; i < values_length; i++){ union { float real; uint32_t base; } u_valuesi; u_valuesi.real = this->values[i]; *(outbuffer + offset + 0) = (u_valuesi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_valuesi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_valuesi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_valuesi.base >> (8 * 3)) & 0xFF; offset += sizeof(this->values[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; 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 values_lengthT = ((uint32_t) (*(inbuffer + offset))); values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->values_length); if(values_lengthT > values_length) this->values = (float*)realloc(this->values, values_lengthT * sizeof(float)); values_length = values_lengthT; for( uint32_t i = 0; i < values_length; i++){ union { float real; uint32_t base; } u_st_values; u_st_values.base = 0; u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_values = u_st_values.real; offset += sizeof(this->st_values); memcpy( &(this->values[i]), &(this->st_values), sizeof(float)); } return offset; } const char * getType(){ return "sensor_msgs/ChannelFloat32"; }; const char * getMD5(){ return "3d40139cdd33dfedcb71ffeeeb42ae7f"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_RegionOfInterest_h #define _ROS_sensor_msgs_RegionOfInterest_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace sensor_msgs { class RegionOfInterest : public ros::Msg { public: typedef uint32_t _x_offset_type; _x_offset_type x_offset; typedef uint32_t _y_offset_type; _y_offset_type y_offset; typedef uint32_t _height_type; _height_type height; typedef uint32_t _width_type; _width_type width; typedef bool _do_rectify_type; _do_rectify_type do_rectify; RegionOfInterest(): x_offset(0), y_offset(0), height(0), width(0), do_rectify(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->x_offset >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->x_offset >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->x_offset >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->x_offset >> (8 * 3)) & 0xFF; offset += sizeof(this->x_offset); *(outbuffer + offset + 0) = (this->y_offset >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->y_offset >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->y_offset >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->y_offset >> (8 * 3)) & 0xFF; offset += sizeof(this->y_offset); *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF; offset += sizeof(this->height); *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF; offset += sizeof(this->width); union { bool real; uint8_t base; } u_do_rectify; u_do_rectify.real = this->do_rectify; *(outbuffer + offset + 0) = (u_do_rectify.base >> (8 * 0)) & 0xFF; offset += sizeof(this->do_rectify); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->x_offset = ((uint32_t) (*(inbuffer + offset))); this->x_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->x_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->x_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->x_offset); this->y_offset = ((uint32_t) (*(inbuffer + offset))); this->y_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->y_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->y_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->y_offset); this->height = ((uint32_t) (*(inbuffer + offset))); this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->height); this->width = ((uint32_t) (*(inbuffer + offset))); this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->width); union { bool real; uint8_t base; } u_do_rectify; u_do_rectify.base = 0; u_do_rectify.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->do_rectify = u_do_rectify.real; offset += sizeof(this->do_rectify); return offset; } const char * getType(){ return "sensor_msgs/RegionOfInterest"; }; const char * getMD5(){ return "bdb633039d588fcccb441a4d43ccfe09"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_MagneticField_h #define _ROS_sensor_msgs_MagneticField_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Vector3.h" namespace sensor_msgs { class MagneticField : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef geometry_msgs::Vector3 _magnetic_field_type; _magnetic_field_type magnetic_field; double magnetic_field_covariance[9]; MagneticField(): header(), magnetic_field(), magnetic_field_covariance() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->magnetic_field.serialize(outbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_magnetic_field_covariancei; u_magnetic_field_covariancei.real = this->magnetic_field_covariance[i]; *(outbuffer + offset + 0) = (u_magnetic_field_covariancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_magnetic_field_covariancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_magnetic_field_covariancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_magnetic_field_covariancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_magnetic_field_covariancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_magnetic_field_covariancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_magnetic_field_covariancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_magnetic_field_covariancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->magnetic_field_covariance[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->magnetic_field.deserialize(inbuffer + offset); for( uint32_t i = 0; i < 9; i++){ union { double real; uint64_t base; } u_magnetic_field_covariancei; u_magnetic_field_covariancei.base = 0; u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->magnetic_field_covariance[i] = u_magnetic_field_covariancei.real; offset += sizeof(this->magnetic_field_covariance[i]); } return offset; } const char * getType(){ return "sensor_msgs/MagneticField"; }; const char * getMD5(){ return "2f3b0b43eed0c9501de0fa3ff89a45aa"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_PointField_h #define _ROS_sensor_msgs_PointField_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace sensor_msgs { class PointField : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef uint32_t _offset_type; _offset_type offset; typedef uint8_t _datatype_type; _datatype_type datatype; typedef uint32_t _count_type; _count_type count; enum { INT8 = 1 }; enum { UINT8 = 2 }; enum { INT16 = 3 }; enum { UINT16 = 4 }; enum { INT32 = 5 }; enum { UINT32 = 6 }; enum { FLOAT32 = 7 }; enum { FLOAT64 = 8 }; PointField(): name(""), offset(0), datatype(0), count(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; *(outbuffer + offset + 0) = (this->offset >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->offset >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->offset >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->offset >> (8 * 3)) & 0xFF; offset += sizeof(this->offset); *(outbuffer + offset + 0) = (this->datatype >> (8 * 0)) & 0xFF; offset += sizeof(this->datatype); *(outbuffer + offset + 0) = (this->count >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->count >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->count >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->count >> (8 * 3)) & 0xFF; offset += sizeof(this->count); 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; this->offset = ((uint32_t) (*(inbuffer + offset))); this->offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->offset); this->datatype = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->datatype); this->count = ((uint32_t) (*(inbuffer + offset))); this->count |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->count |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->count |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->count); return offset; } const char * getType(){ return "sensor_msgs/PointField"; }; const char * getMD5(){ return "268eacb2962780ceac86cbd17e328150"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_JoyFeedbackArray_h #define _ROS_sensor_msgs_JoyFeedbackArray_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "sensor_msgs/JoyFeedback.h" namespace sensor_msgs { class JoyFeedbackArray : public ros::Msg { public: uint32_t array_length; typedef sensor_msgs::JoyFeedback _array_type; _array_type st_array; _array_type * array; JoyFeedbackArray(): array_length(0), array(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->array_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->array_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->array_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->array_length >> (8 * 3)) & 0xFF; offset += sizeof(this->array_length); for( uint32_t i = 0; i < array_length; i++){ offset += this->array[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t array_lengthT = ((uint32_t) (*(inbuffer + offset))); array_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); array_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); array_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->array_length); if(array_lengthT > array_length) this->array = (sensor_msgs::JoyFeedback*)realloc(this->array, array_lengthT * sizeof(sensor_msgs::JoyFeedback)); array_length = array_lengthT; for( uint32_t i = 0; i < array_length; i++){ offset += this->st_array.deserialize(inbuffer + offset); memcpy( &(this->array[i]), &(this->st_array), sizeof(sensor_msgs::JoyFeedback)); } return offset; } const char * getType(){ return "sensor_msgs/JoyFeedbackArray"; }; const char * getMD5(){ return "cde5730a895b1fc4dee6f91b754b213d"; }; }; } #endif

C

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

#ifndef _ROS_sensor_msgs_LaserEcho_h #define _ROS_sensor_msgs_LaserEcho_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace sensor_msgs { class LaserEcho : public ros::Msg { public: uint32_t echoes_length; typedef float _echoes_type; _echoes_type st_echoes; _echoes_type * echoes; LaserEcho(): echoes_length(0), echoes(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->echoes_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->echoes_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->echoes_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->echoes_length >> (8 * 3)) & 0xFF; offset += sizeof(this->echoes_length); for( uint32_t i = 0; i < echoes_length; i++){ union { float real; uint32_t base; } u_echoesi; u_echoesi.real = this->echoes[i]; *(outbuffer + offset + 0) = (u_echoesi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_echoesi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_echoesi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_echoesi.base >> (8 * 3)) & 0xFF; offset += sizeof(this->echoes[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t echoes_lengthT = ((uint32_t) (*(inbuffer + offset))); echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->echoes_length); if(echoes_lengthT > echoes_length) this->echoes = (float*)realloc(this->echoes, echoes_lengthT * sizeof(float)); echoes_length = echoes_lengthT; for( uint32_t i = 0; i < echoes_length; i++){ union { float real; uint32_t base; } u_st_echoes; u_st_echoes.base = 0; u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_echoes = u_st_echoes.real; offset += sizeof(this->st_echoes); memcpy( &(this->echoes[i]), &(this->st_echoes), sizeof(float)); } return offset; } const char * getType(){ return "sensor_msgs/LaserEcho"; }; const char * getMD5(){ return "8bc5ae449b200fba4d552b4225586696"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_TakePanorama_h #define _ROS_SERVICE_TakePanorama_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlebot3_applications_msgs { static const char TAKEPANORAMA[] = "turtlebot3_applications_msgs/TakePanorama"; class TakePanoramaRequest : public ros::Msg { public: typedef uint8_t _mode_type; _mode_type mode; typedef float _pano_angle_type; _pano_angle_type pano_angle; typedef float _snap_interval_type; _snap_interval_type snap_interval; typedef float _rot_vel_type; _rot_vel_type rot_vel; enum { SNAPANDROTATE = 0 }; enum { CONTINUOUS = 1 }; enum { STOP = 2 }; enum { STARTED = 0 }; enum { IN_PROGRESS = 1 }; enum { STOPPED = 2 }; TakePanoramaRequest(): mode(0), pano_angle(0), snap_interval(0), rot_vel(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->mode >> (8 * 0)) & 0xFF; offset += sizeof(this->mode); union { float real; uint32_t base; } u_pano_angle; u_pano_angle.real = this->pano_angle; *(outbuffer + offset + 0) = (u_pano_angle.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_pano_angle.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_pano_angle.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_pano_angle.base >> (8 * 3)) & 0xFF; offset += sizeof(this->pano_angle); union { float real; uint32_t base; } u_snap_interval; u_snap_interval.real = this->snap_interval; *(outbuffer + offset + 0) = (u_snap_interval.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_snap_interval.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_snap_interval.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_snap_interval.base >> (8 * 3)) & 0xFF; offset += sizeof(this->snap_interval); union { float real; uint32_t base; } u_rot_vel; u_rot_vel.real = this->rot_vel; *(outbuffer + offset + 0) = (u_rot_vel.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_rot_vel.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_rot_vel.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_rot_vel.base >> (8 * 3)) & 0xFF; offset += sizeof(this->rot_vel); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->mode = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->mode); union { float real; uint32_t base; } u_pano_angle; u_pano_angle.base = 0; u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->pano_angle = u_pano_angle.real; offset += sizeof(this->pano_angle); union { float real; uint32_t base; } u_snap_interval; u_snap_interval.base = 0; u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->snap_interval = u_snap_interval.real; offset += sizeof(this->snap_interval); union { float real; uint32_t base; } u_rot_vel; u_rot_vel.base = 0; u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->rot_vel = u_rot_vel.real; offset += sizeof(this->rot_vel); return offset; } const char * getType(){ return TAKEPANORAMA; }; const char * getMD5(){ return "ee720ee47c4798b7447cb7a5755b0062"; }; }; class TakePanoramaResponse : public ros::Msg { public: typedef uint8_t _status_type; _status_type status; TakePanoramaResponse(): status(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF; offset += sizeof(this->status); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->status = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->status); return offset; } const char * getType(){ return TAKEPANORAMA; }; const char * getMD5(){ return "284aa12dd9e9e760802ac9f38036ea5e"; }; }; class TakePanorama { public: typedef TakePanoramaRequest Request; typedef TakePanoramaResponse Response; }; } #endif

C

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

#ifndef _ROS_turtlebot3_applications_msgs_PanoramaImg_h #define _ROS_turtlebot3_applications_msgs_PanoramaImg_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "sensor_msgs/Image.h" namespace turtlebot3_applications_msgs { class PanoramaImg : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef const char* _pano_id_type; _pano_id_type pano_id; typedef double _latitude_type; _latitude_type latitude; typedef double _longitude_type; _longitude_type longitude; typedef double _heading_type; _heading_type heading; typedef const char* _geo_tag_type; _geo_tag_type geo_tag; typedef sensor_msgs::Image _image_type; _image_type image; PanoramaImg(): header(), pano_id(""), latitude(0), longitude(0), heading(0), geo_tag(""), image() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); uint32_t length_pano_id = strlen(this->pano_id); varToArr(outbuffer + offset, length_pano_id); offset += 4; memcpy(outbuffer + offset, this->pano_id, length_pano_id); offset += length_pano_id; union { double real; uint64_t base; } u_latitude; u_latitude.real = this->latitude; *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF; offset += sizeof(this->latitude); union { double real; uint64_t base; } u_longitude; u_longitude.real = this->longitude; *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF; offset += sizeof(this->longitude); union { double real; uint64_t base; } u_heading; u_heading.real = this->heading; *(outbuffer + offset + 0) = (u_heading.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_heading.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_heading.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_heading.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_heading.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_heading.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_heading.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_heading.base >> (8 * 7)) & 0xFF; offset += sizeof(this->heading); uint32_t length_geo_tag = strlen(this->geo_tag); varToArr(outbuffer + offset, length_geo_tag); offset += 4; memcpy(outbuffer + offset, this->geo_tag, length_geo_tag); offset += length_geo_tag; offset += this->image.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t length_pano_id; arrToVar(length_pano_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_pano_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_pano_id-1]=0; this->pano_id = (char *)(inbuffer + offset-1); offset += length_pano_id; union { double real; uint64_t base; } u_latitude; u_latitude.base = 0; u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->latitude = u_latitude.real; offset += sizeof(this->latitude); union { double real; uint64_t base; } u_longitude; u_longitude.base = 0; u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->longitude = u_longitude.real; offset += sizeof(this->longitude); union { double real; uint64_t base; } u_heading; u_heading.base = 0; u_heading.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_heading.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_heading.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_heading.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_heading.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_heading.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_heading.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_heading.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->heading = u_heading.real; offset += sizeof(this->heading); uint32_t length_geo_tag; arrToVar(length_geo_tag, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_geo_tag; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_geo_tag-1]=0; this->geo_tag = (char *)(inbuffer + offset-1); offset += length_geo_tag; offset += this->image.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "turtlebot3_applications_msgs/PanoramaImg"; }; const char * getMD5(){ return "aedf66295b374a7249a786af27aecc87"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_SetFollowState_h #define _ROS_SERVICE_SetFollowState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlebot3_applications_msgs { static const char SETFOLLOWSTATE[] = "turtlebot3_applications_msgs/SetFollowState"; class SetFollowStateRequest : public ros::Msg { public: typedef uint8_t _state_type; _state_type state; enum { STOPPED = 0 }; enum { FOLLOW = 1 }; enum { OK = 0 }; enum { ERROR = 1 }; SetFollowStateRequest(): state(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF; offset += sizeof(this->state); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->state = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->state); return offset; } const char * getType(){ return SETFOLLOWSTATE; }; const char * getMD5(){ return "bf26f08bd02c8f904098849ef5e63d81"; }; }; class SetFollowStateResponse : public ros::Msg { public: typedef uint8_t _result_type; _result_type result; SetFollowStateResponse(): result(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF; offset += sizeof(this->result); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->result = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->result); return offset; } const char * getType(){ return SETFOLLOWSTATE; }; const char * getMD5(){ return "25458147911545c320c4c0a299eff763"; }; }; class SetFollowState { public: typedef SetFollowStateRequest Request; typedef SetFollowStateResponse Response; }; } #endif

C

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

#ifndef _ROS_SERVICE_NodeletUnload_h #define _ROS_SERVICE_NodeletUnload_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace nodelet { static const char NODELETUNLOAD[] = "nodelet/NodeletUnload"; class NodeletUnloadRequest : public ros::Msg { public: typedef const char* _name_type; _name_type name; NodeletUnloadRequest(): 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 NODELETUNLOAD; }; const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; }; }; class NodeletUnloadResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; NodeletUnloadResponse(): 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 NODELETUNLOAD; }; const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; }; class NodeletUnload { public: typedef NodeletUnloadRequest Request; typedef NodeletUnloadResponse Response; }; } #endif

C

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

#ifndef _ROS_SERVICE_NodeletList_h #define _ROS_SERVICE_NodeletList_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace nodelet { static const char NODELETLIST[] = "nodelet/NodeletList"; class NodeletListRequest : public ros::Msg { public: NodeletListRequest() { } 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 NODELETLIST; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class NodeletListResponse : public ros::Msg { public: uint32_t nodelets_length; typedef char* _nodelets_type; _nodelets_type st_nodelets; _nodelets_type * nodelets; NodeletListResponse(): nodelets_length(0), nodelets(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->nodelets_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->nodelets_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->nodelets_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->nodelets_length >> (8 * 3)) & 0xFF; offset += sizeof(this->nodelets_length); for( uint32_t i = 0; i < nodelets_length; i++){ uint32_t length_nodeletsi = strlen(this->nodelets[i]); varToArr(outbuffer + offset, length_nodeletsi); offset += 4; memcpy(outbuffer + offset, this->nodelets[i], length_nodeletsi); offset += length_nodeletsi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t nodelets_lengthT = ((uint32_t) (*(inbuffer + offset))); nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->nodelets_length); if(nodelets_lengthT > nodelets_length) this->nodelets = (char**)realloc(this->nodelets, nodelets_lengthT * sizeof(char*)); nodelets_length = nodelets_lengthT; for( uint32_t i = 0; i < nodelets_length; i++){ uint32_t length_st_nodelets; arrToVar(length_st_nodelets, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_nodelets; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_nodelets-1]=0; this->st_nodelets = (char *)(inbuffer + offset-1); offset += length_st_nodelets; memcpy( &(this->nodelets[i]), &(this->st_nodelets), sizeof(char*)); } return offset; } const char * getType(){ return NODELETLIST; }; const char * getMD5(){ return "99c7b10e794f5600b8030e697e946ca7"; }; }; class NodeletList { public: typedef NodeletListRequest Request; typedef NodeletListResponse Response; }; } #endif

C

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

#ifndef _ROS_SERVICE_NodeletLoad_h #define _ROS_SERVICE_NodeletLoad_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace nodelet { static const char NODELETLOAD[] = "nodelet/NodeletLoad"; class NodeletLoadRequest : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef const char* _type_type; _type_type type; uint32_t remap_source_args_length; typedef char* _remap_source_args_type; _remap_source_args_type st_remap_source_args; _remap_source_args_type * remap_source_args; uint32_t remap_target_args_length; typedef char* _remap_target_args_type; _remap_target_args_type st_remap_target_args; _remap_target_args_type * remap_target_args; uint32_t my_argv_length; typedef char* _my_argv_type; _my_argv_type st_my_argv; _my_argv_type * my_argv; typedef const char* _bond_id_type; _bond_id_type bond_id; NodeletLoadRequest(): name(""), type(""), remap_source_args_length(0), remap_source_args(NULL), remap_target_args_length(0), remap_target_args(NULL), my_argv_length(0), my_argv(NULL), bond_id("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; uint32_t length_type = strlen(this->type); varToArr(outbuffer + offset, length_type); offset += 4; memcpy(outbuffer + offset, this->type, length_type); offset += length_type; *(outbuffer + offset + 0) = (this->remap_source_args_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->remap_source_args_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->remap_source_args_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->remap_source_args_length >> (8 * 3)) & 0xFF; offset += sizeof(this->remap_source_args_length); for( uint32_t i = 0; i < remap_source_args_length; i++){ uint32_t length_remap_source_argsi = strlen(this->remap_source_args[i]); varToArr(outbuffer + offset, length_remap_source_argsi); offset += 4; memcpy(outbuffer + offset, this->remap_source_args[i], length_remap_source_argsi); offset += length_remap_source_argsi; } *(outbuffer + offset + 0) = (this->remap_target_args_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->remap_target_args_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->remap_target_args_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->remap_target_args_length >> (8 * 3)) & 0xFF; offset += sizeof(this->remap_target_args_length); for( uint32_t i = 0; i < remap_target_args_length; i++){ uint32_t length_remap_target_argsi = strlen(this->remap_target_args[i]); varToArr(outbuffer + offset, length_remap_target_argsi); offset += 4; memcpy(outbuffer + offset, this->remap_target_args[i], length_remap_target_argsi); offset += length_remap_target_argsi; } *(outbuffer + offset + 0) = (this->my_argv_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->my_argv_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->my_argv_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->my_argv_length >> (8 * 3)) & 0xFF; offset += sizeof(this->my_argv_length); for( uint32_t i = 0; i < my_argv_length; i++){ uint32_t length_my_argvi = strlen(this->my_argv[i]); varToArr(outbuffer + offset, length_my_argvi); offset += 4; memcpy(outbuffer + offset, this->my_argv[i], length_my_argvi); offset += length_my_argvi; } uint32_t length_bond_id = strlen(this->bond_id); varToArr(outbuffer + offset, length_bond_id); offset += 4; memcpy(outbuffer + offset, this->bond_id, length_bond_id); offset += length_bond_id; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; uint32_t length_type; arrToVar(length_type, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_type; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_type-1]=0; this->type = (char *)(inbuffer + offset-1); offset += length_type; uint32_t remap_source_args_lengthT = ((uint32_t) (*(inbuffer + offset))); remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->remap_source_args_length); if(remap_source_args_lengthT > remap_source_args_length) this->remap_source_args = (char**)realloc(this->remap_source_args, remap_source_args_lengthT * sizeof(char*)); remap_source_args_length = remap_source_args_lengthT; for( uint32_t i = 0; i < remap_source_args_length; i++){ uint32_t length_st_remap_source_args; arrToVar(length_st_remap_source_args, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_remap_source_args; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_remap_source_args-1]=0; this->st_remap_source_args = (char *)(inbuffer + offset-1); offset += length_st_remap_source_args; memcpy( &(this->remap_source_args[i]), &(this->st_remap_source_args), sizeof(char*)); } uint32_t remap_target_args_lengthT = ((uint32_t) (*(inbuffer + offset))); remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->remap_target_args_length); if(remap_target_args_lengthT > remap_target_args_length) this->remap_target_args = (char**)realloc(this->remap_target_args, remap_target_args_lengthT * sizeof(char*)); remap_target_args_length = remap_target_args_lengthT; for( uint32_t i = 0; i < remap_target_args_length; i++){ uint32_t length_st_remap_target_args; arrToVar(length_st_remap_target_args, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_remap_target_args; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_remap_target_args-1]=0; this->st_remap_target_args = (char *)(inbuffer + offset-1); offset += length_st_remap_target_args; memcpy( &(this->remap_target_args[i]), &(this->st_remap_target_args), sizeof(char*)); } uint32_t my_argv_lengthT = ((uint32_t) (*(inbuffer + offset))); my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->my_argv_length); if(my_argv_lengthT > my_argv_length) this->my_argv = (char**)realloc(this->my_argv, my_argv_lengthT * sizeof(char*)); my_argv_length = my_argv_lengthT; for( uint32_t i = 0; i < my_argv_length; i++){ uint32_t length_st_my_argv; arrToVar(length_st_my_argv, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_my_argv; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_my_argv-1]=0; this->st_my_argv = (char *)(inbuffer + offset-1); offset += length_st_my_argv; memcpy( &(this->my_argv[i]), &(this->st_my_argv), sizeof(char*)); } uint32_t length_bond_id; arrToVar(length_bond_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_bond_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_bond_id-1]=0; this->bond_id = (char *)(inbuffer + offset-1); offset += length_bond_id; return offset; } const char * getType(){ return NODELETLOAD; }; const char * getMD5(){ return "c6e28cc4d2e259249d96cfb50658fbec"; }; }; class NodeletLoadResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; NodeletLoadResponse(): 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 NODELETLOAD; }; const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; }; class NodeletLoad { public: typedef NodeletLoadRequest Request; typedef NodeletLoadResponse Response; }; } #endif

C

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

#ifndef _ROS_SERVICE_Test_h #define _ROS_SERVICE_Test_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace rosserial_arduino { static const char TEST[] = "rosserial_arduino/Test"; class TestRequest : public ros::Msg { public: typedef const char* _input_type; _input_type input; TestRequest(): input("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_input = strlen(this->input); varToArr(outbuffer + offset, length_input); offset += 4; memcpy(outbuffer + offset, this->input, length_input); offset += length_input; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_input; arrToVar(length_input, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_input; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_input-1]=0; this->input = (char *)(inbuffer + offset-1); offset += length_input; return offset; } const char * getType(){ return TEST; }; const char * getMD5(){ return "39e92f1778057359c64c7b8a7d7b19de"; }; }; class TestResponse : public ros::Msg { public: typedef const char* _output_type; _output_type output; TestResponse(): output("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_output = strlen(this->output); varToArr(outbuffer + offset, length_output); offset += 4; memcpy(outbuffer + offset, this->output, length_output); offset += length_output; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_output; arrToVar(length_output, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_output; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_output-1]=0; this->output = (char *)(inbuffer + offset-1); offset += length_output; return offset; } const char * getType(){ return TEST; }; const char * getMD5(){ return "0825d95fdfa2c8f4bbb4e9c74bccd3fd"; }; }; class Test { public: typedef TestRequest Request; typedef TestResponse Response; }; } #endif

C

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

#ifndef _ROS_rosserial_arduino_Adc_h #define _ROS_rosserial_arduino_Adc_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace rosserial_arduino { class Adc : public ros::Msg { public: typedef uint16_t _adc0_type; _adc0_type adc0; typedef uint16_t _adc1_type; _adc1_type adc1; typedef uint16_t _adc2_type; _adc2_type adc2; typedef uint16_t _adc3_type; _adc3_type adc3; typedef uint16_t _adc4_type; _adc4_type adc4; typedef uint16_t _adc5_type; _adc5_type adc5; Adc(): adc0(0), adc1(0), adc2(0), adc3(0), adc4(0), adc5(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->adc0 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->adc0 >> (8 * 1)) & 0xFF; offset += sizeof(this->adc0); *(outbuffer + offset + 0) = (this->adc1 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->adc1 >> (8 * 1)) & 0xFF; offset += sizeof(this->adc1); *(outbuffer + offset + 0) = (this->adc2 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->adc2 >> (8 * 1)) & 0xFF; offset += sizeof(this->adc2); *(outbuffer + offset + 0) = (this->adc3 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->adc3 >> (8 * 1)) & 0xFF; offset += sizeof(this->adc3); *(outbuffer + offset + 0) = (this->adc4 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->adc4 >> (8 * 1)) & 0xFF; offset += sizeof(this->adc4); *(outbuffer + offset + 0) = (this->adc5 >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->adc5 >> (8 * 1)) & 0xFF; offset += sizeof(this->adc5); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->adc0 = ((uint16_t) (*(inbuffer + offset))); this->adc0 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->adc0); this->adc1 = ((uint16_t) (*(inbuffer + offset))); this->adc1 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->adc1); this->adc2 = ((uint16_t) (*(inbuffer + offset))); this->adc2 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->adc2); this->adc3 = ((uint16_t) (*(inbuffer + offset))); this->adc3 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->adc3); this->adc4 = ((uint16_t) (*(inbuffer + offset))); this->adc4 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->adc4); this->adc5 = ((uint16_t) (*(inbuffer + offset))); this->adc5 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->adc5); return offset; } const char * getType(){ return "rosserial_arduino/Adc"; }; const char * getMD5(){ return "6d7853a614e2e821319068311f2af25b"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_GetPolledImage_h #define _ROS_SERVICE_GetPolledImage_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "sensor_msgs/RegionOfInterest.h" #include "ros/duration.h" #include "ros/time.h" namespace polled_camera { static const char GETPOLLEDIMAGE[] = "polled_camera/GetPolledImage"; class GetPolledImageRequest : public ros::Msg { public: typedef const char* _response_namespace_type; _response_namespace_type response_namespace; typedef ros::Duration _timeout_type; _timeout_type timeout; typedef uint32_t _binning_x_type; _binning_x_type binning_x; typedef uint32_t _binning_y_type; _binning_y_type binning_y; typedef sensor_msgs::RegionOfInterest _roi_type; _roi_type roi; GetPolledImageRequest(): response_namespace(""), timeout(), binning_x(0), binning_y(0), roi() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_response_namespace = strlen(this->response_namespace); varToArr(outbuffer + offset, length_response_namespace); offset += 4; memcpy(outbuffer + offset, this->response_namespace, length_response_namespace); offset += length_response_namespace; *(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); *(outbuffer + offset + 0) = (this->binning_x >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->binning_x >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->binning_x >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->binning_x >> (8 * 3)) & 0xFF; offset += sizeof(this->binning_x); *(outbuffer + offset + 0) = (this->binning_y >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->binning_y >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->binning_y >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->binning_y >> (8 * 3)) & 0xFF; offset += sizeof(this->binning_y); offset += this->roi.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_response_namespace; arrToVar(length_response_namespace, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_response_namespace; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_response_namespace-1]=0; this->response_namespace = (char *)(inbuffer + offset-1); offset += length_response_namespace; 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); this->binning_x = ((uint32_t) (*(inbuffer + offset))); this->binning_x |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->binning_x |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->binning_x |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->binning_x); this->binning_y = ((uint32_t) (*(inbuffer + offset))); this->binning_y |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->binning_y |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->binning_y |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->binning_y); offset += this->roi.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETPOLLEDIMAGE; }; const char * getMD5(){ return "c77ed43e530fd48e9e7a2a93845e154c"; }; }; class GetPolledImageResponse : public ros::Msg { public: typedef bool _success_type; _success_type success; typedef const char* _status_message_type; _status_message_type status_message; typedef ros::Time _stamp_type; _stamp_type stamp; GetPolledImageResponse(): success(0), status_message(""), stamp() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.real = this->success; *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; offset += sizeof(this->success); uint32_t length_status_message = strlen(this->status_message); varToArr(outbuffer + offset, length_status_message); offset += 4; memcpy(outbuffer + offset, this->status_message, length_status_message); offset += length_status_message; *(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->stamp.sec); *(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->stamp.nsec); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_success; u_success.base = 0; u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->success = u_success.real; offset += sizeof(this->success); uint32_t length_status_message; arrToVar(length_status_message, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_status_message; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_status_message-1]=0; this->status_message = (char *)(inbuffer + offset-1); offset += length_status_message; this->stamp.sec = ((uint32_t) (*(inbuffer + offset))); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stamp.sec); this->stamp.nsec = ((uint32_t) (*(inbuffer + offset))); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stamp.nsec); return offset; } const char * getType(){ return GETPOLLEDIMAGE; }; const char * getMD5(){ return "dbf1f851bc511800e6129ccd5a3542ab"; }; }; class GetPolledImage { public: typedef GetPolledImageRequest Request; typedef GetPolledImageResponse Response; }; } #endif

C

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

#ifndef _ROS_controller_manager_msgs_ControllersStatistics_h #define _ROS_controller_manager_msgs_ControllersStatistics_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "controller_manager_msgs/ControllerStatistics.h" namespace controller_manager_msgs { class ControllersStatistics : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t controller_length; typedef controller_manager_msgs::ControllerStatistics _controller_type; _controller_type st_controller; _controller_type * controller; ControllersStatistics(): header(), controller_length(0), controller(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->controller_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->controller_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->controller_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->controller_length >> (8 * 3)) & 0xFF; offset += sizeof(this->controller_length); for( uint32_t i = 0; i < controller_length; i++){ offset += this->controller[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t controller_lengthT = ((uint32_t) (*(inbuffer + offset))); controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->controller_length); if(controller_lengthT > controller_length) this->controller = (controller_manager_msgs::ControllerStatistics*)realloc(this->controller, controller_lengthT * sizeof(controller_manager_msgs::ControllerStatistics)); controller_length = controller_lengthT; for( uint32_t i = 0; i < controller_length; i++){ offset += this->st_controller.deserialize(inbuffer + offset); memcpy( &(this->controller[i]), &(this->st_controller), sizeof(controller_manager_msgs::ControllerStatistics)); } return offset; } const char * getType(){ return "controller_manager_msgs/ControllersStatistics"; }; const char * getMD5(){ return "a154c347736773e3700d1719105df29d"; }; }; } #endif

C

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

#ifndef _ROS_controller_manager_msgs_ControllerState_h #define _ROS_controller_manager_msgs_ControllerState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "controller_manager_msgs/HardwareInterfaceResources.h" namespace controller_manager_msgs { class ControllerState : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef const char* _state_type; _state_type state; typedef const char* _type_type; _type_type type; uint32_t claimed_resources_length; typedef controller_manager_msgs::HardwareInterfaceResources _claimed_resources_type; _claimed_resources_type st_claimed_resources; _claimed_resources_type * claimed_resources; ControllerState(): name(""), state(""), type(""), claimed_resources_length(0), claimed_resources(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; 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_type = strlen(this->type); varToArr(outbuffer + offset, length_type); offset += 4; memcpy(outbuffer + offset, this->type, length_type); offset += length_type; *(outbuffer + offset + 0) = (this->claimed_resources_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->claimed_resources_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->claimed_resources_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->claimed_resources_length >> (8 * 3)) & 0xFF; offset += sizeof(this->claimed_resources_length); for( uint32_t i = 0; i < claimed_resources_length; i++){ offset += this->claimed_resources[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 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_type; arrToVar(length_type, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_type; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_type-1]=0; this->type = (char *)(inbuffer + offset-1); offset += length_type; uint32_t claimed_resources_lengthT = ((uint32_t) (*(inbuffer + offset))); claimed_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); claimed_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); claimed_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->claimed_resources_length); if(claimed_resources_lengthT > claimed_resources_length) this->claimed_resources = (controller_manager_msgs::HardwareInterfaceResources*)realloc(this->claimed_resources, claimed_resources_lengthT * sizeof(controller_manager_msgs::HardwareInterfaceResources)); claimed_resources_length = claimed_resources_lengthT; for( uint32_t i = 0; i < claimed_resources_length; i++){ offset += this->st_claimed_resources.deserialize(inbuffer + offset); memcpy( &(this->claimed_resources[i]), &(this->st_claimed_resources), sizeof(controller_manager_msgs::HardwareInterfaceResources)); } return offset; } const char * getType(){ return "controller_manager_msgs/ControllerState"; }; const char * getMD5(){ return "aeb6b261d97793ab74099a3740245272"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_ListControllerTypes_h #define _ROS_SERVICE_ListControllerTypes_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace controller_manager_msgs { static const char LISTCONTROLLERTYPES[] = "controller_manager_msgs/ListControllerTypes"; class ListControllerTypesRequest : public ros::Msg { public: ListControllerTypesRequest() { } 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 LISTCONTROLLERTYPES; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class ListControllerTypesResponse : public ros::Msg { public: uint32_t types_length; typedef char* _types_type; _types_type st_types; _types_type * types; uint32_t base_classes_length; typedef char* _base_classes_type; _base_classes_type st_base_classes; _base_classes_type * base_classes; ListControllerTypesResponse(): types_length(0), types(NULL), base_classes_length(0), base_classes(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->types_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->types_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->types_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->types_length >> (8 * 3)) & 0xFF; offset += sizeof(this->types_length); for( uint32_t i = 0; i < types_length; i++){ uint32_t length_typesi = strlen(this->types[i]); varToArr(outbuffer + offset, length_typesi); offset += 4; memcpy(outbuffer + offset, this->types[i], length_typesi); offset += length_typesi; } *(outbuffer + offset + 0) = (this->base_classes_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->base_classes_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->base_classes_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->base_classes_length >> (8 * 3)) & 0xFF; offset += sizeof(this->base_classes_length); for( uint32_t i = 0; i < base_classes_length; i++){ uint32_t length_base_classesi = strlen(this->base_classes[i]); varToArr(outbuffer + offset, length_base_classesi); offset += 4; memcpy(outbuffer + offset, this->base_classes[i], length_base_classesi); offset += length_base_classesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t types_lengthT = ((uint32_t) (*(inbuffer + offset))); types_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); types_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); types_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->types_length); if(types_lengthT > types_length) this->types = (char**)realloc(this->types, types_lengthT * sizeof(char*)); types_length = types_lengthT; for( uint32_t i = 0; i < types_length; i++){ uint32_t length_st_types; arrToVar(length_st_types, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_types; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_types-1]=0; this->st_types = (char *)(inbuffer + offset-1); offset += length_st_types; memcpy( &(this->types[i]), &(this->st_types), sizeof(char*)); } uint32_t base_classes_lengthT = ((uint32_t) (*(inbuffer + offset))); base_classes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); base_classes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); base_classes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->base_classes_length); if(base_classes_lengthT > base_classes_length) this->base_classes = (char**)realloc(this->base_classes, base_classes_lengthT * sizeof(char*)); base_classes_length = base_classes_lengthT; for( uint32_t i = 0; i < base_classes_length; i++){ uint32_t length_st_base_classes; arrToVar(length_st_base_classes, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_base_classes; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_base_classes-1]=0; this->st_base_classes = (char *)(inbuffer + offset-1); offset += length_st_base_classes; memcpy( &(this->base_classes[i]), &(this->st_base_classes), sizeof(char*)); } return offset; } const char * getType(){ return LISTCONTROLLERTYPES; }; const char * getMD5(){ return "c1d4cd11aefa9f97ba4aeb5b33987f4e"; }; }; class ListControllerTypes { public: typedef ListControllerTypesRequest Request; typedef ListControllerTypesResponse Response; }; } #endif

C

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

#ifndef _ROS_controller_manager_msgs_HardwareInterfaceResources_h #define _ROS_controller_manager_msgs_HardwareInterfaceResources_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace controller_manager_msgs { class HardwareInterfaceResources : public ros::Msg { public: typedef const char* _hardware_interface_type; _hardware_interface_type hardware_interface; uint32_t resources_length; typedef char* _resources_type; _resources_type st_resources; _resources_type * resources; HardwareInterfaceResources(): hardware_interface(""), resources_length(0), resources(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_hardware_interface = strlen(this->hardware_interface); varToArr(outbuffer + offset, length_hardware_interface); offset += 4; memcpy(outbuffer + offset, this->hardware_interface, length_hardware_interface); offset += length_hardware_interface; *(outbuffer + offset + 0) = (this->resources_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->resources_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->resources_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->resources_length >> (8 * 3)) & 0xFF; offset += sizeof(this->resources_length); for( uint32_t i = 0; i < resources_length; i++){ uint32_t length_resourcesi = strlen(this->resources[i]); varToArr(outbuffer + offset, length_resourcesi); offset += 4; memcpy(outbuffer + offset, this->resources[i], length_resourcesi); offset += length_resourcesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_hardware_interface; arrToVar(length_hardware_interface, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_hardware_interface; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_hardware_interface-1]=0; this->hardware_interface = (char *)(inbuffer + offset-1); offset += length_hardware_interface; uint32_t resources_lengthT = ((uint32_t) (*(inbuffer + offset))); resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->resources_length); if(resources_lengthT > resources_length) this->resources = (char**)realloc(this->resources, resources_lengthT * sizeof(char*)); resources_length = resources_lengthT; for( uint32_t i = 0; i < resources_length; i++){ uint32_t length_st_resources; arrToVar(length_st_resources, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_resources; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_resources-1]=0; this->st_resources = (char *)(inbuffer + offset-1); offset += length_st_resources; memcpy( &(this->resources[i]), &(this->st_resources), sizeof(char*)); } return offset; } const char * getType(){ return "controller_manager_msgs/HardwareInterfaceResources"; }; const char * getMD5(){ return "f25b55cbf1d1f76e82e5ec9e83f76258"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_LoadController_h #define _ROS_SERVICE_LoadController_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace controller_manager_msgs { static const char LOADCONTROLLER[] = "controller_manager_msgs/LoadController"; class LoadControllerRequest : public ros::Msg { public: typedef const char* _name_type; _name_type name; LoadControllerRequest(): 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 LOADCONTROLLER; }; const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; }; }; class LoadControllerResponse : public ros::Msg { public: typedef bool _ok_type; _ok_type ok; LoadControllerResponse(): ok(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_ok; u_ok.real = this->ok; *(outbuffer + offset + 0) = (u_ok.base >> (8 * 0)) & 0xFF; offset += sizeof(this->ok); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_ok; u_ok.base = 0; u_ok.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->ok = u_ok.real; offset += sizeof(this->ok); return offset; } const char * getType(){ return LOADCONTROLLER; }; const char * getMD5(){ return "6f6da3883749771fac40d6deb24a8c02"; }; }; class LoadController { public: typedef LoadControllerRequest Request; typedef LoadControllerResponse Response; }; } #endif

C

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

#ifndef _ROS_controller_manager_msgs_ControllerStatistics_h #define _ROS_controller_manager_msgs_ControllerStatistics_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" #include "ros/duration.h" namespace controller_manager_msgs { class ControllerStatistics : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef const char* _type_type; _type_type type; typedef ros::Time _timestamp_type; _timestamp_type timestamp; typedef bool _running_type; _running_type running; typedef ros::Duration _max_time_type; _max_time_type max_time; typedef ros::Duration _mean_time_type; _mean_time_type mean_time; typedef ros::Duration _variance_time_type; _variance_time_type variance_time; typedef int32_t _num_control_loop_overruns_type; _num_control_loop_overruns_type num_control_loop_overruns; typedef ros::Time _time_last_control_loop_overrun_type; _time_last_control_loop_overrun_type time_last_control_loop_overrun; ControllerStatistics(): name(""), type(""), timestamp(), running(0), max_time(), mean_time(), variance_time(), num_control_loop_overruns(0), time_last_control_loop_overrun() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; uint32_t length_type = strlen(this->type); varToArr(outbuffer + offset, length_type); offset += 4; memcpy(outbuffer + offset, this->type, length_type); offset += length_type; *(outbuffer + offset + 0) = (this->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); union { bool real; uint8_t base; } u_running; u_running.real = this->running; *(outbuffer + offset + 0) = (u_running.base >> (8 * 0)) & 0xFF; offset += sizeof(this->running); *(outbuffer + offset + 0) = (this->max_time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->max_time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->max_time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->max_time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->max_time.sec); *(outbuffer + offset + 0) = (this->max_time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->max_time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->max_time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->max_time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->max_time.nsec); *(outbuffer + offset + 0) = (this->mean_time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->mean_time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->mean_time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->mean_time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->mean_time.sec); *(outbuffer + offset + 0) = (this->mean_time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->mean_time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->mean_time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->mean_time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->mean_time.nsec); *(outbuffer + offset + 0) = (this->variance_time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->variance_time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->variance_time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->variance_time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->variance_time.sec); *(outbuffer + offset + 0) = (this->variance_time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->variance_time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->variance_time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->variance_time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->variance_time.nsec); union { int32_t real; uint32_t base; } u_num_control_loop_overruns; u_num_control_loop_overruns.real = this->num_control_loop_overruns; *(outbuffer + offset + 0) = (u_num_control_loop_overruns.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_num_control_loop_overruns.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_num_control_loop_overruns.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_num_control_loop_overruns.base >> (8 * 3)) & 0xFF; offset += sizeof(this->num_control_loop_overruns); *(outbuffer + offset + 0) = (this->time_last_control_loop_overrun.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time_last_control_loop_overrun.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time_last_control_loop_overrun.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time_last_control_loop_overrun.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time_last_control_loop_overrun.sec); *(outbuffer + offset + 0) = (this->time_last_control_loop_overrun.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time_last_control_loop_overrun.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time_last_control_loop_overrun.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time_last_control_loop_overrun.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time_last_control_loop_overrun.nsec); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; uint32_t length_type; arrToVar(length_type, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_type; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_type-1]=0; this->type = (char *)(inbuffer + offset-1); offset += length_type; this->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); union { bool real; uint8_t base; } u_running; u_running.base = 0; u_running.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->running = u_running.real; offset += sizeof(this->running); this->max_time.sec = ((uint32_t) (*(inbuffer + offset))); this->max_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->max_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->max_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->max_time.sec); this->max_time.nsec = ((uint32_t) (*(inbuffer + offset))); this->max_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->max_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->max_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->max_time.nsec); this->mean_time.sec = ((uint32_t) (*(inbuffer + offset))); this->mean_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->mean_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->mean_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->mean_time.sec); this->mean_time.nsec = ((uint32_t) (*(inbuffer + offset))); this->mean_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->mean_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->mean_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->mean_time.nsec); this->variance_time.sec = ((uint32_t) (*(inbuffer + offset))); this->variance_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->variance_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->variance_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->variance_time.sec); this->variance_time.nsec = ((uint32_t) (*(inbuffer + offset))); this->variance_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->variance_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->variance_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->variance_time.nsec); union { int32_t real; uint32_t base; } u_num_control_loop_overruns; u_num_control_loop_overruns.base = 0; u_num_control_loop_overruns.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_num_control_loop_overruns.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_num_control_loop_overruns.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_num_control_loop_overruns.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->num_control_loop_overruns = u_num_control_loop_overruns.real; offset += sizeof(this->num_control_loop_overruns); this->time_last_control_loop_overrun.sec = ((uint32_t) (*(inbuffer + offset))); this->time_last_control_loop_overrun.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time_last_control_loop_overrun.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time_last_control_loop_overrun.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time_last_control_loop_overrun.sec); this->time_last_control_loop_overrun.nsec = ((uint32_t) (*(inbuffer + offset))); this->time_last_control_loop_overrun.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time_last_control_loop_overrun.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time_last_control_loop_overrun.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time_last_control_loop_overrun.nsec); return offset; } const char * getType(){ return "controller_manager_msgs/ControllerStatistics"; }; const char * getMD5(){ return "697780c372c8d8597a1436d0e2ad3ba8"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_ReloadControllerLibraries_h #define _ROS_SERVICE_ReloadControllerLibraries_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace controller_manager_msgs { static const char RELOADCONTROLLERLIBRARIES[] = "controller_manager_msgs/ReloadControllerLibraries"; class ReloadControllerLibrariesRequest : public ros::Msg { public: typedef bool _force_kill_type; _force_kill_type force_kill; ReloadControllerLibrariesRequest(): force_kill(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_force_kill; u_force_kill.real = this->force_kill; *(outbuffer + offset + 0) = (u_force_kill.base >> (8 * 0)) & 0xFF; offset += sizeof(this->force_kill); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_force_kill; u_force_kill.base = 0; u_force_kill.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->force_kill = u_force_kill.real; offset += sizeof(this->force_kill); return offset; } const char * getType(){ return RELOADCONTROLLERLIBRARIES; }; const char * getMD5(){ return "18442b59be9479097f11c543bddbac62"; }; }; class ReloadControllerLibrariesResponse : public ros::Msg { public: typedef bool _ok_type; _ok_type ok; ReloadControllerLibrariesResponse(): ok(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_ok; u_ok.real = this->ok; *(outbuffer + offset + 0) = (u_ok.base >> (8 * 0)) & 0xFF; offset += sizeof(this->ok); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_ok; u_ok.base = 0; u_ok.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->ok = u_ok.real; offset += sizeof(this->ok); return offset; } const char * getType(){ return RELOADCONTROLLERLIBRARIES; }; const char * getMD5(){ return "6f6da3883749771fac40d6deb24a8c02"; }; }; class ReloadControllerLibraries { public: typedef ReloadControllerLibrariesRequest Request; typedef ReloadControllerLibrariesResponse Response; }; } #endif

C

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

#ifndef _ROS_SERVICE_SwitchController_h #define _ROS_SERVICE_SwitchController_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace controller_manager_msgs { static const char SWITCHCONTROLLER[] = "controller_manager_msgs/SwitchController"; class SwitchControllerRequest : public ros::Msg { public: uint32_t start_controllers_length; typedef char* _start_controllers_type; _start_controllers_type st_start_controllers; _start_controllers_type * start_controllers; uint32_t stop_controllers_length; typedef char* _stop_controllers_type; _stop_controllers_type st_stop_controllers; _stop_controllers_type * stop_controllers; typedef int32_t _strictness_type; _strictness_type strictness; typedef bool _start_asap_type; _start_asap_type start_asap; typedef double _timeout_type; _timeout_type timeout; enum { BEST_EFFORT = 1 }; enum { STRICT = 2 }; SwitchControllerRequest(): start_controllers_length(0), start_controllers(NULL), stop_controllers_length(0), stop_controllers(NULL), strictness(0), start_asap(0), timeout(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->start_controllers_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->start_controllers_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->start_controllers_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->start_controllers_length >> (8 * 3)) & 0xFF; offset += sizeof(this->start_controllers_length); for( uint32_t i = 0; i < start_controllers_length; i++){ uint32_t length_start_controllersi = strlen(this->start_controllers[i]); varToArr(outbuffer + offset, length_start_controllersi); offset += 4; memcpy(outbuffer + offset, this->start_controllers[i], length_start_controllersi); offset += length_start_controllersi; } *(outbuffer + offset + 0) = (this->stop_controllers_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stop_controllers_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stop_controllers_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stop_controllers_length >> (8 * 3)) & 0xFF; offset += sizeof(this->stop_controllers_length); for( uint32_t i = 0; i < stop_controllers_length; i++){ uint32_t length_stop_controllersi = strlen(this->stop_controllers[i]); varToArr(outbuffer + offset, length_stop_controllersi); offset += 4; memcpy(outbuffer + offset, this->stop_controllers[i], length_stop_controllersi); offset += length_stop_controllersi; } union { int32_t real; uint32_t base; } u_strictness; u_strictness.real = this->strictness; *(outbuffer + offset + 0) = (u_strictness.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_strictness.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_strictness.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_strictness.base >> (8 * 3)) & 0xFF; offset += sizeof(this->strictness); union { bool real; uint8_t base; } u_start_asap; u_start_asap.real = this->start_asap; *(outbuffer + offset + 0) = (u_start_asap.base >> (8 * 0)) & 0xFF; offset += sizeof(this->start_asap); union { double real; uint64_t base; } u_timeout; u_timeout.real = this->timeout; *(outbuffer + offset + 0) = (u_timeout.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_timeout.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_timeout.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_timeout.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_timeout.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_timeout.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_timeout.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_timeout.base >> (8 * 7)) & 0xFF; offset += sizeof(this->timeout); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t start_controllers_lengthT = ((uint32_t) (*(inbuffer + offset))); start_controllers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); start_controllers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); start_controllers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->start_controllers_length); if(start_controllers_lengthT > start_controllers_length) this->start_controllers = (char**)realloc(this->start_controllers, start_controllers_lengthT * sizeof(char*)); start_controllers_length = start_controllers_lengthT; for( uint32_t i = 0; i < start_controllers_length; i++){ uint32_t length_st_start_controllers; arrToVar(length_st_start_controllers, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_start_controllers; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_start_controllers-1]=0; this->st_start_controllers = (char *)(inbuffer + offset-1); offset += length_st_start_controllers; memcpy( &(this->start_controllers[i]), &(this->st_start_controllers), sizeof(char*)); } uint32_t stop_controllers_lengthT = ((uint32_t) (*(inbuffer + offset))); stop_controllers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); stop_controllers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); stop_controllers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stop_controllers_length); if(stop_controllers_lengthT > stop_controllers_length) this->stop_controllers = (char**)realloc(this->stop_controllers, stop_controllers_lengthT * sizeof(char*)); stop_controllers_length = stop_controllers_lengthT; for( uint32_t i = 0; i < stop_controllers_length; i++){ uint32_t length_st_stop_controllers; arrToVar(length_st_stop_controllers, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_stop_controllers; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_stop_controllers-1]=0; this->st_stop_controllers = (char *)(inbuffer + offset-1); offset += length_st_stop_controllers; memcpy( &(this->stop_controllers[i]), &(this->st_stop_controllers), sizeof(char*)); } union { int32_t real; uint32_t base; } u_strictness; u_strictness.base = 0; u_strictness.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_strictness.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_strictness.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_strictness.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->strictness = u_strictness.real; offset += sizeof(this->strictness); union { bool real; uint8_t base; } u_start_asap; u_start_asap.base = 0; u_start_asap.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->start_asap = u_start_asap.real; offset += sizeof(this->start_asap); union { double real; uint64_t base; } u_timeout; u_timeout.base = 0; u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_timeout.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->timeout = u_timeout.real; offset += sizeof(this->timeout); return offset; } const char * getType(){ return SWITCHCONTROLLER; }; const char * getMD5(){ return "36d99a977432b71d4bf16ce5847949d7"; }; }; class SwitchControllerResponse : public ros::Msg { public: typedef bool _ok_type; _ok_type ok; SwitchControllerResponse(): ok(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_ok; u_ok.real = this->ok; *(outbuffer + offset + 0) = (u_ok.base >> (8 * 0)) & 0xFF; offset += sizeof(this->ok); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { bool real; uint8_t base; } u_ok; u_ok.base = 0; u_ok.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->ok = u_ok.real; offset += sizeof(this->ok); return offset; } const char * getType(){ return SWITCHCONTROLLER; }; const char * getMD5(){ return "6f6da3883749771fac40d6deb24a8c02"; }; }; class SwitchController { public: typedef SwitchControllerRequest Request; typedef SwitchControllerResponse Response; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_SEAJointState_h #define _ROS_intera_core_msgs_SEAJointState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace intera_core_msgs { class SEAJointState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t name_length; typedef char* _name_type; _name_type st_name; _name_type * name; uint32_t commanded_position_length; typedef double _commanded_position_type; _commanded_position_type st_commanded_position; _commanded_position_type * commanded_position; uint32_t commanded_velocity_length; typedef double _commanded_velocity_type; _commanded_velocity_type st_commanded_velocity; _commanded_velocity_type * commanded_velocity; uint32_t commanded_acceleration_length; typedef double _commanded_acceleration_type; _commanded_acceleration_type st_commanded_acceleration; _commanded_acceleration_type * commanded_acceleration; uint32_t commanded_effort_length; typedef double _commanded_effort_type; _commanded_effort_type st_commanded_effort; _commanded_effort_type * commanded_effort; uint32_t actual_position_length; typedef double _actual_position_type; _actual_position_type st_actual_position; _actual_position_type * actual_position; uint32_t actual_velocity_length; typedef double _actual_velocity_type; _actual_velocity_type st_actual_velocity; _actual_velocity_type * actual_velocity; uint32_t actual_effort_length; typedef double _actual_effort_type; _actual_effort_type st_actual_effort; _actual_effort_type * actual_effort; uint32_t gravity_model_effort_length; typedef double _gravity_model_effort_type; _gravity_model_effort_type st_gravity_model_effort; _gravity_model_effort_type * gravity_model_effort; uint32_t gravity_only_length; typedef double _gravity_only_type; _gravity_only_type st_gravity_only; _gravity_only_type * gravity_only; uint32_t interaction_torque_length; typedef double _interaction_torque_type; _interaction_torque_type st_interaction_torque; _interaction_torque_type * interaction_torque; uint32_t hysteresis_model_effort_length; typedef double _hysteresis_model_effort_type; _hysteresis_model_effort_type st_hysteresis_model_effort; _hysteresis_model_effort_type * hysteresis_model_effort; uint32_t crosstalk_model_effort_length; typedef double _crosstalk_model_effort_type; _crosstalk_model_effort_type st_crosstalk_model_effort; _crosstalk_model_effort_type * crosstalk_model_effort; typedef double _hystState_type; _hystState_type hystState; SEAJointState(): header(), name_length(0), name(NULL), commanded_position_length(0), commanded_position(NULL), commanded_velocity_length(0), commanded_velocity(NULL), commanded_acceleration_length(0), commanded_acceleration(NULL), commanded_effort_length(0), commanded_effort(NULL), actual_position_length(0), actual_position(NULL), actual_velocity_length(0), actual_velocity(NULL), actual_effort_length(0), actual_effort(NULL), gravity_model_effort_length(0), gravity_model_effort(NULL), gravity_only_length(0), gravity_only(NULL), interaction_torque_length(0), interaction_torque(NULL), hysteresis_model_effort_length(0), hysteresis_model_effort(NULL), crosstalk_model_effort_length(0), crosstalk_model_effort(NULL), hystState(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF; offset += sizeof(this->name_length); for( uint32_t i = 0; i < name_length; i++){ uint32_t length_namei = strlen(this->name[i]); varToArr(outbuffer + offset, length_namei); offset += 4; memcpy(outbuffer + offset, this->name[i], length_namei); offset += length_namei; } *(outbuffer + offset + 0) = (this->commanded_position_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commanded_position_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commanded_position_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commanded_position_length >> (8 * 3)) & 0xFF; offset += sizeof(this->commanded_position_length); for( uint32_t i = 0; i < commanded_position_length; i++){ union { double real; uint64_t base; } u_commanded_positioni; u_commanded_positioni.real = this->commanded_position[i]; *(outbuffer + offset + 0) = (u_commanded_positioni.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_commanded_positioni.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_commanded_positioni.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_commanded_positioni.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_commanded_positioni.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_commanded_positioni.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_commanded_positioni.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_commanded_positioni.base >> (8 * 7)) & 0xFF; offset += sizeof(this->commanded_position[i]); } *(outbuffer + offset + 0) = (this->commanded_velocity_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commanded_velocity_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commanded_velocity_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commanded_velocity_length >> (8 * 3)) & 0xFF; offset += sizeof(this->commanded_velocity_length); for( uint32_t i = 0; i < commanded_velocity_length; i++){ union { double real; uint64_t base; } u_commanded_velocityi; u_commanded_velocityi.real = this->commanded_velocity[i]; *(outbuffer + offset + 0) = (u_commanded_velocityi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_commanded_velocityi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_commanded_velocityi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_commanded_velocityi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_commanded_velocityi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_commanded_velocityi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_commanded_velocityi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_commanded_velocityi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->commanded_velocity[i]); } *(outbuffer + offset + 0) = (this->commanded_acceleration_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commanded_acceleration_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commanded_acceleration_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commanded_acceleration_length >> (8 * 3)) & 0xFF; offset += sizeof(this->commanded_acceleration_length); for( uint32_t i = 0; i < commanded_acceleration_length; i++){ union { double real; uint64_t base; } u_commanded_accelerationi; u_commanded_accelerationi.real = this->commanded_acceleration[i]; *(outbuffer + offset + 0) = (u_commanded_accelerationi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_commanded_accelerationi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_commanded_accelerationi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_commanded_accelerationi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_commanded_accelerationi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_commanded_accelerationi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_commanded_accelerationi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_commanded_accelerationi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->commanded_acceleration[i]); } *(outbuffer + offset + 0) = (this->commanded_effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commanded_effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commanded_effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commanded_effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->commanded_effort_length); for( uint32_t i = 0; i < commanded_effort_length; i++){ union { double real; uint64_t base; } u_commanded_efforti; u_commanded_efforti.real = this->commanded_effort[i]; *(outbuffer + offset + 0) = (u_commanded_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_commanded_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_commanded_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_commanded_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_commanded_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_commanded_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_commanded_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_commanded_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->commanded_effort[i]); } *(outbuffer + offset + 0) = (this->actual_position_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->actual_position_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->actual_position_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->actual_position_length >> (8 * 3)) & 0xFF; offset += sizeof(this->actual_position_length); for( uint32_t i = 0; i < actual_position_length; i++){ union { double real; uint64_t base; } u_actual_positioni; u_actual_positioni.real = this->actual_position[i]; *(outbuffer + offset + 0) = (u_actual_positioni.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_actual_positioni.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_actual_positioni.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_actual_positioni.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_actual_positioni.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_actual_positioni.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_actual_positioni.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_actual_positioni.base >> (8 * 7)) & 0xFF; offset += sizeof(this->actual_position[i]); } *(outbuffer + offset + 0) = (this->actual_velocity_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->actual_velocity_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->actual_velocity_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->actual_velocity_length >> (8 * 3)) & 0xFF; offset += sizeof(this->actual_velocity_length); for( uint32_t i = 0; i < actual_velocity_length; i++){ union { double real; uint64_t base; } u_actual_velocityi; u_actual_velocityi.real = this->actual_velocity[i]; *(outbuffer + offset + 0) = (u_actual_velocityi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_actual_velocityi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_actual_velocityi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_actual_velocityi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_actual_velocityi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_actual_velocityi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_actual_velocityi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_actual_velocityi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->actual_velocity[i]); } *(outbuffer + offset + 0) = (this->actual_effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->actual_effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->actual_effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->actual_effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->actual_effort_length); for( uint32_t i = 0; i < actual_effort_length; i++){ union { double real; uint64_t base; } u_actual_efforti; u_actual_efforti.real = this->actual_effort[i]; *(outbuffer + offset + 0) = (u_actual_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_actual_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_actual_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_actual_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_actual_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_actual_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_actual_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_actual_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->actual_effort[i]); } *(outbuffer + offset + 0) = (this->gravity_model_effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->gravity_model_effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->gravity_model_effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->gravity_model_effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->gravity_model_effort_length); for( uint32_t i = 0; i < gravity_model_effort_length; i++){ union { double real; uint64_t base; } u_gravity_model_efforti; u_gravity_model_efforti.real = this->gravity_model_effort[i]; *(outbuffer + offset + 0) = (u_gravity_model_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_gravity_model_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_gravity_model_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_gravity_model_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_gravity_model_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_gravity_model_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_gravity_model_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_gravity_model_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->gravity_model_effort[i]); } *(outbuffer + offset + 0) = (this->gravity_only_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->gravity_only_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->gravity_only_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->gravity_only_length >> (8 * 3)) & 0xFF; offset += sizeof(this->gravity_only_length); for( uint32_t i = 0; i < gravity_only_length; i++){ union { double real; uint64_t base; } u_gravity_onlyi; u_gravity_onlyi.real = this->gravity_only[i]; *(outbuffer + offset + 0) = (u_gravity_onlyi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_gravity_onlyi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_gravity_onlyi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_gravity_onlyi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_gravity_onlyi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_gravity_onlyi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_gravity_onlyi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_gravity_onlyi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->gravity_only[i]); } *(outbuffer + offset + 0) = (this->interaction_torque_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->interaction_torque_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->interaction_torque_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->interaction_torque_length >> (8 * 3)) & 0xFF; offset += sizeof(this->interaction_torque_length); for( uint32_t i = 0; i < interaction_torque_length; i++){ union { double real; uint64_t base; } u_interaction_torquei; u_interaction_torquei.real = this->interaction_torque[i]; *(outbuffer + offset + 0) = (u_interaction_torquei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_interaction_torquei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_interaction_torquei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_interaction_torquei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_interaction_torquei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_interaction_torquei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_interaction_torquei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_interaction_torquei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->interaction_torque[i]); } *(outbuffer + offset + 0) = (this->hysteresis_model_effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->hysteresis_model_effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->hysteresis_model_effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->hysteresis_model_effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->hysteresis_model_effort_length); for( uint32_t i = 0; i < hysteresis_model_effort_length; i++){ union { double real; uint64_t base; } u_hysteresis_model_efforti; u_hysteresis_model_efforti.real = this->hysteresis_model_effort[i]; *(outbuffer + offset + 0) = (u_hysteresis_model_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_hysteresis_model_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_hysteresis_model_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_hysteresis_model_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_hysteresis_model_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_hysteresis_model_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_hysteresis_model_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_hysteresis_model_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->hysteresis_model_effort[i]); } *(outbuffer + offset + 0) = (this->crosstalk_model_effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->crosstalk_model_effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->crosstalk_model_effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->crosstalk_model_effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->crosstalk_model_effort_length); for( uint32_t i = 0; i < crosstalk_model_effort_length; i++){ union { double real; uint64_t base; } u_crosstalk_model_efforti; u_crosstalk_model_efforti.real = this->crosstalk_model_effort[i]; *(outbuffer + offset + 0) = (u_crosstalk_model_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_crosstalk_model_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_crosstalk_model_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_crosstalk_model_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_crosstalk_model_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_crosstalk_model_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_crosstalk_model_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_crosstalk_model_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->crosstalk_model_effort[i]); } union { double real; uint64_t base; } u_hystState; u_hystState.real = this->hystState; *(outbuffer + offset + 0) = (u_hystState.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_hystState.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_hystState.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_hystState.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_hystState.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_hystState.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_hystState.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_hystState.base >> (8 * 7)) & 0xFF; offset += sizeof(this->hystState); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset))); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->name_length); if(name_lengthT > name_length) this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*)); name_length = name_lengthT; for( uint32_t i = 0; i < name_length; i++){ uint32_t length_st_name; arrToVar(length_st_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_name-1]=0; this->st_name = (char *)(inbuffer + offset-1); offset += length_st_name; memcpy( &(this->name[i]), &(this->st_name), sizeof(char*)); } uint32_t commanded_position_lengthT = ((uint32_t) (*(inbuffer + offset))); commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->commanded_position_length); if(commanded_position_lengthT > commanded_position_length) this->commanded_position = (double*)realloc(this->commanded_position, commanded_position_lengthT * sizeof(double)); commanded_position_length = commanded_position_lengthT; for( uint32_t i = 0; i < commanded_position_length; i++){ union { double real; uint64_t base; } u_st_commanded_position; u_st_commanded_position.base = 0; u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_commanded_position = u_st_commanded_position.real; offset += sizeof(this->st_commanded_position); memcpy( &(this->commanded_position[i]), &(this->st_commanded_position), sizeof(double)); } uint32_t commanded_velocity_lengthT = ((uint32_t) (*(inbuffer + offset))); commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->commanded_velocity_length); if(commanded_velocity_lengthT > commanded_velocity_length) this->commanded_velocity = (double*)realloc(this->commanded_velocity, commanded_velocity_lengthT * sizeof(double)); commanded_velocity_length = commanded_velocity_lengthT; for( uint32_t i = 0; i < commanded_velocity_length; i++){ union { double real; uint64_t base; } u_st_commanded_velocity; u_st_commanded_velocity.base = 0; u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_commanded_velocity = u_st_commanded_velocity.real; offset += sizeof(this->st_commanded_velocity); memcpy( &(this->commanded_velocity[i]), &(this->st_commanded_velocity), sizeof(double)); } uint32_t commanded_acceleration_lengthT = ((uint32_t) (*(inbuffer + offset))); commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->commanded_acceleration_length); if(commanded_acceleration_lengthT > commanded_acceleration_length) this->commanded_acceleration = (double*)realloc(this->commanded_acceleration, commanded_acceleration_lengthT * sizeof(double)); commanded_acceleration_length = commanded_acceleration_lengthT; for( uint32_t i = 0; i < commanded_acceleration_length; i++){ union { double real; uint64_t base; } u_st_commanded_acceleration; u_st_commanded_acceleration.base = 0; u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_commanded_acceleration = u_st_commanded_acceleration.real; offset += sizeof(this->st_commanded_acceleration); memcpy( &(this->commanded_acceleration[i]), &(this->st_commanded_acceleration), sizeof(double)); } uint32_t commanded_effort_lengthT = ((uint32_t) (*(inbuffer + offset))); commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->commanded_effort_length); if(commanded_effort_lengthT > commanded_effort_length) this->commanded_effort = (double*)realloc(this->commanded_effort, commanded_effort_lengthT * sizeof(double)); commanded_effort_length = commanded_effort_lengthT; for( uint32_t i = 0; i < commanded_effort_length; i++){ union { double real; uint64_t base; } u_st_commanded_effort; u_st_commanded_effort.base = 0; u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_commanded_effort = u_st_commanded_effort.real; offset += sizeof(this->st_commanded_effort); memcpy( &(this->commanded_effort[i]), &(this->st_commanded_effort), sizeof(double)); } uint32_t actual_position_lengthT = ((uint32_t) (*(inbuffer + offset))); actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->actual_position_length); if(actual_position_lengthT > actual_position_length) this->actual_position = (double*)realloc(this->actual_position, actual_position_lengthT * sizeof(double)); actual_position_length = actual_position_lengthT; for( uint32_t i = 0; i < actual_position_length; i++){ union { double real; uint64_t base; } u_st_actual_position; u_st_actual_position.base = 0; u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_actual_position = u_st_actual_position.real; offset += sizeof(this->st_actual_position); memcpy( &(this->actual_position[i]), &(this->st_actual_position), sizeof(double)); } uint32_t actual_velocity_lengthT = ((uint32_t) (*(inbuffer + offset))); actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->actual_velocity_length); if(actual_velocity_lengthT > actual_velocity_length) this->actual_velocity = (double*)realloc(this->actual_velocity, actual_velocity_lengthT * sizeof(double)); actual_velocity_length = actual_velocity_lengthT; for( uint32_t i = 0; i < actual_velocity_length; i++){ union { double real; uint64_t base; } u_st_actual_velocity; u_st_actual_velocity.base = 0; u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_actual_velocity = u_st_actual_velocity.real; offset += sizeof(this->st_actual_velocity); memcpy( &(this->actual_velocity[i]), &(this->st_actual_velocity), sizeof(double)); } uint32_t actual_effort_lengthT = ((uint32_t) (*(inbuffer + offset))); actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->actual_effort_length); if(actual_effort_lengthT > actual_effort_length) this->actual_effort = (double*)realloc(this->actual_effort, actual_effort_lengthT * sizeof(double)); actual_effort_length = actual_effort_lengthT; for( uint32_t i = 0; i < actual_effort_length; i++){ union { double real; uint64_t base; } u_st_actual_effort; u_st_actual_effort.base = 0; u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_actual_effort = u_st_actual_effort.real; offset += sizeof(this->st_actual_effort); memcpy( &(this->actual_effort[i]), &(this->st_actual_effort), sizeof(double)); } uint32_t gravity_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset))); gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->gravity_model_effort_length); if(gravity_model_effort_lengthT > gravity_model_effort_length) this->gravity_model_effort = (double*)realloc(this->gravity_model_effort, gravity_model_effort_lengthT * sizeof(double)); gravity_model_effort_length = gravity_model_effort_lengthT; for( uint32_t i = 0; i < gravity_model_effort_length; i++){ union { double real; uint64_t base; } u_st_gravity_model_effort; u_st_gravity_model_effort.base = 0; u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_gravity_model_effort = u_st_gravity_model_effort.real; offset += sizeof(this->st_gravity_model_effort); memcpy( &(this->gravity_model_effort[i]), &(this->st_gravity_model_effort), sizeof(double)); } uint32_t gravity_only_lengthT = ((uint32_t) (*(inbuffer + offset))); gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->gravity_only_length); if(gravity_only_lengthT > gravity_only_length) this->gravity_only = (double*)realloc(this->gravity_only, gravity_only_lengthT * sizeof(double)); gravity_only_length = gravity_only_lengthT; for( uint32_t i = 0; i < gravity_only_length; i++){ union { double real; uint64_t base; } u_st_gravity_only; u_st_gravity_only.base = 0; u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_gravity_only = u_st_gravity_only.real; offset += sizeof(this->st_gravity_only); memcpy( &(this->gravity_only[i]), &(this->st_gravity_only), sizeof(double)); } uint32_t interaction_torque_lengthT = ((uint32_t) (*(inbuffer + offset))); interaction_torque_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); interaction_torque_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); interaction_torque_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->interaction_torque_length); if(interaction_torque_lengthT > interaction_torque_length) this->interaction_torque = (double*)realloc(this->interaction_torque, interaction_torque_lengthT * sizeof(double)); interaction_torque_length = interaction_torque_lengthT; for( uint32_t i = 0; i < interaction_torque_length; i++){ union { double real; uint64_t base; } u_st_interaction_torque; u_st_interaction_torque.base = 0; u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_interaction_torque.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_interaction_torque = u_st_interaction_torque.real; offset += sizeof(this->st_interaction_torque); memcpy( &(this->interaction_torque[i]), &(this->st_interaction_torque), sizeof(double)); } uint32_t hysteresis_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset))); hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->hysteresis_model_effort_length); if(hysteresis_model_effort_lengthT > hysteresis_model_effort_length) this->hysteresis_model_effort = (double*)realloc(this->hysteresis_model_effort, hysteresis_model_effort_lengthT * sizeof(double)); hysteresis_model_effort_length = hysteresis_model_effort_lengthT; for( uint32_t i = 0; i < hysteresis_model_effort_length; i++){ union { double real; uint64_t base; } u_st_hysteresis_model_effort; u_st_hysteresis_model_effort.base = 0; u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_hysteresis_model_effort = u_st_hysteresis_model_effort.real; offset += sizeof(this->st_hysteresis_model_effort); memcpy( &(this->hysteresis_model_effort[i]), &(this->st_hysteresis_model_effort), sizeof(double)); } uint32_t crosstalk_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset))); crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->crosstalk_model_effort_length); if(crosstalk_model_effort_lengthT > crosstalk_model_effort_length) this->crosstalk_model_effort = (double*)realloc(this->crosstalk_model_effort, crosstalk_model_effort_lengthT * sizeof(double)); crosstalk_model_effort_length = crosstalk_model_effort_lengthT; for( uint32_t i = 0; i < crosstalk_model_effort_length; i++){ union { double real; uint64_t base; } u_st_crosstalk_model_effort; u_st_crosstalk_model_effort.base = 0; u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_crosstalk_model_effort = u_st_crosstalk_model_effort.real; offset += sizeof(this->st_crosstalk_model_effort); memcpy( &(this->crosstalk_model_effort[i]), &(this->st_crosstalk_model_effort), sizeof(double)); } union { double real; uint64_t base; } u_hystState; u_hystState.base = 0; u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->hystState = u_hystState.real; offset += sizeof(this->hystState); return offset; } const char * getType(){ return "intera_core_msgs/SEAJointState"; }; const char * getMD5(){ return "5df7bfe6612daccc934b34dad7800762"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_HomingCommand_h #define _ROS_intera_core_msgs_HomingCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class HomingCommand : public ros::Msg { public: uint32_t name_length; typedef char* _name_type; _name_type st_name; _name_type * name; uint32_t command_length; typedef int32_t _command_type; _command_type st_command; _command_type * command; enum { MANUAL = 1 }; enum { AUTO = 2 }; enum { NONE = 0 }; HomingCommand(): name_length(0), name(NULL), command_length(0), command(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF; offset += sizeof(this->name_length); for( uint32_t i = 0; i < name_length; i++){ uint32_t length_namei = strlen(this->name[i]); varToArr(outbuffer + offset, length_namei); offset += 4; memcpy(outbuffer + offset, this->name[i], length_namei); offset += length_namei; } *(outbuffer + offset + 0) = (this->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 { int32_t real; uint32_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; offset += sizeof(this->command[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset))); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->name_length); if(name_lengthT > name_length) this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*)); name_length = name_lengthT; for( uint32_t i = 0; i < name_length; i++){ uint32_t length_st_name; arrToVar(length_st_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_name-1]=0; this->st_name = (char *)(inbuffer + offset-1); offset += length_st_name; memcpy( &(this->name[i]), &(this->st_name), sizeof(char*)); } uint32_t 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 = (int32_t*)realloc(this->command, command_lengthT * sizeof(int32_t)); command_length = command_lengthT; for( uint32_t i = 0; i < command_length; i++){ union { int32_t real; uint32_t base; } u_st_command; u_st_command.base = 0; u_st_command.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_command.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_command.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_command.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_command = u_st_command.real; offset += sizeof(this->st_command); memcpy( &(this->command[i]), &(this->st_command), sizeof(int32_t)); } return offset; } const char * getType(){ return "intera_core_msgs/HomingCommand"; }; const char * getMD5(){ return "ff29c86109f0f4cada5bbde945dd55c4"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_CollisionAvoidanceState_h #define _ROS_intera_core_msgs_CollisionAvoidanceState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace intera_core_msgs { class CollisionAvoidanceState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef bool _other_arm_type; _other_arm_type other_arm; uint32_t collision_object_length; typedef char* _collision_object_type; _collision_object_type st_collision_object; _collision_object_type * collision_object; CollisionAvoidanceState(): header(), other_arm(0), collision_object_length(0), collision_object(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_other_arm; u_other_arm.real = this->other_arm; *(outbuffer + offset + 0) = (u_other_arm.base >> (8 * 0)) & 0xFF; offset += sizeof(this->other_arm); *(outbuffer + offset + 0) = (this->collision_object_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->collision_object_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->collision_object_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->collision_object_length >> (8 * 3)) & 0xFF; offset += sizeof(this->collision_object_length); for( uint32_t i = 0; i < collision_object_length; i++){ uint32_t length_collision_objecti = strlen(this->collision_object[i]); varToArr(outbuffer + offset, length_collision_objecti); offset += 4; memcpy(outbuffer + offset, this->collision_object[i], length_collision_objecti); offset += length_collision_objecti; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_other_arm; u_other_arm.base = 0; u_other_arm.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->other_arm = u_other_arm.real; offset += sizeof(this->other_arm); uint32_t collision_object_lengthT = ((uint32_t) (*(inbuffer + offset))); collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->collision_object_length); if(collision_object_lengthT > collision_object_length) this->collision_object = (char**)realloc(this->collision_object, collision_object_lengthT * sizeof(char*)); collision_object_length = collision_object_lengthT; for( uint32_t i = 0; i < collision_object_length; i++){ uint32_t length_st_collision_object; arrToVar(length_st_collision_object, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_collision_object; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_collision_object-1]=0; this->st_collision_object = (char *)(inbuffer + offset-1); offset += length_st_collision_object; memcpy( &(this->collision_object[i]), &(this->st_collision_object), sizeof(char*)); } return offset; } const char * getType(){ return "intera_core_msgs/CollisionAvoidanceState"; }; const char * getMD5(){ return "30f5cb8ae019f1ffe8b599e6d2e589c7"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_URDFConfiguration_h #define _ROS_intera_core_msgs_URDFConfiguration_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" namespace intera_core_msgs { class URDFConfiguration : public ros::Msg { public: typedef ros::Time _time_type; _time_type time; typedef const char* _link_type; _link_type link; typedef const char* _joint_type; _joint_type joint; typedef const char* _urdf_type; _urdf_type urdf; URDFConfiguration(): time(), link(""), joint(""), urdf("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.sec); *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.nsec); uint32_t length_link = strlen(this->link); varToArr(outbuffer + offset, length_link); offset += 4; memcpy(outbuffer + offset, this->link, length_link); offset += length_link; uint32_t length_joint = strlen(this->joint); varToArr(outbuffer + offset, length_joint); offset += 4; memcpy(outbuffer + offset, this->joint, length_joint); offset += length_joint; uint32_t length_urdf = strlen(this->urdf); varToArr(outbuffer + offset, length_urdf); offset += 4; memcpy(outbuffer + offset, this->urdf, length_urdf); offset += length_urdf; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->time.sec = ((uint32_t) (*(inbuffer + offset))); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.sec); this->time.nsec = ((uint32_t) (*(inbuffer + offset))); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.nsec); uint32_t length_link; arrToVar(length_link, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_link; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_link-1]=0; this->link = (char *)(inbuffer + offset-1); offset += length_link; uint32_t length_joint; arrToVar(length_joint, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_joint; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_joint-1]=0; this->joint = (char *)(inbuffer + offset-1); offset += length_joint; uint32_t length_urdf; arrToVar(length_urdf, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_urdf; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_urdf-1]=0; this->urdf = (char *)(inbuffer + offset-1); offset += length_urdf; return offset; } const char * getType(){ return "intera_core_msgs/URDFConfiguration"; }; const char * getMD5(){ return "0c7028d878027820eed2aa0cbf1f5e4a"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_CollisionDetectionState_h #define _ROS_intera_core_msgs_CollisionDetectionState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace intera_core_msgs { class CollisionDetectionState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef bool _collision_state_type; _collision_state_type collision_state; CollisionDetectionState(): header(), collision_state(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_collision_state; u_collision_state.real = this->collision_state; *(outbuffer + offset + 0) = (u_collision_state.base >> (8 * 0)) & 0xFF; offset += sizeof(this->collision_state); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_collision_state; u_collision_state.base = 0; u_collision_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->collision_state = u_collision_state.real; offset += sizeof(this->collision_state); return offset; } const char * getType(){ return "intera_core_msgs/CollisionDetectionState"; }; const char * getMD5(){ return "7bde38c182b4d08fdc0635b116f65d04"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_EndpointStates_h #define _ROS_intera_core_msgs_EndpointStates_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "intera_core_msgs/EndpointState.h" namespace intera_core_msgs { class EndpointStates : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t names_length; typedef char* _names_type; _names_type st_names; _names_type * names; uint32_t states_length; typedef intera_core_msgs::EndpointState _states_type; _states_type st_states; _states_type * states; EndpointStates(): header(), names_length(0), names(NULL), states_length(0), states(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->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; } *(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF; offset += sizeof(this->states_length); for( uint32_t i = 0; i < states_length; i++){ offset += this->states[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t 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*)); } 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 = (intera_core_msgs::EndpointState*)realloc(this->states, states_lengthT * sizeof(intera_core_msgs::EndpointState)); states_length = states_lengthT; for( uint32_t i = 0; i < states_length; i++){ offset += this->st_states.deserialize(inbuffer + offset); memcpy( &(this->states[i]), &(this->st_states), sizeof(intera_core_msgs::EndpointState)); } return offset; } const char * getType(){ return "intera_core_msgs/EndpointStates"; }; const char * getMD5(){ return "d7b5ea85d8388c002e6c6d800ba697bc"; }; }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_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 intera_core_msgs { static const char SOLVEPOSITIONIK[] = "intera_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 int8_t _seed_mode_type; _seed_mode_type seed_mode; uint32_t use_nullspace_goal_length; typedef bool _use_nullspace_goal_type; _use_nullspace_goal_type st_use_nullspace_goal; _use_nullspace_goal_type * use_nullspace_goal; uint32_t nullspace_goal_length; typedef sensor_msgs::JointState _nullspace_goal_type; _nullspace_goal_type st_nullspace_goal; _nullspace_goal_type * nullspace_goal; uint32_t nullspace_gain_length; typedef double _nullspace_gain_type; _nullspace_gain_type st_nullspace_gain; _nullspace_gain_type * nullspace_gain; uint32_t tip_names_length; typedef char* _tip_names_type; _tip_names_type st_tip_names; _tip_names_type * tip_names; 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), use_nullspace_goal_length(0), use_nullspace_goal(NULL), nullspace_goal_length(0), nullspace_goal(NULL), nullspace_gain_length(0), nullspace_gain(NULL), tip_names_length(0), tip_names(NULL) { } 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); } union { int8_t real; uint8_t base; } u_seed_mode; u_seed_mode.real = this->seed_mode; *(outbuffer + offset + 0) = (u_seed_mode.base >> (8 * 0)) & 0xFF; offset += sizeof(this->seed_mode); *(outbuffer + offset + 0) = (this->use_nullspace_goal_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->use_nullspace_goal_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->use_nullspace_goal_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->use_nullspace_goal_length >> (8 * 3)) & 0xFF; offset += sizeof(this->use_nullspace_goal_length); for( uint32_t i = 0; i < use_nullspace_goal_length; i++){ union { bool real; uint8_t base; } u_use_nullspace_goali; u_use_nullspace_goali.real = this->use_nullspace_goal[i]; *(outbuffer + offset + 0) = (u_use_nullspace_goali.base >> (8 * 0)) & 0xFF; offset += sizeof(this->use_nullspace_goal[i]); } *(outbuffer + offset + 0) = (this->nullspace_goal_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->nullspace_goal_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->nullspace_goal_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->nullspace_goal_length >> (8 * 3)) & 0xFF; offset += sizeof(this->nullspace_goal_length); for( uint32_t i = 0; i < nullspace_goal_length; i++){ offset += this->nullspace_goal[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->nullspace_gain_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->nullspace_gain_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->nullspace_gain_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->nullspace_gain_length >> (8 * 3)) & 0xFF; offset += sizeof(this->nullspace_gain_length); for( uint32_t i = 0; i < nullspace_gain_length; i++){ union { double real; uint64_t base; } u_nullspace_gaini; u_nullspace_gaini.real = this->nullspace_gain[i]; *(outbuffer + offset + 0) = (u_nullspace_gaini.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_nullspace_gaini.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_nullspace_gaini.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_nullspace_gaini.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_nullspace_gaini.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_nullspace_gaini.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_nullspace_gaini.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_nullspace_gaini.base >> (8 * 7)) & 0xFF; offset += sizeof(this->nullspace_gain[i]); } *(outbuffer + offset + 0) = (this->tip_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->tip_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->tip_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->tip_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->tip_names_length); for( uint32_t i = 0; i < tip_names_length; i++){ uint32_t length_tip_namesi = strlen(this->tip_names[i]); varToArr(outbuffer + offset, length_tip_namesi); offset += 4; memcpy(outbuffer + offset, this->tip_names[i], length_tip_namesi); offset += length_tip_namesi; } 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)); } union { int8_t real; uint8_t base; } u_seed_mode; u_seed_mode.base = 0; u_seed_mode.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->seed_mode = u_seed_mode.real; offset += sizeof(this->seed_mode); uint32_t use_nullspace_goal_lengthT = ((uint32_t) (*(inbuffer + offset))); use_nullspace_goal_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); use_nullspace_goal_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); use_nullspace_goal_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->use_nullspace_goal_length); if(use_nullspace_goal_lengthT > use_nullspace_goal_length) this->use_nullspace_goal = (bool*)realloc(this->use_nullspace_goal, use_nullspace_goal_lengthT * sizeof(bool)); use_nullspace_goal_length = use_nullspace_goal_lengthT; for( uint32_t i = 0; i < use_nullspace_goal_length; i++){ union { bool real; uint8_t base; } u_st_use_nullspace_goal; u_st_use_nullspace_goal.base = 0; u_st_use_nullspace_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_use_nullspace_goal = u_st_use_nullspace_goal.real; offset += sizeof(this->st_use_nullspace_goal); memcpy( &(this->use_nullspace_goal[i]), &(this->st_use_nullspace_goal), sizeof(bool)); } uint32_t nullspace_goal_lengthT = ((uint32_t) (*(inbuffer + offset))); nullspace_goal_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); nullspace_goal_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); nullspace_goal_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->nullspace_goal_length); if(nullspace_goal_lengthT > nullspace_goal_length) this->nullspace_goal = (sensor_msgs::JointState*)realloc(this->nullspace_goal, nullspace_goal_lengthT * sizeof(sensor_msgs::JointState)); nullspace_goal_length = nullspace_goal_lengthT; for( uint32_t i = 0; i < nullspace_goal_length; i++){ offset += this->st_nullspace_goal.deserialize(inbuffer + offset); memcpy( &(this->nullspace_goal[i]), &(this->st_nullspace_goal), sizeof(sensor_msgs::JointState)); } uint32_t nullspace_gain_lengthT = ((uint32_t) (*(inbuffer + offset))); nullspace_gain_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); nullspace_gain_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); nullspace_gain_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->nullspace_gain_length); if(nullspace_gain_lengthT > nullspace_gain_length) this->nullspace_gain = (double*)realloc(this->nullspace_gain, nullspace_gain_lengthT * sizeof(double)); nullspace_gain_length = nullspace_gain_lengthT; for( uint32_t i = 0; i < nullspace_gain_length; i++){ union { double real; uint64_t base; } u_st_nullspace_gain; u_st_nullspace_gain.base = 0; u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_nullspace_gain.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_nullspace_gain = u_st_nullspace_gain.real; offset += sizeof(this->st_nullspace_gain); memcpy( &(this->nullspace_gain[i]), &(this->st_nullspace_gain), sizeof(double)); } uint32_t tip_names_lengthT = ((uint32_t) (*(inbuffer + offset))); tip_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); tip_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); tip_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->tip_names_length); if(tip_names_lengthT > tip_names_length) this->tip_names = (char**)realloc(this->tip_names, tip_names_lengthT * sizeof(char*)); tip_names_length = tip_names_lengthT; for( uint32_t i = 0; i < tip_names_length; i++){ uint32_t length_st_tip_names; arrToVar(length_st_tip_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_tip_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_tip_names-1]=0; this->st_tip_names = (char *)(inbuffer + offset-1); offset += length_st_tip_names; memcpy( &(this->tip_names[i]), &(this->st_tip_names), sizeof(char*)); } return offset; } const char * getType(){ return SOLVEPOSITIONIK; }; const char * getMD5(){ return "b09dd99695bb18639bfea7c92d0a89ca"; }; }; 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 result_type_length; typedef int8_t _result_type_type; _result_type_type st_result_type; _result_type_type * result_type; enum { IK_FAILED = -1 }; enum { IK_IN_COLLISION = -2 }; enum { IK_ENDPOINT_DOES_NOT_EXIST = -3 }; SolvePositionIKResponse(): joints_length(0), joints(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->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++){ union { int8_t real; uint8_t base; } u_result_typei; u_result_typei.real = this->result_type[i]; *(outbuffer + offset + 0) = (u_result_typei.base >> (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 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 = (int8_t*)realloc(this->result_type, result_type_lengthT * sizeof(int8_t)); result_type_length = result_type_lengthT; for( uint32_t i = 0; i < result_type_length; i++){ union { int8_t real; uint8_t base; } u_st_result_type; u_st_result_type.base = 0; u_st_result_type.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_result_type = u_st_result_type.real; offset += sizeof(this->st_result_type); memcpy( &(this->result_type[i]), &(this->st_result_type), sizeof(int8_t)); } return offset; } const char * getType(){ return SOLVEPOSITIONIK; }; const char * getMD5(){ return "d47b4ca70898ba1b2f99ffdf9b81d911"; }; }; 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/intera_core_msgs/DigitalIOState.h

#ifndef _ROS_intera_core_msgs_DigitalIOState_h #define _ROS_intera_core_msgs_DigitalIOState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class DigitalIOState : public ros::Msg { public: typedef int8_t _state_type; _state_type state; typedef bool _isInputOnly_type; _isInputOnly_type isInputOnly; enum { OFF = 0 }; enum { ON = 1 }; enum { PRESSED = 1 }; enum { UNPRESSED = 0 }; DigitalIOState(): state(0), isInputOnly(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int8_t real; uint8_t base; } u_state; u_state.real = this->state; *(outbuffer + offset + 0) = (u_state.base >> (8 * 0)) & 0xFF; offset += sizeof(this->state); union { bool real; uint8_t base; } u_isInputOnly; u_isInputOnly.real = this->isInputOnly; *(outbuffer + offset + 0) = (u_isInputOnly.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isInputOnly); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int8_t real; uint8_t base; } u_state; u_state.base = 0; u_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->state = u_state.real; offset += sizeof(this->state); union { bool real; uint8_t base; } u_isInputOnly; u_isInputOnly.base = 0; u_isInputOnly.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isInputOnly = u_isInputOnly.real; offset += sizeof(this->isInputOnly); return offset; } const char * getType(){ return "intera_core_msgs/DigitalIOState"; }; const char * getMD5(){ return "29d0be3859dae81a66b28f167ecec98c"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_IOComponentCommandSrv_h #define _ROS_SERVICE_IOComponentCommandSrv_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "intera_core_msgs/IOStatus.h" #include "ros/time.h" #include "intera_core_msgs/IOComponentCommand.h" namespace intera_core_msgs { static const char IOCOMPONENTCOMMANDSRV[] = "intera_core_msgs/IOComponentCommandSrv"; class IOComponentCommandSrvRequest : public ros::Msg { public: typedef intera_core_msgs::IOComponentCommand _command_type; _command_type command; typedef float _timeout_type; _timeout_type timeout; IOComponentCommandSrvRequest(): command(), timeout(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->command.serialize(outbuffer + offset); union { float real; uint32_t base; } u_timeout; u_timeout.real = this->timeout; *(outbuffer + offset + 0) = (u_timeout.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_timeout.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_timeout.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_timeout.base >> (8 * 3)) & 0xFF; offset += sizeof(this->timeout); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->command.deserialize(inbuffer + offset); union { float real; uint32_t base; } u_timeout; u_timeout.base = 0; u_timeout.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_timeout.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_timeout.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_timeout.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->timeout = u_timeout.real; offset += sizeof(this->timeout); return offset; } const char * getType(){ return IOCOMPONENTCOMMANDSRV; }; const char * getMD5(){ return "f1576f0935f7d90abe14dbedf574be71"; }; }; class IOComponentCommandSrvResponse : public ros::Msg { public: typedef ros::Time _time_type; _time_type time; typedef const char* _op_type; _op_type op; typedef intera_core_msgs::IOStatus _status_type; _status_type status; typedef const char* _response_type; _response_type response; IOComponentCommandSrvResponse(): time(), op(""), status(), response("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.sec); *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.nsec); uint32_t length_op = strlen(this->op); varToArr(outbuffer + offset, length_op); offset += 4; memcpy(outbuffer + offset, this->op, length_op); offset += length_op; offset += this->status.serialize(outbuffer + offset); uint32_t length_response = strlen(this->response); varToArr(outbuffer + offset, length_response); offset += 4; memcpy(outbuffer + offset, this->response, length_response); offset += length_response; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->time.sec = ((uint32_t) (*(inbuffer + offset))); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.sec); this->time.nsec = ((uint32_t) (*(inbuffer + offset))); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.nsec); uint32_t length_op; arrToVar(length_op, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_op; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_op-1]=0; this->op = (char *)(inbuffer + offset-1); offset += length_op; offset += this->status.deserialize(inbuffer + offset); uint32_t length_response; arrToVar(length_response, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_response; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_response-1]=0; this->response = (char *)(inbuffer + offset-1); offset += length_response; return offset; } const char * getType(){ return IOCOMPONENTCOMMANDSRV; }; const char * getMD5(){ return "201c021e76b3e871e24d4b9fd38ffd49"; }; }; class IOComponentCommandSrv { public: typedef IOComponentCommandSrvRequest Request; typedef IOComponentCommandSrvResponse Response; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IOComponentConfiguration_h #define _ROS_intera_core_msgs_IOComponentConfiguration_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class IOComponentConfiguration : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef const char* _config_type; _config_type config; IOComponentConfiguration(): name(""), config("") { } 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_config = strlen(this->config); varToArr(outbuffer + offset, length_config); offset += 4; memcpy(outbuffer + offset, this->config, length_config); offset += length_config; 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_config; arrToVar(length_config, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_config; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_config-1]=0; this->config = (char *)(inbuffer + offset-1); offset += length_config; return offset; } const char * getType(){ return "intera_core_msgs/IOComponentConfiguration"; }; const char * getMD5(){ return "cb7717d13a521b51b5c0a02d493c42fd"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IODeviceConfiguration_h #define _ROS_intera_core_msgs_IODeviceConfiguration_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" #include "intera_core_msgs/IOComponentConfiguration.h" namespace intera_core_msgs { class IODeviceConfiguration : public ros::Msg { public: typedef ros::Time _time_type; _time_type time; typedef const char* _commanded_type; _commanded_type commanded; typedef const char* _upgraded_type; _upgraded_type upgraded; typedef intera_core_msgs::IOComponentConfiguration _device_type; _device_type device; uint32_t ports_length; typedef intera_core_msgs::IOComponentConfiguration _ports_type; _ports_type st_ports; _ports_type * ports; uint32_t signals_length; typedef intera_core_msgs::IOComponentConfiguration _signals_type; _signals_type st_signals; _signals_type * signals; IODeviceConfiguration(): time(), commanded(""), upgraded(""), device(), ports_length(0), ports(NULL), signals_length(0), signals(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.sec); *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.nsec); uint32_t length_commanded = strlen(this->commanded); varToArr(outbuffer + offset, length_commanded); offset += 4; memcpy(outbuffer + offset, this->commanded, length_commanded); offset += length_commanded; uint32_t length_upgraded = strlen(this->upgraded); varToArr(outbuffer + offset, length_upgraded); offset += 4; memcpy(outbuffer + offset, this->upgraded, length_upgraded); offset += length_upgraded; offset += this->device.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->ports_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->ports_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->ports_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->ports_length >> (8 * 3)) & 0xFF; offset += sizeof(this->ports_length); for( uint32_t i = 0; i < ports_length; i++){ offset += this->ports[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->signals_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->signals_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->signals_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->signals_length >> (8 * 3)) & 0xFF; offset += sizeof(this->signals_length); for( uint32_t i = 0; i < signals_length; i++){ offset += this->signals[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->time.sec = ((uint32_t) (*(inbuffer + offset))); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.sec); this->time.nsec = ((uint32_t) (*(inbuffer + offset))); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.nsec); uint32_t length_commanded; arrToVar(length_commanded, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_commanded; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_commanded-1]=0; this->commanded = (char *)(inbuffer + offset-1); offset += length_commanded; uint32_t length_upgraded; arrToVar(length_upgraded, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_upgraded; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_upgraded-1]=0; this->upgraded = (char *)(inbuffer + offset-1); offset += length_upgraded; offset += this->device.deserialize(inbuffer + offset); uint32_t ports_lengthT = ((uint32_t) (*(inbuffer + offset))); ports_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); ports_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); ports_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->ports_length); if(ports_lengthT > ports_length) this->ports = (intera_core_msgs::IOComponentConfiguration*)realloc(this->ports, ports_lengthT * sizeof(intera_core_msgs::IOComponentConfiguration)); ports_length = ports_lengthT; for( uint32_t i = 0; i < ports_length; i++){ offset += this->st_ports.deserialize(inbuffer + offset); memcpy( &(this->ports[i]), &(this->st_ports), sizeof(intera_core_msgs::IOComponentConfiguration)); } uint32_t signals_lengthT = ((uint32_t) (*(inbuffer + offset))); signals_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); signals_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); signals_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->signals_length); if(signals_lengthT > signals_length) this->signals = (intera_core_msgs::IOComponentConfiguration*)realloc(this->signals, signals_lengthT * sizeof(intera_core_msgs::IOComponentConfiguration)); signals_length = signals_lengthT; for( uint32_t i = 0; i < signals_length; i++){ offset += this->st_signals.deserialize(inbuffer + offset); memcpy( &(this->signals[i]), &(this->st_signals), sizeof(intera_core_msgs::IOComponentConfiguration)); } return offset; } const char * getType(){ return "intera_core_msgs/IODeviceConfiguration"; }; const char * getMD5(){ return "6757fad6217033498191470cb08f1674"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IODataStatus_h #define _ROS_intera_core_msgs_IODataStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "intera_core_msgs/IOStatus.h" namespace intera_core_msgs { class IODataStatus : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef const char* _format_type; _format_type format; typedef const char* _data_type; _data_type data; typedef intera_core_msgs::IOStatus _status_type; _status_type status; IODataStatus(): name(""), format(""), data(""), status() { } 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_format = strlen(this->format); varToArr(outbuffer + offset, length_format); offset += 4; memcpy(outbuffer + offset, this->format, length_format); offset += length_format; uint32_t length_data = strlen(this->data); varToArr(outbuffer + offset, length_data); offset += 4; memcpy(outbuffer + offset, this->data, length_data); offset += length_data; offset += this->status.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; uint32_t length_format; arrToVar(length_format, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_format; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_format-1]=0; this->format = (char *)(inbuffer + offset-1); offset += length_format; uint32_t length_data; arrToVar(length_data, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_data; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_data-1]=0; this->data = (char *)(inbuffer + offset-1); offset += length_data; offset += this->status.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "intera_core_msgs/IODataStatus"; }; const char * getMD5(){ return "bb31283c6afc4ddea2f5f157264e5909"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_HeadState_h #define _ROS_intera_core_msgs_HeadState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class HeadState : public ros::Msg { public: typedef float _pan_type; _pan_type pan; typedef bool _isTurning_type; _isTurning_type isTurning; typedef bool _isBlocked_type; _isBlocked_type isBlocked; typedef uint8_t _panMode_type; _panMode_type panMode; enum { PASSIVE_MODE = 0 }; enum { ACTIVE_MODE = 1 }; enum { ACTIVE_CANCELLATION_MODE = 2 }; HeadState(): pan(0), isTurning(0), isBlocked(0), panMode(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_isBlocked; u_isBlocked.real = this->isBlocked; *(outbuffer + offset + 0) = (u_isBlocked.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isBlocked); *(outbuffer + offset + 0) = (this->panMode >> (8 * 0)) & 0xFF; offset += sizeof(this->panMode); 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_isBlocked; u_isBlocked.base = 0; u_isBlocked.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isBlocked = u_isBlocked.real; offset += sizeof(this->isBlocked); this->panMode = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->panMode); return offset; } const char * getType(){ return "intera_core_msgs/HeadState"; }; const char * getMD5(){ return "51024ade10ffefe117049c9ba6fd743c"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IOComponentCommand_h #define _ROS_intera_core_msgs_IOComponentCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" namespace intera_core_msgs { class IOComponentCommand : public ros::Msg { public: typedef ros::Time _time_type; _time_type time; typedef const char* _op_type; _op_type op; typedef const char* _args_type; _args_type args; IOComponentCommand(): time(), op(""), args("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.sec); *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.nsec); uint32_t length_op = strlen(this->op); varToArr(outbuffer + offset, length_op); offset += 4; memcpy(outbuffer + offset, this->op, length_op); offset += length_op; uint32_t length_args = strlen(this->args); varToArr(outbuffer + offset, length_args); offset += 4; memcpy(outbuffer + offset, this->args, length_args); offset += length_args; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->time.sec = ((uint32_t) (*(inbuffer + offset))); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.sec); this->time.nsec = ((uint32_t) (*(inbuffer + offset))); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.nsec); uint32_t length_op; arrToVar(length_op, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_op; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_op-1]=0; this->op = (char *)(inbuffer + offset-1); offset += length_op; 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; return offset; } const char * getType(){ return "intera_core_msgs/IOComponentCommand"; }; const char * getMD5(){ return "ede95ba2953dc221dc82cac20f697530"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IODeviceStatus_h #define _ROS_intera_core_msgs_IODeviceStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" #include "intera_core_msgs/IOComponentStatus.h" #include "intera_core_msgs/IODataStatus.h" namespace intera_core_msgs { class IODeviceStatus : public ros::Msg { public: typedef ros::Time _time_type; _time_type time; typedef intera_core_msgs::IOComponentStatus _device_type; _device_type device; uint32_t ports_length; typedef intera_core_msgs::IODataStatus _ports_type; _ports_type st_ports; _ports_type * ports; uint32_t signals_length; typedef intera_core_msgs::IODataStatus _signals_type; _signals_type st_signals; _signals_type * signals; uint32_t commands_length; typedef ros::Time _commands_type; _commands_type st_commands; _commands_type * commands; uint32_t responses_length; typedef char* _responses_type; _responses_type st_responses; _responses_type * responses; IODeviceStatus(): time(), device(), ports_length(0), ports(NULL), signals_length(0), signals(NULL), commands_length(0), commands(NULL), responses_length(0), responses(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.sec); *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.nsec); offset += this->device.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->ports_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->ports_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->ports_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->ports_length >> (8 * 3)) & 0xFF; offset += sizeof(this->ports_length); for( uint32_t i = 0; i < ports_length; i++){ offset += this->ports[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->signals_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->signals_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->signals_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->signals_length >> (8 * 3)) & 0xFF; offset += sizeof(this->signals_length); for( uint32_t i = 0; i < signals_length; i++){ offset += this->signals[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->commands_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commands_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commands_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commands_length >> (8 * 3)) & 0xFF; offset += sizeof(this->commands_length); for( uint32_t i = 0; i < commands_length; i++){ *(outbuffer + offset + 0) = (this->commands[i].sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commands[i].sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commands[i].sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commands[i].sec >> (8 * 3)) & 0xFF; offset += sizeof(this->commands[i].sec); *(outbuffer + offset + 0) = (this->commands[i].nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commands[i].nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commands[i].nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commands[i].nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->commands[i].nsec); } *(outbuffer + offset + 0) = (this->responses_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->responses_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->responses_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->responses_length >> (8 * 3)) & 0xFF; offset += sizeof(this->responses_length); for( uint32_t i = 0; i < responses_length; i++){ uint32_t length_responsesi = strlen(this->responses[i]); varToArr(outbuffer + offset, length_responsesi); offset += 4; memcpy(outbuffer + offset, this->responses[i], length_responsesi); offset += length_responsesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->time.sec = ((uint32_t) (*(inbuffer + offset))); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.sec); this->time.nsec = ((uint32_t) (*(inbuffer + offset))); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.nsec); offset += this->device.deserialize(inbuffer + offset); uint32_t ports_lengthT = ((uint32_t) (*(inbuffer + offset))); ports_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); ports_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); ports_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->ports_length); if(ports_lengthT > ports_length) this->ports = (intera_core_msgs::IODataStatus*)realloc(this->ports, ports_lengthT * sizeof(intera_core_msgs::IODataStatus)); ports_length = ports_lengthT; for( uint32_t i = 0; i < ports_length; i++){ offset += this->st_ports.deserialize(inbuffer + offset); memcpy( &(this->ports[i]), &(this->st_ports), sizeof(intera_core_msgs::IODataStatus)); } uint32_t signals_lengthT = ((uint32_t) (*(inbuffer + offset))); signals_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); signals_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); signals_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->signals_length); if(signals_lengthT > signals_length) this->signals = (intera_core_msgs::IODataStatus*)realloc(this->signals, signals_lengthT * sizeof(intera_core_msgs::IODataStatus)); signals_length = signals_lengthT; for( uint32_t i = 0; i < signals_length; i++){ offset += this->st_signals.deserialize(inbuffer + offset); memcpy( &(this->signals[i]), &(this->st_signals), sizeof(intera_core_msgs::IODataStatus)); } uint32_t commands_lengthT = ((uint32_t) (*(inbuffer + offset))); commands_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); commands_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); commands_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->commands_length); if(commands_lengthT > commands_length) this->commands = (ros::Time*)realloc(this->commands, commands_lengthT * sizeof(ros::Time)); commands_length = commands_lengthT; for( uint32_t i = 0; i < commands_length; i++){ this->st_commands.sec = ((uint32_t) (*(inbuffer + offset))); this->st_commands.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->st_commands.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->st_commands.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->st_commands.sec); this->st_commands.nsec = ((uint32_t) (*(inbuffer + offset))); this->st_commands.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->st_commands.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->st_commands.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->st_commands.nsec); memcpy( &(this->commands[i]), &(this->st_commands), sizeof(ros::Time)); } uint32_t responses_lengthT = ((uint32_t) (*(inbuffer + offset))); responses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); responses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); responses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->responses_length); if(responses_lengthT > responses_length) this->responses = (char**)realloc(this->responses, responses_lengthT * sizeof(char*)); responses_length = responses_lengthT; for( uint32_t i = 0; i < responses_length; i++){ uint32_t length_st_responses; arrToVar(length_st_responses, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_responses; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_responses-1]=0; this->st_responses = (char *)(inbuffer + offset-1); offset += length_st_responses; memcpy( &(this->responses[i]), &(this->st_responses), sizeof(char*)); } return offset; } const char * getType(){ return "intera_core_msgs/IODeviceStatus"; }; const char * getMD5(){ return "0d0c97a2d700848e7ad46e09a77cf896"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_CameraSettings_h #define _ROS_intera_core_msgs_CameraSettings_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "intera_core_msgs/CameraControl.h" namespace intera_core_msgs { class CameraSettings : public ros::Msg { public: typedef int32_t _width_type; _width_type width; typedef int32_t _height_type; _height_type height; typedef float _fps_type; _fps_type fps; uint32_t controls_length; typedef intera_core_msgs::CameraControl _controls_type; _controls_type st_controls; _controls_type * controls; CameraSettings(): width(0), height(0), fps(0), controls_length(0), controls(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int32_t real; uint32_t base; } u_width; u_width.real = this->width; *(outbuffer + offset + 0) = (u_width.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_width.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_width.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_width.base >> (8 * 3)) & 0xFF; offset += sizeof(this->width); union { int32_t real; uint32_t base; } u_height; u_height.real = this->height; *(outbuffer + offset + 0) = (u_height.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_height.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_height.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_height.base >> (8 * 3)) & 0xFF; offset += sizeof(this->height); union { float real; uint32_t base; } u_fps; u_fps.real = this->fps; *(outbuffer + offset + 0) = (u_fps.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_fps.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_fps.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_fps.base >> (8 * 3)) & 0xFF; offset += sizeof(this->fps); *(outbuffer + offset + 0) = (this->controls_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->controls_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->controls_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->controls_length >> (8 * 3)) & 0xFF; offset += sizeof(this->controls_length); for( uint32_t i = 0; i < controls_length; i++){ offset += this->controls[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int32_t real; uint32_t base; } u_width; u_width.base = 0; u_width.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_width.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_width.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_width.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->width = u_width.real; offset += sizeof(this->width); union { int32_t real; uint32_t base; } u_height; u_height.base = 0; u_height.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_height.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_height.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_height.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->height = u_height.real; offset += sizeof(this->height); union { float real; uint32_t base; } u_fps; u_fps.base = 0; u_fps.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_fps.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_fps.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_fps.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->fps = u_fps.real; offset += sizeof(this->fps); uint32_t controls_lengthT = ((uint32_t) (*(inbuffer + offset))); controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->controls_length); if(controls_lengthT > controls_length) this->controls = (intera_core_msgs::CameraControl*)realloc(this->controls, controls_lengthT * sizeof(intera_core_msgs::CameraControl)); controls_length = controls_lengthT; for( uint32_t i = 0; i < controls_length; i++){ offset += this->st_controls.deserialize(inbuffer + offset); memcpy( &(this->controls[i]), &(this->st_controls), sizeof(intera_core_msgs::CameraControl)); } return offset; } const char * getType(){ return "intera_core_msgs/CameraSettings"; }; const char * getMD5(){ return "d133bef4a3bd9a6e490a5dc91d20f429"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_NavigatorState_h #define _ROS_intera_core_msgs_NavigatorState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class NavigatorState : public ros::Msg { public: uint32_t button_names_length; typedef char* _button_names_type; _button_names_type st_button_names; _button_names_type * button_names; uint32_t buttons_length; typedef bool _buttons_type; _buttons_type st_buttons; _buttons_type * buttons; typedef uint8_t _wheel_type; _wheel_type wheel; uint32_t light_names_length; typedef char* _light_names_type; _light_names_type st_light_names; _light_names_type * light_names; uint32_t lights_length; typedef bool _lights_type; _lights_type st_lights; _lights_type * lights; NavigatorState(): button_names_length(0), button_names(NULL), buttons_length(0), buttons(NULL), wheel(0), light_names_length(0), light_names(NULL), lights_length(0), lights(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->button_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->button_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->button_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->button_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->button_names_length); for( uint32_t i = 0; i < button_names_length; i++){ uint32_t length_button_namesi = strlen(this->button_names[i]); varToArr(outbuffer + offset, length_button_namesi); offset += 4; memcpy(outbuffer + offset, this->button_names[i], length_button_namesi); offset += length_button_namesi; } *(outbuffer + offset + 0) = (this->buttons_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->buttons_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->buttons_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->buttons_length >> (8 * 3)) & 0xFF; offset += sizeof(this->buttons_length); for( uint32_t i = 0; i < buttons_length; i++){ union { bool real; uint8_t base; } u_buttonsi; u_buttonsi.real = this->buttons[i]; *(outbuffer + offset + 0) = (u_buttonsi.base >> (8 * 0)) & 0xFF; offset += sizeof(this->buttons[i]); } *(outbuffer + offset + 0) = (this->wheel >> (8 * 0)) & 0xFF; offset += sizeof(this->wheel); *(outbuffer + offset + 0) = (this->light_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->light_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->light_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->light_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->light_names_length); for( uint32_t i = 0; i < light_names_length; i++){ uint32_t length_light_namesi = strlen(this->light_names[i]); varToArr(outbuffer + offset, length_light_namesi); offset += 4; memcpy(outbuffer + offset, this->light_names[i], length_light_namesi); offset += length_light_namesi; } *(outbuffer + offset + 0) = (this->lights_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->lights_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->lights_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->lights_length >> (8 * 3)) & 0xFF; offset += sizeof(this->lights_length); for( uint32_t i = 0; i < lights_length; i++){ union { bool real; uint8_t base; } u_lightsi; u_lightsi.real = this->lights[i]; *(outbuffer + offset + 0) = (u_lightsi.base >> (8 * 0)) & 0xFF; offset += sizeof(this->lights[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t button_names_lengthT = ((uint32_t) (*(inbuffer + offset))); button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->button_names_length); if(button_names_lengthT > button_names_length) this->button_names = (char**)realloc(this->button_names, button_names_lengthT * sizeof(char*)); button_names_length = button_names_lengthT; for( uint32_t i = 0; i < button_names_length; i++){ uint32_t length_st_button_names; arrToVar(length_st_button_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_button_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_button_names-1]=0; this->st_button_names = (char *)(inbuffer + offset-1); offset += length_st_button_names; memcpy( &(this->button_names[i]), &(this->st_button_names), sizeof(char*)); } uint32_t buttons_lengthT = ((uint32_t) (*(inbuffer + offset))); buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->buttons_length); if(buttons_lengthT > buttons_length) this->buttons = (bool*)realloc(this->buttons, buttons_lengthT * sizeof(bool)); buttons_length = buttons_lengthT; for( uint32_t i = 0; i < buttons_length; i++){ union { bool real; uint8_t base; } u_st_buttons; u_st_buttons.base = 0; u_st_buttons.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_buttons = u_st_buttons.real; offset += sizeof(this->st_buttons); memcpy( &(this->buttons[i]), &(this->st_buttons), sizeof(bool)); } this->wheel = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->wheel); uint32_t light_names_lengthT = ((uint32_t) (*(inbuffer + offset))); light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->light_names_length); if(light_names_lengthT > light_names_length) this->light_names = (char**)realloc(this->light_names, light_names_lengthT * sizeof(char*)); light_names_length = light_names_lengthT; for( uint32_t i = 0; i < light_names_length; i++){ uint32_t length_st_light_names; arrToVar(length_st_light_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_light_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_light_names-1]=0; this->st_light_names = (char *)(inbuffer + offset-1); offset += length_st_light_names; memcpy( &(this->light_names[i]), &(this->st_light_names), sizeof(char*)); } uint32_t lights_lengthT = ((uint32_t) (*(inbuffer + offset))); lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->lights_length); if(lights_lengthT > lights_length) this->lights = (bool*)realloc(this->lights, lights_lengthT * sizeof(bool)); lights_length = lights_lengthT; for( uint32_t i = 0; i < lights_length; i++){ union { bool real; uint8_t base; } u_st_lights; u_st_lights.base = 0; u_st_lights.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_lights = u_st_lights.real; offset += sizeof(this->st_lights); memcpy( &(this->lights[i]), &(this->st_lights), sizeof(bool)); } return offset; } const char * getType(){ return "intera_core_msgs/NavigatorState"; }; const char * getMD5(){ return "680d121a1f16a32647298b292492fffd"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_JointLimits_h #define _ROS_intera_core_msgs_JointLimits_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class JointLimits : 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 position_lower_length; typedef double _position_lower_type; _position_lower_type st_position_lower; _position_lower_type * position_lower; uint32_t position_upper_length; typedef double _position_upper_type; _position_upper_type st_position_upper; _position_upper_type * position_upper; uint32_t velocity_length; typedef double _velocity_type; _velocity_type st_velocity; _velocity_type * velocity; uint32_t accel_length; typedef double _accel_type; _accel_type st_accel; _accel_type * accel; uint32_t effort_length; typedef double _effort_type; _effort_type st_effort; _effort_type * effort; JointLimits(): joint_names_length(0), joint_names(NULL), position_lower_length(0), position_lower(NULL), position_upper_length(0), position_upper(NULL), velocity_length(0), velocity(NULL), accel_length(0), accel(NULL), effort_length(0), effort(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->position_lower_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->position_lower_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->position_lower_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->position_lower_length >> (8 * 3)) & 0xFF; offset += sizeof(this->position_lower_length); for( uint32_t i = 0; i < position_lower_length; i++){ union { double real; uint64_t base; } u_position_loweri; u_position_loweri.real = this->position_lower[i]; *(outbuffer + offset + 0) = (u_position_loweri.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_position_loweri.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_position_loweri.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_position_loweri.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_position_loweri.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_position_loweri.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_position_loweri.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_position_loweri.base >> (8 * 7)) & 0xFF; offset += sizeof(this->position_lower[i]); } *(outbuffer + offset + 0) = (this->position_upper_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->position_upper_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->position_upper_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->position_upper_length >> (8 * 3)) & 0xFF; offset += sizeof(this->position_upper_length); for( uint32_t i = 0; i < position_upper_length; i++){ union { double real; uint64_t base; } u_position_upperi; u_position_upperi.real = this->position_upper[i]; *(outbuffer + offset + 0) = (u_position_upperi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_position_upperi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_position_upperi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_position_upperi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_position_upperi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_position_upperi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_position_upperi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_position_upperi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->position_upper[i]); } *(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF; offset += sizeof(this->velocity_length); for( uint32_t i = 0; i < velocity_length; i++){ union { double real; uint64_t base; } u_velocityi; u_velocityi.real = this->velocity[i]; *(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->velocity[i]); } *(outbuffer + offset + 0) = (this->accel_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->accel_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->accel_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->accel_length >> (8 * 3)) & 0xFF; offset += sizeof(this->accel_length); for( uint32_t i = 0; i < accel_length; i++){ union { double real; uint64_t base; } u_acceli; u_acceli.real = this->accel[i]; *(outbuffer + offset + 0) = (u_acceli.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_acceli.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_acceli.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_acceli.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_acceli.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_acceli.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_acceli.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_acceli.base >> (8 * 7)) & 0xFF; offset += sizeof(this->accel[i]); } *(outbuffer + offset + 0) = (this->effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->effort_length); for( uint32_t i = 0; i < effort_length; i++){ union { double real; uint64_t base; } u_efforti; u_efforti.real = this->effort[i]; *(outbuffer + offset + 0) = (u_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->effort[i]); } 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 position_lower_lengthT = ((uint32_t) (*(inbuffer + offset))); position_lower_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); position_lower_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); position_lower_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->position_lower_length); if(position_lower_lengthT > position_lower_length) this->position_lower = (double*)realloc(this->position_lower, position_lower_lengthT * sizeof(double)); position_lower_length = position_lower_lengthT; for( uint32_t i = 0; i < position_lower_length; i++){ union { double real; uint64_t base; } u_st_position_lower; u_st_position_lower.base = 0; u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_position_lower.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_position_lower = u_st_position_lower.real; offset += sizeof(this->st_position_lower); memcpy( &(this->position_lower[i]), &(this->st_position_lower), sizeof(double)); } uint32_t position_upper_lengthT = ((uint32_t) (*(inbuffer + offset))); position_upper_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); position_upper_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); position_upper_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->position_upper_length); if(position_upper_lengthT > position_upper_length) this->position_upper = (double*)realloc(this->position_upper, position_upper_lengthT * sizeof(double)); position_upper_length = position_upper_lengthT; for( uint32_t i = 0; i < position_upper_length; i++){ union { double real; uint64_t base; } u_st_position_upper; u_st_position_upper.base = 0; u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_position_upper.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_position_upper = u_st_position_upper.real; offset += sizeof(this->st_position_upper); memcpy( &(this->position_upper[i]), &(this->st_position_upper), sizeof(double)); } uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset))); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->velocity_length); if(velocity_lengthT > velocity_length) this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double)); velocity_length = velocity_lengthT; for( uint32_t i = 0; i < velocity_length; i++){ union { double real; uint64_t base; } u_st_velocity; u_st_velocity.base = 0; u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_velocity = u_st_velocity.real; offset += sizeof(this->st_velocity); memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double)); } uint32_t accel_lengthT = ((uint32_t) (*(inbuffer + offset))); accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->accel_length); if(accel_lengthT > accel_length) this->accel = (double*)realloc(this->accel, accel_lengthT * sizeof(double)); accel_length = accel_lengthT; for( uint32_t i = 0; i < accel_length; i++){ union { double real; uint64_t base; } u_st_accel; u_st_accel.base = 0; u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_accel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_accel = u_st_accel.real; offset += sizeof(this->st_accel); memcpy( &(this->accel[i]), &(this->st_accel), sizeof(double)); } uint32_t effort_lengthT = ((uint32_t) (*(inbuffer + offset))); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->effort_length); if(effort_lengthT > effort_length) this->effort = (double*)realloc(this->effort, effort_lengthT * sizeof(double)); effort_length = effort_lengthT; for( uint32_t i = 0; i < effort_length; i++){ union { double real; uint64_t base; } u_st_effort; u_st_effort.base = 0; u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_effort = u_st_effort.real; offset += sizeof(this->st_effort); memcpy( &(this->effort[i]), &(this->st_effort), sizeof(double)); } return offset; } const char * getType(){ return "intera_core_msgs/JointLimits"; }; const char * getMD5(){ return "c4c445eb2c9324525a704c84ca1e7598"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_AnalogIOState_h #define _ROS_intera_core_msgs_AnalogIOState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" namespace intera_core_msgs { class AnalogIOState : public ros::Msg { public: typedef ros::Time _timestamp_type; _timestamp_type timestamp; typedef double _value_type; _value_type value; typedef bool _isInputOnly_type; _isInputOnly_type isInputOnly; AnalogIOState(): timestamp(), value(0), isInputOnly(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); union { double real; uint64_t base; } u_value; u_value.real = this->value; *(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_value.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_value.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_value.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_value.base >> (8 * 7)) & 0xFF; offset += sizeof(this->value); union { bool real; uint8_t base; } u_isInputOnly; u_isInputOnly.real = this->isInputOnly; *(outbuffer + offset + 0) = (u_isInputOnly.base >> (8 * 0)) & 0xFF; offset += sizeof(this->isInputOnly); 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); union { double real; uint64_t base; } u_value; u_value.base = 0; u_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->value = u_value.real; offset += sizeof(this->value); union { bool real; uint8_t base; } u_isInputOnly; u_isInputOnly.base = 0; u_isInputOnly.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->isInputOnly = u_isInputOnly.real; offset += sizeof(this->isInputOnly); return offset; } const char * getType(){ return "intera_core_msgs/AnalogIOState"; }; const char * getMD5(){ return "39af371963dc9e4447e91f430c720b33"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_AnalogOutputCommand_h #define _ROS_intera_core_msgs_AnalogOutputCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class AnalogOutputCommand : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef uint16_t _value_type; _value_type value; AnalogOutputCommand(): name(""), value(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_name = strlen(this->name); varToArr(outbuffer + offset, length_name); offset += 4; memcpy(outbuffer + offset, this->name, length_name); offset += length_name; *(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->value >> (8 * 1)) & 0xFF; offset += sizeof(this->value); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_name; arrToVar(length_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_name-1]=0; this->name = (char *)(inbuffer + offset-1); offset += length_name; this->value = ((uint16_t) (*(inbuffer + offset))); this->value |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->value); return offset; } const char * getType(){ return "intera_core_msgs/AnalogOutputCommand"; }; const char * getMD5(){ return "a7b945129a083ca4095d48aa94841d85"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_CameraControl_h #define _ROS_intera_core_msgs_CameraControl_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class CameraControl : public ros::Msg { public: typedef int32_t _id_type; _id_type id; typedef int32_t _value_type; _value_type value; enum { CAMERA_CONTROL_EXPOSURE = 100 }; enum { CAMERA_CONTROL_GAIN = 101 }; enum { CAMERA_CONTROL_WHITE_BALANCE_R = 102 }; enum { CAMERA_CONTROL_WHITE_BALANCE_G = 103 }; enum { CAMERA_CONTROL_WHITE_BALANCE_B = 104 }; enum { CAMERA_CONTROL_WINDOW_X = 105 }; enum { CAMERA_CONTROL_WINDOW_Y = 106 }; enum { CAMERA_CONTROL_FLIP = 107 }; enum { CAMERA_CONTROL_MIRROR = 108 }; enum { CAMERA_CONTROL_RESOLUTION_HALF = 109 }; CameraControl(): id(0), value(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { int32_t real; uint32_t base; } u_id; u_id.real = this->id; *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF; offset += sizeof(this->id); union { int32_t real; uint32_t base; } u_value; u_value.real = this->value; *(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF; offset += sizeof(this->value); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { int32_t real; uint32_t base; } u_id; u_id.base = 0; u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->id = u_id.real; offset += sizeof(this->id); union { int32_t real; uint32_t base; } u_value; u_value.base = 0; u_value.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_value.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_value.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_value.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->value = u_value.real; offset += sizeof(this->value); return offset; } const char * getType(){ return "intera_core_msgs/CameraControl"; }; const char * getMD5(){ return "01e38dd67dfb36af457f0915248629d1"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IOComponentStatus_h #define _ROS_intera_core_msgs_IOComponentStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "intera_core_msgs/IOStatus.h" namespace intera_core_msgs { class IOComponentStatus : public ros::Msg { public: typedef const char* _name_type; _name_type name; typedef intera_core_msgs::IOStatus _status_type; _status_type status; IOComponentStatus(): name(""), status() { } 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->status.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->status.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "intera_core_msgs/IOComponentStatus"; }; const char * getMD5(){ return "7daed407477edd76573df598b0375a48"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IOStatus_h #define _ROS_intera_core_msgs_IOStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class IOStatus : public ros::Msg { public: typedef const char* _tag_type; _tag_type tag; typedef const char* _id_type; _id_type id; typedef const char* _detail_type; _detail_type detail; enum { DOWN = down }; enum { READY = ready }; enum { BUSY = busy }; enum { UNREADY = unready }; enum { ERROR = error }; IOStatus(): tag(""), id(""), detail("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_tag = strlen(this->tag); varToArr(outbuffer + offset, length_tag); offset += 4; memcpy(outbuffer + offset, this->tag, length_tag); offset += length_tag; 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_detail = strlen(this->detail); varToArr(outbuffer + offset, length_detail); offset += 4; memcpy(outbuffer + offset, this->detail, length_detail); offset += length_detail; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_tag; arrToVar(length_tag, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_tag; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_tag-1]=0; this->tag = (char *)(inbuffer + offset-1); offset += length_tag; 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_detail; arrToVar(length_detail, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_detail; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_detail-1]=0; this->detail = (char *)(inbuffer + offset-1); offset += length_detail; return offset; } const char * getType(){ return "intera_core_msgs/IOStatus"; }; const char * getMD5(){ return "a8daeb84c9abffc88ad8ca636f5fd8a0"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IONodeConfiguration_h #define _ROS_intera_core_msgs_IONodeConfiguration_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" #include "intera_core_msgs/IOComponentConfiguration.h" namespace intera_core_msgs { class IONodeConfiguration : public ros::Msg { public: typedef ros::Time _time_type; _time_type time; typedef intera_core_msgs::IOComponentConfiguration _node_type; _node_type node; uint32_t devices_length; typedef intera_core_msgs::IOComponentConfiguration _devices_type; _devices_type st_devices; _devices_type * devices; uint32_t plugins_length; typedef intera_core_msgs::IOComponentConfiguration _plugins_type; _plugins_type st_plugins; _plugins_type * plugins; IONodeConfiguration(): time(), node(), devices_length(0), devices(NULL), plugins_length(0), plugins(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.sec); *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.nsec); offset += this->node.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->devices_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->devices_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->devices_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->devices_length >> (8 * 3)) & 0xFF; offset += sizeof(this->devices_length); for( uint32_t i = 0; i < devices_length; i++){ offset += this->devices[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->plugins_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->plugins_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->plugins_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->plugins_length >> (8 * 3)) & 0xFF; offset += sizeof(this->plugins_length); for( uint32_t i = 0; i < plugins_length; i++){ offset += this->plugins[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->time.sec = ((uint32_t) (*(inbuffer + offset))); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.sec); this->time.nsec = ((uint32_t) (*(inbuffer + offset))); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.nsec); offset += this->node.deserialize(inbuffer + offset); uint32_t devices_lengthT = ((uint32_t) (*(inbuffer + offset))); devices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); devices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); devices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->devices_length); if(devices_lengthT > devices_length) this->devices = (intera_core_msgs::IOComponentConfiguration*)realloc(this->devices, devices_lengthT * sizeof(intera_core_msgs::IOComponentConfiguration)); devices_length = devices_lengthT; for( uint32_t i = 0; i < devices_length; i++){ offset += this->st_devices.deserialize(inbuffer + offset); memcpy( &(this->devices[i]), &(this->st_devices), sizeof(intera_core_msgs::IOComponentConfiguration)); } uint32_t plugins_lengthT = ((uint32_t) (*(inbuffer + offset))); plugins_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); plugins_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); plugins_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->plugins_length); if(plugins_lengthT > plugins_length) this->plugins = (intera_core_msgs::IOComponentConfiguration*)realloc(this->plugins, plugins_lengthT * sizeof(intera_core_msgs::IOComponentConfiguration)); plugins_length = plugins_lengthT; for( uint32_t i = 0; i < plugins_length; i++){ offset += this->st_plugins.deserialize(inbuffer + offset); memcpy( &(this->plugins[i]), &(this->st_plugins), sizeof(intera_core_msgs::IOComponentConfiguration)); } return offset; } const char * getType(){ return "intera_core_msgs/IONodeConfiguration"; }; const char * getMD5(){ return "66800b32dbb52df00e2454d58668ac33"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_IONodeStatus_h #define _ROS_intera_core_msgs_IONodeStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" #include "intera_core_msgs/IOComponentStatus.h" namespace intera_core_msgs { class IONodeStatus : public ros::Msg { public: typedef ros::Time _time_type; _time_type time; typedef intera_core_msgs::IOComponentStatus _node_type; _node_type node; uint32_t devices_length; typedef intera_core_msgs::IOComponentStatus _devices_type; _devices_type st_devices; _devices_type * devices; uint32_t commands_length; typedef ros::Time _commands_type; _commands_type st_commands; _commands_type * commands; IONodeStatus(): time(), node(), devices_length(0), devices(NULL), commands_length(0), commands(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.sec); *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->time.nsec); offset += this->node.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->devices_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->devices_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->devices_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->devices_length >> (8 * 3)) & 0xFF; offset += sizeof(this->devices_length); for( uint32_t i = 0; i < devices_length; i++){ offset += this->devices[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->commands_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commands_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commands_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commands_length >> (8 * 3)) & 0xFF; offset += sizeof(this->commands_length); for( uint32_t i = 0; i < commands_length; i++){ *(outbuffer + offset + 0) = (this->commands[i].sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commands[i].sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commands[i].sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commands[i].sec >> (8 * 3)) & 0xFF; offset += sizeof(this->commands[i].sec); *(outbuffer + offset + 0) = (this->commands[i].nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->commands[i].nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->commands[i].nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->commands[i].nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->commands[i].nsec); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->time.sec = ((uint32_t) (*(inbuffer + offset))); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.sec); this->time.nsec = ((uint32_t) (*(inbuffer + offset))); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->time.nsec); offset += this->node.deserialize(inbuffer + offset); uint32_t devices_lengthT = ((uint32_t) (*(inbuffer + offset))); devices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); devices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); devices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->devices_length); if(devices_lengthT > devices_length) this->devices = (intera_core_msgs::IOComponentStatus*)realloc(this->devices, devices_lengthT * sizeof(intera_core_msgs::IOComponentStatus)); devices_length = devices_lengthT; for( uint32_t i = 0; i < devices_length; i++){ offset += this->st_devices.deserialize(inbuffer + offset); memcpy( &(this->devices[i]), &(this->st_devices), sizeof(intera_core_msgs::IOComponentStatus)); } uint32_t commands_lengthT = ((uint32_t) (*(inbuffer + offset))); commands_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); commands_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); commands_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->commands_length); if(commands_lengthT > commands_length) this->commands = (ros::Time*)realloc(this->commands, commands_lengthT * sizeof(ros::Time)); commands_length = commands_lengthT; for( uint32_t i = 0; i < commands_length; i++){ this->st_commands.sec = ((uint32_t) (*(inbuffer + offset))); this->st_commands.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->st_commands.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->st_commands.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->st_commands.sec); this->st_commands.nsec = ((uint32_t) (*(inbuffer + offset))); this->st_commands.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->st_commands.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->st_commands.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->st_commands.nsec); memcpy( &(this->commands[i]), &(this->st_commands), sizeof(ros::Time)); } return offset; } const char * getType(){ return "intera_core_msgs/IONodeStatus"; }; const char * getMD5(){ return "260fce3c02f43bd977c92642b3c09c1d"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_EndpointState_h #define _ROS_intera_core_msgs_EndpointState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Pose.h" #include "geometry_msgs/Twist.h" #include "geometry_msgs/Wrench.h" namespace intera_core_msgs { class EndpointState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef geometry_msgs::Pose _pose_type; _pose_type pose; typedef geometry_msgs::Twist _twist_type; _twist_type twist; typedef geometry_msgs::Wrench _wrench_type; _wrench_type wrench; typedef bool _valid_type; _valid_type valid; EndpointState(): header(), pose(), twist(), wrench(), valid(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->pose.serialize(outbuffer + offset); offset += this->twist.serialize(outbuffer + offset); offset += this->wrench.serialize(outbuffer + offset); 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); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->pose.deserialize(inbuffer + offset); offset += this->twist.deserialize(inbuffer + offset); offset += this->wrench.deserialize(inbuffer + offset); 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); return offset; } const char * getType(){ return "intera_core_msgs/EndpointState"; }; const char * getMD5(){ return "ec04f0f9bc02b3e335181c07d68c2c98"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_InteractionControlCommand_h #define _ROS_intera_core_msgs_InteractionControlCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "geometry_msgs/Pose.h" namespace intera_core_msgs { class InteractionControlCommand : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef bool _interaction_control_active_type; _interaction_control_active_type interaction_control_active; uint32_t K_impedance_length; typedef double _K_impedance_type; _K_impedance_type st_K_impedance; _K_impedance_type * K_impedance; uint32_t max_impedance_length; typedef bool _max_impedance_type; _max_impedance_type st_max_impedance; _max_impedance_type * max_impedance; uint32_t D_impedance_length; typedef double _D_impedance_type; _D_impedance_type st_D_impedance; _D_impedance_type * D_impedance; uint32_t K_nullspace_length; typedef double _K_nullspace_type; _K_nullspace_type st_K_nullspace; _K_nullspace_type * K_nullspace; uint32_t force_command_length; typedef double _force_command_type; _force_command_type st_force_command; _force_command_type * force_command; typedef geometry_msgs::Pose _interaction_frame_type; _interaction_frame_type interaction_frame; typedef const char* _endpoint_name_type; _endpoint_name_type endpoint_name; typedef bool _in_endpoint_frame_type; _in_endpoint_frame_type in_endpoint_frame; typedef bool _disable_damping_in_force_control_type; _disable_damping_in_force_control_type disable_damping_in_force_control; typedef bool _disable_reference_resetting_type; _disable_reference_resetting_type disable_reference_resetting; uint32_t interaction_control_mode_length; typedef uint8_t _interaction_control_mode_type; _interaction_control_mode_type st_interaction_control_mode; _interaction_control_mode_type * interaction_control_mode; typedef bool _rotations_for_constrained_zeroG_type; _rotations_for_constrained_zeroG_type rotations_for_constrained_zeroG; enum { IMPEDANCE_MODE = 1 }; enum { FORCE_MODE = 2 }; enum { IMPEDANCE_WITH_FORCE_LIMIT_MODE = 3 }; enum { FORCE_WITH_MOTION_LIMIT_MODE = 4 }; InteractionControlCommand(): header(), interaction_control_active(0), K_impedance_length(0), K_impedance(NULL), max_impedance_length(0), max_impedance(NULL), D_impedance_length(0), D_impedance(NULL), K_nullspace_length(0), K_nullspace(NULL), force_command_length(0), force_command(NULL), interaction_frame(), endpoint_name(""), in_endpoint_frame(0), disable_damping_in_force_control(0), disable_reference_resetting(0), interaction_control_mode_length(0), interaction_control_mode(NULL), rotations_for_constrained_zeroG(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_interaction_control_active; u_interaction_control_active.real = this->interaction_control_active; *(outbuffer + offset + 0) = (u_interaction_control_active.base >> (8 * 0)) & 0xFF; offset += sizeof(this->interaction_control_active); *(outbuffer + offset + 0) = (this->K_impedance_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->K_impedance_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->K_impedance_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->K_impedance_length >> (8 * 3)) & 0xFF; offset += sizeof(this->K_impedance_length); for( uint32_t i = 0; i < K_impedance_length; i++){ union { double real; uint64_t base; } u_K_impedancei; u_K_impedancei.real = this->K_impedance[i]; *(outbuffer + offset + 0) = (u_K_impedancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_K_impedancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_K_impedancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_K_impedancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_K_impedancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_K_impedancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_K_impedancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_K_impedancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->K_impedance[i]); } *(outbuffer + offset + 0) = (this->max_impedance_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->max_impedance_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->max_impedance_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->max_impedance_length >> (8 * 3)) & 0xFF; offset += sizeof(this->max_impedance_length); for( uint32_t i = 0; i < max_impedance_length; i++){ union { bool real; uint8_t base; } u_max_impedancei; u_max_impedancei.real = this->max_impedance[i]; *(outbuffer + offset + 0) = (u_max_impedancei.base >> (8 * 0)) & 0xFF; offset += sizeof(this->max_impedance[i]); } *(outbuffer + offset + 0) = (this->D_impedance_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->D_impedance_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->D_impedance_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->D_impedance_length >> (8 * 3)) & 0xFF; offset += sizeof(this->D_impedance_length); for( uint32_t i = 0; i < D_impedance_length; i++){ union { double real; uint64_t base; } u_D_impedancei; u_D_impedancei.real = this->D_impedance[i]; *(outbuffer + offset + 0) = (u_D_impedancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_D_impedancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_D_impedancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_D_impedancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_D_impedancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_D_impedancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_D_impedancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_D_impedancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->D_impedance[i]); } *(outbuffer + offset + 0) = (this->K_nullspace_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->K_nullspace_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->K_nullspace_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->K_nullspace_length >> (8 * 3)) & 0xFF; offset += sizeof(this->K_nullspace_length); for( uint32_t i = 0; i < K_nullspace_length; i++){ union { double real; uint64_t base; } u_K_nullspacei; u_K_nullspacei.real = this->K_nullspace[i]; *(outbuffer + offset + 0) = (u_K_nullspacei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_K_nullspacei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_K_nullspacei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_K_nullspacei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_K_nullspacei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_K_nullspacei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_K_nullspacei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_K_nullspacei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->K_nullspace[i]); } *(outbuffer + offset + 0) = (this->force_command_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->force_command_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->force_command_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->force_command_length >> (8 * 3)) & 0xFF; offset += sizeof(this->force_command_length); for( uint32_t i = 0; i < force_command_length; i++){ union { double real; uint64_t base; } u_force_commandi; u_force_commandi.real = this->force_command[i]; *(outbuffer + offset + 0) = (u_force_commandi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_force_commandi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_force_commandi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_force_commandi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_force_commandi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_force_commandi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_force_commandi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_force_commandi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->force_command[i]); } offset += this->interaction_frame.serialize(outbuffer + offset); uint32_t length_endpoint_name = strlen(this->endpoint_name); varToArr(outbuffer + offset, length_endpoint_name); offset += 4; memcpy(outbuffer + offset, this->endpoint_name, length_endpoint_name); offset += length_endpoint_name; union { bool real; uint8_t base; } u_in_endpoint_frame; u_in_endpoint_frame.real = this->in_endpoint_frame; *(outbuffer + offset + 0) = (u_in_endpoint_frame.base >> (8 * 0)) & 0xFF; offset += sizeof(this->in_endpoint_frame); union { bool real; uint8_t base; } u_disable_damping_in_force_control; u_disable_damping_in_force_control.real = this->disable_damping_in_force_control; *(outbuffer + offset + 0) = (u_disable_damping_in_force_control.base >> (8 * 0)) & 0xFF; offset += sizeof(this->disable_damping_in_force_control); union { bool real; uint8_t base; } u_disable_reference_resetting; u_disable_reference_resetting.real = this->disable_reference_resetting; *(outbuffer + offset + 0) = (u_disable_reference_resetting.base >> (8 * 0)) & 0xFF; offset += sizeof(this->disable_reference_resetting); *(outbuffer + offset + 0) = (this->interaction_control_mode_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->interaction_control_mode_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->interaction_control_mode_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->interaction_control_mode_length >> (8 * 3)) & 0xFF; offset += sizeof(this->interaction_control_mode_length); for( uint32_t i = 0; i < interaction_control_mode_length; i++){ *(outbuffer + offset + 0) = (this->interaction_control_mode[i] >> (8 * 0)) & 0xFF; offset += sizeof(this->interaction_control_mode[i]); } union { bool real; uint8_t base; } u_rotations_for_constrained_zeroG; u_rotations_for_constrained_zeroG.real = this->rotations_for_constrained_zeroG; *(outbuffer + offset + 0) = (u_rotations_for_constrained_zeroG.base >> (8 * 0)) & 0xFF; offset += sizeof(this->rotations_for_constrained_zeroG); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_interaction_control_active; u_interaction_control_active.base = 0; u_interaction_control_active.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->interaction_control_active = u_interaction_control_active.real; offset += sizeof(this->interaction_control_active); uint32_t K_impedance_lengthT = ((uint32_t) (*(inbuffer + offset))); K_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); K_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); K_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->K_impedance_length); if(K_impedance_lengthT > K_impedance_length) this->K_impedance = (double*)realloc(this->K_impedance, K_impedance_lengthT * sizeof(double)); K_impedance_length = K_impedance_lengthT; for( uint32_t i = 0; i < K_impedance_length; i++){ union { double real; uint64_t base; } u_st_K_impedance; u_st_K_impedance.base = 0; u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_K_impedance = u_st_K_impedance.real; offset += sizeof(this->st_K_impedance); memcpy( &(this->K_impedance[i]), &(this->st_K_impedance), sizeof(double)); } uint32_t max_impedance_lengthT = ((uint32_t) (*(inbuffer + offset))); max_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); max_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); max_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->max_impedance_length); if(max_impedance_lengthT > max_impedance_length) this->max_impedance = (bool*)realloc(this->max_impedance, max_impedance_lengthT * sizeof(bool)); max_impedance_length = max_impedance_lengthT; for( uint32_t i = 0; i < max_impedance_length; i++){ union { bool real; uint8_t base; } u_st_max_impedance; u_st_max_impedance.base = 0; u_st_max_impedance.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_max_impedance = u_st_max_impedance.real; offset += sizeof(this->st_max_impedance); memcpy( &(this->max_impedance[i]), &(this->st_max_impedance), sizeof(bool)); } uint32_t D_impedance_lengthT = ((uint32_t) (*(inbuffer + offset))); D_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); D_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); D_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->D_impedance_length); if(D_impedance_lengthT > D_impedance_length) this->D_impedance = (double*)realloc(this->D_impedance, D_impedance_lengthT * sizeof(double)); D_impedance_length = D_impedance_lengthT; for( uint32_t i = 0; i < D_impedance_length; i++){ union { double real; uint64_t base; } u_st_D_impedance; u_st_D_impedance.base = 0; u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_D_impedance = u_st_D_impedance.real; offset += sizeof(this->st_D_impedance); memcpy( &(this->D_impedance[i]), &(this->st_D_impedance), sizeof(double)); } uint32_t K_nullspace_lengthT = ((uint32_t) (*(inbuffer + offset))); K_nullspace_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); K_nullspace_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); K_nullspace_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->K_nullspace_length); if(K_nullspace_lengthT > K_nullspace_length) this->K_nullspace = (double*)realloc(this->K_nullspace, K_nullspace_lengthT * sizeof(double)); K_nullspace_length = K_nullspace_lengthT; for( uint32_t i = 0; i < K_nullspace_length; i++){ union { double real; uint64_t base; } u_st_K_nullspace; u_st_K_nullspace.base = 0; u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_K_nullspace.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_K_nullspace = u_st_K_nullspace.real; offset += sizeof(this->st_K_nullspace); memcpy( &(this->K_nullspace[i]), &(this->st_K_nullspace), sizeof(double)); } uint32_t force_command_lengthT = ((uint32_t) (*(inbuffer + offset))); force_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); force_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); force_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->force_command_length); if(force_command_lengthT > force_command_length) this->force_command = (double*)realloc(this->force_command, force_command_lengthT * sizeof(double)); force_command_length = force_command_lengthT; for( uint32_t i = 0; i < force_command_length; i++){ union { double real; uint64_t base; } u_st_force_command; u_st_force_command.base = 0; u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_force_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_force_command = u_st_force_command.real; offset += sizeof(this->st_force_command); memcpy( &(this->force_command[i]), &(this->st_force_command), sizeof(double)); } offset += this->interaction_frame.deserialize(inbuffer + offset); uint32_t length_endpoint_name; arrToVar(length_endpoint_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_endpoint_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_endpoint_name-1]=0; this->endpoint_name = (char *)(inbuffer + offset-1); offset += length_endpoint_name; union { bool real; uint8_t base; } u_in_endpoint_frame; u_in_endpoint_frame.base = 0; u_in_endpoint_frame.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->in_endpoint_frame = u_in_endpoint_frame.real; offset += sizeof(this->in_endpoint_frame); union { bool real; uint8_t base; } u_disable_damping_in_force_control; u_disable_damping_in_force_control.base = 0; u_disable_damping_in_force_control.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->disable_damping_in_force_control = u_disable_damping_in_force_control.real; offset += sizeof(this->disable_damping_in_force_control); union { bool real; uint8_t base; } u_disable_reference_resetting; u_disable_reference_resetting.base = 0; u_disable_reference_resetting.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->disable_reference_resetting = u_disable_reference_resetting.real; offset += sizeof(this->disable_reference_resetting); uint32_t interaction_control_mode_lengthT = ((uint32_t) (*(inbuffer + offset))); interaction_control_mode_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); interaction_control_mode_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); interaction_control_mode_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->interaction_control_mode_length); if(interaction_control_mode_lengthT > interaction_control_mode_length) this->interaction_control_mode = (uint8_t*)realloc(this->interaction_control_mode, interaction_control_mode_lengthT * sizeof(uint8_t)); interaction_control_mode_length = interaction_control_mode_lengthT; for( uint32_t i = 0; i < interaction_control_mode_length; i++){ this->st_interaction_control_mode = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->st_interaction_control_mode); memcpy( &(this->interaction_control_mode[i]), &(this->st_interaction_control_mode), sizeof(uint8_t)); } union { bool real; uint8_t base; } u_rotations_for_constrained_zeroG; u_rotations_for_constrained_zeroG.base = 0; u_rotations_for_constrained_zeroG.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->rotations_for_constrained_zeroG = u_rotations_for_constrained_zeroG.real; offset += sizeof(this->rotations_for_constrained_zeroG); return offset; } const char * getType(){ return "intera_core_msgs/InteractionControlCommand"; }; const char * getMD5(){ return "762b5d197d5d786f83741af7fe6261a6"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_HeadPanCommand_h #define _ROS_intera_core_msgs_HeadPanCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_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 _pan_mode_type; _pan_mode_type pan_mode; enum { MAX_SPEED_RATIO = 1.0 }; enum { MIN_SPEED_RATIO = 0.0 }; enum { SET_PASSIVE_MODE = 0 }; enum { SET_ACTIVE_MODE = 1 }; enum { SET_ACTIVE_CANCELLATION_MODE = 2 }; enum { NO_MODE_CHANGE = 3 }; HeadPanCommand(): target(0), speed_ratio(0), pan_mode(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->pan_mode >> (8 * 0)) & 0xFF; offset += sizeof(this->pan_mode); 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->pan_mode = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->pan_mode); return offset; } const char * getType(){ return "intera_core_msgs/HeadPanCommand"; }; const char * getMD5(){ return "5cb68e8755646564cf47813f91cee216"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_EndpointNamesArray_h #define _ROS_intera_core_msgs_EndpointNamesArray_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class EndpointNamesArray : public ros::Msg { public: uint32_t endpoint_names_length; typedef char* _endpoint_names_type; _endpoint_names_type st_endpoint_names; _endpoint_names_type * endpoint_names; EndpointNamesArray(): endpoint_names_length(0), endpoint_names(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->endpoint_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->endpoint_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->endpoint_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->endpoint_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->endpoint_names_length); for( uint32_t i = 0; i < endpoint_names_length; i++){ uint32_t length_endpoint_namesi = strlen(this->endpoint_names[i]); varToArr(outbuffer + offset, length_endpoint_namesi); offset += 4; memcpy(outbuffer + offset, this->endpoint_names[i], length_endpoint_namesi); offset += length_endpoint_namesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t endpoint_names_lengthT = ((uint32_t) (*(inbuffer + offset))); endpoint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); endpoint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); endpoint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->endpoint_names_length); if(endpoint_names_lengthT > endpoint_names_length) this->endpoint_names = (char**)realloc(this->endpoint_names, endpoint_names_lengthT * sizeof(char*)); endpoint_names_length = endpoint_names_lengthT; for( uint32_t i = 0; i < endpoint_names_length; i++){ uint32_t length_st_endpoint_names; arrToVar(length_st_endpoint_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_endpoint_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_endpoint_names-1]=0; this->st_endpoint_names = (char *)(inbuffer + offset-1); offset += length_st_endpoint_names; memcpy( &(this->endpoint_names[i]), &(this->st_endpoint_names), sizeof(char*)); } return offset; } const char * getType(){ return "intera_core_msgs/EndpointNamesArray"; }; const char * getMD5(){ return "6bf0a2d04056051f84da1291f261f35a"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_JointCommand_h #define _ROS_intera_core_msgs_JointCommand_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace intera_core_msgs { class JointCommand : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef int32_t _mode_type; _mode_type mode; uint32_t names_length; typedef char* _names_type; _names_type st_names; _names_type * names; uint32_t position_length; typedef double _position_type; _position_type st_position; _position_type * position; uint32_t velocity_length; typedef double _velocity_type; _velocity_type st_velocity; _velocity_type * velocity; uint32_t acceleration_length; typedef double _acceleration_type; _acceleration_type st_acceleration; _acceleration_type * acceleration; uint32_t effort_length; typedef double _effort_type; _effort_type st_effort; _effort_type * effort; enum { POSITION_MODE = 1 }; enum { VELOCITY_MODE = 2 }; enum { TORQUE_MODE = 3 }; enum { TRAJECTORY_MODE = 4 }; JointCommand(): header(), mode(0), names_length(0), names(NULL), position_length(0), position(NULL), velocity_length(0), velocity(NULL), acceleration_length(0), acceleration(NULL), effort_length(0), effort(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); 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->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; } *(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF; offset += sizeof(this->position_length); for( uint32_t i = 0; i < position_length; i++){ union { double real; uint64_t base; } u_positioni; u_positioni.real = this->position[i]; *(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF; offset += sizeof(this->position[i]); } *(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF; offset += sizeof(this->velocity_length); for( uint32_t i = 0; i < velocity_length; i++){ union { double real; uint64_t base; } u_velocityi; u_velocityi.real = this->velocity[i]; *(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->velocity[i]); } *(outbuffer + offset + 0) = (this->acceleration_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->acceleration_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->acceleration_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->acceleration_length >> (8 * 3)) & 0xFF; offset += sizeof(this->acceleration_length); for( uint32_t i = 0; i < acceleration_length; i++){ union { double real; uint64_t base; } u_accelerationi; u_accelerationi.real = this->acceleration[i]; *(outbuffer + offset + 0) = (u_accelerationi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_accelerationi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_accelerationi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_accelerationi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_accelerationi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_accelerationi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_accelerationi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_accelerationi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->acceleration[i]); } *(outbuffer + offset + 0) = (this->effort_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->effort_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->effort_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->effort_length >> (8 * 3)) & 0xFF; offset += sizeof(this->effort_length); for( uint32_t i = 0; i < effort_length; i++){ union { double real; uint64_t base; } u_efforti; u_efforti.real = this->effort[i]; *(outbuffer + offset + 0) = (u_efforti.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_efforti.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_efforti.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_efforti.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_efforti.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_efforti.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_efforti.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_efforti.base >> (8 * 7)) & 0xFF; offset += sizeof(this->effort[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); 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 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*)); } uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset))); position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->position_length); if(position_lengthT > position_length) this->position = (double*)realloc(this->position, position_lengthT * sizeof(double)); position_length = position_lengthT; for( uint32_t i = 0; i < position_length; i++){ union { double real; uint64_t base; } u_st_position; u_st_position.base = 0; u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_position = u_st_position.real; offset += sizeof(this->st_position); memcpy( &(this->position[i]), &(this->st_position), sizeof(double)); } uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset))); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->velocity_length); if(velocity_lengthT > velocity_length) this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double)); velocity_length = velocity_lengthT; for( uint32_t i = 0; i < velocity_length; i++){ union { double real; uint64_t base; } u_st_velocity; u_st_velocity.base = 0; u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_velocity = u_st_velocity.real; offset += sizeof(this->st_velocity); memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double)); } uint32_t acceleration_lengthT = ((uint32_t) (*(inbuffer + offset))); acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->acceleration_length); if(acceleration_lengthT > acceleration_length) this->acceleration = (double*)realloc(this->acceleration, acceleration_lengthT * sizeof(double)); acceleration_length = acceleration_lengthT; for( uint32_t i = 0; i < acceleration_length; i++){ union { double real; uint64_t base; } u_st_acceleration; u_st_acceleration.base = 0; u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_acceleration = u_st_acceleration.real; offset += sizeof(this->st_acceleration); memcpy( &(this->acceleration[i]), &(this->st_acceleration), sizeof(double)); } uint32_t effort_lengthT = ((uint32_t) (*(inbuffer + offset))); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->effort_length); if(effort_lengthT > effort_length) this->effort = (double*)realloc(this->effort, effort_lengthT * sizeof(double)); effort_length = effort_lengthT; for( uint32_t i = 0; i < effort_length; i++){ union { double real; uint64_t base; } u_st_effort; u_st_effort.base = 0; u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_effort = u_st_effort.real; offset += sizeof(this->st_effort); memcpy( &(this->effort[i]), &(this->st_effort), sizeof(double)); } return offset; } const char * getType(){ return "intera_core_msgs/JointCommand"; }; const char * getMD5(){ return "c8c85922d297da6209a089a906207e5d"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_InteractionControlState_h #define _ROS_intera_core_msgs_InteractionControlState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" namespace intera_core_msgs { class InteractionControlState : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef bool _interaction_control_active_type; _interaction_control_active_type interaction_control_active; uint32_t K_impedance_length; typedef double _K_impedance_type; _K_impedance_type st_K_impedance; _K_impedance_type * K_impedance; uint32_t D_impedance_length; typedef double _D_impedance_type; _D_impedance_type st_D_impedance; _D_impedance_type * D_impedance; uint32_t endpoint_force_command_length; typedef double _endpoint_force_command_type; _endpoint_force_command_type st_endpoint_force_command; _endpoint_force_command_type * endpoint_force_command; typedef const char* _endpoint_name_type; _endpoint_name_type endpoint_name; typedef bool _in_endpoint_frame_type; _in_endpoint_frame_type in_endpoint_frame; typedef bool _disable_damping_in_force_control_type; _disable_damping_in_force_control_type disable_damping_in_force_control; typedef bool _disable_reference_resetting_type; _disable_reference_resetting_type disable_reference_resetting; typedef bool _rotations_for_constrained_zeroG_type; _rotations_for_constrained_zeroG_type rotations_for_constrained_zeroG; InteractionControlState(): header(), interaction_control_active(0), K_impedance_length(0), K_impedance(NULL), D_impedance_length(0), D_impedance(NULL), endpoint_force_command_length(0), endpoint_force_command(NULL), endpoint_name(""), in_endpoint_frame(0), disable_damping_in_force_control(0), disable_reference_resetting(0), rotations_for_constrained_zeroG(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); union { bool real; uint8_t base; } u_interaction_control_active; u_interaction_control_active.real = this->interaction_control_active; *(outbuffer + offset + 0) = (u_interaction_control_active.base >> (8 * 0)) & 0xFF; offset += sizeof(this->interaction_control_active); *(outbuffer + offset + 0) = (this->K_impedance_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->K_impedance_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->K_impedance_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->K_impedance_length >> (8 * 3)) & 0xFF; offset += sizeof(this->K_impedance_length); for( uint32_t i = 0; i < K_impedance_length; i++){ union { double real; uint64_t base; } u_K_impedancei; u_K_impedancei.real = this->K_impedance[i]; *(outbuffer + offset + 0) = (u_K_impedancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_K_impedancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_K_impedancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_K_impedancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_K_impedancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_K_impedancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_K_impedancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_K_impedancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->K_impedance[i]); } *(outbuffer + offset + 0) = (this->D_impedance_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->D_impedance_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->D_impedance_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->D_impedance_length >> (8 * 3)) & 0xFF; offset += sizeof(this->D_impedance_length); for( uint32_t i = 0; i < D_impedance_length; i++){ union { double real; uint64_t base; } u_D_impedancei; u_D_impedancei.real = this->D_impedance[i]; *(outbuffer + offset + 0) = (u_D_impedancei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_D_impedancei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_D_impedancei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_D_impedancei.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_D_impedancei.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_D_impedancei.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_D_impedancei.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_D_impedancei.base >> (8 * 7)) & 0xFF; offset += sizeof(this->D_impedance[i]); } *(outbuffer + offset + 0) = (this->endpoint_force_command_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->endpoint_force_command_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->endpoint_force_command_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->endpoint_force_command_length >> (8 * 3)) & 0xFF; offset += sizeof(this->endpoint_force_command_length); for( uint32_t i = 0; i < endpoint_force_command_length; i++){ union { double real; uint64_t base; } u_endpoint_force_commandi; u_endpoint_force_commandi.real = this->endpoint_force_command[i]; *(outbuffer + offset + 0) = (u_endpoint_force_commandi.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_endpoint_force_commandi.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_endpoint_force_commandi.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_endpoint_force_commandi.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_endpoint_force_commandi.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_endpoint_force_commandi.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_endpoint_force_commandi.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_endpoint_force_commandi.base >> (8 * 7)) & 0xFF; offset += sizeof(this->endpoint_force_command[i]); } uint32_t length_endpoint_name = strlen(this->endpoint_name); varToArr(outbuffer + offset, length_endpoint_name); offset += 4; memcpy(outbuffer + offset, this->endpoint_name, length_endpoint_name); offset += length_endpoint_name; union { bool real; uint8_t base; } u_in_endpoint_frame; u_in_endpoint_frame.real = this->in_endpoint_frame; *(outbuffer + offset + 0) = (u_in_endpoint_frame.base >> (8 * 0)) & 0xFF; offset += sizeof(this->in_endpoint_frame); union { bool real; uint8_t base; } u_disable_damping_in_force_control; u_disable_damping_in_force_control.real = this->disable_damping_in_force_control; *(outbuffer + offset + 0) = (u_disable_damping_in_force_control.base >> (8 * 0)) & 0xFF; offset += sizeof(this->disable_damping_in_force_control); union { bool real; uint8_t base; } u_disable_reference_resetting; u_disable_reference_resetting.real = this->disable_reference_resetting; *(outbuffer + offset + 0) = (u_disable_reference_resetting.base >> (8 * 0)) & 0xFF; offset += sizeof(this->disable_reference_resetting); union { bool real; uint8_t base; } u_rotations_for_constrained_zeroG; u_rotations_for_constrained_zeroG.real = this->rotations_for_constrained_zeroG; *(outbuffer + offset + 0) = (u_rotations_for_constrained_zeroG.base >> (8 * 0)) & 0xFF; offset += sizeof(this->rotations_for_constrained_zeroG); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); union { bool real; uint8_t base; } u_interaction_control_active; u_interaction_control_active.base = 0; u_interaction_control_active.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->interaction_control_active = u_interaction_control_active.real; offset += sizeof(this->interaction_control_active); uint32_t K_impedance_lengthT = ((uint32_t) (*(inbuffer + offset))); K_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); K_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); K_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->K_impedance_length); if(K_impedance_lengthT > K_impedance_length) this->K_impedance = (double*)realloc(this->K_impedance, K_impedance_lengthT * sizeof(double)); K_impedance_length = K_impedance_lengthT; for( uint32_t i = 0; i < K_impedance_length; i++){ union { double real; uint64_t base; } u_st_K_impedance; u_st_K_impedance.base = 0; u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_K_impedance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_K_impedance = u_st_K_impedance.real; offset += sizeof(this->st_K_impedance); memcpy( &(this->K_impedance[i]), &(this->st_K_impedance), sizeof(double)); } uint32_t D_impedance_lengthT = ((uint32_t) (*(inbuffer + offset))); D_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); D_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); D_impedance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->D_impedance_length); if(D_impedance_lengthT > D_impedance_length) this->D_impedance = (double*)realloc(this->D_impedance, D_impedance_lengthT * sizeof(double)); D_impedance_length = D_impedance_lengthT; for( uint32_t i = 0; i < D_impedance_length; i++){ union { double real; uint64_t base; } u_st_D_impedance; u_st_D_impedance.base = 0; u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_D_impedance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_D_impedance = u_st_D_impedance.real; offset += sizeof(this->st_D_impedance); memcpy( &(this->D_impedance[i]), &(this->st_D_impedance), sizeof(double)); } uint32_t endpoint_force_command_lengthT = ((uint32_t) (*(inbuffer + offset))); endpoint_force_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); endpoint_force_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); endpoint_force_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->endpoint_force_command_length); if(endpoint_force_command_lengthT > endpoint_force_command_length) this->endpoint_force_command = (double*)realloc(this->endpoint_force_command, endpoint_force_command_lengthT * sizeof(double)); endpoint_force_command_length = endpoint_force_command_lengthT; for( uint32_t i = 0; i < endpoint_force_command_length; i++){ union { double real; uint64_t base; } u_st_endpoint_force_command; u_st_endpoint_force_command.base = 0; u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_st_endpoint_force_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->st_endpoint_force_command = u_st_endpoint_force_command.real; offset += sizeof(this->st_endpoint_force_command); memcpy( &(this->endpoint_force_command[i]), &(this->st_endpoint_force_command), sizeof(double)); } uint32_t length_endpoint_name; arrToVar(length_endpoint_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_endpoint_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_endpoint_name-1]=0; this->endpoint_name = (char *)(inbuffer + offset-1); offset += length_endpoint_name; union { bool real; uint8_t base; } u_in_endpoint_frame; u_in_endpoint_frame.base = 0; u_in_endpoint_frame.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->in_endpoint_frame = u_in_endpoint_frame.real; offset += sizeof(this->in_endpoint_frame); union { bool real; uint8_t base; } u_disable_damping_in_force_control; u_disable_damping_in_force_control.base = 0; u_disable_damping_in_force_control.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->disable_damping_in_force_control = u_disable_damping_in_force_control.real; offset += sizeof(this->disable_damping_in_force_control); union { bool real; uint8_t base; } u_disable_reference_resetting; u_disable_reference_resetting.base = 0; u_disable_reference_resetting.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->disable_reference_resetting = u_disable_reference_resetting.real; offset += sizeof(this->disable_reference_resetting); union { bool real; uint8_t base; } u_rotations_for_constrained_zeroG; u_rotations_for_constrained_zeroG.base = 0; u_rotations_for_constrained_zeroG.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->rotations_for_constrained_zeroG = u_rotations_for_constrained_zeroG.real; offset += sizeof(this->rotations_for_constrained_zeroG); return offset; } const char * getType(){ return "intera_core_msgs/InteractionControlState"; }; const char * getMD5(){ return "f3fbd4a2356cb48da2df759db65614d8"; }; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_HomingState_h #define _ROS_intera_core_msgs_HomingState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class HomingState : public ros::Msg { public: uint32_t name_length; typedef char* _name_type; _name_type st_name; _name_type * name; uint32_t state_length; typedef int32_t _state_type; _state_type st_state; _state_type * state; enum { HOMED = 0 }; enum { HOMING = 1 }; enum { NOT_HOMED = 2 }; HomingState(): name_length(0), name(NULL), state_length(0), state(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF; offset += sizeof(this->name_length); for( uint32_t i = 0; i < name_length; i++){ uint32_t length_namei = strlen(this->name[i]); varToArr(outbuffer + offset, length_namei); offset += 4; memcpy(outbuffer + offset, this->name[i], length_namei); offset += length_namei; } *(outbuffer + offset + 0) = (this->state_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->state_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->state_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->state_length >> (8 * 3)) & 0xFF; offset += sizeof(this->state_length); for( uint32_t i = 0; i < state_length; i++){ union { int32_t real; uint32_t base; } u_statei; u_statei.real = this->state[i]; *(outbuffer + offset + 0) = (u_statei.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_statei.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_statei.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_statei.base >> (8 * 3)) & 0xFF; offset += sizeof(this->state[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset))); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->name_length); if(name_lengthT > name_length) this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*)); name_length = name_lengthT; for( uint32_t i = 0; i < name_length; i++){ uint32_t length_st_name; arrToVar(length_st_name, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_name; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_name-1]=0; this->st_name = (char *)(inbuffer + offset-1); offset += length_st_name; memcpy( &(this->name[i]), &(this->st_name), sizeof(char*)); } uint32_t state_lengthT = ((uint32_t) (*(inbuffer + offset))); state_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); state_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); state_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->state_length); if(state_lengthT > state_length) this->state = (int32_t*)realloc(this->state, state_lengthT * sizeof(int32_t)); state_length = state_lengthT; for( uint32_t i = 0; i < state_length; i++){ union { int32_t real; uint32_t base; } u_st_state; u_st_state.base = 0; u_st_state.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_state.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_state.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_state.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_state = u_st_state.real; offset += sizeof(this->st_state); memcpy( &(this->state[i]), &(this->st_state), sizeof(int32_t)); } return offset; } const char * getType(){ return "intera_core_msgs/HomingState"; }; const char * getMD5(){ return "eacb82bc7d74638daa749d9caab52b99"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_SolvePositionFK_h #define _ROS_SERVICE_SolvePositionFK_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 intera_core_msgs { static const char SOLVEPOSITIONFK[] = "intera_core_msgs/SolvePositionFK"; class SolvePositionFKRequest : public ros::Msg { public: uint32_t configuration_length; typedef sensor_msgs::JointState _configuration_type; _configuration_type st_configuration; _configuration_type * configuration; uint32_t tip_names_length; typedef char* _tip_names_type; _tip_names_type st_tip_names; _tip_names_type * tip_names; SolvePositionFKRequest(): configuration_length(0), configuration(NULL), tip_names_length(0), tip_names(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->configuration_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->configuration_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->configuration_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->configuration_length >> (8 * 3)) & 0xFF; offset += sizeof(this->configuration_length); for( uint32_t i = 0; i < configuration_length; i++){ offset += this->configuration[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->tip_names_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->tip_names_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->tip_names_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->tip_names_length >> (8 * 3)) & 0xFF; offset += sizeof(this->tip_names_length); for( uint32_t i = 0; i < tip_names_length; i++){ uint32_t length_tip_namesi = strlen(this->tip_names[i]); varToArr(outbuffer + offset, length_tip_namesi); offset += 4; memcpy(outbuffer + offset, this->tip_names[i], length_tip_namesi); offset += length_tip_namesi; } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t configuration_lengthT = ((uint32_t) (*(inbuffer + offset))); configuration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); configuration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); configuration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->configuration_length); if(configuration_lengthT > configuration_length) this->configuration = (sensor_msgs::JointState*)realloc(this->configuration, configuration_lengthT * sizeof(sensor_msgs::JointState)); configuration_length = configuration_lengthT; for( uint32_t i = 0; i < configuration_length; i++){ offset += this->st_configuration.deserialize(inbuffer + offset); memcpy( &(this->configuration[i]), &(this->st_configuration), sizeof(sensor_msgs::JointState)); } uint32_t tip_names_lengthT = ((uint32_t) (*(inbuffer + offset))); tip_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); tip_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); tip_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->tip_names_length); if(tip_names_lengthT > tip_names_length) this->tip_names = (char**)realloc(this->tip_names, tip_names_lengthT * sizeof(char*)); tip_names_length = tip_names_lengthT; for( uint32_t i = 0; i < tip_names_length; i++){ uint32_t length_st_tip_names; arrToVar(length_st_tip_names, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_st_tip_names; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_st_tip_names-1]=0; this->st_tip_names = (char *)(inbuffer + offset-1); offset += length_st_tip_names; memcpy( &(this->tip_names[i]), &(this->st_tip_names), sizeof(char*)); } return offset; } const char * getType(){ return SOLVEPOSITIONFK; }; const char * getMD5(){ return "14c88cbabc4e4d6c183969e91f5e56ca"; }; }; class SolvePositionFKResponse : 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 isValid_length; typedef bool _isValid_type; _isValid_type st_isValid; _isValid_type * isValid; uint32_t inCollision_length; typedef bool _inCollision_type; _inCollision_type st_inCollision; _inCollision_type * inCollision; SolvePositionFKResponse(): pose_stamp_length(0), pose_stamp(NULL), isValid_length(0), isValid(NULL), inCollision_length(0), inCollision(NULL) { } 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->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->inCollision_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->inCollision_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->inCollision_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->inCollision_length >> (8 * 3)) & 0xFF; offset += sizeof(this->inCollision_length); for( uint32_t i = 0; i < inCollision_length; i++){ union { bool real; uint8_t base; } u_inCollisioni; u_inCollisioni.real = this->inCollision[i]; *(outbuffer + offset + 0) = (u_inCollisioni.base >> (8 * 0)) & 0xFF; offset += sizeof(this->inCollision[i]); } 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 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 inCollision_lengthT = ((uint32_t) (*(inbuffer + offset))); inCollision_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); inCollision_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); inCollision_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->inCollision_length); if(inCollision_lengthT > inCollision_length) this->inCollision = (bool*)realloc(this->inCollision, inCollision_lengthT * sizeof(bool)); inCollision_length = inCollision_lengthT; for( uint32_t i = 0; i < inCollision_length; i++){ union { bool real; uint8_t base; } u_st_inCollision; u_st_inCollision.base = 0; u_st_inCollision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->st_inCollision = u_st_inCollision.real; offset += sizeof(this->st_inCollision); memcpy( &(this->inCollision[i]), &(this->st_inCollision), sizeof(bool)); } return offset; } const char * getType(){ return SOLVEPOSITIONFK; }; const char * getMD5(){ return "907cf9ee4b255127ce59627076bd1e85"; }; }; class SolvePositionFK { public: typedef SolvePositionFKRequest Request; typedef SolvePositionFKResponse Response; }; } #endif

C

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

#ifndef _ROS_intera_core_msgs_RobotAssemblyState_h #define _ROS_intera_core_msgs_RobotAssemblyState_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace intera_core_msgs { class RobotAssemblyState : public ros::Msg { public: typedef bool _homed_type; _homed_type homed; 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 bool _lowVoltage_type; _lowVoltage_type lowVoltage; 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_ENGINE = 4 }; RobotAssemblyState(): homed(0), ready(0), enabled(0), stopped(0), error(0), lowVoltage(0), estop_button(0), estop_source(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { bool real; uint8_t base; } u_homed; u_homed.real = this->homed; *(outbuffer + offset + 0) = (u_homed.base >> (8 * 0)) & 0xFF; offset += sizeof(this->homed); 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); union { bool real; uint8_t base; } u_lowVoltage; u_lowVoltage.real = this->lowVoltage; *(outbuffer + offset + 0) = (u_lowVoltage.base >> (8 * 0)) & 0xFF; offset += sizeof(this->lowVoltage); *(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_homed; u_homed.base = 0; u_homed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->homed = u_homed.real; offset += sizeof(this->homed); 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); union { bool real; uint8_t base; } u_lowVoltage; u_lowVoltage.base = 0; u_lowVoltage.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); this->lowVoltage = u_lowVoltage.real; offset += sizeof(this->lowVoltage); 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 "intera_core_msgs/RobotAssemblyState"; }; const char * getMD5(){ return "df79ce5f75a6b23626e9fcdf1cc4d298"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_Int32MultiArray_h #define _ROS_std_msgs_Int32MultiArray_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/MultiArrayLayout.h" namespace std_msgs { class Int32MultiArray : public ros::Msg { public: typedef std_msgs::MultiArrayLayout _layout_type; _layout_type layout; uint32_t data_length; typedef int32_t _data_type; _data_type st_data; _data_type * data; Int32MultiArray(): layout(), data_length(0), data(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->layout.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF; offset += sizeof(this->data_length); for( uint32_t i = 0; i < data_length; i++){ union { int32_t real; uint32_t base; } u_datai; u_datai.real = this->data[i]; *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF; offset += sizeof(this->data[i]); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->layout.deserialize(inbuffer + offset); uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset))); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data_length); if(data_lengthT > data_length) this->data = (int32_t*)realloc(this->data, data_lengthT * sizeof(int32_t)); data_length = data_lengthT; for( uint32_t i = 0; i < data_length; i++){ union { int32_t real; uint32_t base; } u_st_data; u_st_data.base = 0; u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->st_data = u_st_data.real; offset += sizeof(this->st_data); memcpy( &(this->data[i]), &(this->st_data), sizeof(int32_t)); } return offset; } const char * getType(){ return "std_msgs/Int32MultiArray"; }; const char * getMD5(){ return "1d99f79f8b325b44fee908053e9c945b"; }; }; } #endif

C

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

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

C

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

#ifndef _ROS_std_msgs_Header_h #define _ROS_std_msgs_Header_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" namespace std_msgs { class Header : public ros::Msg { public: typedef uint32_t _seq_type; _seq_type seq; typedef ros::Time _stamp_type; _stamp_type stamp; typedef const char* _frame_id_type; _frame_id_type frame_id; Header(): seq(0), stamp(), frame_id("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->seq >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->seq >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->seq >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->seq >> (8 * 3)) & 0xFF; offset += sizeof(this->seq); *(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->stamp.sec); *(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->stamp.nsec); uint32_t length_frame_id = strlen(this->frame_id); varToArr(outbuffer + offset, length_frame_id); offset += 4; memcpy(outbuffer + offset, this->frame_id, length_frame_id); offset += length_frame_id; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->seq = ((uint32_t) (*(inbuffer + offset))); this->seq |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->seq |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->seq |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->seq); this->stamp.sec = ((uint32_t) (*(inbuffer + offset))); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stamp.sec); this->stamp.nsec = ((uint32_t) (*(inbuffer + offset))); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stamp.nsec); uint32_t length_frame_id; arrToVar(length_frame_id, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_frame_id; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_frame_id-1]=0; this->frame_id = (char *)(inbuffer + offset-1); offset += length_frame_id; return offset; } const char * getType(){ return "std_msgs/Header"; }; const char * getMD5(){ return "2176decaecbce78abc3b96ef049fabed"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_UInt32_h #define _ROS_std_msgs_UInt32_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace std_msgs { class UInt32 : public ros::Msg { public: typedef uint32_t _data_type; _data_type data; UInt32(): data(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data >> (8 * 3)) & 0xFF; offset += sizeof(this->data); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->data = ((uint32_t) (*(inbuffer + offset))); this->data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data); return offset; } const char * getType(){ return "std_msgs/UInt32"; }; const char * getMD5(){ return "304a39449588c7f8ce2df6e8001c5fce"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_UInt16_h #define _ROS_std_msgs_UInt16_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace std_msgs { class UInt16 : public ros::Msg { public: typedef uint16_t _data_type; _data_type data; UInt16(): data(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data >> (8 * 1)) & 0xFF; offset += sizeof(this->data); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->data = ((uint16_t) (*(inbuffer + offset))); this->data |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); offset += sizeof(this->data); return offset; } const char * getType(){ return "std_msgs/UInt16"; }; const char * getMD5(){ return "1df79edf208b629fe6b81923a544552d"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_UInt8_h #define _ROS_std_msgs_UInt8_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace std_msgs { class UInt8 : public ros::Msg { public: typedef uint8_t _data_type; _data_type data; UInt8(): data(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF; offset += sizeof(this->data); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->data = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->data); return offset; } const char * getType(){ return "std_msgs/UInt8"; }; const char * getMD5(){ return "7c8164229e7d2c17eb95e9231617fdee"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_MultiArrayLayout_h #define _ROS_std_msgs_MultiArrayLayout_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/MultiArrayDimension.h" namespace std_msgs { class MultiArrayLayout : public ros::Msg { public: uint32_t dim_length; typedef std_msgs::MultiArrayDimension _dim_type; _dim_type st_dim; _dim_type * dim; typedef uint32_t _data_offset_type; _data_offset_type data_offset; MultiArrayLayout(): dim_length(0), dim(NULL), data_offset(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->dim_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->dim_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->dim_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->dim_length >> (8 * 3)) & 0xFF; offset += sizeof(this->dim_length); for( uint32_t i = 0; i < dim_length; i++){ offset += this->dim[i].serialize(outbuffer + offset); } *(outbuffer + offset + 0) = (this->data_offset >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data_offset >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data_offset >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data_offset >> (8 * 3)) & 0xFF; offset += sizeof(this->data_offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t dim_lengthT = ((uint32_t) (*(inbuffer + offset))); dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->dim_length); if(dim_lengthT > dim_length) this->dim = (std_msgs::MultiArrayDimension*)realloc(this->dim, dim_lengthT * sizeof(std_msgs::MultiArrayDimension)); dim_length = dim_lengthT; for( uint32_t i = 0; i < dim_length; i++){ offset += this->st_dim.deserialize(inbuffer + offset); memcpy( &(this->dim[i]), &(this->st_dim), sizeof(std_msgs::MultiArrayDimension)); } this->data_offset = ((uint32_t) (*(inbuffer + offset))); this->data_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->data_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->data_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data_offset); return offset; } const char * getType(){ return "std_msgs/MultiArrayLayout"; }; const char * getMD5(){ return "0fed2a11c13e11c5571b4e2a995a91a3"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_Duration_h #define _ROS_std_msgs_Duration_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/duration.h" namespace std_msgs { class Duration : public ros::Msg { public: typedef ros::Duration _data_type; _data_type data; Duration(): data() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->data.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->data.sec); *(outbuffer + offset + 0) = (this->data.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->data.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->data.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->data.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->data.nsec); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->data.sec = ((uint32_t) (*(inbuffer + offset))); this->data.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->data.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->data.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data.sec); this->data.nsec = ((uint32_t) (*(inbuffer + offset))); this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->data.nsec); return offset; } const char * getType(){ return "std_msgs/Duration"; }; const char * getMD5(){ return "3e286caf4241d664e55f3ad380e2ae46"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_MultiArrayDimension_h #define _ROS_std_msgs_MultiArrayDimension_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace std_msgs { class MultiArrayDimension : public ros::Msg { public: typedef const char* _label_type; _label_type label; typedef uint32_t _size_type; _size_type size; typedef uint32_t _stride_type; _stride_type stride; MultiArrayDimension(): label(""), size(0), stride(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_label = strlen(this->label); varToArr(outbuffer + offset, length_label); offset += 4; memcpy(outbuffer + offset, this->label, length_label); offset += length_label; *(outbuffer + offset + 0) = (this->size >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->size >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->size >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->size >> (8 * 3)) & 0xFF; offset += sizeof(this->size); *(outbuffer + offset + 0) = (this->stride >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stride >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stride >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stride >> (8 * 3)) & 0xFF; offset += sizeof(this->stride); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_label; arrToVar(length_label, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_label; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_label-1]=0; this->label = (char *)(inbuffer + offset-1); offset += length_label; this->size = ((uint32_t) (*(inbuffer + offset))); this->size |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->size |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->size |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->size); this->stride = ((uint32_t) (*(inbuffer + offset))); this->stride |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->stride |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->stride |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stride); return offset; } const char * getType(){ return "std_msgs/MultiArrayDimension"; }; const char * getMD5(){ return "4cd0c83a8683deae40ecdac60e53bfa8"; }; }; } #endif

C

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

#ifndef _ROS_std_msgs_ColorRGBA_h #define _ROS_std_msgs_ColorRGBA_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace std_msgs { class ColorRGBA : public ros::Msg { public: typedef float _r_type; _r_type r; typedef float _g_type; _g_type g; typedef float _b_type; _b_type b; typedef float _a_type; _a_type a; ColorRGBA(): r(0), g(0), b(0), a(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { float real; uint32_t base; } u_r; u_r.real = this->r; *(outbuffer + offset + 0) = (u_r.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_r.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_r.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_r.base >> (8 * 3)) & 0xFF; offset += sizeof(this->r); union { float real; uint32_t base; } u_g; u_g.real = this->g; *(outbuffer + offset + 0) = (u_g.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_g.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_g.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_g.base >> (8 * 3)) & 0xFF; offset += sizeof(this->g); union { float real; uint32_t base; } u_b; u_b.real = this->b; *(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF; offset += sizeof(this->b); union { float real; uint32_t base; } u_a; u_a.real = this->a; *(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF; offset += sizeof(this->a); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { float real; uint32_t base; } u_r; u_r.base = 0; u_r.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_r.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_r.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_r.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->r = u_r.real; offset += sizeof(this->r); union { float real; uint32_t base; } u_g; u_g.base = 0; u_g.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_g.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_g.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_g.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->g = u_g.real; offset += sizeof(this->g); union { float real; uint32_t base; } u_b; u_b.base = 0; u_b.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_b.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_b.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_b.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->b = u_b.real; offset += sizeof(this->b); union { float real; uint32_t base; } u_a; u_a.base = 0; u_a.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); u_a.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); u_a.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); u_a.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); this->a = u_a.real; offset += sizeof(this->a); return offset; } const char * getType(){ return "std_msgs/ColorRGBA"; }; const char * getMD5(){ return "a29a96539573343b1310c73607334b00"; }; }; } #endif

C

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

#ifndef _ROS_actionlib_msgs_GoalStatus_h #define _ROS_actionlib_msgs_GoalStatus_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "actionlib_msgs/GoalID.h" namespace actionlib_msgs { class GoalStatus : public ros::Msg { public: typedef actionlib_msgs::GoalID _goal_id_type; _goal_id_type goal_id; typedef uint8_t _status_type; _status_type status; typedef const char* _text_type; _text_type text; enum { PENDING = 0 }; enum { ACTIVE = 1 }; enum { PREEMPTED = 2 }; enum { SUCCEEDED = 3 }; enum { ABORTED = 4 }; enum { REJECTED = 5 }; enum { PREEMPTING = 6 }; enum { RECALLING = 7 }; enum { RECALLED = 8 }; enum { LOST = 9 }; GoalStatus(): goal_id(), status(0), text("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->goal_id.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF; offset += sizeof(this->status); uint32_t length_text = strlen(this->text); varToArr(outbuffer + offset, length_text); offset += 4; memcpy(outbuffer + offset, this->text, length_text); offset += length_text; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->goal_id.deserialize(inbuffer + offset); this->status = ((uint8_t) (*(inbuffer + offset))); offset += sizeof(this->status); uint32_t length_text; arrToVar(length_text, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_text; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_text-1]=0; this->text = (char *)(inbuffer + offset-1); offset += length_text; return offset; } const char * getType(){ return "actionlib_msgs/GoalStatus"; }; const char * getMD5(){ return "d388f9b87b3c471f784434d671988d4a"; }; }; } #endif

C

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

#ifndef _ROS_actionlib_msgs_GoalStatusArray_h #define _ROS_actionlib_msgs_GoalStatusArray_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "actionlib_msgs/GoalStatus.h" namespace actionlib_msgs { class GoalStatusArray : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; uint32_t status_list_length; typedef actionlib_msgs::GoalStatus _status_list_type; _status_list_type st_status_list; _status_list_type * status_list; GoalStatusArray(): header(), status_list_length(0), status_list(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); *(outbuffer + offset + 0) = (this->status_list_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->status_list_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->status_list_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->status_list_length >> (8 * 3)) & 0xFF; offset += sizeof(this->status_list_length); for( uint32_t i = 0; i < status_list_length; i++){ offset += this->status_list[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); uint32_t status_list_lengthT = ((uint32_t) (*(inbuffer + offset))); status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->status_list_length); if(status_list_lengthT > status_list_length) this->status_list = (actionlib_msgs::GoalStatus*)realloc(this->status_list, status_list_lengthT * sizeof(actionlib_msgs::GoalStatus)); status_list_length = status_list_lengthT; for( uint32_t i = 0; i < status_list_length; i++){ offset += this->st_status_list.deserialize(inbuffer + offset); memcpy( &(this->status_list[i]), &(this->st_status_list), sizeof(actionlib_msgs::GoalStatus)); } return offset; } const char * getType(){ return "actionlib_msgs/GoalStatusArray"; }; const char * getMD5(){ return "8b2b82f13216d0a8ea88bd3af735e619"; }; }; } #endif

C

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

#ifndef _ROS_actionlib_msgs_GoalID_h #define _ROS_actionlib_msgs_GoalID_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "ros/time.h" namespace actionlib_msgs { class GoalID : public ros::Msg { public: typedef ros::Time _stamp_type; _stamp_type stamp; typedef const char* _id_type; _id_type id; GoalID(): stamp(), id("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF; offset += sizeof(this->stamp.sec); *(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF; offset += sizeof(this->stamp.nsec); uint32_t length_id = strlen(this->id); varToArr(outbuffer + offset, length_id); offset += 4; memcpy(outbuffer + offset, this->id, length_id); offset += length_id; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; this->stamp.sec = ((uint32_t) (*(inbuffer + offset))); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stamp.sec); this->stamp.nsec = ((uint32_t) (*(inbuffer + offset))); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->stamp.nsec); 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; return offset; } const char * getType(){ return "actionlib_msgs/GoalID"; }; const char * getMD5(){ return "302881f31927c1df708a2dbab0e80ee8"; }; }; } #endif

C

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

#ifndef _ROS_turtlebot3_example_Turtlebot3Result_h #define _ROS_turtlebot3_example_Turtlebot3Result_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlebot3_example { class Turtlebot3Result : public ros::Msg { public: typedef const char* _result_type; _result_type result; Turtlebot3Result(): result("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_result = strlen(this->result); varToArr(outbuffer + offset, length_result); offset += 4; memcpy(outbuffer + offset, this->result, length_result); offset += length_result; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_result; arrToVar(length_result, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_result; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_result-1]=0; this->result = (char *)(inbuffer + offset-1); offset += length_result; return offset; } const char * getType(){ return "turtlebot3_example/Turtlebot3Result"; }; const char * getMD5(){ return "c22f2a1ed8654a0b365f1bb3f7ff2c0f"; }; }; } #endif

C

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

#ifndef _ROS_turtlebot3_example_Turtlebot3Goal_h #define _ROS_turtlebot3_example_Turtlebot3Goal_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "geometry_msgs/Vector3.h" namespace turtlebot3_example { class Turtlebot3Goal : public ros::Msg { public: typedef geometry_msgs::Vector3 _goal_type; _goal_type goal; Turtlebot3Goal(): goal() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->goal.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->goal.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "turtlebot3_example/Turtlebot3Goal"; }; const char * getMD5(){ return "8ad3bd0e46ff6777ce7cd2fdd945cb9e"; }; }; } #endif

C

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

#ifndef _ROS_turtlebot3_example_Turtlebot3ActionGoal_h #define _ROS_turtlebot3_example_Turtlebot3ActionGoal_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "actionlib_msgs/GoalID.h" #include "turtlebot3_example/Turtlebot3Goal.h" namespace turtlebot3_example { class Turtlebot3ActionGoal : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef actionlib_msgs::GoalID _goal_id_type; _goal_id_type goal_id; typedef turtlebot3_example::Turtlebot3Goal _goal_type; _goal_type goal; Turtlebot3ActionGoal(): header(), goal_id(), goal() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->goal_id.serialize(outbuffer + offset); offset += this->goal.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->goal_id.deserialize(inbuffer + offset); offset += this->goal.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "turtlebot3_example/Turtlebot3ActionGoal"; }; const char * getMD5(){ return "629663823fea578d64180162f10bec87"; }; }; } #endif

C

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

#ifndef _ROS_turtlebot3_example_Turtlebot3Feedback_h #define _ROS_turtlebot3_example_Turtlebot3Feedback_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" namespace turtlebot3_example { class Turtlebot3Feedback : public ros::Msg { public: typedef const char* _state_type; _state_type state; Turtlebot3Feedback(): state("") { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; uint32_t length_state = strlen(this->state); varToArr(outbuffer + offset, length_state); offset += 4; memcpy(outbuffer + offset, this->state, length_state); offset += length_state; return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t length_state; arrToVar(length_state, (inbuffer + offset)); offset += 4; for(unsigned int k= offset; k< offset+length_state; ++k){ inbuffer[k-1]=inbuffer[k]; } inbuffer[offset+length_state-1]=0; this->state = (char *)(inbuffer + offset-1); offset += length_state; return offset; } const char * getType(){ return "turtlebot3_example/Turtlebot3Feedback"; }; const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; }; }; } #endif

C

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

#ifndef _ROS_turtlebot3_example_Turtlebot3Action_h #define _ROS_turtlebot3_example_Turtlebot3Action_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "turtlebot3_example/Turtlebot3ActionGoal.h" #include "turtlebot3_example/Turtlebot3ActionResult.h" #include "turtlebot3_example/Turtlebot3ActionFeedback.h" namespace turtlebot3_example { class Turtlebot3Action : public ros::Msg { public: typedef turtlebot3_example::Turtlebot3ActionGoal _action_goal_type; _action_goal_type action_goal; typedef turtlebot3_example::Turtlebot3ActionResult _action_result_type; _action_result_type action_result; typedef turtlebot3_example::Turtlebot3ActionFeedback _action_feedback_type; _action_feedback_type action_feedback; Turtlebot3Action(): 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 "turtlebot3_example/Turtlebot3Action"; }; const char * getMD5(){ return "86a69578ab4eb5bb3e55984730f14503"; }; }; } #endif

C

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

#ifndef _ROS_SERVICE_ProjectedMapsInfo_h #define _ROS_SERVICE_ProjectedMapsInfo_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "map_msgs/ProjectedMapInfo.h" namespace map_msgs { static const char PROJECTEDMAPSINFO[] = "map_msgs/ProjectedMapsInfo"; class ProjectedMapsInfoRequest : public ros::Msg { public: uint32_t projected_maps_info_length; typedef map_msgs::ProjectedMapInfo _projected_maps_info_type; _projected_maps_info_type st_projected_maps_info; _projected_maps_info_type * projected_maps_info; ProjectedMapsInfoRequest(): projected_maps_info_length(0), projected_maps_info(NULL) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; *(outbuffer + offset + 0) = (this->projected_maps_info_length >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (this->projected_maps_info_length >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (this->projected_maps_info_length >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (this->projected_maps_info_length >> (8 * 3)) & 0xFF; offset += sizeof(this->projected_maps_info_length); for( uint32_t i = 0; i < projected_maps_info_length; i++){ offset += this->projected_maps_info[i].serialize(outbuffer + offset); } return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; uint32_t projected_maps_info_lengthT = ((uint32_t) (*(inbuffer + offset))); projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); offset += sizeof(this->projected_maps_info_length); if(projected_maps_info_lengthT > projected_maps_info_length) this->projected_maps_info = (map_msgs::ProjectedMapInfo*)realloc(this->projected_maps_info, projected_maps_info_lengthT * sizeof(map_msgs::ProjectedMapInfo)); projected_maps_info_length = projected_maps_info_lengthT; for( uint32_t i = 0; i < projected_maps_info_length; i++){ offset += this->st_projected_maps_info.deserialize(inbuffer + offset); memcpy( &(this->projected_maps_info[i]), &(this->st_projected_maps_info), sizeof(map_msgs::ProjectedMapInfo)); } return offset; } const char * getType(){ return PROJECTEDMAPSINFO; }; const char * getMD5(){ return "d7980a33202421c8cd74565e57a4d229"; }; }; class ProjectedMapsInfoResponse : public ros::Msg { public: ProjectedMapsInfoResponse() { } 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 PROJECTEDMAPSINFO; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class ProjectedMapsInfo { public: typedef ProjectedMapsInfoRequest Request; typedef ProjectedMapsInfoResponse Response; }; } #endif

C

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

#ifndef _ROS_SERVICE_GetMapROI_h #define _ROS_SERVICE_GetMapROI_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "nav_msgs/OccupancyGrid.h" namespace map_msgs { static const char GETMAPROI[] = "map_msgs/GetMapROI"; class GetMapROIRequest : public ros::Msg { public: typedef double _x_type; _x_type x; typedef double _y_type; _y_type y; typedef double _l_x_type; _l_x_type l_x; typedef double _l_y_type; _l_y_type l_y; GetMapROIRequest(): x(0), y(0), l_x(0), l_y(0) { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; union { double real; uint64_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; *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF; offset += sizeof(this->x); union { double real; uint64_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; *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF; offset += sizeof(this->y); union { double real; uint64_t base; } u_l_x; u_l_x.real = this->l_x; *(outbuffer + offset + 0) = (u_l_x.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_l_x.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_l_x.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_l_x.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_l_x.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_l_x.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_l_x.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_l_x.base >> (8 * 7)) & 0xFF; offset += sizeof(this->l_x); union { double real; uint64_t base; } u_l_y; u_l_y.real = this->l_y; *(outbuffer + offset + 0) = (u_l_y.base >> (8 * 0)) & 0xFF; *(outbuffer + offset + 1) = (u_l_y.base >> (8 * 1)) & 0xFF; *(outbuffer + offset + 2) = (u_l_y.base >> (8 * 2)) & 0xFF; *(outbuffer + offset + 3) = (u_l_y.base >> (8 * 3)) & 0xFF; *(outbuffer + offset + 4) = (u_l_y.base >> (8 * 4)) & 0xFF; *(outbuffer + offset + 5) = (u_l_y.base >> (8 * 5)) & 0xFF; *(outbuffer + offset + 6) = (u_l_y.base >> (8 * 6)) & 0xFF; *(outbuffer + offset + 7) = (u_l_y.base >> (8 * 7)) & 0xFF; offset += sizeof(this->l_y); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; union { double real; uint64_t base; } u_x; u_x.base = 0; u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->x = u_x.real; offset += sizeof(this->x); union { double real; uint64_t base; } u_y; u_y.base = 0; u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->y = u_y.real; offset += sizeof(this->y); union { double real; uint64_t base; } u_l_x; u_l_x.base = 0; u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->l_x = u_l_x.real; offset += sizeof(this->l_x); union { double real; uint64_t base; } u_l_y; u_l_y.base = 0; u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); this->l_y = u_l_y.real; offset += sizeof(this->l_y); return offset; } const char * getType(){ return GETMAPROI; }; const char * getMD5(){ return "43c2ff8f45af555c0eaf070c401e9a47"; }; }; class GetMapROIResponse : public ros::Msg { public: typedef nav_msgs::OccupancyGrid _sub_map_type; _sub_map_type sub_map; GetMapROIResponse(): sub_map() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->sub_map.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->sub_map.deserialize(inbuffer + offset); return offset; } const char * getType(){ return GETMAPROI; }; const char * getMD5(){ return "4d1986519c00d81967d2891a606b234c"; }; }; class GetMapROI { public: typedef GetMapROIRequest Request; typedef GetMapROIResponse Response; }; } #endif

C

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

#ifndef _ROS_SERVICE_GetPointMap_h #define _ROS_SERVICE_GetPointMap_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "sensor_msgs/PointCloud2.h" namespace map_msgs { static const char GETPOINTMAP[] = "map_msgs/GetPointMap"; class GetPointMapRequest : public ros::Msg { public: GetPointMapRequest() { } 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 GETPOINTMAP; }; const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; }; class GetPointMapResponse : public ros::Msg { public: typedef sensor_msgs::PointCloud2 _map_type; _map_type map; GetPointMapResponse(): 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 GETPOINTMAP; }; const char * getMD5(){ return "b84fbb39505086eb6a62d933c75cb7b4"; }; }; class GetPointMap { public: typedef GetPointMapRequest Request; typedef GetPointMapResponse Response; }; } #endif

C