file_path
stringlengths 21
224
| content
stringlengths 0
80.8M
|
|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/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
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/controller_manager_msgs/UnloadController.h | #ifndef _ROS_SERVICE_UnloadController_h
#define _ROS_SERVICE_UnloadController_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace controller_manager_msgs
{
static const char UNLOADCONTROLLER[] = "controller_manager_msgs/UnloadController";
class UnloadControllerRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
UnloadControllerRequest():
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 UNLOADCONTROLLER; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class UnloadControllerResponse : public ros::Msg
{
public:
typedef bool _ok_type;
_ok_type ok;
UnloadControllerResponse():
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 UNLOADCONTROLLER; };
const char * getMD5(){ return "6f6da3883749771fac40d6deb24a8c02"; };
};
class UnloadController {
public:
typedef UnloadControllerRequest Request;
typedef UnloadControllerResponse Response;
};
}
#endif
|
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
|
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
|
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
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_core_msgs/DigitalOutputCommand.h | #ifndef _ROS_intera_core_msgs_DigitalOutputCommand_h
#define _ROS_intera_core_msgs_DigitalOutputCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace intera_core_msgs
{
class DigitalOutputCommand : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef bool _value_type;
_value_type value;
DigitalOutputCommand():
name(""),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "intera_core_msgs/DigitalOutputCommand"; };
const char * getMD5(){ return "23f05028c1a699fb83e22401228c3a9e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_core_msgs/DigitalIOStates.h | #ifndef _ROS_intera_core_msgs_DigitalIOStates_h
#define _ROS_intera_core_msgs_DigitalIOStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "intera_core_msgs/DigitalIOState.h"
namespace intera_core_msgs
{
class DigitalIOStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef intera_core_msgs::DigitalIOState _states_type;
_states_type st_states;
_states_type * states;
DigitalIOStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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;
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::DigitalIOState*)realloc(this->states, states_lengthT * sizeof(intera_core_msgs::DigitalIOState));
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::DigitalIOState));
}
return offset;
}
const char * getType(){ return "intera_core_msgs/DigitalIOStates"; };
const char * getMD5(){ return "d434210c6ec20947fec667d6c13d6062"; };
};
}
#endif
|
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
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_core_msgs/AnalogIOStates.h | #ifndef _ROS_intera_core_msgs_AnalogIOStates_h
#define _ROS_intera_core_msgs_AnalogIOStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "intera_core_msgs/AnalogIOState.h"
namespace intera_core_msgs
{
class AnalogIOStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef intera_core_msgs::AnalogIOState _states_type;
_states_type st_states;
_states_type * states;
AnalogIOStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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;
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::AnalogIOState*)realloc(this->states, states_lengthT * sizeof(intera_core_msgs::AnalogIOState));
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::AnalogIOState));
}
return offset;
}
const char * getType(){ return "intera_core_msgs/AnalogIOStates"; };
const char * getMD5(){ return "0a05ba3bbb53a8a3b164e34946d619f7"; };
};
}
#endif
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_core_msgs/NavigatorStates.h | #ifndef _ROS_intera_core_msgs_NavigatorStates_h
#define _ROS_intera_core_msgs_NavigatorStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "intera_core_msgs/NavigatorState.h"
namespace intera_core_msgs
{
class NavigatorStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef intera_core_msgs::NavigatorState _states_type;
_states_type st_states;
_states_type * states;
NavigatorStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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;
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::NavigatorState*)realloc(this->states, states_lengthT * sizeof(intera_core_msgs::NavigatorState));
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::NavigatorState));
}
return offset;
}
const char * getType(){ return "intera_core_msgs/NavigatorStates"; };
const char * getMD5(){ return "2c2eeb02fbbaa6f1ab6c680887f2db78"; };
};
}
#endif
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int64MultiArray.h | #ifndef _ROS_std_msgs_Int64MultiArray_h
#define _ROS_std_msgs_Int64MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Int64MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef int64_t _data_type;
_data_type st_data;
_data_type * data;
Int64MultiArray():
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 {
int64_t real;
uint64_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;
*(outbuffer + offset + 4) = (u_datai.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_datai.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_datai.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_datai.base >> (8 * 7)) & 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 = (int64_t*)realloc(this->data, data_lengthT * sizeof(int64_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int64_t real;
uint64_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int64_t));
}
return offset;
}
const char * getType(){ return "std_msgs/Int64MultiArray"; };
const char * getMD5(){ return "54865aa6c65be0448113a2afc6a49270"; };
};
}
#endif
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt64.h | #ifndef _ROS_std_msgs_UInt64_h
#define _ROS_std_msgs_UInt64_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class UInt64 : public ros::Msg
{
public:
typedef uint64_t _data_type;
_data_type data;
UInt64():
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;
*(outbuffer + offset + 4) = (this->data >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (this->data >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (this->data >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (this->data >> (8 * 7)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->data = ((uint64_t) (*(inbuffer + offset)));
this->data |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->data |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->data |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->data |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
this->data |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
this->data |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
this->data |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/UInt64"; };
const char * getMD5(){ return "1b2a79973e8bf53d7b53acb71299cb57"; };
};
}
#endif
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Float32.h | #ifndef _ROS_std_msgs_Float32_h
#define _ROS_std_msgs_Float32_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Float32 : public ros::Msg
{
public:
typedef float _data_type;
_data_type data;
Float32():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Float32"; };
const char * getMD5(){ return "73fcbf46b49191e672908e50842a83d4"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/ByteMultiArray.h | #ifndef _ROS_std_msgs_ByteMultiArray_h
#define _ROS_std_msgs_ByteMultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class ByteMultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
ByteMultiArray():
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 {
int8_t real;
uint8_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->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 = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "std_msgs/ByteMultiArray"; };
const char * getMD5(){ return "70ea476cbcfd65ac2f68f3cda1e891fe"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int32.h | #ifndef _ROS_std_msgs_Int32_h
#define _ROS_std_msgs_Int32_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Int32 : public ros::Msg
{
public:
typedef int32_t _data_type;
_data_type data;
Int32():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Int32"; };
const char * getMD5(){ return "da5909fbe378aeaf85e547e830cc1bb7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt16MultiArray.h | #ifndef _ROS_std_msgs_UInt16MultiArray_h
#define _ROS_std_msgs_UInt16MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class UInt16MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef uint16_t _data_type;
_data_type st_data;
_data_type * data;
UInt16MultiArray():
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++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 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 = (uint16_t*)realloc(this->data, data_lengthT * sizeof(uint16_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint16_t) (*(inbuffer + offset)));
this->st_data |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint16_t));
}
return offset;
}
const char * getType(){ return "std_msgs/UInt16MultiArray"; };
const char * getMD5(){ return "52f264f1c973c4b73790d384c6cb4484"; };
};
}
#endif
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int16.h | #ifndef _ROS_std_msgs_Int16_h
#define _ROS_std_msgs_Int16_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Int16 : public ros::Msg
{
public:
typedef int16_t _data_type;
_data_type data;
Int16():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int16_t real;
uint16_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int16_t real;
uint16_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_data.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Int16"; };
const char * getMD5(){ return "8524586e34fbd7cb1c08c5f5f1ca0e57"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int64.h | #ifndef _ROS_std_msgs_Int64_h
#define _ROS_std_msgs_Int64_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Int64 : public ros::Msg
{
public:
typedef int64_t _data_type;
_data_type data;
Int64():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_data.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_data.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_data.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_data.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Int64"; };
const char * getMD5(){ return "34add168574510e6e17f5d23ecc077ef"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Float64.h | #ifndef _ROS_std_msgs_Float64_h
#define _ROS_std_msgs_Float64_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Float64 : public ros::Msg
{
public:
typedef double _data_type;
_data_type data;
Float64():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_data.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_data.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_data.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_data.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Float64"; };
const char * getMD5(){ return "fdb28210bfa9d7c91146260178d9a584"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt32MultiArray.h | #ifndef _ROS_std_msgs_UInt32MultiArray_h
#define _ROS_std_msgs_UInt32MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class UInt32MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef uint32_t _data_type;
_data_type st_data;
_data_type * data;
UInt32MultiArray():
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++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->data[i]);
}
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 = (uint32_t*)realloc(this->data, data_lengthT * sizeof(uint32_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint32_t) (*(inbuffer + offset)));
this->st_data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint32_t));
}
return offset;
}
const char * getType(){ return "std_msgs/UInt32MultiArray"; };
const char * getMD5(){ return "4d6a180abc9be191b96a7eda6c8a233d"; };
};
}
#endif
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Byte.h | #ifndef _ROS_std_msgs_Byte_h
#define _ROS_std_msgs_Byte_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Byte : public ros::Msg
{
public:
typedef int8_t _data_type;
_data_type data;
Byte():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t 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 {
int8_t 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/Byte"; };
const char * getMD5(){ return "ad736a2e8818154c487bb80fe42ce43b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/String.h | #ifndef _ROS_std_msgs_String_h
#define _ROS_std_msgs_String_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class String : public ros::Msg
{
public:
typedef const char* _data_type;
_data_type data;
String():
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
return offset;
}
const char * getType(){ return "std_msgs/String"; };
const char * getMD5(){ return "992ce8a1687cec8c8bd883ec73ca41d1"; };
};
}
#endif
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt8MultiArray.h | #ifndef _ROS_std_msgs_UInt8MultiArray_h
#define _ROS_std_msgs_UInt8MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class UInt8MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef uint8_t _data_type;
_data_type st_data;
_data_type * data;
UInt8MultiArray():
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++){
*(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->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 = (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 "std_msgs/UInt8MultiArray"; };
const char * getMD5(){ return "82373f1612381bb6ee473b5cd6f5d89c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int16MultiArray.h | #ifndef _ROS_std_msgs_Int16MultiArray_h
#define _ROS_std_msgs_Int16MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Int16MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef int16_t _data_type;
_data_type st_data;
_data_type * data;
Int16MultiArray():
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 {
int16_t real;
uint16_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;
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 = (int16_t*)realloc(this->data, data_lengthT * sizeof(int16_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int16_t real;
uint16_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int16_t));
}
return offset;
}
const char * getType(){ return "std_msgs/Int16MultiArray"; };
const char * getMD5(){ return "d9338d7f523fcb692fae9d0a0e9f067c"; };
};
}
#endif
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt64MultiArray.h | #ifndef _ROS_std_msgs_UInt64MultiArray_h
#define _ROS_std_msgs_UInt64MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class UInt64MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef uint64_t _data_type;
_data_type st_data;
_data_type * data;
UInt64MultiArray():
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++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data[i] >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (this->data[i] >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (this->data[i] >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (this->data[i] >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (this->data[i] >> (8 * 7)) & 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 = (uint64_t*)realloc(this->data, data_lengthT * sizeof(uint64_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint64_t) (*(inbuffer + offset)));
this->st_data |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint64_t));
}
return offset;
}
const char * getType(){ return "std_msgs/UInt64MultiArray"; };
const char * getMD5(){ return "6088f127afb1d6c72927aa1247e945af"; };
};
}
#endif
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Float64MultiArray.h | #ifndef _ROS_std_msgs_Float64MultiArray_h
#define _ROS_std_msgs_Float64MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Float64MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef double _data_type;
_data_type st_data;
_data_type * data;
Float64MultiArray():
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 {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_datai.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_datai.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_datai.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_datai.base >> (8 * 7)) & 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 = (double*)realloc(this->data, data_lengthT * sizeof(double));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
double real;
uint64_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(double));
}
return offset;
}
const char * getType(){ return "std_msgs/Float64MultiArray"; };
const char * getMD5(){ return "4b7d974086d4060e7db4613a7e6c3ba4"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Time.h | #ifndef _ROS_std_msgs_Time_h
#define _ROS_std_msgs_Time_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace std_msgs
{
class Time : public ros::Msg
{
public:
typedef ros::Time _data_type;
_data_type data;
Time():
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/Time"; };
const char * getMD5(){ return "cd7166c74c552c311fbcc2fe5a7bc289"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Char.h | #ifndef _ROS_std_msgs_Char_h
#define _ROS_std_msgs_Char_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Char : public ros::Msg
{
public:
typedef uint8_t _data_type;
_data_type data;
Char():
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/Char"; };
const char * getMD5(){ return "1bf77f25acecdedba0e224b162199717"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Float32MultiArray.h | #ifndef _ROS_std_msgs_Float32MultiArray_h
#define _ROS_std_msgs_Float32MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Float32MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef float _data_type;
_data_type st_data;
_data_type * data;
Float32MultiArray():
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 {
float 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 = (float*)realloc(this->data, data_lengthT * sizeof(float));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
float 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(float));
}
return offset;
}
const char * getType(){ return "std_msgs/Float32MultiArray"; };
const char * getMD5(){ return "6a40e0ffa6a17a503ac3f8616991b1f6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int8MultiArray.h | #ifndef _ROS_std_msgs_Int8MultiArray_h
#define _ROS_std_msgs_Int8MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Int8MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
Int8MultiArray():
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 {
int8_t real;
uint8_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->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 = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "std_msgs/Int8MultiArray"; };
const char * getMD5(){ return "d7c1af35a1b4781bbe79e03dd94b7c13"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int8.h | #ifndef _ROS_std_msgs_Int8_h
#define _ROS_std_msgs_Int8_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Int8 : public ros::Msg
{
public:
typedef int8_t _data_type;
_data_type data;
Int8():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t 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 {
int8_t 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/Int8"; };
const char * getMD5(){ return "27ffa0c9c4b8fb8492252bcad9e5c57b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Empty.h | #ifndef _ROS_std_msgs_Empty_h
#define _ROS_std_msgs_Empty_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Empty : public ros::Msg
{
public:
Empty()
{
}
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 "std_msgs/Empty"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3ActionFeedback.h | #ifndef _ROS_turtlebot3_example_Turtlebot3ActionFeedback_h
#define _ROS_turtlebot3_example_Turtlebot3ActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "turtlebot3_example/Turtlebot3Feedback.h"
namespace turtlebot3_example
{
class Turtlebot3ActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtlebot3_example::Turtlebot3Feedback _feedback_type;
_feedback_type feedback;
Turtlebot3ActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "turtlebot3_example/Turtlebot3ActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3ActionResult.h | #ifndef _ROS_turtlebot3_example_Turtlebot3ActionResult_h
#define _ROS_turtlebot3_example_Turtlebot3ActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "turtlebot3_example/Turtlebot3Result.h"
namespace turtlebot3_example
{
class Turtlebot3ActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtlebot3_example::Turtlebot3Result _result_type;
_result_type result;
Turtlebot3ActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "turtlebot3_example/Turtlebot3ActionResult"; };
const char * getMD5(){ return "5489bcfa93e36e07a0b801f3ac4c7c97"; };
};
}
#endif
|
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
|
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
|
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
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/OccupancyGridUpdate.h | #ifndef _ROS_map_msgs_OccupancyGridUpdate_h
#define _ROS_map_msgs_OccupancyGridUpdate_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace map_msgs
{
class OccupancyGridUpdate : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef int32_t _x_type;
_x_type x;
typedef int32_t _y_type;
_y_type y;
typedef uint32_t _width_type;
_width_type width;
typedef uint32_t _height_type;
_height_type height;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
OccupancyGridUpdate():
header(),
x(0),
y(0),
width(0),
height(0),
data_length(0), data(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_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
int32_t real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
int32_t real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "map_msgs/OccupancyGridUpdate"; };
const char * getMD5(){ return "b295be292b335c34718bd939deebe1c9"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/GetPointMapROI.h | #ifndef _ROS_SERVICE_GetPointMapROI_h
#define _ROS_SERVICE_GetPointMapROI_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 GETPOINTMAPROI[] = "map_msgs/GetPointMapROI";
class GetPointMapROIRequest : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
typedef double _r_type;
_r_type r;
typedef double _l_x_type;
_l_x_type l_x;
typedef double _l_y_type;
_l_y_type l_y;
typedef double _l_z_type;
_l_z_type l_z;
GetPointMapROIRequest():
x(0),
y(0),
z(0),
r(0),
l_x(0),
l_y(0),
l_z(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_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->z);
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_r.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_r.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_r.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_r.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->r);
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);
union {
double real;
uint64_t base;
} u_l_z;
u_l_z.real = this->l_z;
*(outbuffer + offset + 0) = (u_l_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_z);
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_z;
u_z.base = 0;
u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->z = u_z.real;
offset += sizeof(this->z);
union {
double real;
uint64_t base;
} u_r;
u_r.base = 0;
u_r.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->r = u_r.real;
offset += sizeof(this->r);
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);
union {
double real;
uint64_t base;
} u_l_z;
u_l_z.base = 0;
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_z = u_l_z.real;
offset += sizeof(this->l_z);
return offset;
}
const char * getType(){ return GETPOINTMAPROI; };
const char * getMD5(){ return "895f7e437a9a6dd225316872b187a303"; };
};
class GetPointMapROIResponse : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud2 _sub_map_type;
_sub_map_type sub_map;
GetPointMapROIResponse():
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 GETPOINTMAPROI; };
const char * getMD5(){ return "313769f8b0e724525c6463336cbccd63"; };
};
class GetPointMapROI {
public:
typedef GetPointMapROIRequest Request;
typedef GetPointMapROIResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/SetMapProjections.h | #ifndef _ROS_SERVICE_SetMapProjections_h
#define _ROS_SERVICE_SetMapProjections_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 SETMAPPROJECTIONS[] = "map_msgs/SetMapProjections";
class SetMapProjectionsRequest : public ros::Msg
{
public:
SetMapProjectionsRequest()
{
}
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 SETMAPPROJECTIONS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetMapProjectionsResponse : 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;
SetMapProjectionsResponse():
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 SETMAPPROJECTIONS; };
const char * getMD5(){ return "d7980a33202421c8cd74565e57a4d229"; };
};
class SetMapProjections {
public:
typedef SetMapProjectionsRequest Request;
typedef SetMapProjectionsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/SaveMap.h | #ifndef _ROS_SERVICE_SaveMap_h
#define _ROS_SERVICE_SaveMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/String.h"
namespace map_msgs
{
static const char SAVEMAP[] = "map_msgs/SaveMap";
class SaveMapRequest : public ros::Msg
{
public:
typedef std_msgs::String _filename_type;
_filename_type filename;
SaveMapRequest():
filename()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->filename.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->filename.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "716e25f9d9dc76ceba197f93cbf05dc7"; };
};
class SaveMapResponse : public ros::Msg
{
public:
SaveMapResponse()
{
}
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 SAVEMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SaveMap {
public:
typedef SaveMapRequest Request;
typedef SaveMapResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/ProjectedMapInfo.h | #ifndef _ROS_map_msgs_ProjectedMapInfo_h
#define _ROS_map_msgs_ProjectedMapInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace map_msgs
{
class ProjectedMapInfo : public ros::Msg
{
public:
typedef const char* _frame_id_type;
_frame_id_type frame_id;
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _width_type;
_width_type width;
typedef double _height_type;
_height_type height;
typedef double _min_z_type;
_min_z_type min_z;
typedef double _max_z_type;
_max_z_type max_z;
ProjectedMapInfo():
frame_id(""),
x(0),
y(0),
width(0),
height(0),
min_z(0),
max_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
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;
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_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;
*(outbuffer + offset + 4) = (u_width.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_width.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_width.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_width.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->width);
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_height.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_height.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_height.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_height.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->height);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.real = this->min_z;
*(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.real = this->max_z;
*(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
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_width;
u_width.base = 0;
u_width.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->width = u_width.real;
offset += sizeof(this->width);
union {
double real;
uint64_t base;
} u_height;
u_height.base = 0;
u_height.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->height = u_height.real;
offset += sizeof(this->height);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.base = 0;
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_z = u_min_z.real;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.base = 0;
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_z = u_max_z.real;
offset += sizeof(this->max_z);
return offset;
}
const char * getType(){ return "map_msgs/ProjectedMapInfo"; };
const char * getMD5(){ return "2dc10595ae94de23f22f8a6d2a0eef7a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/PointCloud2Update.h | #ifndef _ROS_map_msgs_PointCloud2Update_h
#define _ROS_map_msgs_PointCloud2Update_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/PointCloud2.h"
namespace map_msgs
{
class PointCloud2Update : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _type_type;
_type_type type;
typedef sensor_msgs::PointCloud2 _points_type;
_points_type points;
enum { ADD = 0 };
enum { DELETE = 1 };
PointCloud2Update():
header(),
type(0),
points()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->type >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->type >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->type >> (8 * 3)) & 0xFF;
offset += sizeof(this->type);
offset += this->points.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->type = ((uint32_t) (*(inbuffer + offset)));
this->type |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->type |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->type |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->type);
offset += this->points.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "map_msgs/PointCloud2Update"; };
const char * getMD5(){ return "6c58e4f249ae9cd2b24fb1ee0f99195e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/ProjectedMap.h | #ifndef _ROS_map_msgs_ProjectedMap_h
#define _ROS_map_msgs_ProjectedMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace map_msgs
{
class ProjectedMap : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
typedef double _min_z_type;
_min_z_type min_z;
typedef double _max_z_type;
_max_z_type max_z;
ProjectedMap():
map(),
min_z(0),
max_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.real = this->min_z;
*(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.real = this->max_z;
*(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.base = 0;
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_z = u_min_z.real;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.base = 0;
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_z = u_max_z.real;
offset += sizeof(this->max_z);
return offset;
}
const char * getType(){ return "map_msgs/ProjectedMap"; };
const char * getMD5(){ return "7bbe8f96e45089681dc1ea7d023cbfca"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/base_local_planner/Position2DInt.h | #ifndef _ROS_base_local_planner_Position2DInt_h
#define _ROS_base_local_planner_Position2DInt_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace base_local_planner
{
class Position2DInt : public ros::Msg
{
public:
typedef int64_t _x_type;
_x_type x;
typedef int64_t _y_type;
_y_type y;
Position2DInt():
x(0),
y(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t 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 {
int64_t 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);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t 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 {
int64_t 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);
return offset;
}
const char * getType(){ return "base_local_planner/Position2DInt"; };
const char * getMD5(){ return "3b834ede922a0fff22c43585c533b49f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/KeyValue.h | #ifndef _ROS_diagnostic_msgs_KeyValue_h
#define _ROS_diagnostic_msgs_KeyValue_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace diagnostic_msgs
{
class KeyValue : public ros::Msg
{
public:
typedef const char* _key_type;
_key_type key;
typedef const char* _value_type;
_value_type value;
KeyValue():
key(""),
value("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_key = strlen(this->key);
varToArr(outbuffer + offset, length_key);
offset += 4;
memcpy(outbuffer + offset, this->key, length_key);
offset += length_key;
uint32_t length_value = strlen(this->value);
varToArr(outbuffer + offset, length_value);
offset += 4;
memcpy(outbuffer + offset, this->value, length_value);
offset += length_value;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_key;
arrToVar(length_key, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_key; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_key-1]=0;
this->key = (char *)(inbuffer + offset-1);
offset += length_key;
uint32_t length_value;
arrToVar(length_value, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_value; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_value-1]=0;
this->value = (char *)(inbuffer + offset-1);
offset += length_value;
return offset;
}
const char * getType(){ return "diagnostic_msgs/KeyValue"; };
const char * getMD5(){ return "cf57fdc6617a881a88c16e768132149c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/DiagnosticArray.h | #ifndef _ROS_diagnostic_msgs_DiagnosticArray_h
#define _ROS_diagnostic_msgs_DiagnosticArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "diagnostic_msgs/DiagnosticStatus.h"
namespace diagnostic_msgs
{
class DiagnosticArray : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t status_length;
typedef diagnostic_msgs::DiagnosticStatus _status_type;
_status_type st_status;
_status_type * status;
DiagnosticArray():
header(),
status_length(0), status(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->status_length);
for( uint32_t i = 0; i < status_length; i++){
offset += this->status[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->status_length);
if(status_lengthT > status_length)
this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
status_length = status_lengthT;
for( uint32_t i = 0; i < status_length; i++){
offset += this->st_status.deserialize(inbuffer + offset);
memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
}
return offset;
}
const char * getType(){ return "diagnostic_msgs/DiagnosticArray"; };
const char * getMD5(){ return "60810da900de1dd6ddd437c3503511da"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/DiagnosticStatus.h | #ifndef _ROS_diagnostic_msgs_DiagnosticStatus_h
#define _ROS_diagnostic_msgs_DiagnosticStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "diagnostic_msgs/KeyValue.h"
namespace diagnostic_msgs
{
class DiagnosticStatus : public ros::Msg
{
public:
typedef int8_t _level_type;
_level_type level;
typedef const char* _name_type;
_name_type name;
typedef const char* _message_type;
_message_type message;
typedef const char* _hardware_id_type;
_hardware_id_type hardware_id;
uint32_t values_length;
typedef diagnostic_msgs::KeyValue _values_type;
_values_type st_values;
_values_type * values;
enum { OK = 0 };
enum { WARN = 1 };
enum { ERROR = 2 };
enum { STALE = 3 };
DiagnosticStatus():
level(0),
name(""),
message(""),
hardware_id(""),
values_length(0), values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_level;
u_level.real = this->level;
*(outbuffer + offset + 0) = (u_level.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
uint32_t length_hardware_id = strlen(this->hardware_id);
varToArr(outbuffer + offset, length_hardware_id);
offset += 4;
memcpy(outbuffer + offset, this->hardware_id, length_hardware_id);
offset += length_hardware_id;
*(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++){
offset += this->values[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_level;
u_level.base = 0;
u_level.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->level = u_level.real;
offset += sizeof(this->level);
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
uint32_t length_hardware_id;
arrToVar(length_hardware_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_hardware_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_hardware_id-1]=0;
this->hardware_id = (char *)(inbuffer + offset-1);
offset += length_hardware_id;
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 = (diagnostic_msgs::KeyValue*)realloc(this->values, values_lengthT * sizeof(diagnostic_msgs::KeyValue));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
offset += this->st_values.deserialize(inbuffer + offset);
memcpy( &(this->values[i]), &(this->st_values), sizeof(diagnostic_msgs::KeyValue));
}
return offset;
}
const char * getType(){ return "diagnostic_msgs/DiagnosticStatus"; };
const char * getMD5(){ return "d0ce08bc6e5ba34c7754f563a9cabaf1"; };
};
}
#endif
|
Subsets and Splits