file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerFeedback.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerFeedback_h
#define _ROS_visualization_msgs_InteractiveMarkerFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Point.h"
namespace visualization_msgs
{
class InteractiveMarkerFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _client_id_type;
_client_id_type client_id;
typedef const char* _marker_name_type;
_marker_name_type marker_name;
typedef const char* _control_name_type;
_control_name_type control_name;
typedef uint8_t _event_type_type;
_event_type_type event_type;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef uint32_t _menu_entry_id_type;
_menu_entry_id_type menu_entry_id;
typedef geometry_msgs::Point _mouse_point_type;
_mouse_point_type mouse_point;
typedef bool _mouse_point_valid_type;
_mouse_point_valid_type mouse_point_valid;
enum { KEEP_ALIVE = 0 };
enum { POSE_UPDATE = 1 };
enum { MENU_SELECT = 2 };
enum { BUTTON_CLICK = 3 };
enum { MOUSE_DOWN = 4 };
enum { MOUSE_UP = 5 };
InteractiveMarkerFeedback():
header(),
client_id(""),
marker_name(""),
control_name(""),
event_type(0),
pose(),
menu_entry_id(0),
mouse_point(),
mouse_point_valid(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_client_id = strlen(this->client_id);
varToArr(outbuffer + offset, length_client_id);
offset += 4;
memcpy(outbuffer + offset, this->client_id, length_client_id);
offset += length_client_id;
uint32_t length_marker_name = strlen(this->marker_name);
varToArr(outbuffer + offset, length_marker_name);
offset += 4;
memcpy(outbuffer + offset, this->marker_name, length_marker_name);
offset += length_marker_name;
uint32_t length_control_name = strlen(this->control_name);
varToArr(outbuffer + offset, length_control_name);
offset += 4;
memcpy(outbuffer + offset, this->control_name, length_control_name);
offset += length_control_name;
*(outbuffer + offset + 0) = (this->event_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->event_type);
offset += this->pose.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->menu_entry_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->menu_entry_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->menu_entry_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->menu_entry_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->menu_entry_id);
offset += this->mouse_point.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_mouse_point_valid;
u_mouse_point_valid.real = this->mouse_point_valid;
*(outbuffer + offset + 0) = (u_mouse_point_valid.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->mouse_point_valid);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_client_id;
arrToVar(length_client_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_client_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_client_id-1]=0;
this->client_id = (char *)(inbuffer + offset-1);
offset += length_client_id;
uint32_t length_marker_name;
arrToVar(length_marker_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_marker_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_marker_name-1]=0;
this->marker_name = (char *)(inbuffer + offset-1);
offset += length_marker_name;
uint32_t length_control_name;
arrToVar(length_control_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_control_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_control_name-1]=0;
this->control_name = (char *)(inbuffer + offset-1);
offset += length_control_name;
this->event_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->event_type);
offset += this->pose.deserialize(inbuffer + offset);
this->menu_entry_id = ((uint32_t) (*(inbuffer + offset)));
this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->menu_entry_id);
offset += this->mouse_point.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_mouse_point_valid;
u_mouse_point_valid.base = 0;
u_mouse_point_valid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->mouse_point_valid = u_mouse_point_valid.real;
offset += sizeof(this->mouse_point_valid);
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerFeedback"; };
const char * getMD5(){ return "ab0f1eee058667e28c19ff3ffc3f4b78"; };
};
}
#endif
| 5,650 | C | 36.177631 | 85 | 0.602832 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarker.h | #ifndef _ROS_visualization_msgs_InteractiveMarker_h
#define _ROS_visualization_msgs_InteractiveMarker_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "visualization_msgs/MenuEntry.h"
#include "visualization_msgs/InteractiveMarkerControl.h"
namespace visualization_msgs
{
class InteractiveMarker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef const char* _name_type;
_name_type name;
typedef const char* _description_type;
_description_type description;
typedef float _scale_type;
_scale_type scale;
uint32_t menu_entries_length;
typedef visualization_msgs::MenuEntry _menu_entries_type;
_menu_entries_type st_menu_entries;
_menu_entries_type * menu_entries;
uint32_t controls_length;
typedef visualization_msgs::InteractiveMarkerControl _controls_type;
_controls_type st_controls;
_controls_type * controls;
InteractiveMarker():
header(),
pose(),
name(""),
description(""),
scale(0),
menu_entries_length(0), menu_entries(NULL),
controls_length(0), controls(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_description = strlen(this->description);
varToArr(outbuffer + offset, length_description);
offset += 4;
memcpy(outbuffer + offset, this->description, length_description);
offset += length_description;
union {
float real;
uint32_t base;
} u_scale;
u_scale.real = this->scale;
*(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->scale);
*(outbuffer + offset + 0) = (this->menu_entries_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->menu_entries_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->menu_entries_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->menu_entries_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->menu_entries_length);
for( uint32_t i = 0; i < menu_entries_length; i++){
offset += this->menu_entries[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->controls_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->controls_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->controls_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->controls_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->controls_length);
for( uint32_t i = 0; i < controls_length; i++){
offset += this->controls[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_description;
arrToVar(length_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_description-1]=0;
this->description = (char *)(inbuffer + offset-1);
offset += length_description;
union {
float real;
uint32_t base;
} u_scale;
u_scale.base = 0;
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->scale = u_scale.real;
offset += sizeof(this->scale);
uint32_t menu_entries_lengthT = ((uint32_t) (*(inbuffer + offset)));
menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->menu_entries_length);
if(menu_entries_lengthT > menu_entries_length)
this->menu_entries = (visualization_msgs::MenuEntry*)realloc(this->menu_entries, menu_entries_lengthT * sizeof(visualization_msgs::MenuEntry));
menu_entries_length = menu_entries_lengthT;
for( uint32_t i = 0; i < menu_entries_length; i++){
offset += this->st_menu_entries.deserialize(inbuffer + offset);
memcpy( &(this->menu_entries[i]), &(this->st_menu_entries), sizeof(visualization_msgs::MenuEntry));
}
uint32_t controls_lengthT = ((uint32_t) (*(inbuffer + offset)));
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->controls_length);
if(controls_lengthT > controls_length)
this->controls = (visualization_msgs::InteractiveMarkerControl*)realloc(this->controls, controls_lengthT * sizeof(visualization_msgs::InteractiveMarkerControl));
controls_length = controls_lengthT;
for( uint32_t i = 0; i < controls_length; i++){
offset += this->st_controls.deserialize(inbuffer + offset);
memcpy( &(this->controls[i]), &(this->st_controls), sizeof(visualization_msgs::InteractiveMarkerControl));
}
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarker"; };
const char * getMD5(){ return "dd86d22909d5a3364b384492e35c10af"; };
};
}
#endif
| 6,727 | C | 40.78882 | 169 | 0.602497 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/IntParameter.h | #ifndef _ROS_dynamic_reconfigure_IntParameter_h
#define _ROS_dynamic_reconfigure_IntParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class IntParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef int32_t _value_type;
_value_type value;
IntParameter():
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 {
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;
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 {
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 "dynamic_reconfigure/IntParameter"; };
const char * getMD5(){ return "65fedc7a0cbfb8db035e46194a350bf1"; };
};
}
#endif
| 2,253 | C | 27.175 | 73 | 0.559254 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/Group.h | #ifndef _ROS_dynamic_reconfigure_Group_h
#define _ROS_dynamic_reconfigure_Group_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/ParamDescription.h"
namespace dynamic_reconfigure
{
class Group : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _type_type;
_type_type type;
uint32_t parameters_length;
typedef dynamic_reconfigure::ParamDescription _parameters_type;
_parameters_type st_parameters;
_parameters_type * parameters;
typedef int32_t _parent_type;
_parent_type parent;
typedef int32_t _id_type;
_id_type id;
Group():
name(""),
type(""),
parameters_length(0), parameters(NULL),
parent(0),
id(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
*(outbuffer + offset + 0) = (this->parameters_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameters_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameters_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameters_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameters_length);
for( uint32_t i = 0; i < parameters_length; i++){
offset += this->parameters[i].serialize(outbuffer + offset);
}
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.real = this->parent;
*(outbuffer + offset + 0) = (u_parent.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_parent.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_parent.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_parent.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->parent);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
uint32_t parameters_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameters_length);
if(parameters_lengthT > parameters_length)
this->parameters = (dynamic_reconfigure::ParamDescription*)realloc(this->parameters, parameters_lengthT * sizeof(dynamic_reconfigure::ParamDescription));
parameters_length = parameters_lengthT;
for( uint32_t i = 0; i < parameters_length; i++){
offset += this->st_parameters.deserialize(inbuffer + offset);
memcpy( &(this->parameters[i]), &(this->st_parameters), sizeof(dynamic_reconfigure::ParamDescription));
}
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.base = 0;
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->parent = u_parent.real;
offset += sizeof(this->parent);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/Group"; };
const char * getMD5(){ return "9e8cd9e9423c94823db3614dd8b1cf7a"; };
};
}
#endif
| 5,382 | C | 35.619047 | 161 | 0.560572 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/StrParameter.h | #ifndef _ROS_dynamic_reconfigure_StrParameter_h
#define _ROS_dynamic_reconfigure_StrParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class StrParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _value_type;
_value_type value;
StrParameter():
name(""),
value("")
{
}
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_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_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_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 "dynamic_reconfigure/StrParameter"; };
const char * getMD5(){ return "bc6ccc4a57f61779c8eaae61e9f422e0"; };
};
}
#endif
| 1,913 | C | 25.219178 | 73 | 0.608468 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/SensorLevels.h | #ifndef _ROS_dynamic_reconfigure_SensorLevels_h
#define _ROS_dynamic_reconfigure_SensorLevels_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class SensorLevels : public ros::Msg
{
public:
enum { RECONFIGURE_CLOSE = 3 };
enum { RECONFIGURE_STOP = 1 };
enum { RECONFIGURE_RUNNING = 0 };
SensorLevels()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "dynamic_reconfigure/SensorLevels"; };
const char * getMD5(){ return "6322637bee96d5489db6e2127c47602c"; };
};
}
#endif
| 808 | C | 18.261904 | 73 | 0.636139 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/BoolParameter.h | #ifndef _ROS_dynamic_reconfigure_BoolParameter_h
#define _ROS_dynamic_reconfigure_BoolParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class BoolParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef bool _value_type;
_value_type value;
BoolParameter():
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 "dynamic_reconfigure/BoolParameter"; };
const char * getMD5(){ return "23f05028c1a699fb83e22401228c3a9e"; };
};
}
#endif
| 1,820 | C | 23.608108 | 74 | 0.581319 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/GroupState.h | #ifndef _ROS_dynamic_reconfigure_GroupState_h
#define _ROS_dynamic_reconfigure_GroupState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class GroupState : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef bool _state_type;
_state_type state;
typedef int32_t _id_type;
_id_type id;
typedef int32_t _parent_type;
_parent_type parent;
GroupState():
name(""),
state(0),
id(0),
parent(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
bool real;
uint8_t base;
} u_state;
u_state.real = this->state;
*(outbuffer + offset + 0) = (u_state.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->state);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.real = this->parent;
*(outbuffer + offset + 0) = (u_parent.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_parent.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_parent.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_parent.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->parent);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
bool real;
uint8_t base;
} u_state;
u_state.base = 0;
u_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->state = u_state.real;
offset += sizeof(this->state);
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_parent;
u_parent.base = 0;
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_parent.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->parent = u_parent.real;
offset += sizeof(this->parent);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/GroupState"; };
const char * getMD5(){ return "a2d87f51dc22930325041a2f8b1571f8"; };
};
}
#endif
| 3,687 | C | 29.229508 | 74 | 0.521562 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/ParamDescription.h | #ifndef _ROS_dynamic_reconfigure_ParamDescription_h
#define _ROS_dynamic_reconfigure_ParamDescription_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class ParamDescription : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _type_type;
_type_type type;
typedef uint32_t _level_type;
_level_type level;
typedef const char* _description_type;
_description_type description;
typedef const char* _edit_method_type;
_edit_method_type edit_method;
ParamDescription():
name(""),
type(""),
level(0),
description(""),
edit_method("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
*(outbuffer + offset + 0) = (this->level >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->level >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->level >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->level >> (8 * 3)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_description = strlen(this->description);
varToArr(outbuffer + offset, length_description);
offset += 4;
memcpy(outbuffer + offset, this->description, length_description);
offset += length_description;
uint32_t length_edit_method = strlen(this->edit_method);
varToArr(outbuffer + offset, length_edit_method);
offset += 4;
memcpy(outbuffer + offset, this->edit_method, length_edit_method);
offset += length_edit_method;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
this->level = ((uint32_t) (*(inbuffer + offset)));
this->level |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->level |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->level |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->level);
uint32_t length_description;
arrToVar(length_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_description-1]=0;
this->description = (char *)(inbuffer + offset-1);
offset += length_description;
uint32_t length_edit_method;
arrToVar(length_edit_method, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_edit_method; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_edit_method-1]=0;
this->edit_method = (char *)(inbuffer + offset-1);
offset += length_edit_method;
return offset;
}
const char * getType(){ return "dynamic_reconfigure/ParamDescription"; };
const char * getMD5(){ return "7434fcb9348c13054e0c3b267c8cb34d"; };
};
}
#endif
| 4,049 | C | 32.75 | 77 | 0.595703 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/Reconfigure.h | #ifndef _ROS_SERVICE_Reconfigure_h
#define _ROS_SERVICE_Reconfigure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/Config.h"
namespace dynamic_reconfigure
{
static const char RECONFIGURE[] = "dynamic_reconfigure/Reconfigure";
class ReconfigureRequest : public ros::Msg
{
public:
typedef dynamic_reconfigure::Config _config_type;
_config_type config;
ReconfigureRequest():
config()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->config.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return RECONFIGURE; };
const char * getMD5(){ return "ac41a77620a4a0348b7001641796a8a1"; };
};
class ReconfigureResponse : public ros::Msg
{
public:
typedef dynamic_reconfigure::Config _config_type;
_config_type config;
ReconfigureResponse():
config()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->config.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return RECONFIGURE; };
const char * getMD5(){ return "ac41a77620a4a0348b7001641796a8a1"; };
};
class Reconfigure {
public:
typedef ReconfigureRequest Request;
typedef ReconfigureResponse Response;
};
}
#endif
| 1,774 | C | 20.646341 | 72 | 0.653326 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/Config.h | #ifndef _ROS_dynamic_reconfigure_Config_h
#define _ROS_dynamic_reconfigure_Config_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/BoolParameter.h"
#include "dynamic_reconfigure/IntParameter.h"
#include "dynamic_reconfigure/StrParameter.h"
#include "dynamic_reconfigure/DoubleParameter.h"
#include "dynamic_reconfigure/GroupState.h"
namespace dynamic_reconfigure
{
class Config : public ros::Msg
{
public:
uint32_t bools_length;
typedef dynamic_reconfigure::BoolParameter _bools_type;
_bools_type st_bools;
_bools_type * bools;
uint32_t ints_length;
typedef dynamic_reconfigure::IntParameter _ints_type;
_ints_type st_ints;
_ints_type * ints;
uint32_t strs_length;
typedef dynamic_reconfigure::StrParameter _strs_type;
_strs_type st_strs;
_strs_type * strs;
uint32_t doubles_length;
typedef dynamic_reconfigure::DoubleParameter _doubles_type;
_doubles_type st_doubles;
_doubles_type * doubles;
uint32_t groups_length;
typedef dynamic_reconfigure::GroupState _groups_type;
_groups_type st_groups;
_groups_type * groups;
Config():
bools_length(0), bools(NULL),
ints_length(0), ints(NULL),
strs_length(0), strs(NULL),
doubles_length(0), doubles(NULL),
groups_length(0), groups(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->bools_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->bools_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->bools_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->bools_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->bools_length);
for( uint32_t i = 0; i < bools_length; i++){
offset += this->bools[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->ints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints_length);
for( uint32_t i = 0; i < ints_length; i++){
offset += this->ints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->strs_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->strs_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->strs_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->strs_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->strs_length);
for( uint32_t i = 0; i < strs_length; i++){
offset += this->strs[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->doubles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->doubles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->doubles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->doubles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->doubles_length);
for( uint32_t i = 0; i < doubles_length; i++){
offset += this->doubles[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->groups_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->groups_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->groups_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->groups_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->groups_length);
for( uint32_t i = 0; i < groups_length; i++){
offset += this->groups[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t bools_lengthT = ((uint32_t) (*(inbuffer + offset)));
bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->bools_length);
if(bools_lengthT > bools_length)
this->bools = (dynamic_reconfigure::BoolParameter*)realloc(this->bools, bools_lengthT * sizeof(dynamic_reconfigure::BoolParameter));
bools_length = bools_lengthT;
for( uint32_t i = 0; i < bools_length; i++){
offset += this->st_bools.deserialize(inbuffer + offset);
memcpy( &(this->bools[i]), &(this->st_bools), sizeof(dynamic_reconfigure::BoolParameter));
}
uint32_t ints_lengthT = ((uint32_t) (*(inbuffer + offset)));
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ints_length);
if(ints_lengthT > ints_length)
this->ints = (dynamic_reconfigure::IntParameter*)realloc(this->ints, ints_lengthT * sizeof(dynamic_reconfigure::IntParameter));
ints_length = ints_lengthT;
for( uint32_t i = 0; i < ints_length; i++){
offset += this->st_ints.deserialize(inbuffer + offset);
memcpy( &(this->ints[i]), &(this->st_ints), sizeof(dynamic_reconfigure::IntParameter));
}
uint32_t strs_lengthT = ((uint32_t) (*(inbuffer + offset)));
strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->strs_length);
if(strs_lengthT > strs_length)
this->strs = (dynamic_reconfigure::StrParameter*)realloc(this->strs, strs_lengthT * sizeof(dynamic_reconfigure::StrParameter));
strs_length = strs_lengthT;
for( uint32_t i = 0; i < strs_length; i++){
offset += this->st_strs.deserialize(inbuffer + offset);
memcpy( &(this->strs[i]), &(this->st_strs), sizeof(dynamic_reconfigure::StrParameter));
}
uint32_t doubles_lengthT = ((uint32_t) (*(inbuffer + offset)));
doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->doubles_length);
if(doubles_lengthT > doubles_length)
this->doubles = (dynamic_reconfigure::DoubleParameter*)realloc(this->doubles, doubles_lengthT * sizeof(dynamic_reconfigure::DoubleParameter));
doubles_length = doubles_lengthT;
for( uint32_t i = 0; i < doubles_length; i++){
offset += this->st_doubles.deserialize(inbuffer + offset);
memcpy( &(this->doubles[i]), &(this->st_doubles), sizeof(dynamic_reconfigure::DoubleParameter));
}
uint32_t groups_lengthT = ((uint32_t) (*(inbuffer + offset)));
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->groups_length);
if(groups_lengthT > groups_length)
this->groups = (dynamic_reconfigure::GroupState*)realloc(this->groups, groups_lengthT * sizeof(dynamic_reconfigure::GroupState));
groups_length = groups_lengthT;
for( uint32_t i = 0; i < groups_length; i++){
offset += this->st_groups.deserialize(inbuffer + offset);
memcpy( &(this->groups[i]), &(this->st_groups), sizeof(dynamic_reconfigure::GroupState));
}
return offset;
}
const char * getType(){ return "dynamic_reconfigure/Config"; };
const char * getMD5(){ return "958f16a05573709014982821e6822580"; };
};
}
#endif
| 8,011 | C | 46.408284 | 150 | 0.587442 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/DoubleParameter.h | #ifndef _ROS_dynamic_reconfigure_DoubleParameter_h
#define _ROS_dynamic_reconfigure_DoubleParameter_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace dynamic_reconfigure
{
class DoubleParameter : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef double _value_type;
_value_type value;
DoubleParameter():
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 {
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);
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 {
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);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/DoubleParameter"; };
const char * getMD5(){ return "d8512f27253c0f65f928a67c329cd658"; };
};
}
#endif
| 2,833 | C | 31.204545 | 76 | 0.54324 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/dynamic_reconfigure/ConfigDescription.h | #ifndef _ROS_dynamic_reconfigure_ConfigDescription_h
#define _ROS_dynamic_reconfigure_ConfigDescription_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "dynamic_reconfigure/Group.h"
#include "dynamic_reconfigure/Config.h"
namespace dynamic_reconfigure
{
class ConfigDescription : public ros::Msg
{
public:
uint32_t groups_length;
typedef dynamic_reconfigure::Group _groups_type;
_groups_type st_groups;
_groups_type * groups;
typedef dynamic_reconfigure::Config _max_type;
_max_type max;
typedef dynamic_reconfigure::Config _min_type;
_min_type min;
typedef dynamic_reconfigure::Config _dflt_type;
_dflt_type dflt;
ConfigDescription():
groups_length(0), groups(NULL),
max(),
min(),
dflt()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->groups_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->groups_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->groups_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->groups_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->groups_length);
for( uint32_t i = 0; i < groups_length; i++){
offset += this->groups[i].serialize(outbuffer + offset);
}
offset += this->max.serialize(outbuffer + offset);
offset += this->min.serialize(outbuffer + offset);
offset += this->dflt.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t groups_lengthT = ((uint32_t) (*(inbuffer + offset)));
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->groups_length);
if(groups_lengthT > groups_length)
this->groups = (dynamic_reconfigure::Group*)realloc(this->groups, groups_lengthT * sizeof(dynamic_reconfigure::Group));
groups_length = groups_lengthT;
for( uint32_t i = 0; i < groups_length; i++){
offset += this->st_groups.deserialize(inbuffer + offset);
memcpy( &(this->groups[i]), &(this->st_groups), sizeof(dynamic_reconfigure::Group));
}
offset += this->max.deserialize(inbuffer + offset);
offset += this->min.deserialize(inbuffer + offset);
offset += this->dflt.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "dynamic_reconfigure/ConfigDescription"; };
const char * getMD5(){ return "757ce9d44ba8ddd801bb30bc456f946f"; };
};
}
#endif
| 2,821 | C | 33.839506 | 127 | 0.615385 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/costmap_2d/VoxelGrid.h | #ifndef _ROS_costmap_2d_VoxelGrid_h
#define _ROS_costmap_2d_VoxelGrid_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point32.h"
#include "geometry_msgs/Vector3.h"
namespace costmap_2d
{
class VoxelGrid : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t data_length;
typedef uint32_t _data_type;
_data_type st_data;
_data_type * data;
typedef geometry_msgs::Point32 _origin_type;
_origin_type origin;
typedef geometry_msgs::Vector3 _resolutions_type;
_resolutions_type resolutions;
typedef uint32_t _size_x_type;
_size_x_type size_x;
typedef uint32_t _size_y_type;
_size_y_type size_y;
typedef uint32_t _size_z_type;
_size_z_type size_z;
VoxelGrid():
header(),
data_length(0), data(NULL),
origin(),
resolutions(),
size_x(0),
size_y(0),
size_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->data[i]);
}
offset += this->origin.serialize(outbuffer + offset);
offset += this->resolutions.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->size_x >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->size_x >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->size_x >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->size_x >> (8 * 3)) & 0xFF;
offset += sizeof(this->size_x);
*(outbuffer + offset + 0) = (this->size_y >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->size_y >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->size_y >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->size_y >> (8 * 3)) & 0xFF;
offset += sizeof(this->size_y);
*(outbuffer + offset + 0) = (this->size_z >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->size_z >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->size_z >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->size_z >> (8 * 3)) & 0xFF;
offset += sizeof(this->size_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (uint32_t*)realloc(this->data, data_lengthT * sizeof(uint32_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint32_t) (*(inbuffer + offset)));
this->st_data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint32_t));
}
offset += this->origin.deserialize(inbuffer + offset);
offset += this->resolutions.deserialize(inbuffer + offset);
this->size_x = ((uint32_t) (*(inbuffer + offset)));
this->size_x |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->size_x |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->size_x |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->size_x);
this->size_y = ((uint32_t) (*(inbuffer + offset)));
this->size_y |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->size_y |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->size_y |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->size_y);
this->size_z = ((uint32_t) (*(inbuffer + offset)));
this->size_z |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->size_z |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->size_z |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->size_z);
return offset;
}
const char * getType(){ return "costmap_2d/VoxelGrid"; };
const char * getMD5(){ return "48a040827e1322073d78ece5a497029c"; };
};
}
#endif
| 5,334 | C | 40.356589 | 85 | 0.531871 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/laser_assembler/AssembleScans2.h | #ifndef _ROS_SERVICE_AssembleScans2_h
#define _ROS_SERVICE_AssembleScans2_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/PointCloud2.h"
#include "ros/time.h"
namespace laser_assembler
{
static const char ASSEMBLESCANS2[] = "laser_assembler/AssembleScans2";
class AssembleScans2Request : public ros::Msg
{
public:
typedef ros::Time _begin_type;
_begin_type begin;
typedef ros::Time _end_type;
_end_type end;
AssembleScans2Request():
begin(),
end()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->begin.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.sec);
*(outbuffer + offset + 0) = (this->begin.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.nsec);
*(outbuffer + offset + 0) = (this->end.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.sec);
*(outbuffer + offset + 0) = (this->end.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->begin.sec = ((uint32_t) (*(inbuffer + offset)));
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.sec);
this->begin.nsec = ((uint32_t) (*(inbuffer + offset)));
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.nsec);
this->end.sec = ((uint32_t) (*(inbuffer + offset)));
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.sec);
this->end.nsec = ((uint32_t) (*(inbuffer + offset)));
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.nsec);
return offset;
}
const char * getType(){ return ASSEMBLESCANS2; };
const char * getMD5(){ return "b341004f74e15bf5e1b2053a9183bdc7"; };
};
class AssembleScans2Response : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud2 _cloud_type;
_cloud_type cloud;
AssembleScans2Response():
cloud()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->cloud.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->cloud.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return ASSEMBLESCANS2; };
const char * getMD5(){ return "96cec5374164b3b3d1d7ef5d7628a7ed"; };
};
class AssembleScans2 {
public:
typedef AssembleScans2Request Request;
typedef AssembleScans2Response Response;
};
}
#endif
| 4,357 | C | 34.145161 | 77 | 0.551985 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/laser_assembler/AssembleScans.h | #ifndef _ROS_SERVICE_AssembleScans_h
#define _ROS_SERVICE_AssembleScans_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "sensor_msgs/PointCloud.h"
namespace laser_assembler
{
static const char ASSEMBLESCANS[] = "laser_assembler/AssembleScans";
class AssembleScansRequest : public ros::Msg
{
public:
typedef ros::Time _begin_type;
_begin_type begin;
typedef ros::Time _end_type;
_end_type end;
AssembleScansRequest():
begin(),
end()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->begin.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.sec);
*(outbuffer + offset + 0) = (this->begin.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->begin.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->begin.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->begin.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->begin.nsec);
*(outbuffer + offset + 0) = (this->end.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.sec);
*(outbuffer + offset + 0) = (this->end.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->begin.sec = ((uint32_t) (*(inbuffer + offset)));
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.sec);
this->begin.nsec = ((uint32_t) (*(inbuffer + offset)));
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->begin.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->begin.nsec);
this->end.sec = ((uint32_t) (*(inbuffer + offset)));
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.sec);
this->end.nsec = ((uint32_t) (*(inbuffer + offset)));
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end.nsec);
return offset;
}
const char * getType(){ return ASSEMBLESCANS; };
const char * getMD5(){ return "b341004f74e15bf5e1b2053a9183bdc7"; };
};
class AssembleScansResponse : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud _cloud_type;
_cloud_type cloud;
AssembleScansResponse():
cloud()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->cloud.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->cloud.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return ASSEMBLESCANS; };
const char * getMD5(){ return "4217b28a903e4ad7869a83b3653110ff"; };
};
class AssembleScans {
public:
typedef AssembleScansRequest Request;
typedef AssembleScansResponse Response;
};
}
#endif
| 4,342 | C | 34.024193 | 77 | 0.550438 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_srvs/Trigger.h | #ifndef _ROS_SERVICE_Trigger_h
#define _ROS_SERVICE_Trigger_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_srvs
{
static const char TRIGGER[] = "std_srvs/Trigger";
class TriggerRequest : public ros::Msg
{
public:
TriggerRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return TRIGGER; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class TriggerResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _message_type;
_message_type message;
TriggerResponse():
success(0),
message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
return offset;
}
const char * getType(){ return TRIGGER; };
const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
};
class Trigger {
public:
typedef TriggerRequest Request;
typedef TriggerResponse Response;
};
}
#endif
| 2,428 | C | 21.915094 | 74 | 0.595552 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_srvs/SetBool.h | #ifndef _ROS_SERVICE_SetBool_h
#define _ROS_SERVICE_SetBool_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_srvs
{
static const char SETBOOL[] = "std_srvs/SetBool";
class SetBoolRequest : public ros::Msg
{
public:
typedef bool _data_type;
_data_type data;
SetBoolRequest():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return SETBOOL; };
const char * getMD5(){ return "8b94c1b53db61fb6aed406028ad6332a"; };
};
class SetBoolResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _message_type;
_message_type message;
SetBoolResponse():
success(0),
message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
return offset;
}
const char * getType(){ return SETBOOL; };
const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
};
class SetBool {
public:
typedef SetBoolRequest Request;
typedef SetBoolResponse Response;
};
}
#endif
| 2,937 | C | 22.693548 | 74 | 0.573715 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_srvs/Empty.h | #ifndef _ROS_SERVICE_Empty_h
#define _ROS_SERVICE_Empty_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_srvs
{
static const char EMPTY[] = "std_srvs/Empty";
class EmptyRequest : public ros::Msg
{
public:
EmptyRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class EmptyResponse : public ros::Msg
{
public:
EmptyResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class Empty {
public:
typedef EmptyRequest Request;
typedef EmptyResponse Response;
};
}
#endif
| 1,194 | C | 15.830986 | 72 | 0.618928 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciActionFeedback.h | #ifndef _ROS_actionlib_tutorials_FibonacciActionFeedback_h
#define _ROS_actionlib_tutorials_FibonacciActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib_tutorials/FibonacciFeedback.h"
namespace actionlib_tutorials
{
class FibonacciActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::FibonacciFeedback _feedback_type;
_feedback_type feedback;
FibonacciActionFeedback():
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 "actionlib_tutorials/FibonacciActionFeedback"; };
const char * getMD5(){ return "73b8497a9f629a31c0020900e4148f07"; };
};
}
#endif
| 1,530 | C | 25.859649 | 84 | 0.681699 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingActionGoal.h | #ifndef _ROS_actionlib_tutorials_AveragingActionGoal_h
#define _ROS_actionlib_tutorials_AveragingActionGoal_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 "actionlib_tutorials/AveragingGoal.h"
namespace actionlib_tutorials
{
class AveragingActionGoal : 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 actionlib_tutorials::AveragingGoal _goal_type;
_goal_type goal;
AveragingActionGoal():
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 "actionlib_tutorials/AveragingActionGoal"; };
const char * getMD5(){ return "1561825b734ebd6039851c501e3fb570"; };
};
}
#endif
| 1,476 | C | 24.91228 | 80 | 0.665989 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciGoal.h | #ifndef _ROS_actionlib_tutorials_FibonacciGoal_h
#define _ROS_actionlib_tutorials_FibonacciGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class FibonacciGoal : public ros::Msg
{
public:
typedef int32_t _order_type;
_order_type order;
FibonacciGoal():
order(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_order;
u_order.real = this->order;
*(outbuffer + offset + 0) = (u_order.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_order.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_order.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_order.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->order);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_order;
u_order.base = 0;
u_order.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_order.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_order.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_order.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->order = u_order.real;
offset += sizeof(this->order);
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciGoal"; };
const char * getMD5(){ return "6889063349a00b249bd1661df429d822"; };
};
}
#endif
| 1,652 | C | 25.238095 | 74 | 0.554479 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingResult.h | #ifndef _ROS_actionlib_tutorials_AveragingResult_h
#define _ROS_actionlib_tutorials_AveragingResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class AveragingResult : public ros::Msg
{
public:
typedef float _mean_type;
_mean_type mean;
typedef float _std_dev_type;
_std_dev_type std_dev;
AveragingResult():
mean(0),
std_dev(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_mean;
u_mean.real = this->mean;
*(outbuffer + offset + 0) = (u_mean.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mean.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mean.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mean.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.real = this->std_dev;
*(outbuffer + offset + 0) = (u_std_dev.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_std_dev.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_std_dev.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_std_dev.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->std_dev);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_mean;
u_mean.base = 0;
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->mean = u_mean.real;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.base = 0;
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->std_dev = u_std_dev.real;
offset += sizeof(this->std_dev);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingResult"; };
const char * getMD5(){ return "d5c7decf6df75ffb4367a05c1bcc7612"; };
};
}
#endif
| 2,633 | C | 29.275862 | 76 | 0.524497 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciResult.h | #ifndef _ROS_actionlib_tutorials_FibonacciResult_h
#define _ROS_actionlib_tutorials_FibonacciResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class FibonacciResult : public ros::Msg
{
public:
uint32_t sequence_length;
typedef int32_t _sequence_type;
_sequence_type st_sequence;
_sequence_type * sequence;
FibonacciResult():
sequence_length(0), sequence(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->sequence_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sequence_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sequence_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sequence_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence_length);
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_sequencei;
u_sequencei.real = this->sequence[i];
*(outbuffer + offset + 0) = (u_sequencei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sequencei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sequencei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sequencei.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t sequence_lengthT = ((uint32_t) (*(inbuffer + offset)));
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sequence_length);
if(sequence_lengthT > sequence_length)
this->sequence = (int32_t*)realloc(this->sequence, sequence_lengthT * sizeof(int32_t));
sequence_length = sequence_lengthT;
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_sequence;
u_st_sequence.base = 0;
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_sequence = u_st_sequence.real;
offset += sizeof(this->st_sequence);
memcpy( &(this->sequence[i]), &(this->st_sequence), sizeof(int32_t));
}
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciResult"; };
const char * getMD5(){ return "b81e37d2a31925a0e8ae261a8699cb79"; };
};
}
#endif
| 2,951 | C | 34.566265 | 95 | 0.569637 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciActionGoal.h | #ifndef _ROS_actionlib_tutorials_FibonacciActionGoal_h
#define _ROS_actionlib_tutorials_FibonacciActionGoal_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 "actionlib_tutorials/FibonacciGoal.h"
namespace actionlib_tutorials
{
class FibonacciActionGoal : 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 actionlib_tutorials::FibonacciGoal _goal_type;
_goal_type goal;
FibonacciActionGoal():
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 "actionlib_tutorials/FibonacciActionGoal"; };
const char * getMD5(){ return "006871c7fa1d0e3d5fe2226bf17b2a94"; };
};
}
#endif
| 1,476 | C | 24.91228 | 80 | 0.665989 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingFeedback.h | #ifndef _ROS_actionlib_tutorials_AveragingFeedback_h
#define _ROS_actionlib_tutorials_AveragingFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class AveragingFeedback : public ros::Msg
{
public:
typedef int32_t _sample_type;
_sample_type sample;
typedef float _data_type;
_data_type data;
typedef float _mean_type;
_mean_type mean;
typedef float _std_dev_type;
_std_dev_type std_dev;
AveragingFeedback():
sample(0),
data(0),
mean(0),
std_dev(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sample;
u_sample.real = this->sample;
*(outbuffer + offset + 0) = (u_sample.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sample.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sample.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sample.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sample);
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);
union {
float real;
uint32_t base;
} u_mean;
u_mean.real = this->mean;
*(outbuffer + offset + 0) = (u_mean.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mean.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mean.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mean.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.real = this->std_dev;
*(outbuffer + offset + 0) = (u_std_dev.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_std_dev.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_std_dev.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_std_dev.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->std_dev);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sample;
u_sample.base = 0;
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sample.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->sample = u_sample.real;
offset += sizeof(this->sample);
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);
union {
float real;
uint32_t base;
} u_mean;
u_mean.base = 0;
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mean.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->mean = u_mean.real;
offset += sizeof(this->mean);
union {
float real;
uint32_t base;
} u_std_dev;
u_std_dev.base = 0;
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->std_dev = u_std_dev.real;
offset += sizeof(this->std_dev);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingFeedback"; };
const char * getMD5(){ return "9e8dfc53c2f2a032ca33fa80ec46fd4f"; };
};
}
#endif
| 4,561 | C | 32.792592 | 78 | 0.506468 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingAction.h | #ifndef _ROS_actionlib_tutorials_AveragingAction_h
#define _ROS_actionlib_tutorials_AveragingAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib_tutorials/AveragingActionGoal.h"
#include "actionlib_tutorials/AveragingActionResult.h"
#include "actionlib_tutorials/AveragingActionFeedback.h"
namespace actionlib_tutorials
{
class AveragingAction : public ros::Msg
{
public:
typedef actionlib_tutorials::AveragingActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib_tutorials::AveragingActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib_tutorials::AveragingActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
AveragingAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingAction"; };
const char * getMD5(){ return "628678f2b4fa6a5951746a4a2d39e716"; };
};
}
#endif
| 1,696 | C | 28.771929 | 81 | 0.702241 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciActionResult.h | #ifndef _ROS_actionlib_tutorials_FibonacciActionResult_h
#define _ROS_actionlib_tutorials_FibonacciActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib_tutorials/FibonacciResult.h"
namespace actionlib_tutorials
{
class FibonacciActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::FibonacciResult _result_type;
_result_type result;
FibonacciActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciActionResult"; };
const char * getMD5(){ return "bee73a9fe29ae25e966e105f5553dd03"; };
};
}
#endif
| 1,504 | C | 25.403508 | 82 | 0.676197 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingActionFeedback.h | #ifndef _ROS_actionlib_tutorials_AveragingActionFeedback_h
#define _ROS_actionlib_tutorials_AveragingActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib_tutorials/AveragingFeedback.h"
namespace actionlib_tutorials
{
class AveragingActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::AveragingFeedback _feedback_type;
_feedback_type feedback;
AveragingActionFeedback():
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 "actionlib_tutorials/AveragingActionFeedback"; };
const char * getMD5(){ return "78a4a09241b1791069223ae7ebd5b16b"; };
};
}
#endif
| 1,530 | C | 25.859649 | 84 | 0.681699 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciFeedback.h | #ifndef _ROS_actionlib_tutorials_FibonacciFeedback_h
#define _ROS_actionlib_tutorials_FibonacciFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class FibonacciFeedback : public ros::Msg
{
public:
uint32_t sequence_length;
typedef int32_t _sequence_type;
_sequence_type st_sequence;
_sequence_type * sequence;
FibonacciFeedback():
sequence_length(0), sequence(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->sequence_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sequence_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sequence_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sequence_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence_length);
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_sequencei;
u_sequencei.real = this->sequence[i];
*(outbuffer + offset + 0) = (u_sequencei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sequencei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sequencei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sequencei.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t sequence_lengthT = ((uint32_t) (*(inbuffer + offset)));
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sequence_length);
if(sequence_lengthT > sequence_length)
this->sequence = (int32_t*)realloc(this->sequence, sequence_lengthT * sizeof(int32_t));
sequence_length = sequence_lengthT;
for( uint32_t i = 0; i < sequence_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_sequence;
u_st_sequence.base = 0;
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_sequence = u_st_sequence.real;
offset += sizeof(this->st_sequence);
memcpy( &(this->sequence[i]), &(this->st_sequence), sizeof(int32_t));
}
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciFeedback"; };
const char * getMD5(){ return "b81e37d2a31925a0e8ae261a8699cb79"; };
};
}
#endif
| 2,961 | C | 34.686747 | 95 | 0.571091 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/FibonacciAction.h | #ifndef _ROS_actionlib_tutorials_FibonacciAction_h
#define _ROS_actionlib_tutorials_FibonacciAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib_tutorials/FibonacciActionGoal.h"
#include "actionlib_tutorials/FibonacciActionResult.h"
#include "actionlib_tutorials/FibonacciActionFeedback.h"
namespace actionlib_tutorials
{
class FibonacciAction : public ros::Msg
{
public:
typedef actionlib_tutorials::FibonacciActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib_tutorials::FibonacciActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib_tutorials::FibonacciActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
FibonacciAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib_tutorials/FibonacciAction"; };
const char * getMD5(){ return "f59df5767bf7634684781c92598b2406"; };
};
}
#endif
| 1,696 | C | 28.771929 | 81 | 0.702241 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingActionResult.h | #ifndef _ROS_actionlib_tutorials_AveragingActionResult_h
#define _ROS_actionlib_tutorials_AveragingActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib_tutorials/AveragingResult.h"
namespace actionlib_tutorials
{
class AveragingActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib_tutorials::AveragingResult _result_type;
_result_type result;
AveragingActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingActionResult"; };
const char * getMD5(){ return "8672cb489d347580acdcd05c5d497497"; };
};
}
#endif
| 1,504 | C | 25.403508 | 82 | 0.676197 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_tutorials/AveragingGoal.h | #ifndef _ROS_actionlib_tutorials_AveragingGoal_h
#define _ROS_actionlib_tutorials_AveragingGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib_tutorials
{
class AveragingGoal : public ros::Msg
{
public:
typedef int32_t _samples_type;
_samples_type samples;
AveragingGoal():
samples(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_samples;
u_samples.real = this->samples;
*(outbuffer + offset + 0) = (u_samples.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_samples.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_samples.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_samples.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->samples);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_samples;
u_samples.base = 0;
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_samples.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->samples = u_samples.real;
offset += sizeof(this->samples);
return offset;
}
const char * getType(){ return "actionlib_tutorials/AveragingGoal"; };
const char * getMD5(){ return "32c9b10ef9b253faa93b93f564762c8f"; };
};
}
#endif
| 1,694 | C | 25.904761 | 75 | 0.565525 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapActionFeedback.h | #ifndef _ROS_nav_msgs_GetMapActionFeedback_h
#define _ROS_nav_msgs_GetMapActionFeedback_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 "nav_msgs/GetMapFeedback.h"
namespace nav_msgs
{
class GetMapActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef nav_msgs::GetMapFeedback _feedback_type;
_feedback_type feedback;
GetMapActionFeedback():
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 "nav_msgs/GetMapActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
| 1,443 | C | 24.333333 | 72 | 0.662509 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/MapMetaData.h | #ifndef _ROS_nav_msgs_MapMetaData_h
#define _ROS_nav_msgs_MapMetaData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "geometry_msgs/Pose.h"
namespace nav_msgs
{
class MapMetaData : public ros::Msg
{
public:
typedef ros::Time _map_load_time_type;
_map_load_time_type map_load_time;
typedef float _resolution_type;
_resolution_type resolution;
typedef uint32_t _width_type;
_width_type width;
typedef uint32_t _height_type;
_height_type height;
typedef geometry_msgs::Pose _origin_type;
_origin_type origin;
MapMetaData():
map_load_time(),
resolution(0),
width(0),
height(0),
origin()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->map_load_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->map_load_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->map_load_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->map_load_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->map_load_time.sec);
*(outbuffer + offset + 0) = (this->map_load_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->map_load_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->map_load_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->map_load_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->map_load_time.nsec);
union {
float real;
uint32_t base;
} u_resolution;
u_resolution.real = this->resolution;
*(outbuffer + offset + 0) = (u_resolution.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_resolution.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_resolution.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_resolution.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->resolution);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
offset += this->origin.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->map_load_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->map_load_time.sec);
this->map_load_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->map_load_time.nsec);
union {
float real;
uint32_t base;
} u_resolution;
u_resolution.base = 0;
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->resolution = u_resolution.real;
offset += sizeof(this->resolution);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
offset += this->origin.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "nav_msgs/MapMetaData"; };
const char * getMD5(){ return "10cfc8a2818024d3248802c00c95f11b"; };
};
}
#endif
| 4,966 | C | 40.739495 | 85 | 0.538663 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/SetMap.h | #ifndef _ROS_SERVICE_SetMap_h
#define _ROS_SERVICE_SetMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
#include "geometry_msgs/PoseWithCovarianceStamped.h"
namespace nav_msgs
{
static const char SETMAP[] = "nav_msgs/SetMap";
class SetMapRequest : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
typedef geometry_msgs::PoseWithCovarianceStamped _initial_pose_type;
_initial_pose_type initial_pose;
SetMapRequest():
map(),
initial_pose()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
offset += this->initial_pose.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
offset += this->initial_pose.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETMAP; };
const char * getMD5(){ return "91149a20d7be299b87c340df8cc94fd4"; };
};
class SetMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
SetMapResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return SETMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class SetMap {
public:
typedef SetMapRequest Request;
typedef SetMapResponse Response;
};
}
#endif
| 2,317 | C | 21.950495 | 74 | 0.611998 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapActionResult.h | #ifndef _ROS_nav_msgs_GetMapActionResult_h
#define _ROS_nav_msgs_GetMapActionResult_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 "nav_msgs/GetMapResult.h"
namespace nav_msgs
{
class GetMapActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef nav_msgs::GetMapResult _result_type;
_result_type result;
GetMapActionResult():
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 "nav_msgs/GetMapActionResult"; };
const char * getMD5(){ return "ac66e5b9a79bb4bbd33dab245236c892"; };
};
}
#endif
| 1,417 | C | 23.877193 | 72 | 0.656316 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMap.h | #ifndef _ROS_SERVICE_GetMap_h
#define _ROS_SERVICE_GetMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace nav_msgs
{
static const char GETMAP[] = "nav_msgs/GetMap";
class GetMapRequest : public ros::Msg
{
public:
GetMapRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return GETMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetMapResponse : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
GetMapResponse():
map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMAP; };
const char * getMD5(){ return "6cdd0a18e0aff5b0a3ca2326a89b54ff"; };
};
class GetMap {
public:
typedef GetMapRequest Request;
typedef GetMapResponse Response;
};
}
#endif
| 1,441 | C | 17.727272 | 72 | 0.625954 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetPlan.h | #ifndef _ROS_SERVICE_GetPlan_h
#define _ROS_SERVICE_GetPlan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
#include "nav_msgs/Path.h"
namespace nav_msgs
{
static const char GETPLAN[] = "nav_msgs/GetPlan";
class GetPlanRequest : public ros::Msg
{
public:
typedef geometry_msgs::PoseStamped _start_type;
_start_type start;
typedef geometry_msgs::PoseStamped _goal_type;
_goal_type goal;
typedef float _tolerance_type;
_tolerance_type tolerance;
GetPlanRequest():
start(),
goal(),
tolerance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->start.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_tolerance;
u_tolerance.real = this->tolerance;
*(outbuffer + offset + 0) = (u_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_tolerance.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->tolerance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->start.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_tolerance;
u_tolerance.base = 0;
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->tolerance = u_tolerance.real;
offset += sizeof(this->tolerance);
return offset;
}
const char * getType(){ return GETPLAN; };
const char * getMD5(){ return "e25a43e0752bcca599a8c2eef8282df8"; };
};
class GetPlanResponse : public ros::Msg
{
public:
typedef nav_msgs::Path _plan_type;
_plan_type plan;
GetPlanResponse():
plan()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->plan.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->plan.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLAN; };
const char * getMD5(){ return "0002bc113c0259d71f6cf8cbc9430e18"; };
};
class GetPlan {
public:
typedef GetPlanRequest Request;
typedef GetPlanResponse Response;
};
}
#endif
| 2,941 | C | 25.267857 | 77 | 0.592996 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapActionGoal.h | #ifndef _ROS_nav_msgs_GetMapActionGoal_h
#define _ROS_nav_msgs_GetMapActionGoal_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 "nav_msgs/GetMapGoal.h"
namespace nav_msgs
{
class GetMapActionGoal : 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 nav_msgs::GetMapGoal _goal_type;
_goal_type goal;
GetMapActionGoal():
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 "nav_msgs/GetMapActionGoal"; };
const char * getMD5(){ return "4b30be6cd12b9e72826df56b481f40e0"; };
};
}
#endif
| 1,389 | C | 23.385965 | 72 | 0.645068 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapResult.h | #ifndef _ROS_nav_msgs_GetMapResult_h
#define _ROS_nav_msgs_GetMapResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace nav_msgs
{
class GetMapResult : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
GetMapResult():
map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "nav_msgs/GetMapResult"; };
const char * getMD5(){ return "6cdd0a18e0aff5b0a3ca2326a89b54ff"; };
};
}
#endif
| 875 | C | 18.466666 | 72 | 0.635429 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GridCells.h | #ifndef _ROS_nav_msgs_GridCells_h
#define _ROS_nav_msgs_GridCells_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point.h"
namespace nav_msgs
{
class GridCells : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef float _cell_width_type;
_cell_width_type cell_width;
typedef float _cell_height_type;
_cell_height_type cell_height;
uint32_t cells_length;
typedef geometry_msgs::Point _cells_type;
_cells_type st_cells;
_cells_type * cells;
GridCells():
header(),
cell_width(0),
cell_height(0),
cells_length(0), cells(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_cell_width;
u_cell_width.real = this->cell_width;
*(outbuffer + offset + 0) = (u_cell_width.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cell_width.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cell_width.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cell_width.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cell_width);
union {
float real;
uint32_t base;
} u_cell_height;
u_cell_height.real = this->cell_height;
*(outbuffer + offset + 0) = (u_cell_height.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cell_height.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cell_height.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cell_height.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cell_height);
*(outbuffer + offset + 0) = (this->cells_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cells_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cells_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cells_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cells_length);
for( uint32_t i = 0; i < cells_length; i++){
offset += this->cells[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_cell_width;
u_cell_width.base = 0;
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->cell_width = u_cell_width.real;
offset += sizeof(this->cell_width);
union {
float real;
uint32_t base;
} u_cell_height;
u_cell_height.base = 0;
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->cell_height = u_cell_height.real;
offset += sizeof(this->cell_height);
uint32_t cells_lengthT = ((uint32_t) (*(inbuffer + offset)));
cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cells_length);
if(cells_lengthT > cells_length)
this->cells = (geometry_msgs::Point*)realloc(this->cells, cells_lengthT * sizeof(geometry_msgs::Point));
cells_length = cells_lengthT;
for( uint32_t i = 0; i < cells_length; i++){
offset += this->st_cells.deserialize(inbuffer + offset);
memcpy( &(this->cells[i]), &(this->st_cells), sizeof(geometry_msgs::Point));
}
return offset;
}
const char * getType(){ return "nav_msgs/GridCells"; };
const char * getMD5(){ return "b9e4f5df6d28e272ebde00a3994830f5"; };
};
}
#endif
| 4,405 | C | 36.02521 | 112 | 0.552554 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/Path.h | #ifndef _ROS_nav_msgs_Path_h
#define _ROS_nav_msgs_Path_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/PoseStamped.h"
namespace nav_msgs
{
class Path : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t poses_length;
typedef geometry_msgs::PoseStamped _poses_type;
_poses_type st_poses;
_poses_type * poses;
Path():
header(),
poses_length(0), poses(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->poses_length);
for( uint32_t i = 0; i < poses_length; i++){
offset += this->poses[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->poses_length);
if(poses_lengthT > poses_length)
this->poses = (geometry_msgs::PoseStamped*)realloc(this->poses, poses_lengthT * sizeof(geometry_msgs::PoseStamped));
poses_length = poses_lengthT;
for( uint32_t i = 0; i < poses_length; i++){
offset += this->st_poses.deserialize(inbuffer + offset);
memcpy( &(this->poses[i]), &(this->st_poses), sizeof(geometry_msgs::PoseStamped));
}
return offset;
}
const char * getType(){ return "nav_msgs/Path"; };
const char * getMD5(){ return "6227e2b7e9cce15051f669a5e197bbf7"; };
};
}
#endif
| 2,267 | C | 30.943662 | 124 | 0.588443 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapFeedback.h | #ifndef _ROS_nav_msgs_GetMapFeedback_h
#define _ROS_nav_msgs_GetMapFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace nav_msgs
{
class GetMapFeedback : public ros::Msg
{
public:
GetMapFeedback()
{
}
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 "nav_msgs/GetMapFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 651 | C | 15.717948 | 72 | 0.639017 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/Odometry.h | #ifndef _ROS_nav_msgs_Odometry_h
#define _ROS_nav_msgs_Odometry_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/PoseWithCovariance.h"
#include "geometry_msgs/TwistWithCovariance.h"
namespace nav_msgs
{
class Odometry : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _child_frame_id_type;
_child_frame_id_type child_frame_id;
typedef geometry_msgs::PoseWithCovariance _pose_type;
_pose_type pose;
typedef geometry_msgs::TwistWithCovariance _twist_type;
_twist_type twist;
Odometry():
header(),
child_frame_id(""),
pose(),
twist()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_child_frame_id = strlen(this->child_frame_id);
varToArr(outbuffer + offset, length_child_frame_id);
offset += 4;
memcpy(outbuffer + offset, this->child_frame_id, length_child_frame_id);
offset += length_child_frame_id;
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_child_frame_id;
arrToVar(length_child_frame_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_child_frame_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_child_frame_id-1]=0;
this->child_frame_id = (char *)(inbuffer + offset-1);
offset += length_child_frame_id;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "nav_msgs/Odometry"; };
const char * getMD5(){ return "cd5e73d190d741a2f92e81eda573aca7"; };
};
}
#endif
| 2,153 | C | 28.108108 | 78 | 0.639573 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapGoal.h | #ifndef _ROS_nav_msgs_GetMapGoal_h
#define _ROS_nav_msgs_GetMapGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace nav_msgs
{
class GetMapGoal : public ros::Msg
{
public:
GetMapGoal()
{
}
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 "nav_msgs/GetMapGoal"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 631 | C | 15.205128 | 72 | 0.627575 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/OccupancyGrid.h | #ifndef _ROS_nav_msgs_OccupancyGrid_h
#define _ROS_nav_msgs_OccupancyGrid_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "nav_msgs/MapMetaData.h"
namespace nav_msgs
{
class OccupancyGrid : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef nav_msgs::MapMetaData _info_type;
_info_type info;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
OccupancyGrid():
header(),
info(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->info.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->header.deserialize(inbuffer + offset);
offset += this->info.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 "nav_msgs/OccupancyGrid"; };
const char * getMD5(){ return "3381f2d731d4076ec5c71b0759edbe4e"; };
};
}
#endif
| 2,746 | C | 29.865168 | 81 | 0.560452 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nav_msgs/GetMapAction.h | #ifndef _ROS_nav_msgs_GetMapAction_h
#define _ROS_nav_msgs_GetMapAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/GetMapActionGoal.h"
#include "nav_msgs/GetMapActionResult.h"
#include "nav_msgs/GetMapActionFeedback.h"
namespace nav_msgs
{
class GetMapAction : public ros::Msg
{
public:
typedef nav_msgs::GetMapActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef nav_msgs::GetMapActionResult _action_result_type;
_action_result_type action_result;
typedef nav_msgs::GetMapActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
GetMapAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "nav_msgs/GetMapAction"; };
const char * getMD5(){ return "e611ad23fbf237c031b7536416dc7cd7"; };
};
}
#endif
| 1,553 | C | 26.263157 | 72 | 0.674823 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestAction.h | #ifndef _ROS_actionlib_TestAction_h
#define _ROS_actionlib_TestAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib/TestActionGoal.h"
#include "actionlib/TestActionResult.h"
#include "actionlib/TestActionFeedback.h"
namespace actionlib
{
class TestAction : public ros::Msg
{
public:
typedef actionlib::TestActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib::TestActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib::TestActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
TestAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib/TestAction"; };
const char * getMD5(){ return "991e87a72802262dfbe5d1b3cf6efc9a"; };
};
}
#endif
| 1,541 | C | 26.052631 | 72 | 0.67878 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestResult.h | #ifndef _ROS_actionlib_TestResult_h
#define _ROS_actionlib_TestResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestResult : public ros::Msg
{
public:
typedef int32_t _result_type;
_result_type result;
TestResult():
result(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_result;
u_result.real = this->result;
*(outbuffer + offset + 0) = (u_result.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_result.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_result.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_result.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->result);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_result;
u_result.base = 0;
u_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->result = u_result.real;
offset += sizeof(this->result);
return offset;
}
const char * getType(){ return "actionlib/TestResult"; };
const char * getMD5(){ return "034a8e20d6a306665e3a5b340fab3f09"; };
};
}
#endif
| 1,618 | C | 24.698412 | 74 | 0.54759 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsActionResult.h | #ifndef _ROS_actionlib_TwoIntsActionResult_h
#define _ROS_actionlib_TwoIntsActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib/TwoIntsResult.h"
namespace actionlib
{
class TwoIntsActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib::TwoIntsResult _result_type;
_result_type result;
TwoIntsActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib/TwoIntsActionResult"; };
const char * getMD5(){ return "3ba7dea8b8cddcae4528ade4ef74b6e7"; };
};
}
#endif
| 1,430 | C | 24.105263 | 72 | 0.663636 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestGoal.h | #ifndef _ROS_actionlib_TestGoal_h
#define _ROS_actionlib_TestGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestGoal : public ros::Msg
{
public:
typedef int32_t _goal_type;
_goal_type goal;
TestGoal():
goal(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_goal;
u_goal.real = this->goal;
*(outbuffer + offset + 0) = (u_goal.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_goal.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_goal.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_goal.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_goal;
u_goal.base = 0;
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_goal.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->goal = u_goal.real;
offset += sizeof(this->goal);
return offset;
}
const char * getType(){ return "actionlib/TestGoal"; };
const char * getMD5(){ return "18df0149936b7aa95588e3862476ebde"; };
};
}
#endif
| 1,566 | C | 23.873015 | 72 | 0.532567 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestGoal.h | #ifndef _ROS_actionlib_TestRequestGoal_h
#define _ROS_actionlib_TestRequestGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
namespace actionlib
{
class TestRequestGoal : public ros::Msg
{
public:
typedef int32_t _terminate_status_type;
_terminate_status_type terminate_status;
typedef bool _ignore_cancel_type;
_ignore_cancel_type ignore_cancel;
typedef const char* _result_text_type;
_result_text_type result_text;
typedef int32_t _the_result_type;
_the_result_type the_result;
typedef bool _is_simple_client_type;
_is_simple_client_type is_simple_client;
typedef ros::Duration _delay_accept_type;
_delay_accept_type delay_accept;
typedef ros::Duration _delay_terminate_type;
_delay_terminate_type delay_terminate;
typedef ros::Duration _pause_status_type;
_pause_status_type pause_status;
enum { TERMINATE_SUCCESS = 0 };
enum { TERMINATE_ABORTED = 1 };
enum { TERMINATE_REJECTED = 2 };
enum { TERMINATE_LOSE = 3 };
enum { TERMINATE_DROP = 4 };
enum { TERMINATE_EXCEPTION = 5 };
TestRequestGoal():
terminate_status(0),
ignore_cancel(0),
result_text(""),
the_result(0),
is_simple_client(0),
delay_accept(),
delay_terminate(),
pause_status()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_terminate_status;
u_terminate_status.real = this->terminate_status;
*(outbuffer + offset + 0) = (u_terminate_status.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_terminate_status.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_terminate_status.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_terminate_status.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->terminate_status);
union {
bool real;
uint8_t base;
} u_ignore_cancel;
u_ignore_cancel.real = this->ignore_cancel;
*(outbuffer + offset + 0) = (u_ignore_cancel.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->ignore_cancel);
uint32_t length_result_text = strlen(this->result_text);
varToArr(outbuffer + offset, length_result_text);
offset += 4;
memcpy(outbuffer + offset, this->result_text, length_result_text);
offset += length_result_text;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.real = this->the_result;
*(outbuffer + offset + 0) = (u_the_result.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_the_result.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_the_result.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_the_result.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_client;
u_is_simple_client.real = this->is_simple_client;
*(outbuffer + offset + 0) = (u_is_simple_client.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_simple_client);
*(outbuffer + offset + 0) = (this->delay_accept.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_accept.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_accept.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_accept.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_accept.sec);
*(outbuffer + offset + 0) = (this->delay_accept.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_accept.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_accept.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_accept.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_accept.nsec);
*(outbuffer + offset + 0) = (this->delay_terminate.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_terminate.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_terminate.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_terminate.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_terminate.sec);
*(outbuffer + offset + 0) = (this->delay_terminate.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->delay_terminate.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->delay_terminate.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->delay_terminate.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->delay_terminate.nsec);
*(outbuffer + offset + 0) = (this->pause_status.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pause_status.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pause_status.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pause_status.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->pause_status.sec);
*(outbuffer + offset + 0) = (this->pause_status.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pause_status.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pause_status.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pause_status.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->pause_status.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_terminate_status;
u_terminate_status.base = 0;
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->terminate_status = u_terminate_status.real;
offset += sizeof(this->terminate_status);
union {
bool real;
uint8_t base;
} u_ignore_cancel;
u_ignore_cancel.base = 0;
u_ignore_cancel.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->ignore_cancel = u_ignore_cancel.real;
offset += sizeof(this->ignore_cancel);
uint32_t length_result_text;
arrToVar(length_result_text, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_result_text; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_result_text-1]=0;
this->result_text = (char *)(inbuffer + offset-1);
offset += length_result_text;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.base = 0;
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->the_result = u_the_result.real;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_client;
u_is_simple_client.base = 0;
u_is_simple_client.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_simple_client = u_is_simple_client.real;
offset += sizeof(this->is_simple_client);
this->delay_accept.sec = ((uint32_t) (*(inbuffer + offset)));
this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_accept.sec);
this->delay_accept.nsec = ((uint32_t) (*(inbuffer + offset)));
this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_accept.nsec);
this->delay_terminate.sec = ((uint32_t) (*(inbuffer + offset)));
this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_terminate.sec);
this->delay_terminate.nsec = ((uint32_t) (*(inbuffer + offset)));
this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->delay_terminate.nsec);
this->pause_status.sec = ((uint32_t) (*(inbuffer + offset)));
this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pause_status.sec);
this->pause_status.nsec = ((uint32_t) (*(inbuffer + offset)));
this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pause_status.nsec);
return offset;
}
const char * getType(){ return "actionlib/TestRequestGoal"; };
const char * getMD5(){ return "db5d00ba98302d6c6dd3737e9a03ceea"; };
};
}
#endif
| 10,031 | C | 45.444444 | 87 | 0.558469 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsFeedback.h | #ifndef _ROS_actionlib_TwoIntsFeedback_h
#define _ROS_actionlib_TwoIntsFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TwoIntsFeedback : public ros::Msg
{
public:
TwoIntsFeedback()
{
}
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 "actionlib/TwoIntsFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 660 | C | 15.948718 | 72 | 0.65 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestActionResult.h | #ifndef _ROS_actionlib_TestActionResult_h
#define _ROS_actionlib_TestActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib/TestResult.h"
namespace actionlib
{
class TestActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib::TestResult _result_type;
_result_type result;
TestActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib/TestActionResult"; };
const char * getMD5(){ return "3d669e3a63aa986c667ea7b0f46ce85e"; };
};
}
#endif
| 1,409 | C | 23.736842 | 72 | 0.658623 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestActionFeedback.h | #ifndef _ROS_actionlib_TestRequestActionFeedback_h
#define _ROS_actionlib_TestRequestActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib/TestRequestFeedback.h"
namespace actionlib
{
class TestRequestActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib::TestRequestFeedback _feedback_type;
_feedback_type feedback;
TestRequestActionFeedback():
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 "actionlib/TestRequestActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
| 1,484 | C | 25.052631 | 76 | 0.675876 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestFeedback.h | #ifndef _ROS_actionlib_TestRequestFeedback_h
#define _ROS_actionlib_TestRequestFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestRequestFeedback : public ros::Msg
{
public:
TestRequestFeedback()
{
}
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 "actionlib/TestRequestFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 680 | C | 16.461538 | 72 | 0.660294 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestActionGoal.h | #ifndef _ROS_actionlib_TestActionGoal_h
#define _ROS_actionlib_TestActionGoal_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 "actionlib/TestGoal.h"
namespace actionlib
{
class TestActionGoal : 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 actionlib::TestGoal _goal_type;
_goal_type goal;
TestActionGoal():
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 "actionlib/TestActionGoal"; };
const char * getMD5(){ return "348369c5b403676156094e8c159720bf"; };
};
}
#endif
| 1,381 | C | 23.245614 | 72 | 0.647357 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsGoal.h | #ifndef _ROS_actionlib_TwoIntsGoal_h
#define _ROS_actionlib_TwoIntsGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TwoIntsGoal : public ros::Msg
{
public:
typedef int64_t _a_type;
_a_type a;
typedef int64_t _b_type;
_b_type b;
TwoIntsGoal():
a(0),
b(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_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;
*(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->a);
union {
int64_t real;
uint64_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;
*(outbuffer + offset + 4) = (u_b.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_b.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_b.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_b.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->b);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.base = 0;
u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->a = u_a.real;
offset += sizeof(this->a);
union {
int64_t real;
uint64_t base;
} u_b;
u_b.base = 0;
u_b.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->b = u_b.real;
offset += sizeof(this->b);
return offset;
}
const char * getType(){ return "actionlib/TwoIntsGoal"; };
const char * getMD5(){ return "36d09b846be0b371c5f190354dd3153e"; };
};
}
#endif
| 3,468 | C | 32.679611 | 72 | 0.469146 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsActionGoal.h | #ifndef _ROS_actionlib_TwoIntsActionGoal_h
#define _ROS_actionlib_TwoIntsActionGoal_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 "actionlib/TwoIntsGoal.h"
namespace actionlib
{
class TwoIntsActionGoal : 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 actionlib::TwoIntsGoal _goal_type;
_goal_type goal;
TwoIntsActionGoal():
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 "actionlib/TwoIntsActionGoal"; };
const char * getMD5(){ return "684a2db55d6ffb8046fb9d6764ce0860"; };
};
}
#endif
| 1,402 | C | 23.614035 | 72 | 0.652639 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestFeedback.h | #ifndef _ROS_actionlib_TestFeedback_h
#define _ROS_actionlib_TestFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestFeedback : public ros::Msg
{
public:
typedef int32_t _feedback_type;
_feedback_type feedback;
TestFeedback():
feedback(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_feedback;
u_feedback.real = this->feedback;
*(outbuffer + offset + 0) = (u_feedback.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_feedback.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_feedback.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_feedback.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->feedback);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_feedback;
u_feedback.base = 0;
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->feedback = u_feedback.real;
offset += sizeof(this->feedback);
return offset;
}
const char * getType(){ return "actionlib/TestFeedback"; };
const char * getMD5(){ return "49ceb5b32ea3af22073ede4a0328249e"; };
};
}
#endif
| 1,670 | C | 25.523809 | 76 | 0.561677 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsAction.h | #ifndef _ROS_actionlib_TwoIntsAction_h
#define _ROS_actionlib_TwoIntsAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib/TwoIntsActionGoal.h"
#include "actionlib/TwoIntsActionResult.h"
#include "actionlib/TwoIntsActionFeedback.h"
namespace actionlib
{
class TwoIntsAction : public ros::Msg
{
public:
typedef actionlib::TwoIntsActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib::TwoIntsActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib::TwoIntsActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
TwoIntsAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib/TwoIntsAction"; };
const char * getMD5(){ return "6d1aa538c4bd6183a2dfb7fcac41ee50"; };
};
}
#endif
| 1,574 | C | 26.631578 | 72 | 0.685515 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestResult.h | #ifndef _ROS_actionlib_TestRequestResult_h
#define _ROS_actionlib_TestRequestResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestRequestResult : public ros::Msg
{
public:
typedef int32_t _the_result_type;
_the_result_type the_result;
typedef bool _is_simple_server_type;
_is_simple_server_type is_simple_server;
TestRequestResult():
the_result(0),
is_simple_server(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.real = this->the_result;
*(outbuffer + offset + 0) = (u_the_result.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_the_result.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_the_result.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_the_result.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_server;
u_is_simple_server.real = this->is_simple_server;
*(outbuffer + offset + 0) = (u_is_simple_server.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_simple_server);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.base = 0;
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->the_result = u_the_result.real;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_server;
u_is_simple_server.base = 0;
u_is_simple_server.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_simple_server = u_is_simple_server.real;
offset += sizeof(this->is_simple_server);
return offset;
}
const char * getType(){ return "actionlib/TestRequestResult"; };
const char * getMD5(){ return "61c2364524499c7c5017e2f3fce7ba06"; };
};
}
#endif
| 2,426 | C | 28.962963 | 83 | 0.565952 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestActionFeedback.h | #ifndef _ROS_actionlib_TestActionFeedback_h
#define _ROS_actionlib_TestActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib/TestFeedback.h"
namespace actionlib
{
class TestActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib::TestFeedback _feedback_type;
_feedback_type feedback;
TestActionFeedback():
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 "actionlib/TestActionFeedback"; };
const char * getMD5(){ return "6d3d0bf7fb3dda24779c010a9f3eb7cb"; };
};
}
#endif
| 1,435 | C | 24.192982 | 72 | 0.664808 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsActionFeedback.h | #ifndef _ROS_actionlib_TwoIntsActionFeedback_h
#define _ROS_actionlib_TwoIntsActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib/TwoIntsFeedback.h"
namespace actionlib
{
class TwoIntsActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib::TwoIntsFeedback _feedback_type;
_feedback_type feedback;
TwoIntsActionFeedback():
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 "actionlib/TwoIntsActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
| 1,456 | C | 24.561403 | 72 | 0.669643 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestActionResult.h | #ifndef _ROS_actionlib_TestRequestActionResult_h
#define _ROS_actionlib_TestRequestActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "actionlib/TestRequestResult.h"
namespace actionlib
{
class TestRequestActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef actionlib::TestRequestResult _result_type;
_result_type result;
TestRequestActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib/TestRequestActionResult"; };
const char * getMD5(){ return "0476d1fdf437a3a6e7d6d0e9f5561298"; };
};
}
#endif
| 1,458 | C | 24.596491 | 74 | 0.670096 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestAction.h | #ifndef _ROS_actionlib_TestRequestAction_h
#define _ROS_actionlib_TestRequestAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib/TestRequestActionGoal.h"
#include "actionlib/TestRequestActionResult.h"
#include "actionlib/TestRequestActionFeedback.h"
namespace actionlib
{
class TestRequestAction : public ros::Msg
{
public:
typedef actionlib::TestRequestActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef actionlib::TestRequestActionResult _action_result_type;
_action_result_type action_result;
typedef actionlib::TestRequestActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
TestRequestAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "actionlib/TestRequestAction"; };
const char * getMD5(){ return "dc44b1f4045dbf0d1db54423b3b86b30"; };
};
}
#endif
| 1,618 | C | 27.403508 | 73 | 0.694067 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestActionGoal.h | #ifndef _ROS_actionlib_TestRequestActionGoal_h
#define _ROS_actionlib_TestRequestActionGoal_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 "actionlib/TestRequestGoal.h"
namespace actionlib
{
class TestRequestActionGoal : 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 actionlib::TestRequestGoal _goal_type;
_goal_type goal;
TestRequestActionGoal():
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 "actionlib/TestRequestActionGoal"; };
const char * getMD5(){ return "1889556d3fef88f821c7cb004e4251f3"; };
};
}
#endif
| 1,430 | C | 24.105263 | 72 | 0.659441 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TwoIntsResult.h | #ifndef _ROS_actionlib_TwoIntsResult_h
#define _ROS_actionlib_TwoIntsResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TwoIntsResult : public ros::Msg
{
public:
typedef int64_t _sum_type;
_sum_type sum;
TwoIntsResult():
sum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.real = this->sum;
*(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sum.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sum.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sum.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sum.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.base = 0;
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sum = u_sum.real;
offset += sizeof(this->sum);
return offset;
}
const char * getType(){ return "actionlib/TwoIntsResult"; };
const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
};
}
#endif
| 2,122 | C | 28.901408 | 72 | 0.511781 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ContactSensor/ContactSensor.cpp | #include "ContactSensor.hpp"
#include <Arduino.h>
void ContactSensor::Initialize(const int & in_sensor_pin, const int & in_led_pin) {
sensor_pin = in_sensor_pin;
led_pin = in_led_pin;
// pinMode(led_pin, OUTPUT);
double av = 0;
for(int i=0; i < numSamples; i++) {
av += analogRead(sensor_pin);
delay(5);
}
center = av / static_cast<double>(numSamples);
thresh = center;
}
void ContactSensor::update_clk() {
val = alpha * prev_val + (1 - alpha) * abs(analogRead(sensor_pin) - center); // read the input pin
prev_val = val;
// if(val > thresh) {
// digitalWrite(led_pin, HIGH);
// } else {
// digitalWrite(led_pin, LOW);
// }
}
bool ContactSensor::isTriggered() {
if(val > thresh) {
return true;
}
return false;
}
double ContactSensor::ReturnVal()
{
return val;
}
| 823 | C++ | 19.6 | 101 | 0.619684 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ContactSensor/ContactSensor.hpp | #ifndef CONTACTSENSOR_INCLUDE_GUARD_HPP
#define CONTACTSENSOR_INCLUDE_GUARD_HPP
/// \file
/// \brief Contact Sensor Library. Adapted from https://github.com/adham-elarabawy/OpenQuadruped
class ContactSensor {
private:
int led_pin;
int sensor_pin;
double center = 0;
double prev_val = 0;
double val = 0;
int numSamples = 200;
double thresh = 2.5;
double alpha = 0.999;
public:
void Initialize(const int & in_sensor_pin, const int & in_led_pin);
bool isTriggered();
void update_clk();
double ReturnVal();
};
#endif
| 543 | C++ | 21.666666 | 96 | 0.699816 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/SpotServo/SpotServo.hpp | #ifndef SPOTSERVO_INCLUDE_GUARD_HPP
#define SPOTSERVO_INCLUDE_GUARD_HPP
/// \file
/// \brief Servo Speed Control Library
#include <Servo.h>
#include <Arduino.h>
#include <math.h>
// #include <cmath>
enum LegType {FL, FR, BL, BR};
enum JointType {Shoulder, Elbow, Wrist};
/// \brief SpotServo class responsible servo control
class SpotServo
{
public:
// using default constructor
/// \brief Initialize parameters
/// \param servo_pin: pin number on Teensy 4.0 (see dataseet)
/// \param home_angle_: default joint angle
/// \param offset_: motor position offset (due to mechanical fit issues)
/// \param leg_type_: Front Left, Front Right, Back Left, or Back Right leg (see enum)
/// \param joint_type_: Shoulder, Elbow or Wrist (see enum)
void Initialize(const int & servo_pin, const double & stand_angle_, const double & home_angle_, const double & offset_, const LegType & leg_type_, const JointType & joint_type_,
const int & min_pwm_ = 500, const int & max_pwm_ = 2500, const double & ang_min_pwm = 0.0, const double & ang_max_pwm = 270.0);
/// \brief Commands a motor to move to a certain goal instantly when stepping, and slowly when viewing
/// \param goal_pose_: the desired motor position in degrees
/// \param desired_speed_: the desired motor speed (deg/sec) while reaching this goal
/// \param step_or_view_: operation mode, stepping or viewing.
void SetGoal(const double & goal_pose_, const double & desired_speed_, const bool & step_or_view_ = true);
/// \brief returns joint_type
/// \returns: joint_type
JointType return_joint_type();
/// \brief returns leg_type
/// \returns: leg_type
LegType return_legtype();
/// \brief returns this servo's home angle
/// \returns: home_angle
double return_home();
/// \brief Return the interpolated position (time-step is small enough that this is mostly accurate)
/// \returns: motor_pose_est
double GetPoseEstimate();
/// \brief Perform one motor update, potentially sending a new motor command, and updating the time-step.
void update_clk();
/// \brief Check if goal position reached
bool GoalReached();
/// \biref Actuate motors
void actuate();
/// \brief directly write pulse width in us
/// \param pulse: pulse width to write
void writePulse(const int & pulse);
/// \brief Attach servo
/// \param servo_pin: pin number on Teensy 4.0 (see dataseet)
/// \param min_pwm: minimum us value
/// \param max_pwm: maximum us value
void AssemblyInit(const int & servo_pin, const int & min_pwm_, const int & max_pwm_);
private:
// Intrinsic Parameters
Servo servo;
// time elapsed since last servo update
double last_actuated = 0.0;
// error threshold for servo position
double error_threshold = 0.5;
// maximum servo angle (minimum is 0)
double control_range = 270.0;
// loop period (milisec)
double wait_time = 1.0;
// motor position offset (due to mechanical fit issues)
int offset = 0;
// Leg Type (see enum)
LegType leg_type;
// Joint Type (see enum)
JointType joint_type;
// default angle
double home_angle = 0.0;
double stand_angle = 0.0;
// Changeable Parameters
double goal_pose = -999; // deg
double current_pose = 0.0; // deg
double desired_speed = 0.0; // deg/sec
// Servo's PWM range (usec)
// NOTE: This is unique to your servos, VERY IMPORTANT
int min_pwm = 500;
int max_pwm = 2500;
// Interpolation to convert from deg to usec
double conv_slope = 0.0;
double conv_intcpt = 0.0;
// False is step, True is view
bool step_or_view = false;
// indicated servo mode
bool calibrating = false;
};
#endif | 3,799 | C++ | 32.043478 | 181 | 0.653856 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/SpotServo/SpotServo.cpp | #include "SpotServo.hpp"
using namespace std;
// Spot Full Constructor
void SpotServo::Initialize(const int & servo_pin, const double & stand_angle_, const double & home_angle_, const double & offset_, const LegType & leg_type_, const JointType & joint_type_,
const int & min_pwm_, const int & max_pwm_, const double & ang_min_pwm, const double & ang_max_pwm)
{
// use defaults for servo attach
AssemblyInit(servo_pin, min_pwm, max_pwm);
// these are not really min and max, just used for interpolation
min_pwm = min_pwm_;
max_pwm = max_pwm_;
conv_slope = (double)(max_pwm - min_pwm) / (ang_max_pwm - ang_min_pwm);
conv_intcpt = max_pwm - conv_slope * ang_max_pwm;
offset = offset_;
home_angle = home_angle_;
leg_type = leg_type_;
joint_type = joint_type;
stand_angle = stand_angle_;
goal_pose = stand_angle + offset;
current_pose = stand_angle + offset;
int pwm = round((goal_pose) * conv_slope + conv_intcpt);
servo.writeMicroseconds(pwm);
last_actuated = millis();
}
void SpotServo::SetGoal(const double & goal_pose_, const double & desired_speed_, const bool & step_or_view_)
{
// remove calibrating flag
calibrating = false;
// Update Move Type
step_or_view = step_or_view_;
// Catch for invalid command (used by calibration node to single out motors)
// Only update if valid command
if (goal_pose_ > -998)
{
goal_pose = goal_pose_;
// Add Offset
goal_pose += offset;
// TODO: ADD JOINT LIM
desired_speed = desired_speed_;
}
}
JointType SpotServo::return_joint_type()
{
return joint_type;
}
LegType SpotServo::return_legtype()
{
return leg_type;
}
double SpotServo::return_home()
{
return home_angle;
}
double SpotServo::GetPoseEstimate()
{
return current_pose - offset;
}
void SpotServo::actuate()
{
if (goal_pose > -998)
{
// Only update position if not within threshold
if(!GoalReached())
{
// returns 1.0 * sign of goal_pose - current_pose
double direction = 1.0;
if (goal_pose - current_pose < 0.0)
{
direction = -1.0;
}
current_pose += direction * (wait_time / 1000.0) * desired_speed;
int pwm = round((current_pose) * conv_slope + conv_intcpt);
servo.writeMicroseconds(pwm);
last_actuated = millis();
} else
// if we are at small error thresh, actuate directly
{
int pwm = round((goal_pose) * conv_slope + conv_intcpt);
current_pose = goal_pose;
servo.writeMicroseconds(pwm);
last_actuated = millis();
}
}
}
void SpotServo::update_clk()
{
if (!calibrating)
{
// Only perform update if loop rate is met - or instantly if walking
if ((millis() - last_actuated > wait_time ) or !step_or_view)
{
actuate();
}
}
}
bool SpotServo::GoalReached()
{
return (abs(current_pose - goal_pose) < error_threshold);
}
void SpotServo::writePulse(const int & pulse)
{
servo.writeMicroseconds(pulse);
calibrating = true;
}
void SpotServo::AssemblyInit(const int & servo_pin, const int & min_pwm_, const int & max_pwm_)
{
// use defaults for servo attach
servo.attach(servo_pin, min_pwm, max_pwm);
} | 3,038 | C++ | 23.119047 | 188 | 0.671824 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/servo_model.py | #!/usr/bin/env python
import numpy as np
import busio
import digitalio
import board
import adafruit_mcp3xxx.mcp3008 as MCP
from adafruit_mcp3xxx.analog_in import AnalogIn
import time
from adafruit_servokit import ServoKit
class ServoJoint:
def __init__(self,
name,
effort=0.15,
speed=8.76,
gpio=22,
fb_chan=0,
pwm_chan=0,
pwm_min=600,
pwm_max=2800,
servo_horn_bias=0,
actuation_range=270):
self.name = name
self.effort = effort # Nm
self.speed = speed # rad/s
# offset in mechanical design
self.servo_horn_bias = servo_horn_bias
# create the spi bus
self.spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)
# create the cs (chip select)
if gpio == 22:
self.cs = digitalio.DigitalInOut(board.D22)
elif gpio == 27:
self.cs = digitalio.DigitalInOut(board.D27)
# create the mcp object
self.mcp = MCP.MCP3008(self.spi, self.cs)
# fb_chan from 0 to 7 for each MCP ADC
if fb_chan == 0:
self.chan = AnalogIn(self.mcp, MCP.P0)
elif fb_chan == 1:
self.chan = AnalogIn(self.mcp, MCP.P1)
elif fb_chan == 2:
self.chan = AnalogIn(self.mcp, MCP.P2)
elif fb_chan == 3:
self.chan = AnalogIn(self.mcp, MCP.P3)
elif fb_chan == 4:
self.chan = AnalogIn(self.mcp, MCP.P4)
elif fb_chan == 5:
self.chan = AnalogIn(self.mcp, MCP.P5)
elif fb_chan == 6:
self.chan = AnalogIn(self.mcp, MCP.P6)
elif fb_chan == 7:
self.chan = AnalogIn(self.mcp, MCP.P7)
self.kit = ServoKit(channels=16)
self.pwm_chan = pwm_chan
self.kit.servo[self.pwm_chan].set_pulse_width_range(pwm_min, pwm_max)
self.kit.servo[self.pwm_chan].actuation_range = actuation_range
self.bias = self.rad2deg(self.servo_horn_bias) # degrees
def forward_propagate(self, current_pos, desired_pos, dt):
""" Predict the new position of the actuated servo
motor joint
"""
pos_change = desired_pos - current_pos
percent_of_pos_reached = (self.speed * dt) / np.abs(pos_change)
# Cap at 100%
if percent_of_pos_reached > 100.0:
percent_of_pos_reached = 100.0
return current_pos + (pos_change * percent_of_pos_reached)
def calibrate(self, min_val, max_val, num_iters=22):
# Send to min value and record digital sig
# Send to max value and record digital sig
# OR INCREMENT TO GET MORE DATA
commands = np.array([])
measurements = np.array([])
# Number of data points to collect
num_iters = num_iters
for i in range(num_iters):
# commanded_value = (-np.pi / 2.0) + (i *
# (np.pi) / float(num_iters - 1))
range_val = max_val - min_val
commanded_value = (min_val) + (i *
(range_val) / float(num_iters - 1))
commands = np.append(commands, commanded_value)
self.actuate(commanded_value)
time.sleep(.5) # according to rated speed 0.1sec/60deg
measurements = np.append(measurements, self.chan.value)
time.sleep(1.0) # according to rated speed 0.1sec/60deg
# Perform fit
print("COMMANDS: {}".format(commands))
print("MEASUREMENTS: {}".format(measurements))
polynomial = 4
# We want to input measurements and receive equivalent commanded angles in radians
self.fit = np.poly1d(np.polyfit(measurements, commands, polynomial))
# Test Fit
print("TESTING FIT: 90 DEG; RESULT IS {}".format(
self.fit(self.chan.value)))
print("RETURNING TO -90")
self.actuate(-np.pi / 2)
# Save fit
np.save(self.name + "_fit", self.fit)
def load_calibration(self):
# Load fit
self.fit = np.load(self.name + "_fit.npy")
def remap(self, value):
# Use calibraton value to remap from Digital Sig to Angle
p = np.poly1d(self.fit)
return p(value)
def measure(self):
return self.remap(self.chan.value)
def rad2deg(self, rad):
deg = rad * 180.0 / np.pi
if deg > 90:
deg = 90
elif deg < -90:
deg = -90
return deg
def deg2rad(self, deg):
return deg * np.pi / 180.0
def actuate(self, desired_pos):
self.kit.servo[
self.pwm_chan].angle = self.bias + self.rad2deg(desired_pos)
def actuate_deg(self, desired_pos):
self.kit.servo[
self.pwm_chan].angle = desired_pos
| 4,877 | Python | 31.092105 | 90 | 0.555464 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/serial_test.py | import time
from Teensy_Interface import TeensyInterface
ti = TeensyInterface()
while True:
s = input("Send? [y/n]")
if s == "y":
ti.add_to_buffer(4, 0, 135, 60)
ti.send_buffer()
r = input("Read? [y/n]")
if r == "y":
print(ti.read_buffer())
| 284 | Python | 17.999999 | 44 | 0.552817 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/motor_calibrate.py | #!/usr/bin/env python
import time
import numpy as np
from servo_model import ServoJoint
joint_names = [
'rb_servo_r_hip', 'r_hip_r_thigh', 'r_thigh_r_knee', 'r_knee_r_shin',
'r_shin_r_ankle', 'r_ankle_r_foot', 'lb_servo_l_hip', 'l_hip_l_thigh',
'l_thigh_l_knee', 'l_knee_l_shin', 'l_shin_l_ankle', 'l_ankle_l_foot',
'torso_r_shoulder', 'r_shoulder_rs_servo', 're_servo_r_elbow',
'torso_l_shoulder', 'l_shoulder_ls_servo', 'le_servo_l_elbow'
]
loop = True
pwm_min = int(input("Enter Min PWM: ")) # 500
pwm_max = int(input("Enter Max PWM: ")) # 2400
actuation_range = int(input("Enter Actuation Range: "))
while loop:
channel = int(
input("Which channel is your servo connected to? [0-11]: "))
servo = ServoJoint(name=joint_names[channel],
pwm_chan=channel,
pwm_min=pwm_min,
pwm_max=pwm_max,
actuation_range=actuation_range)
inner_loop = True
while inner_loop:
val = float(input("Select an angle value (deg): [q to quit]"))
if val == "q" or val == "Q":
inner_loop = False
else:
servo.actuate_deg(val)
cont = input("Test another motor [y] or quit [n]? ")
if cont == "n":
loop = False
| 1,292 | Python | 29.069767 | 74 | 0.563467 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/Teensy_Interface.py | import serial
class TeensyInterface:
def __init__(self, port='/dev/ttyS0', baud=500000, timeout=0.2):
self.ser = serial.Serial(port, baud)
self.ser.flush()
self.buffer = []
def __construct_string(self, i, x, y, z):
return "{},{},{},{}\n".format(i, x, y, z)
def add_to_buffer(self, i, x, y, z):
self.buffer.append(self.__construct_string(i, x, y, z))
def add_raw(self, val):
self.buffer.append("{}\n".format(val))
def send_buffer(self):
for message in self.buffer:
self.ser.write(message.encode('utf-8'))
self.buffer = []
def read_buffer(self):
return self.ser.read_until(b'\n')
| 694 | Python | 24.74074 | 68 | 0.559078 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/RPi/lib/imu.py | import time
import board
import busio
import adafruit_lsm9ds1
import numpy as np
import math
# i2c permission: sudo usermod -a -G i2c <user>
# https://www.raspberrypi.org/forums/viewtopic.php?t=58782
# use ROS with python3: https://medium.com/@beta_b0t/how-to-setup-ros-with-python-3-44a69ca36674
class IMU:
def __init__(self, rp_flip=True, r_neg=False, p_neg=True, y_neg=True):
# I2C connection:
# SPI connection:
# from digitalio import DigitalInOut, Direction
# spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
# csag = DigitalInOut(board.D5)
# csag.direction = Direction.OUTPUT
# csag.value = True
# csm = DigitalInOut(board.D6)
# csm.direction = Direction.OUTPUT
# csm.value = True
# sensor = adafruit_lsm9ds1.LSM9DS1_SPI(spi, csag, csm)
self.i2c = busio.I2C(board.SCL, board.SDA)
self.sensor = adafruit_lsm9ds1.LSM9DS1_I2C(self.i2c)
# Calibration Parameters
self.x_gyro_calibration = 0
self.y_gyro_calibration = 0
self.z_gyro_calibration = 0
self.roll_calibration = 0
self.pitch_calibration = 0
self.yaw_calibration = 0
# IMU Parameters: acc (x,y,z), gyro(x,y,z)
self.imu_data = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
# Time in seconds
self.prev_time = time.time()
# IMU timer
self.imu_diff = 0
# Gyroscope integrals for filtering
self.roll_int = 0
self.pitch_int = 0
self.yaw_int = 0
# Complementary Filter Coefficient
self.comp_filter = 0.02
# Filtered RPY
self.roll = 0
self.pitch = 0
self.yaw = 0
# Used to turn the IMU into right-hand coordinate system
self.rp_flip = rp_flip
self.r_neg = r_neg
self.p_neg = p_neg
self.y_neg = y_neg
# Magnemometer Calibration Values
self.scale_x = 1
self.scale_y = 1
self.scale_z = 1
self.mag_x_bias = 0
self.mag_y_bias = 0
self.mag_z_bias = 0
self.yaw_bias = 0
# CALIBRATE
self.calibrate_imu()
print("IMU Calibrated!\n")
def calibrate_imu(self):
"""
"""
# Reset calibration params
self.x_gyro_calibration = 0
self.y_gyro_calibration = 0
self.z_gyro_calibration = 0
self.roll_calibration = 0
self.pitch_calibration = 0
self.yaw_calibration = 0
sum_xg = 0
sum_yg = 0
sum_zg = 0
sum_xa = 0
sum_ya = 0
sum_za = 0
sum_roll = 0
sum_pitch = 0
sum_yaw = 0
num_calibrations = 1000
print("Calibrating Gyroscope and Accelerometer...\n")
for i in range(num_calibrations):
""" GYRO/ACC CALIBRATION
"""
self.read_imu()
sum_xg += self.imu_data[0]
sum_yg += self.imu_data[1]
sum_zg += self.imu_data[2]
sum_xa += self.imu_data[3]
sum_ya += self.imu_data[4]
sum_za += self.imu_data[5]
# Y,Z accelerations make up roll
sum_roll += (math.atan2(self.imu_data[3],
self.imu_data[5])) * 180.0 / np.pi
# X,Z accelerations make up pitch
sum_pitch += (math.atan2(self.imu_data[4],
self.imu_data[5])) * 180.0 / np.pi
# # Y, X accelerations make up yaw
# sum_yaw += (math.atan2(self.imu_data[7], self.imu_data[6]) *
# 180.0 / np.pi)
# Average values for calibration
self.x_gyro_calibration = sum_xg / float(num_calibrations)
self.y_gyro_calibration = sum_yg / float(num_calibrations)
self.z_gyro_calibration = sum_zg / float(num_calibrations)
self.roll_calibration = sum_roll / float(num_calibrations)
self.pitch_calibration = sum_pitch / float(num_calibrations)
# self.yaw_calibration = sum_yaw / float(num_calibrations)
print("Gyroscope and Accelerometer calibrated!\n")
# magne_cal = input(
# "Calibrate Magnemometer [c] or Load Existing Calibration [l] ?")
# if magne_cal == "c":
# print("Calibrating Magnetometer...")
# self.calibrate_magnemometer()
# else:
# print("Loading Magnetometer Calibration...")
# self.load_magnemometer_calibration()
# input(
# "Put the robot at its zero-yaw position and press Enter to calibrate Yaw"
# )
# self.read_imu()
# self.yaw_bias = (math.atan2(self.imu_data[7], self.imu_data[6]) *
# 180.0 / np.pi)
# print("Recorded Bias: {}".format(self.yaw_bias))
# input("Enter To Start")
def load_magnemometer_calibration(self):
return True
def calibrate_magnemometer(self):
# Get 10 seconds of magnemometer data
collection_time = 10.0
# Hard Iron Offset
mag_x_max = -32767
mag_x_min = 32767
mag_y_max = -32767
mag_y_min = 32767
mag_z_max = -32767
mag_z_min = 32767
input("Press Enter to start data collection for " +
str(collection_time) + " seconds:")
start_time = time.time()
elapsed_time = time.time() - start_time
while elapsed_time < collection_time:
elapsed_time = time.time() - start_time
self.read_imu()
# Set Max/Min for x
if self.imu_data[6] > mag_x_max:
mag_x_max = self.imu_data[6]
if self.imu_data[6] < mag_x_min:
mag_x_min = self.imu_data[6]
# Set Max/Min for y
if self.imu_data[7] > mag_y_max:
mag_y_max = self.imu_data[7]
if self.imu_data[7] < mag_y_min:
mag_y_min = self.imu_data[6]
# Set Max/Min for z
if self.imu_data[8] > mag_z_max:
mag_z_max = self.imu_data[8]
if self.imu_data[8] < mag_z_min:
mag_z_min = self.imu_data[8]
# Get Hard Iron Correction
self.mag_x_bias = (mag_x_max + mag_x_min) / 2.0
self.mag_y_bias = (mag_y_max + mag_y_min) / 2.0
self.mag_z_bias = (mag_z_max + mag_z_min) / 2.0
# Soft Iron Distortion - SCALE BIASES METHOD
# https://appelsiini.net/2018/calibrate-magnetometer/
# NOTE: Can also do Matrix Method
mag_x_delta = (mag_x_max - mag_x_min) / 2.0
mag_y_delta = (mag_y_max - mag_y_min) / 2.0
mag_z_delta = (mag_z_max - mag_z_min) / 2.0
avg_delta = (mag_x_delta + mag_y_delta + mag_z_delta) / 3.0
self.scale_x = avg_delta / mag_x_delta
self.scale_y = avg_delta / mag_y_delta
self.scale_y = avg_delta / mag_z_delta
# NOW, FOR EACH AXIS: corrected_reading = (reading - bias) * scale
input("Press Enter to save results")
def read_imu(self):
"""
"""
accel_x, accel_y, accel_z = self.sensor.acceleration
mag_x, mag_y, mag_z = self.sensor.magnetic
gyro_x, gyro_y, gyro_z = self.sensor.gyro
# temp = self.sensor.temperature
# Populate imu data list
# Gyroscope Values (Degrees/sec)
self.imu_data[0] = gyro_x - self.x_gyro_calibration
self.imu_data[1] = gyro_y - self.y_gyro_calibration
self.imu_data[2] = gyro_z - self.z_gyro_calibration
# Accelerometer Values (m/s^2)
self.imu_data[3] = accel_x
self.imu_data[4] = accel_y
self.imu_data[5] = accel_z
# Magnemometer Values
self.imu_data[6] = (mag_x - self.mag_x_bias) * self.scale_x
self.imu_data[7] = (mag_y - self.mag_y_bias) * self.scale_y
self.imu_data[8] = (mag_z - self.mag_z_bias) * self.scale_z
def filter_rpy(self):
"""
"""
# Get Readings
self.read_imu()
# Get Current Time in seconds
current_time = time.time()
self.imu_diff = current_time - self.prev_time
# Set new previous time
self.prev_time = current_time
# Catch rollovers
if self.imu_diff < 0:
self.imu_diff = 0
# Complementary filter for RPY
# TODO: DOUBLE CHECK THIS!!!!!!!
roll_gyro_delta = self.imu_data[1] * self.imu_diff
pitch_gyro_delta = self.imu_data[0] * self.imu_diff
yaw_gyro_delta = self.imu_data[2] * self.imu_diff
self.roll_int += roll_gyro_delta
self.pitch_int += pitch_gyro_delta
self.yaw_int += yaw_gyro_delta
# RPY from Accelerometer
# Y,Z accelerations make up roll
roll_a = (math.atan2(self.imu_data[3], self.imu_data[5])
) * 180.0 / np.pi - self.roll_calibration
# X,Z accelerations make up pitch
pitch_a = (math.atan2(self.imu_data[4], self.imu_data[5])
) * 180.0 / np.pi - self.pitch_calibration
# Y, X Magnetometer data makes up yaw
yaw_m = (math.atan2(self.imu_data[7], self.imu_data[6]) * 180.0 /
np.pi)
# Calculate Filtered RPY
self.roll = roll_a * self.comp_filter + (1 - self.comp_filter) * (
roll_gyro_delta + self.roll)
self.pitch = pitch_a * self.comp_filter + (1 - self.comp_filter) * (
pitch_gyro_delta + self.pitch)
self.yaw = math.atan2(self.imu_data[7],
self.imu_data[6]) * 180.0 / np.pi
self.yaw = yaw_m - self.yaw_bias
# Wrap from -PI to PI
self.yaw -= 360.0 * math.floor((self.yaw + 180) / 360.0)
# self.yaw = yaw_m * self.comp_filter + (1 - self.comp_filter) * (
# pitch_gyro_delta + self.yaw)
# self.roll = roll_a
# self.pitch = pitch_a
# self.yaw = yaw_a
# Recenter Roll and Pitch for Right Handed Frame
self.recenter_rp()
def recenter_rp(self):
""" LSM9DS1 IMU does not adhere to right hand rule.
this function allows the user to specify which coordinate
frame standards to use by deciding when to flip and/or negate
Roll and Pitch in the class constructor.
"""
if self.rp_flip:
if self.r_neg:
self.true_roll = -self.pitch
else:
self.true_roll = self.pitch
if self.p_neg:
self.true_pitch = -self.roll
else:
self.true_pitch = self.roll
else:
if self.r_neg:
self.true_roll = -self.roll
else:
self.true_roll = self.roll
if self.p_neg:
self.true_pitch = -self.pitch
else:
self.true_pitch = self.pitch
if self.y_neg:
self.yaw = -self.yaw
if __name__ == "__main__":
imu = IMU()
while True:
imu.filter_rpy()
print("ROLL: {} \t PICH: {} \t YAW: {} \n".format(
imu.true_roll, imu.true_pitch, imu.yaw)) | 11,139 | Python | 33.596273 | 96 | 0.534429 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/setup.py | ## ! DO NOT MANUALLY INVOKE THIS setup.py, USE CATKIN INSTEAD
## Copies from http://docs.ros.org/melodic/api/catkin/html/howto/format2/installing_python.html and edited for our package
from distutils.core import setup
from catkin_pkg.python_setup import generate_distutils_setup
# fetch values from package.xml
setup_args = generate_distutils_setup(
packages=['mini_bullet', 'ars_lib'],
package_dir={'../mini_bullet/src': ''})
setup(**setup_args)
| 457 | Python | 37.166664 | 122 | 0.746171 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/src/spot_sm.cpp | /// \file
/// \brief Draws Each Obstacle in RViz using MarkerArrays
///
/// PARAMETERS:
/// PUBLISHES:
/// SUBSCRIBES:
/// FUNCTIONS:
#include <ros/ros.h>
#include <math.h>
#include <string>
#include <vector>
#include <mini_ros/spot.hpp>
#include <mini_ros/teleop.hpp>
#include "mini_ros/MiniCmd.h"
#include "std_srvs/Empty.h"
#include "std_msgs/Bool.h"
// Global Vars
spot::Spot spot_mini = spot::Spot();
bool teleop_flag = false;
bool motion_flag = false;
bool ESTOP = false;
// Init Time
ros::Time current_time;
ros::Time last_time;
void teleop_callback(const geometry_msgs::Twist &tw)
{
/// \brief cmd_vel subscriber callback. Records commanded twist
///
/// \param tw (geometry_msgs::Twist): the commanded linear and angular velocity
/**
* This function runs every time we get a geometry_msgs::Twist message on the "cmd_vel" topic.
* We generally use the const <message>ConstPtr &msg syntax to prevent our node from accidentally
* changing the message, in the case that another node is also listening to it.
*/
spot_mini.update_command(tw.linear.x, tw.linear.y, tw.linear.z, tw.angular.z, tw.angular.x, tw.angular.y);
}
void estop_callback(const std_msgs::Bool &estop)
{
if (estop.data)
{
spot_mini.update_command(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
motion_flag = true;
if (!ESTOP)
{
ROS_ERROR("ENGAGING MANUAL E-STOP!");
ESTOP = true;
} else
{
ROS_WARN("DIS-ENGAGING MANUAL E-STOP!");
ESTOP = false;
}
}
last_time = ros::Time::now();
}
bool swm_callback(std_srvs::Empty::Request&, std_srvs::Empty::Response&)
/// Switches the Movement mode from FB (Forward/Backward) to LR (Left/Right)
/// and vice versa
{
spot_mini.switch_movement();
motion_flag = true;
return true;
}
int main(int argc, char** argv)
/// The Main Function ///
{
ROS_INFO("STARTING NODE: spot_mini State Machine");
// Vars
double frequency = 5;
// Seconds for timeout
double timeout = 1.0;
ros::init(argc, argv, "mini_sm_node"); // register the node on ROS
ros::NodeHandle nh; // get a handle to ROS
ros::NodeHandle nh_("~"); // get a handle to ROS
// Parameters
nh_.getParam("frequency", frequency);
// Init Subscriber
ros::Subscriber teleop_sub = nh.subscribe("teleop", 1, teleop_callback);
ros::Subscriber estop_sub = nh.subscribe("estop", 1, estop_callback);
// Init Command Publisher
ros::Publisher mini_pub = nh.advertise<mini_ros::MiniCmd>("mini_cmd", 1);
// Init Switch Movement Service Server
ros::ServiceServer switch_movement_server = nh.advertiseService("switch_movement", swm_callback);
// Init MiniCmd
mini_ros::MiniCmd mini_cmd;
// Placeholder
mini_cmd.x_velocity = 0.0;
mini_cmd.y_velocity = 0.0;
mini_cmd.rate = 0.0;
mini_cmd.roll = 0.0;
mini_cmd.pitch = 0.0;
mini_cmd.yaw = 0.0;
mini_cmd.z = 0.0;
mini_cmd.faster = 0.0;
mini_cmd.slower = 0.0;
mini_cmd.motion = "Stop";
mini_cmd.movement = "Stepping";
ros::Rate rate(frequency);
current_time = ros::Time::now();
last_time = ros::Time::now();
// Main While
while (ros::ok())
{
ros::spinOnce();
current_time = ros::Time::now();
spot::SpotCommand cmd = spot_mini.return_command();
// Condition for sending non-stop command
if (!motion_flag and !(current_time.toSec() - last_time.toSec() > timeout) and !ESTOP)
{
mini_cmd.x_velocity = cmd.x_velocity;
mini_cmd.y_velocity = cmd.y_velocity;
mini_cmd.rate = cmd.rate;
mini_cmd.roll = cmd.roll;
mini_cmd.pitch = cmd.pitch;
mini_cmd.yaw = cmd.yaw;
mini_cmd.z = cmd.z;
mini_cmd.faster = cmd.faster;
mini_cmd.slower = cmd.slower;
// Now convert enum to string
// Motion
if (cmd.motion == spot::Go)
{
mini_cmd.motion = "Go";
} else
{
mini_cmd.motion = "Stop";
}
// Movement
if (cmd.movement == spot::Stepping)
{
mini_cmd.movement = "Stepping";
} else
{
mini_cmd.movement = "Viewing";
}
} else
{
mini_cmd.x_velocity = 0.0;
mini_cmd.y_velocity = 0.0;
mini_cmd.rate = 0.0;
mini_cmd.roll = 0.0;
mini_cmd.pitch = 0.0;
mini_cmd.yaw = 0.0;
mini_cmd.z = 0.0;
mini_cmd.faster = 0.0;
mini_cmd.slower = 0.0;
mini_cmd.motion = "Stop";
}
if (current_time.toSec() - last_time.toSec() > timeout)
{
ROS_ERROR("TIMEOUT...ENGAGING E-STOP!");
}
// Now publish
mini_pub.publish(mini_cmd);
motion_flag = false;
rate.sleep();
}
return 0;
} | 4,882 | C++ | 25.538043 | 108 | 0.579271 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/src/teleop_node.cpp | /// \file
/// \brief Draws Each Obstacle in RViz using MarkerArrays
///
/// PARAMETERS:
/// PUBLISHES:
/// SUBSCRIBES:
/// FUNCTIONS:
#include <ros/ros.h>
#include <math.h>
#include <string>
#include <vector>
#include <mini_ros/spot.hpp>
#include <mini_ros/teleop.hpp>
#include "mini_ros/MiniCmd.h"
#include "std_msgs/Bool.h"
#include "std_srvs/Empty.h"
#include "mini_ros/JoyButtons.h"
#include <functional> // To use std::bind
int main(int argc, char** argv)
/// The Main Function ///
{
ROS_INFO("STARTING NODE: Teleoperation");
// Vars
double frequency = 60;
int linear_x = 4;
int linear_y = 3;
int linear_z = 1;
int angular = 0;
int sw = 0;
int es = 1;
int RB = 5;
int LB = 2;
int RT = 5;
int LT = 4;
int UD = 7;
int LR = 6;
double l_scale = 1.0;
double a_scale = 1.0;
double B_scale = 1.0;
double debounce_thresh = 0.15; // sec
ros::init(argc, argv, "teleop_node"); // register the node on ROS
ros::NodeHandle nh; // get a handle to ROS
ros::NodeHandle nh_("~"); // get a handle to ROS
// Parameters
nh_.getParam("frequency", frequency);
nh_.getParam("axis_linear_x", linear_x);
nh_.getParam("axis_linear_y", linear_y);
nh_.getParam("axis_linear_z", linear_z);
nh_.getParam("axis_angular", angular);
nh_.getParam("scale_linear", l_scale);
nh_.getParam("scale_angular", a_scale);
nh_.getParam("scale_bumper", B_scale);
nh_.getParam("button_switch", sw);
nh_.getParam("button_estop", es);
nh_.getParam("rb", RB);
nh_.getParam("lb", LB);
nh_.getParam("rt", RT);
nh_.getParam("lt", LT);
nh_.getParam("updown", UD);
nh_.getParam("leftright", LR);
nh_.getParam("debounce_thresh", debounce_thresh);
tele::Teleop teleop = tele::Teleop(linear_x, linear_y, linear_z, angular,
l_scale, a_scale, LB, RB, B_scale, LT,
RT, UD, LR, sw, es);
// Init Switch Movement Server
ros::ServiceClient switch_movement_client = nh.serviceClient<std_srvs::Empty>("switch_movement");
ros::service::waitForService("switch_movement", -1);
// Init ESTOP Publisher
ros::Publisher estop_pub = nh.advertise<std_msgs::Bool>("estop", 1);
// Init Command Publisher
ros::Publisher vel_pub = nh.advertise<geometry_msgs::Twist>("teleop", 1);
// Init Joy Button Publisher
ros::Publisher jb_pub = nh.advertise<mini_ros::JoyButtons>("joybuttons", 1);
// Init Subscriber (also handles pub)
// TODO: Figure out how to use std::bind properly
// ros::Subscriber joy_sub = nh.subscribe<sensor_msgs::Joy>("joy", 1, std::bind(&tele::Teleop::joyCallback, std::placeholders::_1, vel_pub), &teleop);
ros::Subscriber joy_sub = nh.subscribe<sensor_msgs::Joy>("joy", 1, &tele::Teleop::joyCallback, &teleop);
ros::Rate rate(frequency);
// Record time for debouncing buttons
ros::Time current_time = ros::Time::now();
ros::Time last_time = ros::Time::now();
// Main While
while (ros::ok())
{
ros::spinOnce();
current_time = ros::Time::now();
std_msgs::Bool estop;
estop.data = teleop.return_estop();
if (estop.data and current_time.toSec() - last_time.toSec() >= debounce_thresh)
{
ROS_INFO("SENDING E-STOP COMMAND!");
last_time = ros::Time::now();
} else if (!teleop.return_trigger())
{
// Send Twist
vel_pub.publish(teleop.return_twist());
estop.data = 0;
} else if (current_time.toSec() - last_time.toSec() >= debounce_thresh)
{
// Call Switch Service
std_srvs::Empty e;
switch_movement_client.call(e);
estop.data = 0;
last_time = ros::Time::now();
}
// pub buttons
jb_pub.publish(teleop.return_buttons());
estop_pub.publish(estop);
rate.sleep();
}
return 0;
} | 4,002 | C++ | 28.873134 | 154 | 0.582459 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/src/mini_ros/teleop.cpp | #include "mini_ros/teleop.hpp"
namespace tele
{
Teleop::Teleop(const int & linear_x, const int & linear_y, const int & linear_z,
const int & angular, const double & l_scale, const double & a_scale,
const int & LB, const int & RB, const int & B_scale, const int & LT,
const int & RT, const int & UD, const int & LR,
const int & sw, const int & es)
{
// step length or pitch
linear_x_ = linear_x;
// lateral fraction or roll
linear_y_ = linear_y;
// height
linear_z_ = linear_z;
// yaw rate or yaw
angular_ = angular;
// scale linear axis (usually just 1)
l_scale_ = l_scale;
// scale angular axis (usually just 1)
a_scale_ = a_scale;
// for incrementing and decrementing step velocity
// Bottom Bumpers
RB_ = RB;
LB_ = LB;
// scale Bottom Trigger axis (usually just 1)
B_scale_ = B_scale;
// Top Bumpers
RT_ = RT;
LT_ = LT;
// Switch between Stepping and Viewing
sw_ = sw;
// E-STOP
es_ = es;
// Arrow PAd
UD_ = UD;
LR_ = LR;
switch_trigger = false;
ESTOP = false;
updown = 0;
leftright = 0;
left_bump = false;
right_bump = false;
}
void Teleop::joyCallback(const sensor_msgs::Joy::ConstPtr& joy)
{
twist.linear.x = l_scale_*joy->axes[linear_x_];
twist.linear.y = l_scale_*joy->axes[linear_y_];
// NOTE: used to control robot height
twist.linear.z = -l_scale_*joy->axes[linear_z_];
twist.angular.z = a_scale_*joy->axes[angular_];
// NOTE: bottom bumpers used for changing step velocity
twist.angular.x = B_scale_*joy->axes[RB_];
twist.angular.y = B_scale_*joy->axes[LB_];
// Switch Trigger: Button A
switch_trigger = joy->buttons[sw_];
// ESTOP: Button B
ESTOP = joy->buttons[es_];
// Arrow Pad
updown = joy->axes[UD_];
leftright = -joy->axes[LR_];
// Top Bumpers
left_bump = joy->buttons[LT_];
right_bump = joy->buttons[RT_];
}
geometry_msgs::Twist Teleop::return_twist()
{
return twist;
}
bool Teleop::return_trigger()
{
return switch_trigger;
}
bool Teleop::return_estop()
{
return ESTOP;
}
mini_ros::JoyButtons Teleop::return_buttons()
{
mini_ros::JoyButtons jb;
jb.updown = updown;
jb.leftright = leftright;
jb.left_bump = left_bump;
jb.right_bump = right_bump;
return jb;
}
} | 2,308 | C++ | 21.637255 | 84 | 0.612218 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/src/mini_ros/spot.cpp | #include "mini_ros/spot.hpp"
namespace spot
{
// Spot Constructor
Spot::Spot()
{
cmd.x_velocity = 0.0;
cmd.y_velocity = 0.0;
cmd.rate = 0.0;
cmd.roll = 0.0;
cmd.pitch = 0.0;
cmd.yaw = 0.0;
cmd.z = 0.0;
cmd.motion = Stop;
cmd.movement = Viewing;
}
void Spot::update_command(const double & vx, const double & vy, const double & z,
const double & w, const double & wx, const double & wy)
{
// If Command is nearly zero, just give zero
if (almost_equal(vx, 0.0) and almost_equal(vy, 0.0) and almost_equal(z, 0.0) and almost_equal(w, 0.0))
{
cmd.motion = Stop;
cmd.x_velocity = 0.0;
cmd.y_velocity = 0.0;
cmd.rate = 0.0;
cmd.roll = 0.0;
cmd.pitch = 0.0;
cmd.yaw = 0.0;
cmd.z = 0.0;
cmd.faster = 0.0;
cmd.slower = 0.0;
} else
{
cmd.motion = Go;
if (cmd.movement == Stepping)
{
// Stepping Mode, use commands as vx, vy, rate, Z
cmd.x_velocity = vx;
cmd.y_velocity = vy;
cmd.rate = w;
cmd.z = z;
cmd.roll = 0.0;
cmd.pitch = 0.0;
cmd.yaw = 0.0;
// change clearance height from +- 0-2 * scaling
cmd.faster = 1.0 - wx;
cmd.slower = -(1.0 - wy);
} else
{
// Viewing Mode, use commands as RPY, Z
cmd.x_velocity = 0.0;
cmd.y_velocity = 0.0;
cmd.rate = 0.0;
cmd.roll = vy;
cmd.pitch = vx;
cmd.yaw = w;
cmd.z = z;
cmd.faster = 0.0;
cmd.slower = 0.0;
}
}
}
void Spot::switch_movement()
{
if (!almost_equal(cmd.x_velocity, 0.0) and !almost_equal(cmd.y_velocity, 0.0) and !almost_equal(cmd.rate, 0.0))
{
ROS_WARN("MAKE SURE BOTH LINEAR [%.2f, %.2f] AND ANGULAR VELOCITY [%.2f] ARE AT 0.0 BEFORE SWITCHING!", cmd.x_velocity, cmd.y_velocity, cmd.rate);
ROS_WARN("STOPPING ROBOT...");
cmd.motion = Stop;
cmd.x_velocity = 0.0;
cmd.y_velocity = 0.0;
cmd.rate = 0.0;
cmd.roll = 0.0;
cmd.pitch = 0.0;
cmd.yaw = 0.0;
cmd.z = 0.0;
cmd.faster = 0.0;
cmd.slower = 0.0;
} else
{
cmd.x_velocity = 0.0;
cmd.y_velocity = 0.0;
cmd.rate = 0.0;
cmd.roll = 0.0;
cmd.pitch = 0.0;
cmd.yaw = 0.0;
cmd.z = 0.0;
cmd.faster = 0.0;
cmd.slower = 0.0;
if (cmd.movement == Viewing)
{
ROS_INFO("SWITCHING TO STEPPING MOTION, COMMANDS NOW MAPPED TO VX|VY|W|Z.");
cmd.movement = Stepping;
cmd.motion = Stop;
} else
{
ROS_INFO("SWITCHING TO VIEWING MOTION, COMMANDS NOW MAPPED TO R|P|Y|Z.");
cmd.movement = Viewing;
cmd.motion = Stop;
}
}
}
SpotCommand Spot::return_command()
{
return cmd;
}
} | 2,725 | C++ | 22.101695 | 149 | 0.52844 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/include/mini_ros/teleop.hpp | #ifndef TELEOP_INCLUDE_GUARD_HPP
#define TELEOP_INCLUDE_GUARD_HPP
/// \file
/// \brief Teleoperation Library that converts Joystick commands to motion
#include <vector>
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <sensor_msgs/Joy.h>
#include "mini_ros/JoyButtons.h"
namespace tele
{
// \brief Teleop class responsible for convertick Joystick commands into linear and angular velocity
class Teleop
{
public:
// \brief Teleop constructor that defines the axes used for control and sets their scaling factor
// \param linear_x: joystick axis assigned to linear velocity (x)
// \param linear_y: joystick axis assigned to linear velocity (y)
// \param linear_z: joystick axis assigned to robot height [overloading]
// \param angular: joystick axis assigned to angular velocity
// \param l_scale: scaling factor for linear velocity
// \param a_scale: scaling factor for angular velocity
// \param LB: left bottom bumper axis
// \param RB: right bottom bumper axis
// \param B_scale: scaling factor for bottom bumpers
// \param LT: left top bumper button
// \param RT: right top bumper button
// \param UD: up/down key on arrow pad
// \param LR: left/right key on arrow pad
// \param sw: button for switch_trigger
// \param es: button for ESTOP
Teleop(const int & linear_x, const int & linear_y, const int & linear_z,
const int & angular, const double & l_scale, const double & a_scale,
const int & LB, const int & RB, const int & B_scale, const int & LT,
const int & RT, const int & UD, const int & LR,
const int & sw, const int & es);
// \brief Takes a Joy messages and converts it to linear and angular velocity (Twist)
// \param joy: sensor_msgs describing Joystick inputs
void joyCallback(const sensor_msgs::Joy::ConstPtr& joy);
// \brief returns the most recently commanded Twist
// \returns: Twist
geometry_msgs::Twist return_twist();
// \brief returns a boolean indicating whether the movement switch trigger has been pressed
// \returns: switch_trigger(bool)
bool return_trigger();
// \brief returns whether the E-STOP has been pressed
// \returns: ESTOP(bool)
bool return_estop();
/// \brief returns other joystick buttons triggers, arrow pad etc)
mini_ros::JoyButtons return_buttons();
private:
// AXES ON JOYSTICK
int linear_x_ = 0;
int linear_y_ = 0;
int linear_z_ = 0;
int angular_= 0;
int RB_ = 0;
int LB_ = 0;
// BUTTONS ON JOYSTICK
int sw_ = 0;
int es_ = 0;
int RT_ = 0;
int LT_ = 0;
int UD_ = 0;
int LR_ = 0;
// AXIS SCALES
double l_scale_, a_scale_, B_scale_;
// TWIST
geometry_msgs::Twist twist;
// TRIGGERS
bool switch_trigger = false;
bool ESTOP = false;
int updown = 0;
int leftright = 0;
bool left_bump = false;
bool right_bump = false;
};
}
#endif
| 3,232 | C++ | 34.922222 | 105 | 0.601176 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/include/mini_ros/spot.hpp | #ifndef SPOT_INCLUDE_GUARD_HPP
#define SPOT_INCLUDE_GUARD_HPP
/// \file
/// \brief Spots library which contains control functionality for Spot Mini Mini.
#include <vector>
#include <ros/ros.h>
namespace spot
{
/// \brief approximately compare two floating-point numbers using
/// an absolute comparison
/// \param d1 - a number to compare
/// \param d2 - a second number to compare
/// \param epsilon - absolute threshold required for equality
/// \return true if abs(d1 - d2) < epsilon
/// Note: the fabs function in <cmath> (c++ equivalent of math.h) will
/// be useful here
// constexpr are all define in .hpp
// constexpr allows fcn to be run at compile time and interface with
// static_assert tests.
// Note high default epsilon since using controller
constexpr bool almost_equal(double d1, double d2, double epsilon=1.0e-1)
{
if (fabs(d1 - d2) < epsilon)
{
return true;
} else {
return false;
}
}
enum Motion {Go, Stop};
enum Movement {Stepping, Viewing};
// \brief Struct to store the commanded type of motion, velocity and rate
struct SpotCommand
{
Motion motion = Stop;
Movement movement = Viewing;
double x_velocity = 0.0;
double y_velocity = 0.0;
double rate = 0.0;
double roll = 0.0;
double pitch = 0.0;
double yaw = 0.0;
double z = 0.0;
double faster = 0.0;
double slower = 0.0;
};
// \brief Spot class responsible for high-level motion commands
class Spot
{
public:
// \brief Constructor for Spot class
Spot();
// \brief updates the type and velocity of motion to be commanded to the Spot
// \param vx: linear velocity (x)
// \param vy: linear velocity (y)
// \param z: robot height
// \param w: angular velocity
// \param wx: step height increase
// \param wy: step height decrease
void update_command(const double & vx, const double & vy, const double & z,
const double & w, const double & wx, const double & wy);
// \brief changes the commanded motion from Forward/Backward to Left/Right or vice-versa
void switch_movement();
// \brief returns the Spot's current command (Motion, v,w) for external use
// \returns SpotCommand
SpotCommand return_command();
private:
SpotCommand cmd;
};
}
#endif
| 2,544 | C++ | 29.297619 | 96 | 0.600236 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/config/policy_params.yaml | # AGENT PARAMS - SCALING and FILTERING
# Clearance Height and Penetration Depth
CD_SCALE: 0.05
# Step Length and Velocity
SLV_SCALE: 0.05
# Residuals
RESIDUALS_SCALE: 0.015
# Body Height Modulation
Z_SCALE: 0.035
# Exponential Filter Amplitude
alpha: 0.7
# Added this to avoid filtering residuals
# -1 for all
actions_to_filter: 14 | 331 | YAML | 22.714284 | 41 | 0.767372 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/config/control.yaml | spot:
joint_states_controller:
type: joint_state_controller/JointStateController
publish_rate: 50
joint_group_position_controller:
type: effort_controllers/JointTrajectoryController
joints:
- motor_front_left_hip
- motor_front_left_upper_leg
- motor_front_left_lower_leg
- motor_front_right_hip
- motor_front_right_upper_leg
- motor_front_right_lower_leg
- motor_back_left_hip
- motor_back_left_upper_leg
- motor_back_left_lower_leg
- motor_back_right_hip
- motor_back_right_upper_leg
- motor_back_right_lower_leg
gains:
motor_front_left_hip : {p: 180, d: 0.9, i: 20}
motor_front_left_upper_leg : {p: 180, d: 0.9, i: 20}
motor_front_left_lower_leg : {p: 180, d: 0.9, i: 20}
motor_front_right_hip : {p: 180, d: 0.9, i: 20}
motor_front_right_upper_leg : {p: 180, d: 0.9, i: 20}
motor_front_right_lower_leg : {p: 180, d: 0.9, i: 20}
motor_back_left_hip : {p: 180, d: 0.9, i: 20}
motor_back_left_upper_leg : {p: 180, d: 0.9, i: 20}
motor_back_left_lower_leg : {p: 180, d: 0.9, i: 20}
motor_back_right_hip : {p: 180, d: 0.9, i: 20}
motor_back_right_upper_leg : {p: 180, d: 0.9, i: 20}
motor_back_right_lower_leg : {p: 180, d: 0.9, i: 20} | 1,420 | YAML | 40.794116 | 61 | 0.545775 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/config/joy_params.yaml | # Right Joystick (Push U/D L/R)
STEPLENGTH_SCALE: 0.05
# Left Joystick (Push U/D)
Z_SCALE_CTRL: 0.15
# Right Joystick (Push U/D L/R) | Left Joystick (Push L/R)
RPY_SCALE: 0.785
# Lower Bumpers (Step Velocity [Left Lowers | Right Raises])
SV_SCALE: 0.05
# Arrow Pad (U/D for Clearance Height | L/R for Penetration Depth)
CHPD_SCALE: 0.0005
# Left Joystick (L/R)
YAW_SCALE: 1.25 | 376 | YAML | 30.416664 | 66 | 0.702128 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/mini_ros/config/spot_params.yaml | # MEASURE
# COM to Shoulder
shoulder_length: 0.055
# Shoulder to Elbow
elbow_length: 0.10652
# Elbow to Wrist
wrist_length: 0.145
# Forward Hip Separation
hip_x: 0.23
# Lateral Hip Separation
hip_y: 0.075
# ADJUSTABLE
# Stance Length
foot_x: 0.23
# Stance Width
foot_y: 0.185
# Stance Height
height: 0.20
# Adjust for balanced walk
com_offset: 0.0
# Time Step
dt: 0.001
# Swing Period (lower is faster)
Tswing: 0.2
SwingPeriod_LIMITS: [0.1, 0.3]
# Step Velocity (Using very low value as my main form of speed control is swing period)
BaseStepVelocity: 0.001
# Foot Clearance Height
BaseClearanceHeight: 0.035
ClearanceHeight_LIMITS: [0.0, 0.04]
# Foot Penetration Depth
BasePenetrationDepth: 0.003
PenetrationDepth_LIMITS: [0.0, 0.02] | 740 | YAML | 18 | 87 | 0.741892 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/spot.py | """
CODE BASED ON EXAMPLE FROM:
@misc{coumans2017pybullet,
title={Pybullet, a python module for physics simulation in robotics, games and machine learning},
author={Coumans, Erwin and Bai, Yunfei},
url={www.pybullet.org},
year={2017},
}
Example: minitaur.py
https://github.com/bulletphysics/bullet3/blob/master/examples/pybullet/gym/pybullet_envs/bullet/minitaur.py
"""
import collections
import copy
import math
import re
import numpy as np
from . import motor
from spotmicro.util import pybullet_data
print(pybullet_data.getDataPath())
from spotmicro.Kinematics.SpotKinematics import SpotModel
import spotmicro.Kinematics.LieAlgebra as LA
INIT_POSITION = [0, 0, 0.25]
INIT_RACK_POSITION = [0, 0, 1]
# NOTE: URDF IS FACING THE WRONG WAY
# TEMP FIX
INIT_ORIENTATION = [0, 0, 0, 1]
OVERHEAT_SHUTDOWN_TORQUE = 2.45
OVERHEAT_SHUTDOWN_TIME = 1.0
# -math.pi / 5
INIT_LEG_POS = -0.658319
# math.pi / 3
INIT_FOOT_POS = 1.0472
OLD_LEG_POSITION = ["front_left", "front_right", "rear_left", "rear_right"]
OLD_MOTOR_NAMES = [
"motor_front_left_shoulder", "motor_front_left_leg",
"foot_motor_front_left", "motor_front_right_shoulder",
"motor_front_right_leg", "foot_motor_front_right",
"motor_rear_left_shoulder", "motor_rear_left_leg", "foot_motor_rear_left",
"motor_rear_right_shoulder", "motor_rear_right_leg",
"foot_motor_rear_right"
]
OLD_MOTOR_LIMITS_BY_NAME = {}
for name in OLD_MOTOR_NAMES:
if "shoulder" in name:
OLD_MOTOR_LIMITS_BY_NAME[name] = [-1.04, 1.04]
elif "leg" in name:
OLD_MOTOR_LIMITS_BY_NAME[name] = [-2.59, 1.571]
elif "foot" in name:
OLD_MOTOR_LIMITS_BY_NAME[name] = [-1.571, 2.9]
OLD_FOOT_NAMES = [
"front_left_toe", "front_right_toe", "rear_left_toe", "rear_right_toe"
]
LEG_POSITION = ["front_left", "front_right", "back_left", "back_right"]
MOTOR_NAMES = [
"motor_front_left_hip", "motor_front_left_upper_leg",
"motor_front_left_lower_leg", "motor_front_right_hip",
"motor_front_right_upper_leg", "motor_front_right_lower_leg",
"motor_back_left_hip", "motor_back_left_upper_leg",
"motor_back_left_lower_leg", "motor_back_right_hip",
"motor_back_right_upper_leg", "motor_back_right_lower_leg"
]
MOTOR_LIMITS_BY_NAME = {}
for name in MOTOR_NAMES:
if "hip" in name:
MOTOR_LIMITS_BY_NAME[name] = [-1.04, 1.04]
elif "upper_leg" in name:
MOTOR_LIMITS_BY_NAME[name] = [-1.571, 2.59]
elif "lower_leg" in name:
MOTOR_LIMITS_BY_NAME[name] = [-2.9, 1.671]
FOOT_NAMES = [
"front_left_leg_foot", "front_right_leg_foot", "back_left_leg_foot",
"back_right_leg_foot"
]
_CHASSIS_NAME_PATTERN = re.compile(r"chassis\D*")
_MOTOR_NAME_PATTERN = re.compile(r"motor\D*")
_FOOT_NAME_PATTERN = re.compile(r"foot\D*")
SENSOR_NOISE_STDDEV = (0.0, 0.0, 0.0, 0.0, 0.0)
TWO_PI = 2 * math.pi
def MapToMinusPiToPi(angles):
"""Maps a list of angles to [-pi, pi].
Args:
angles: A list of angles in rad.
Returns:
A list of angle mapped to [-pi, pi].
"""
mapped_angles = copy.deepcopy(angles)
for i in range(len(angles)):
mapped_angles[i] = math.fmod(angles[i], TWO_PI)
if mapped_angles[i] >= math.pi:
mapped_angles[i] -= TWO_PI
elif mapped_angles[i] < -math.pi:
mapped_angles[i] += TWO_PI
return mapped_angles
class Spot(object):
"""The spot class that simulates a quadruped robot.
"""
INIT_POSES = {
'stand':
np.array([
0.15192765, 0.7552236, -1.5104472, -0.15192765, 0.7552236,
-1.5104472, 0.15192765, 0.7552236, -1.5104472, -0.15192765,
0.7552236, -1.5104472
]),
'liedown':
np.array([-0.4, -1.5, 6, 0.4, -1.5, 6, -0.4, -1.5, 6, 0.4, -1.5, 6]),
'zero':
np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
}
def __init__(self,
pybullet_client,
urdf_root=pybullet_data.getDataPath(),
time_step=0.01,
action_repeat=1,
self_collision_enabled=False,
motor_velocity_limit=9.7,
pd_control_enabled=False,
accurate_motor_model_enabled=False,
remove_default_joint_damping=False,
max_force=100.0,
motor_kp=1.0,
motor_kd=0.02,
pd_latency=0.0,
control_latency=0.0,
observation_noise_stdev=SENSOR_NOISE_STDDEV,
torque_control_enabled=False,
motor_overheat_protection=False,
on_rack=False,
kd_for_pd_controllers=0.3,
pose_id='stand',
np_random=np.random,
contacts=True):
"""Constructs a spot and reset it to the initial states.
Args:
pybullet_client: The instance of BulletClient to manage different
simulations.
urdf_root: The path to the urdf folder.
time_step: The time step of the simulation.
action_repeat: The number of ApplyAction() for each control step.
self_collision_enabled: Whether to enable self collision.
motor_velocity_limit: The upper limit of the motor velocity.
pd_control_enabled: Whether to use PD control for the motors.
accurate_motor_model_enabled: Whether to use the accurate DC motor model.
remove_default_joint_damping: Whether to remove the default joint damping.
motor_kp: proportional gain for the accurate motor model.
motor_kd: derivative gain for the accurate motor model.
pd_latency: The latency of the observations (in seconds) used to calculate
PD control. On the real hardware, it is the latency between the
microcontroller and the motor controller.
control_latency: The latency of the observations (in second) used to
calculate action. On the real hardware, it is the latency from the motor
controller, the microcontroller to the host (Nvidia TX2).
observation_noise_stdev: The standard deviation of a Gaussian noise model
for the sensor. It should be an array for separate sensors in the
following order [motor_angle, motor_velocity, motor_torque,
base_roll_pitch_yaw, base_angular_velocity]
torque_control_enabled: Whether to use the torque control, if set to
False, pose control will be used.
motor_overheat_protection: Whether to shutdown the motor that has exerted
large torque (OVERHEAT_SHUTDOWN_TORQUE) for an extended amount of time
(OVERHEAT_SHUTDOWN_TIME). See ApplyAction() in spot.py for more
details.
on_rack: Whether to place the spot on rack. This is only used to debug
the walking gait. In this mode, the spot's base is hanged midair so
that its walking gait is clearer to visualize.
"""
# SPOT MODEL
self.spot = SpotModel()
# Whether to include contact sensing
self.contacts = contacts
# Control Inputs
self.StepLength = 0.0
self.StepVelocity = 0.0
self.LateralFraction = 0.0
self.YawRate = 0.0
# Leg Phases
self.LegPhases = [0.0, 0.0, 0.0, 0.0]
# used to calculate minitaur acceleration
self.init_leg = INIT_LEG_POS
self.init_foot = INIT_FOOT_POS
self.prev_ang_twist = np.array([0, 0, 0])
self.prev_lin_twist = np.array([0, 0, 0])
self.prev_lin_acc = np.array([0, 0, 0])
self.num_motors = 12
self.num_legs = int(self.num_motors / 3)
self._pybullet_client = pybullet_client
self._action_repeat = action_repeat
self._urdf_root = urdf_root
self._self_collision_enabled = self_collision_enabled
self._motor_velocity_limit = motor_velocity_limit
self._pd_control_enabled = pd_control_enabled
self._motor_direction = np.ones(self.num_motors)
self._observed_motor_torques = np.zeros(self.num_motors)
self._applied_motor_torques = np.zeros(self.num_motors)
self._max_force = max_force
self._pd_latency = pd_latency
self._control_latency = control_latency
self._observation_noise_stdev = observation_noise_stdev
self._accurate_motor_model_enabled = accurate_motor_model_enabled
self._remove_default_joint_damping = remove_default_joint_damping
self._observation_history = collections.deque(maxlen=100)
self._control_observation = []
self._chassis_link_ids = [-1]
self._leg_link_ids = []
self._motor_link_ids = []
self._foot_link_ids = []
self._torque_control_enabled = torque_control_enabled
self._motor_overheat_protection = motor_overheat_protection
self._on_rack = on_rack
self._pose_id = pose_id
self.np_random = np_random
if self._accurate_motor_model_enabled:
self._kp = motor_kp
self._kd = motor_kd
self._motor_model = motor.MotorModel(
torque_control_enabled=self._torque_control_enabled,
kp=self._kp,
kd=self._kd)
elif self._pd_control_enabled:
self._kp = 8
self._kd = kd_for_pd_controllers
else:
self._kp = 1
self._kd = 1
self.time_step = time_step
self._step_counter = 0
# reset_time=-1.0 means skipping the reset motion.
# See Reset for more details.
self.Reset(reset_time=-1)
self.init_on_rack_position = INIT_RACK_POSITION
self.init_position = INIT_POSITION
self.initial_pose = self.INIT_POSES[pose_id]
def _RecordMassInfoFromURDF(self):
self._base_mass_urdf = []
for chassis_id in self._chassis_link_ids:
self._base_mass_urdf.append(
self._pybullet_client.getDynamicsInfo(self.quadruped,
chassis_id)[0])
self._leg_masses_urdf = []
for leg_id in self._leg_link_ids:
self._leg_masses_urdf.append(
self._pybullet_client.getDynamicsInfo(self.quadruped,
leg_id)[0])
for motor_id in self._motor_link_ids:
self._leg_masses_urdf.append(
self._pybullet_client.getDynamicsInfo(self.quadruped,
motor_id)[0])
def GetBaseMassFromURDF(self):
"""Get the mass of the base from the URDF file."""
return self._base_mass_urdf
def SetBaseMass(self, base_mass):
for i in range(len(self._chassis_link_ids)):
self._pybullet_client.changeDynamics(self.quadruped,
self._chassis_link_ids[i],
mass=base_mass[i])
def _RecordInertiaInfoFromURDF(self):
"""Record the inertia of each body from URDF file."""
self._link_urdf = []
num_bodies = self._pybullet_client.getNumJoints(self.quadruped)
for body_id in range(-1, num_bodies): # -1 is for the base link.
inertia = self._pybullet_client.getDynamicsInfo(
self.quadruped, body_id)[2]
self._link_urdf.append(inertia)
# We need to use id+1 to index self._link_urdf because it has the base
# (index = -1) at the first element.
self._base_inertia_urdf = [
self._link_urdf[chassis_id + 1]
for chassis_id in self._chassis_link_ids
]
self._leg_inertia_urdf = [
self._link_urdf[leg_id + 1] for leg_id in self._leg_link_ids
]
self._leg_inertia_urdf.extend([
self._link_urdf[motor_id + 1] for motor_id in self._motor_link_ids
])
def _BuildJointNameToIdDict(self):
num_joints = self._pybullet_client.getNumJoints(self.quadruped)
self._joint_name_to_id = {}
for i in range(num_joints):
joint_info = self._pybullet_client.getJointInfo(self.quadruped, i)
self._joint_name_to_id[joint_info[1].decode(
"UTF-8")] = joint_info[0]
def _BuildMotorIdList(self):
self._motor_id_list = [
self._joint_name_to_id[motor_name] for motor_name in MOTOR_NAMES
]
def _BuildFootIdList(self):
self._foot_id_list = [
self._joint_name_to_id[foot_name] for foot_name in FOOT_NAMES
]
print(self._foot_id_list)
def _BuildUrdfIds(self):
"""Build the link Ids from its name in the URDF file."""
c = []
m = []
f = []
lg = []
num_joints = self._pybullet_client.getNumJoints(self.quadruped)
self._chassis_link_ids = [-1]
# the self._leg_link_ids include both the upper and lower links of the leg.
self._leg_link_ids = []
self._motor_link_ids = []
self._foot_link_ids = []
for i in range(num_joints):
joint_info = self._pybullet_client.getJointInfo(self.quadruped, i)
joint_name = joint_info[1].decode("UTF-8")
joint_id = self._joint_name_to_id[joint_name]
if _CHASSIS_NAME_PATTERN.match(joint_name):
c.append(joint_name)
self._chassis_link_ids.append(joint_id)
elif _MOTOR_NAME_PATTERN.match(joint_name):
m.append(joint_name)
self._motor_link_ids.append(joint_id)
elif _FOOT_NAME_PATTERN.match(joint_name):
f.append(joint_name)
self._foot_link_ids.append(joint_id)
else:
lg.append(joint_name)
self._leg_link_ids.append(joint_id)
self._leg_link_ids.extend(self._foot_link_ids)
self._chassis_link_ids.sort()
self._motor_link_ids.sort()
self._foot_link_ids.sort()
self._leg_link_ids.sort()
def Reset(self,
reload_urdf=True,
default_motor_angles=None,
reset_time=3.0):
"""Reset the spot to its initial states.
Args:
reload_urdf: Whether to reload the urdf file. If not, Reset() just place
the spot back to its starting position.
default_motor_angles: The default motor angles. If it is None, spot
will hold a default pose for 100 steps. In
torque control mode, the phase of holding the default pose is skipped.
reset_time: The duration (in seconds) to hold the default motor angles. If
reset_time <= 0 or in torque control mode, the phase of holding the
default pose is skipped.
"""
if self._on_rack:
init_position = INIT_RACK_POSITION
else:
init_position = INIT_POSITION
if reload_urdf:
if self._self_collision_enabled:
self.quadruped = self._pybullet_client.loadURDF(
pybullet_data.getDataPath() + "/assets/urdf/spot.urdf",
init_position,
useFixedBase=self._on_rack,
flags=self._pybullet_client.URDF_USE_SELF_COLLISION_EXCLUDE_PARENT)
else:
self.quadruped = self._pybullet_client.loadURDF(
pybullet_data.getDataPath() + "/assets/urdf/spot.urdf",
init_position,
INIT_ORIENTATION,
useFixedBase=self._on_rack)
self._BuildJointNameToIdDict()
self._BuildUrdfIds()
if self._remove_default_joint_damping:
self._RemoveDefaultJointDamping()
self._BuildMotorIdList()
self._BuildFootIdList()
self._RecordMassInfoFromURDF()
self._RecordInertiaInfoFromURDF()
self.ResetPose(add_constraint=True)
else:
self._pybullet_client.resetBasePositionAndOrientation(
self.quadruped, init_position, INIT_ORIENTATION)
self._pybullet_client.resetBaseVelocity(self.quadruped, [0, 0, 0],
[0, 0, 0])
# self._pybullet_client.changeDynamics(self.quadruped, -1, lateralFriction=0.8)
self.ResetPose(add_constraint=False)
self._overheat_counter = np.zeros(self.num_motors)
self._motor_enabled_list = [True] * self.num_motors
self._step_counter = 0
# Perform reset motion within reset_duration if in position control mode.
# Nothing is performed if in torque control mode for now.
self._observation_history.clear()
if reset_time > 0.0 and default_motor_angles is not None:
self.RealisticObservation()
for _ in range(100):
self.ApplyAction(self.initial_pose)
self._pybullet_client.stepSimulation()
self.RealisticObservation()
num_steps_to_reset = int(reset_time / self.time_step)
for _ in range(num_steps_to_reset):
self.ApplyAction(default_motor_angles)
self._pybullet_client.stepSimulation()
self.RealisticObservation()
self.RealisticObservation()
# Set Foot Friction
self.SetFootFriction()
def _RemoveDefaultJointDamping(self):
num_joints = self._pybullet_client.getNumJoints(self.quadruped)
for i in range(num_joints):
joint_info = self._pybullet_client.getJointInfo(self.quadruped, i)
self._pybullet_client.changeDynamics(joint_info[0],
-1,
linearDamping=0,
angularDamping=0)
def _SetMotorTorqueById(self, motor_id, torque):
self._pybullet_client.setJointMotorControl2(
bodyIndex=self.quadruped,
jointIndex=motor_id,
controlMode=self._pybullet_client.TORQUE_CONTROL,
force=torque)
def _SetDesiredMotorAngleById(self, motor_id, desired_angle):
if self._pd_control_enabled or self._accurate_motor_model_enabled:
self._pybullet_client.setJointMotorControl2(
bodyIndex=self.quadruped,
jointIndex=motor_id,
controlMode=self._pybullet_client.POSITION_CONTROL,
targetPosition=desired_angle,
positionGain=self._kp,
velocityGain=self._kd,
force=self._max_force)
# Pybullet has a 'perfect' joint controller with its default p,d
else:
self._pybullet_client.setJointMotorControl2(
bodyIndex=self.quadruped,
jointIndex=motor_id,
controlMode=self._pybullet_client.POSITION_CONTROL,
targetPosition=desired_angle)
def _SetDesiredMotorAngleByName(self, motor_name, desired_angle):
self._SetDesiredMotorAngleById(self._joint_name_to_id[motor_name],
desired_angle)
def ResetPose(self, add_constraint):
"""Reset the pose of the spot.
Args:
add_constraint: Whether to add a constraint at the joints of two feet.
"""
for i in range(self.num_legs):
self._ResetPoseForLeg(i, add_constraint)
def _ResetPoseForLeg(self, leg_id, add_constraint):
"""Reset the initial pose for the leg.
Args:
leg_id: It should be 0, 1, 2, or 3, which represents the leg at
front_left, back_left, front_right and back_right.
add_constraint: Whether to add a constraint at the joints of two feet.
"""
knee_friction_force = 0
pi = math.pi
leg_position = LEG_POSITION[leg_id]
self._pybullet_client.resetJointState(
self.quadruped,
self._joint_name_to_id["motor_" + leg_position + "_hip"],
self.INIT_POSES[self._pose_id][3 * leg_id],
targetVelocity=0)
self._pybullet_client.resetJointState(
self.quadruped,
self._joint_name_to_id["motor_" + leg_position + "_upper_leg"],
self.INIT_POSES[self._pose_id][3 * leg_id + 1],
targetVelocity=0)
self._pybullet_client.resetJointState(
self.quadruped,
self._joint_name_to_id["motor_" + leg_position + "_lower_leg"],
self.INIT_POSES[self._pose_id][3 * leg_id + 2],
targetVelocity=0)
if self._accurate_motor_model_enabled or self._pd_control_enabled:
# Disable the default motor in pybullet.
self._pybullet_client.setJointMotorControl2(
bodyIndex=self.quadruped,
jointIndex=(self._joint_name_to_id["motor_" + leg_position +
"_hip"]),
controlMode=self._pybullet_client.VELOCITY_CONTROL,
targetVelocity=0,
force=knee_friction_force)
self._pybullet_client.setJointMotorControl2(
bodyIndex=self.quadruped,
jointIndex=(self._joint_name_to_id["motor_" + leg_position +
"_upper_leg"]),
controlMode=self._pybullet_client.VELOCITY_CONTROL,
targetVelocity=0,
force=knee_friction_force)
self._pybullet_client.setJointMotorControl2(
bodyIndex=self.quadruped,
jointIndex=(self._joint_name_to_id["motor_" + leg_position +
"_lower_leg"]),
controlMode=self._pybullet_client.VELOCITY_CONTROL,
targetVelocity=0,
force=knee_friction_force)
def GetBasePosition(self):
"""Get the position of spot's base.
Returns:
The position of spot's base.
"""
position, _ = (self._pybullet_client.getBasePositionAndOrientation(
self.quadruped))
return position
def GetBaseOrientation(self):
"""Get the orientation of spot's base, represented as quaternion.
Returns:
The orientation of spot's base.
"""
_, orientation = (self._pybullet_client.getBasePositionAndOrientation(
self.quadruped))
return orientation
def GetBaseRollPitchYaw(self):
"""Get the rate of orientation change of the spot's base in euler angle.
Returns:
rate of (roll, pitch, yaw) change of the spot's base.
"""
vel = self._pybullet_client.getBaseVelocity(self.quadruped)
return np.asarray([vel[1][0], vel[1][1], vel[1][2]])
def GetBaseRollPitchYawRate(self):
"""Get the rate of orientation change of the spot's base in euler angle.
This function mimicks the noisy sensor reading and adds latency.
Returns:
rate of (roll, pitch, yaw) change of the spot's base polluted by noise
and latency.
"""
return self._AddSensorNoise(
np.array(self._control_observation[3 * self.num_motors +
4:3 * self.num_motors + 7]),
self._observation_noise_stdev[4])
def GetBaseTwist(self):
"""Get the Twist of minitaur's base.
Returns:
The Twist of the minitaur's base.
"""
return self._pybullet_client.getBaseVelocity(self.quadruped)
def GetActionDimension(self):
"""Get the length of the action list.
Returns:
The length of the action list.
"""
return self.num_motors
def GetObservationUpperBound(self):
"""Get the upper bound of the observation.
Returns:
The upper bound of an observation. See GetObservation() for the details
of each element of an observation.
NOTE: Changed just like GetObservation()
"""
upper_bound = np.array([0.0] * self.GetObservationDimension())
# roll, pitch
upper_bound[0:2] = 2.0 * np.pi
# acc, rate in x,y,z
upper_bound[2:8] = np.inf
# Leg Phases
upper_bound[8:12] = 2.0
# Contacts
if self.contacts:
upper_bound[12:] = 1.0
return upper_bound
def GetObservationLowerBound(self):
"""Get the lower bound of the observation."""
return -self.GetObservationUpperBound()
def GetObservationDimension(self):
"""Get the length of the observation list.
Returns:
The length of the observation list.
"""
return len(self.GetObservation())
def GetObservation(self):
"""Get the observations of minitaur.
It includes the angles, velocities, torques and the orientation of the base.
Returns:
The observation list. observation[0:8] are motor angles. observation[8:16]
are motor velocities, observation[16:24] are motor torques.
observation[24:28] is the orientation of the base, in quaternion form.
NOTE: DIVERGES FROM STOCK MINITAUR ENV. WILL LEAVE ORIGINAL COMMENTED
For my purpose, the observation space includes Roll and Pitch, as well as
acceleration and gyroscopic rate along the x,y,z axes. All of this
information can be collected from an onboard IMU. The reward function
will contain a hidden velocity reward (fwd, bwd) which cannot be measured
and so is not included. For spinning, the gyroscopic z rate will be used
as the (explicit) velocity reward.
This version operates without motor torques, angles and velocities. Erwin
Coumans' paper suggests a sparse observation space leads to higher reward
# NOTE: use True version for perfect data, or other for realistic data
"""
observation = []
# GETTING TWIST IN BODY FRAME
pos = self.GetBasePosition()
orn = self.GetBaseOrientation()
roll, pitch, yaw = self._pybullet_client.getEulerFromQuaternion(
[orn[0], orn[1], orn[2], orn[3]])
# rpy = LA.RPY(roll, pitch, yaw)
# R, _ = LA.TransToRp(rpy)
# T_wb = LA.RpToTrans(R, np.array([pos[0], pos[1], pos[2]]))
# T_bw = LA.TransInv(T_wb)
# Adj_Tbw = LA.Adjoint(T_bw)
# Get Linear and Angular Twist in WORLD FRAME
lin_twist, ang_twist = self.GetBaseTwist()
lin_twist = np.array([lin_twist[0], lin_twist[1], lin_twist[2]])
ang_twist = np.array([ang_twist[0], ang_twist[1], ang_twist[2]])
# Vw = np.concatenate((ang_twist, lin_twist))
# Vb = np.dot(Adj_Tbw, Vw)
# roll, pitch, _ = self._pybullet_client.getEulerFromQuaternion(
# [orn[0], orn[1], orn[2], orn[3]])
# # Get linear accelerations
# lin_twist = -Vb[3:]
# ang_twist = Vb[:3]
lin_acc = lin_twist - self.prev_lin_twist
if lin_acc.all() == 0.0:
lin_acc = self.prev_lin_acc
self.prev_lin_acc = lin_acc
# print("LIN TWIST: ", lin_twist)
self.prev_lin_twist = lin_twist
self.prev_ang_twist = ang_twist
# Get Contacts
CONTACT = list(self._pybullet_client.getContactPoints(self.quadruped))
FLC = 0
FRC = 0
BLC = 0
BRC = 0
if len(CONTACT) > 0:
for i in range(len(CONTACT)):
Contact_Link_Index = CONTACT[i][3]
if Contact_Link_Index == self._foot_id_list[0]:
FLC = 1
# print("FL CONTACT")
if Contact_Link_Index == self._foot_id_list[1]:
FRC = 1
# print("FR CONTACT")
if Contact_Link_Index == self._foot_id_list[2]:
BLC = 1
# print("BL CONTACT")
if Contact_Link_Index == self._foot_id_list[3]:
BRC = 1
# print("BR CONTACT")
# order: roll, pitch, gyro(x,y,z), acc(x, y, z)
observation.append(roll)
observation.append(pitch)
observation.extend(list(ang_twist))
observation.extend(list(lin_acc))
# Control Input
# observation.append(self.StepLength)
# observation.append(self.StepVelocity)
# observation.append(self.LateralFraction)
# observation.append(self.YawRate)
observation.extend(self.LegPhases)
if self.contacts:
observation.append(FLC)
observation.append(FRC)
observation.append(BLC)
observation.append(BRC)
# print("CONTACTS: {} {} {} {}".format(FLC, FRC, BLC, BRC))
return observation
def GetControlInput(self, controller):
""" Store Control Input as Observation
"""
_, _, StepLength, LateralFraction, YawRate, StepVelocity, _, _ = controller.return_bezier_params(
)
self.StepLength = StepLength
self.StepVelocity = StepVelocity
self.LateralFraction = LateralFraction
self.YawRate = YawRate
def GetLegPhases(self, TrajectoryGenerator):
""" Leg phases according to TG from 0->2
0->1: Stance
1->2 Swing
"""
self.LegPhases = TrajectoryGenerator.Phases
def GetExternalObservations(self, TrajectoryGenerator, controller):
""" Augment State Space
"""
self.GetControlInput(controller)
self.GetLegPhases(TrajectoryGenerator)
def ConvertFromLegModel(self, action):
# TODO
joint_angles = action
return joint_angles
def ApplyMotorLimits(self, joint_angles):
eps = 0.001
for i in range(len(joint_angles)):
LIM = MOTOR_LIMITS_BY_NAME[MOTOR_NAMES[i]]
joint_angles[i] = np.clip(joint_angles[i], LIM[0] + eps,
LIM[1] - eps)
return joint_angles
def ApplyAction(self, motor_commands):
"""Set the desired motor angles to the motors of the minitaur.
The desired motor angles are clipped based on the maximum allowed velocity.
If the pd_control_enabled is True, a torque is calculated according to
the difference between current and desired joint angle, as well as the joint
velocity. This torque is exerted to the motor. For more information about
PD control, please refer to: https://en.wikipedia.org/wiki/PID_controller.
Args:
motor_commands: The eight desired motor angles.
"""
# FIRST, APPLY MOTOR LIMITS:
motor_commands = self.ApplyMotorLimits(motor_commands)
if self._motor_velocity_limit < np.inf:
current_motor_angle = self.GetMotorAngles()
motor_commands_max = (current_motor_angle +
self.time_step * self._motor_velocity_limit)
motor_commands_min = (current_motor_angle -
self.time_step * self._motor_velocity_limit)
motor_commands = np.clip(motor_commands, motor_commands_min,
motor_commands_max)
if self._accurate_motor_model_enabled or self._pd_control_enabled:
q = self.GetMotorAngles()
qdot = self.GetMotorVelocities()
if self._accurate_motor_model_enabled:
actual_torque, observed_torque = self._motor_model.convert_to_torque(
motor_commands, q, qdot)
if self._motor_overheat_protection:
for i in range(self.num_motors):
if abs(actual_torque[i]) > OVERHEAT_SHUTDOWN_TORQUE:
self._overheat_counter[i] += 1
else:
self._overheat_counter[i] = 0
if (self._overheat_counter[i] >
OVERHEAT_SHUTDOWN_TIME / self.time_step):
self._motor_enabled_list[i] = False
# The torque is already in the observation space because we use
# GetMotorAngles and GetMotorVelocities.
self._observed_motor_torques = observed_torque
# Transform into the motor space when applying the torque.
self._applied_motor_torque = np.multiply(
actual_torque, self._motor_direction)
for motor_id, motor_torque, motor_enabled in zip(
self._motor_id_list, self._applied_motor_torque,
self._motor_enabled_list):
if motor_enabled:
self._SetMotorTorqueById(motor_id, motor_torque)
else:
self._SetMotorTorqueById(motor_id, 0)
else:
torque_commands = -self._kp * (
q - motor_commands) - self._kd * qdot
# The torque is already in the observation space because we use
# GetMotorAngles and GetMotorVelocities.
self._observed_motor_torques = torque_commands
# Transform into the motor space when applying the torque.
self._applied_motor_torques = np.multiply(
self._observed_motor_torques, self._motor_direction)
for motor_id, motor_torque in zip(self._motor_id_list,
self._applied_motor_torques):
self._SetMotorTorqueById(motor_id, motor_torque)
else:
motor_commands_with_direction = np.multiply(
motor_commands, self._motor_direction)
for motor_id, motor_command_with_direction in zip(
self._motor_id_list, motor_commands_with_direction):
self._SetDesiredMotorAngleById(motor_id,
motor_command_with_direction)
def Step(self, action):
for _ in range(self._action_repeat):
self.ApplyAction(action)
self._pybullet_client.stepSimulation()
self.RealisticObservation()
self._step_counter += 1
def GetTimeSinceReset(self):
return self._step_counter * self.time_step
def GetMotorAngles(self):
"""Gets the eight motor angles at the current moment, mapped to [-pi, pi].
Returns:
Motor angles, mapped to [-pi, pi].
"""
motor_angles = [
self._pybullet_client.getJointState(self.quadruped, motor_id)[0]
for motor_id in self._motor_id_list
]
motor_angles = np.multiply(motor_angles, self._motor_direction)
return MapToMinusPiToPi(motor_angles)
def GetMotorVelocities(self):
"""Get the velocity of all eight motors.
Returns:
Velocities of all eight motors.
"""
motor_velocities = [
self._pybullet_client.getJointState(self.quadruped, motor_id)[1]
for motor_id in self._motor_id_list
]
motor_velocities = np.multiply(motor_velocities, self._motor_direction)
return motor_velocities
def GetMotorTorques(self):
"""Get the amount of torque the motors are exerting.
Returns:
Motor torques of all eight motors.
"""
if self._accurate_motor_model_enabled or self._pd_control_enabled:
return self._observed_motor_torques
else:
motor_torques = [
self._pybullet_client.getJointState(self.quadruped,
motor_id)[3]
for motor_id in self._motor_id_list
]
motor_torques = np.multiply(motor_torques, self._motor_direction)
return motor_torques
def GetBaseMassesFromURDF(self):
"""Get the mass of the base from the URDF file."""
return self._base_mass_urdf
def GetBaseInertiasFromURDF(self):
"""Get the inertia of the base from the URDF file."""
return self._base_inertia_urdf
def GetLegMassesFromURDF(self):
"""Get the mass of the legs from the URDF file."""
return self._leg_masses_urdf
def GetLegInertiasFromURDF(self):
"""Get the inertia of the legs from the URDF file."""
return self._leg_inertia_urdf
def SetBaseMasses(self, base_mass):
"""Set the mass of spot's base.
Args:
base_mass: A list of masses of each body link in CHASIS_LINK_IDS. The
length of this list should be the same as the length of CHASIS_LINK_IDS.
Raises:
ValueError: It is raised when the length of base_mass is not the same as
the length of self._chassis_link_ids.
"""
if len(base_mass) != len(self._chassis_link_ids):
raise ValueError(
"The length of base_mass {} and self._chassis_link_ids {} are not "
"the same.".format(len(base_mass),
len(self._chassis_link_ids)))
for chassis_id, chassis_mass in zip(self._chassis_link_ids, base_mass):
self._pybullet_client.changeDynamics(self.quadruped,
chassis_id,
mass=chassis_mass)
def SetLegMasses(self, leg_masses):
"""Set the mass of the legs.
Args:
leg_masses: The leg and motor masses for all the leg links and motors.
Raises:
ValueError: It is raised when the length of masses is not equal to number
of links + motors.
"""
if len(leg_masses) != len(self._leg_link_ids) + len(
self._motor_link_ids):
raise ValueError("The number of values passed to SetLegMasses are "
"different than number of leg links and motors.")
for leg_id, leg_mass in zip(self._leg_link_ids, leg_masses):
self._pybullet_client.changeDynamics(self.quadruped,
leg_id,
mass=leg_mass)
motor_masses = leg_masses[len(self._leg_link_ids):]
for link_id, motor_mass in zip(self._motor_link_ids, motor_masses):
self._pybullet_client.changeDynamics(self.quadruped,
link_id,
mass=motor_mass)
def SetBaseInertias(self, base_inertias):
"""Set the inertias of spot's base.
Args:
base_inertias: A list of inertias of each body link in CHASIS_LINK_IDS.
The length of this list should be the same as the length of
CHASIS_LINK_IDS.
Raises:
ValueError: It is raised when the length of base_inertias is not the same
as the length of self._chassis_link_ids and base_inertias contains
negative values.
"""
if len(base_inertias) != len(self._chassis_link_ids):
raise ValueError(
"The length of base_inertias {} and self._chassis_link_ids {} are "
"not the same.".format(len(base_inertias),
len(self._chassis_link_ids)))
for chassis_id, chassis_inertia in zip(self._chassis_link_ids,
base_inertias):
for inertia_value in chassis_inertia:
if (np.asarray(inertia_value) < 0).any():
raise ValueError(
"Values in inertia matrix should be non-negative.")
self._pybullet_client.changeDynamics(
self.quadruped,
chassis_id,
localInertiaDiagonal=chassis_inertia)
def SetLegInertias(self, leg_inertias):
"""Set the inertias of the legs.
Args:
leg_inertias: The leg and motor inertias for all the leg links and motors.
Raises:
ValueError: It is raised when the length of inertias is not equal to
the number of links + motors or leg_inertias contains negative values.
"""
if len(leg_inertias) != len(self._leg_link_ids) + len(
self._motor_link_ids):
raise ValueError("The number of values passed to SetLegMasses are "
"different than number of leg links and motors.")
for leg_id, leg_inertia in zip(self._leg_link_ids, leg_inertias):
for inertia_value in leg_inertias:
if (np.asarray(inertia_value) < 0).any():
raise ValueError(
"Values in inertia matrix should be non-negative.")
self._pybullet_client.changeDynamics(
self.quadruped, leg_id, localInertiaDiagonal=leg_inertia)
motor_inertias = leg_inertias[len(self._leg_link_ids):]
for link_id, motor_inertia in zip(self._motor_link_ids,
motor_inertias):
for inertia_value in motor_inertias:
if (np.asarray(inertia_value) < 0).any():
raise ValueError(
"Values in inertia matrix should be non-negative.")
self._pybullet_client.changeDynamics(
self.quadruped, link_id, localInertiaDiagonal=motor_inertia)
def SetFootFriction(self, foot_friction=100.0):
"""Set the lateral friction of the feet.
Args:
foot_friction: The lateral friction coefficient of the foot. This value is
shared by all four feet.
"""
for link_id in self._foot_link_ids:
self._pybullet_client.changeDynamics(self.quadruped,
link_id,
lateralFriction=foot_friction)
# TODO(b/73748980): Add more API's to set other contact parameters.
def SetFootRestitution(self, link_id, foot_restitution=1.0):
"""Set the coefficient of restitution at the feet.
Args:
foot_restitution: The coefficient of restitution (bounciness) of the feet.
This value is shared by all four feet.
"""
self._pybullet_client.changeDynamics(self.quadruped,
link_id,
restitution=foot_restitution)
def SetJointFriction(self, joint_frictions):
for knee_joint_id, friction in zip(self._foot_link_ids,
joint_frictions):
self._pybullet_client.setJointMotorControl2(
bodyIndex=self.quadruped,
jointIndex=knee_joint_id,
controlMode=self._pybullet_client.VELOCITY_CONTROL,
targetVelocity=0,
force=friction)
def GetNumKneeJoints(self):
return len(self._foot_link_ids)
def SetBatteryVoltage(self, voltage):
if self._accurate_motor_model_enabled:
self._motor_model.set_voltage(voltage)
def SetMotorViscousDamping(self, viscous_damping):
if self._accurate_motor_model_enabled:
self._motor_model.set_viscous_damping(viscous_damping)
def RealisticObservation(self):
"""Receive the observation from sensors.
This function is called once per step. The observations are only updated
when this function is called.
"""
self._observation_history.appendleft(self.GetObservation())
self._control_observation = self._GetDelayedObservation(
self._control_latency)
self._control_observation = self._AddSensorNoise(
self._control_observation, self._observation_noise_stdev)
return self._control_observation
def _GetDelayedObservation(self, latency):
"""Get observation that is delayed by the amount specified in latency.
Args:
latency: The latency (in seconds) of the delayed observation.
Returns:
observation: The observation which was actually latency seconds ago.
"""
if latency <= 0 or len(self._observation_history) == 1:
observation = self._observation_history[0]
else:
n_steps_ago = int(latency / self.time_step)
if n_steps_ago + 1 >= len(self._observation_history):
return self._observation_history[-1]
remaining_latency = latency - n_steps_ago * self.time_step
blend_alpha = remaining_latency / self.time_step
observation = (
(1.0 - blend_alpha) *
np.array(self._observation_history[n_steps_ago]) +
blend_alpha *
np.array(self._observation_history[n_steps_ago + 1]))
return observation
def _GetPDObservation(self):
pd_delayed_observation = self._GetDelayedObservation(self._pd_latency)
q = pd_delayed_observation[0:self.num_motors]
qdot = pd_delayed_observation[self.num_motors:2 * self.num_motors]
return (np.array(q), np.array(qdot))
def _AddSensorNoise(self, observation, noise_stdev):
# if self._observation_noise_stdev > 0:
# observation += (self.np_random.normal(scale=noise_stdev,
# size=observation.shape) *
# self.GetObservationUpperBound())
return observation
def SetControlLatency(self, latency):
"""Set the latency of the control loop.
It measures the duration between sending an action from Nvidia TX2 and
receiving the observation from microcontroller.
Args:
latency: The latency (in seconds) of the control loop.
"""
self._control_latency = latency
def GetControlLatency(self):
"""Get the control latency.
Returns:
The latency (in seconds) between when the motor command is sent and when
the sensor measurements are reported back to the controller.
"""
return self._control_latency
def SetMotorGains(self, kp, kd):
"""Set the gains of all motors.
These gains are PD gains for motor positional control. kp is the
proportional gain and kd is the derivative gain.
Args:
kp: proportional gain of the motors.
kd: derivative gain of the motors.
"""
self._kp = kp
self._kd = kd
if self._accurate_motor_model_enabled:
self._motor_model.set_motor_gains(kp, kd)
def GetMotorGains(self):
"""Get the gains of the motor.
Returns:
The proportional gain.
The derivative gain.
"""
return self._kp, self._kd
def SetMotorStrengthRatio(self, ratio):
"""Set the strength of all motors relative to the default value.
Args:
ratio: The relative strength. A scalar range from 0.0 to 1.0.
"""
if self._accurate_motor_model_enabled:
self._motor_model.set_strength_ratios([ratio] * self.num_motors)
def SetMotorStrengthRatios(self, ratios):
"""Set the strength of each motor relative to the default value.
Args:
ratios: The relative strength. A numpy array ranging from 0.0 to 1.0.
"""
if self._accurate_motor_model_enabled:
self._motor_model.set_strength_ratios(ratios)
def SetTimeSteps(self, action_repeat, simulation_step):
"""Set the time steps of the control and simulation.
Args:
action_repeat: The number of simulation steps that the same action is
repeated.
simulation_step: The simulation time step.
"""
self.time_step = simulation_step
self._action_repeat = action_repeat
@property
def chassis_link_ids(self):
return self._chassis_link_ids
| 47,996 | Python | 40.269991 | 107 | 0.578777 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/env_randomizer_base.py | """Abstract base class for environment randomizer.
Source: https://github.com/bulletphysics/bullet3/blob/master/examples/pybullet/gym/pybullet_envs/minitaur/envs/env_randomizer_base.py
"""
import abc
class EnvRandomizerBase(object):
"""Abstract base class for environment randomizer.
An EnvRandomizer is called in environment.reset(). It will
randomize physical parameters of the objects in the simulation.
The physical parameters will be fixed for that episode and be
randomized again in the next environment.reset().
"""
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def randomize_env(self, env):
"""Randomize the simulated_objects in the environment.
Args:
env: The environment to be randomized.
"""
pass
| 758 | Python | 26.107142 | 133 | 0.744063 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/spot_gym_env.py | """
CODE BASED ON EXAMPLE FROM:
@misc{coumans2017pybullet,
title={Pybullet, a python module for physics simulation in robotics, games and machine learning},
author={Coumans, Erwin and Bai, Yunfei},
url={www.pybullet.org},
year={2017},
}
Example: minitaur_gym_env.py
https://github.com/bulletphysics/bullet3/blob/master/examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_gym_env.py
"""
import math
import time
import gym
import numpy as np
import pybullet
import pybullet_data
from gym import spaces
from gym.utils import seeding
from pkg_resources import parse_version
from spotmicro import spot
import pybullet_utils.bullet_client as bullet_client
from gym.envs.registration import register
from spotmicro.heightfield import HeightField
from spotmicro.OpenLoopSM.SpotOL import BezierStepper
import spotmicro.Kinematics.LieAlgebra as LA
from spotmicro.spot_env_randomizer import SpotEnvRandomizer
NUM_SUBSTEPS = 5
NUM_MOTORS = 12
MOTOR_ANGLE_OBSERVATION_INDEX = 0
MOTOR_VELOCITY_OBSERVATION_INDEX = MOTOR_ANGLE_OBSERVATION_INDEX + NUM_MOTORS
MOTOR_TORQUE_OBSERVATION_INDEX = MOTOR_VELOCITY_OBSERVATION_INDEX + NUM_MOTORS
BASE_ORIENTATION_OBSERVATION_INDEX = MOTOR_TORQUE_OBSERVATION_INDEX + NUM_MOTORS
ACTION_EPS = 0.01
OBSERVATION_EPS = 0.01
RENDER_HEIGHT = 720
RENDER_WIDTH = 960
SENSOR_NOISE_STDDEV = spot.SENSOR_NOISE_STDDEV
DEFAULT_URDF_VERSION = "default"
NUM_SIMULATION_ITERATION_STEPS = 1000
spot_URDF_VERSION_MAP = {DEFAULT_URDF_VERSION: spot.Spot}
# Register as OpenAI Gym Environment
register(
id="SpotMicroEnv-v0",
entry_point='spotmicro.spot_gym_env:spotGymEnv',
max_episode_steps=1000,
)
def convert_to_list(obj):
try:
iter(obj)
return obj
except TypeError:
return [obj]
class spotGymEnv(gym.Env):
"""The gym environment for spot.
It simulates the locomotion of spot, a quadruped robot. The state space
include the angles, velocities and torques for all the motors and the action
space is the desired motor angle for each motor. The reward function is based
on how far spot walks in 1000 steps and penalizes the energy
expenditure.
"""
metadata = {
"render.modes": ["human", "rgb_array"],
"video.frames_per_second": 50
}
def __init__(self,
distance_weight=1.0,
rotation_weight=1.0,
energy_weight=0.0005,
shake_weight=0.005,
drift_weight=2.0,
rp_weight=0.1,
rate_weight=0.1,
urdf_root=pybullet_data.getDataPath(),
urdf_version=None,
distance_limit=float("inf"),
observation_noise_stdev=SENSOR_NOISE_STDDEV,
self_collision_enabled=True,
motor_velocity_limit=np.inf,
pd_control_enabled=False,
leg_model_enabled=False,
accurate_motor_model_enabled=False,
remove_default_joint_damping=False,
motor_kp=2.0,
motor_kd=0.03,
control_latency=0.0,
pd_latency=0.0,
torque_control_enabled=False,
motor_overheat_protection=False,
hard_reset=False,
on_rack=False,
render=True,
num_steps_to_log=1000,
action_repeat=1,
control_time_step=None,
env_randomizer=SpotEnvRandomizer(),
forward_reward_cap=float("inf"),
reflection=True,
log_path=None,
desired_velocity=0.5,
desired_rate=0.0,
lateral=False,
draw_foot_path=False,
height_field=False,
height_field_iters=2,
AutoStepper=False,
contacts=True):
"""Initialize the spot gym environment.
Args:
urdf_root: The path to the urdf data folder.
urdf_version: [DEFAULT_URDF_VERSION] are allowable
versions. If None, DEFAULT_URDF_VERSION is used.
distance_weight: The weight of the distance term in the reward.
energy_weight: The weight of the energy term in the reward.
shake_weight: The weight of the vertical shakiness term in the reward.
drift_weight: The weight of the sideways drift term in the reward.
distance_limit: The maximum distance to terminate the episode.
observation_noise_stdev: The standard deviation of observation noise.
self_collision_enabled: Whether to enable self collision in the sim.
motor_velocity_limit: The velocity limit of each motor.
pd_control_enabled: Whether to use PD controller for each motor.
leg_model_enabled: Whether to use a leg motor to reparameterize the action
space.
accurate_motor_model_enabled: Whether to use the accurate DC motor model.
remove_default_joint_damping: Whether to remove the default joint damping.
motor_kp: proportional gain for the accurate motor model.
motor_kd: derivative gain for the accurate motor model.
control_latency: It is the delay in the controller between when an
observation is made at some point, and when that reading is reported
back to the Neural Network.
pd_latency: latency of the PD controller loop. PD calculates PWM based on
the motor angle and velocity. The latency measures the time between when
the motor angle and velocity are observed on the microcontroller and
when the true state happens on the motor. It is typically (0.001-
0.002s).
torque_control_enabled: Whether to use the torque control, if set to
False, pose control will be used.
motor_overheat_protection: Whether to shutdown the motor that has exerted
large torque (OVERHEAT_SHUTDOWN_TORQUE) for an extended amount of time
(OVERHEAT_SHUTDOWN_TIME). See ApplyAction() in spot.py for more
details.
hard_reset: Whether to wipe the simulation and load everything when reset
is called. If set to false, reset just place spot back to start
position and set its pose to initial configuration.
on_rack: Whether to place spot on rack. This is only used to debug
the walking gait. In this mode, spot's base is hanged midair so
that its walking gait is clearer to visualize.
render: Whether to render the simulation.
num_steps_to_log: The max number of control steps in one episode that will
be logged. If the number of steps is more than num_steps_to_log, the
environment will still be running, but only first num_steps_to_log will
be recorded in logging.
action_repeat: The number of simulation steps before actions are applied.
control_time_step: The time step between two successive control signals.
env_randomizer: An instance (or a list) of EnvRandomizer(s). An
EnvRandomizer may randomize the physical property of spot, change
the terrrain during reset(), or add perturbation forces during step().
forward_reward_cap: The maximum value that forward reward is capped at.
Disabled (Inf) by default.
log_path: The path to write out logs. For the details of logging, refer to
spot_logging.proto.
Raises:
ValueError: If the urdf_version is not supported.
"""
# Sense Contacts
self.contacts = contacts
# Enable Auto Stepper State Machine
self.AutoStepper = AutoStepper
# Enable Rough Terrain or Not
self.height_field = height_field
self.draw_foot_path = draw_foot_path
# DRAWING FEET PATH
self.prev_feet_path = np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0],
[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
# CONTROL METRICS
self.desired_velocity = desired_velocity
self.desired_rate = desired_rate
self.lateral = lateral
# Set up logging.
self._log_path = log_path
# @TODO fix logging
# NUM ITERS
self._time_step = 0.01
self._action_repeat = action_repeat
self._num_bullet_solver_iterations = 300
self.logging = None
if pd_control_enabled or accurate_motor_model_enabled:
self._time_step /= NUM_SUBSTEPS
self._num_bullet_solver_iterations /= NUM_SUBSTEPS
self._action_repeat *= NUM_SUBSTEPS
# PD control needs smaller time step for stability.
if control_time_step is not None:
self.control_time_step = control_time_step
else:
# Get Control Timestep
self.control_time_step = self._time_step * self._action_repeat
# TODO: Fix the value of self._num_bullet_solver_iterations.
self._num_bullet_solver_iterations = int(
NUM_SIMULATION_ITERATION_STEPS / self._action_repeat)
# URDF
self._urdf_root = urdf_root
self._self_collision_enabled = self_collision_enabled
self._motor_velocity_limit = motor_velocity_limit
self._observation = []
self._true_observation = []
self._objectives = []
self._objective_weights = [
distance_weight, energy_weight, drift_weight, shake_weight
]
self._env_step_counter = 0
self._num_steps_to_log = num_steps_to_log
self._is_render = render
self._last_base_position = [0, 0, 0]
self._last_base_orientation = [0, 0, 0, 1]
self._distance_weight = distance_weight
self._rotation_weight = rotation_weight
self._energy_weight = energy_weight
self._drift_weight = drift_weight
self._shake_weight = shake_weight
self._rp_weight = rp_weight
self._rate_weight = rate_weight
self._distance_limit = distance_limit
self._observation_noise_stdev = observation_noise_stdev
self._action_bound = 1
self._pd_control_enabled = pd_control_enabled
self._leg_model_enabled = leg_model_enabled
self._accurate_motor_model_enabled = accurate_motor_model_enabled
self._remove_default_joint_damping = remove_default_joint_damping
self._motor_kp = motor_kp
self._motor_kd = motor_kd
self._torque_control_enabled = torque_control_enabled
self._motor_overheat_protection = motor_overheat_protection
self._on_rack = on_rack
self._cam_dist = 1.0
self._cam_yaw = 0
self._cam_pitch = -30
self._forward_reward_cap = forward_reward_cap
self._hard_reset = True
self._last_frame_time = 0.0
self._control_latency = control_latency
self._pd_latency = pd_latency
self._urdf_version = urdf_version
self._ground_id = None
self._reflection = reflection
self._env_randomizer = env_randomizer
# @TODO fix logging
self._episode_proto = None
if self._is_render:
self._pybullet_client = bullet_client.BulletClient(
connection_mode=pybullet.GUI)
else:
self._pybullet_client = bullet_client.BulletClient()
if self._urdf_version is None:
self._urdf_version = DEFAULT_URDF_VERSION
self._pybullet_client.setPhysicsEngineParameter(enableConeFriction=0)
self.seed()
# Only update after HF has been generated
self.height_field = False
self.reset()
observation_high = (self.spot.GetObservationUpperBound() +
OBSERVATION_EPS)
observation_low = (self.spot.GetObservationLowerBound() -
OBSERVATION_EPS)
action_dim = NUM_MOTORS
action_high = np.array([self._action_bound] * action_dim)
self.action_space = spaces.Box(-action_high, action_high)
self.observation_space = spaces.Box(observation_low, observation_high)
self.viewer = None
self._hard_reset = hard_reset # This assignment need to be after reset()
self.goal_reached = False
# Generate HeightField or not
self.height_field = height_field
self.hf = HeightField()
if self.height_field:
# Do 3x for extra roughness
for i in range(height_field_iters):
self.hf._generate_field(self)
def set_env_randomizer(self, env_randomizer):
self._env_randomizer = env_randomizer
def configure(self, args):
self._args = args
def reset(self,
initial_motor_angles=None,
reset_duration=1.0,
desired_velocity=None,
desired_rate=None):
# Use Autostepper
if self.AutoStepper:
self.StateMachine = BezierStepper(dt=self._time_step)
# Shuffle order of states
self.StateMachine.reshuffle()
self._pybullet_client.configureDebugVisualizer(
self._pybullet_client.COV_ENABLE_RENDERING, 0)
if self._hard_reset:
self._pybullet_client.resetSimulation()
self._pybullet_client.setPhysicsEngineParameter(
numSolverIterations=int(self._num_bullet_solver_iterations))
self._pybullet_client.setTimeStep(self._time_step)
self._ground_id = self._pybullet_client.loadURDF("%s/plane.urdf" %
self._urdf_root)
if self._reflection:
self._pybullet_client.changeVisualShape(
self._ground_id, -1, rgbaColor=[1, 1, 1, 0.8])
self._pybullet_client.configureDebugVisualizer(
self._pybullet_client.COV_ENABLE_PLANAR_REFLECTION,
self._ground_id)
self._pybullet_client.setGravity(0, 0, -9.81)
acc_motor = self._accurate_motor_model_enabled
motor_protect = self._motor_overheat_protection
if self._urdf_version not in spot_URDF_VERSION_MAP:
raise ValueError("%s is not a supported urdf_version." %
self._urdf_version)
else:
self.spot = (spot_URDF_VERSION_MAP[self._urdf_version](
pybullet_client=self._pybullet_client,
action_repeat=self._action_repeat,
urdf_root=self._urdf_root,
time_step=self._time_step,
self_collision_enabled=self._self_collision_enabled,
motor_velocity_limit=self._motor_velocity_limit,
pd_control_enabled=self._pd_control_enabled,
accurate_motor_model_enabled=acc_motor,
remove_default_joint_damping=self.
_remove_default_joint_damping,
motor_kp=self._motor_kp,
motor_kd=self._motor_kd,
control_latency=self._control_latency,
pd_latency=self._pd_latency,
observation_noise_stdev=self._observation_noise_stdev,
torque_control_enabled=self._torque_control_enabled,
motor_overheat_protection=motor_protect,
on_rack=self._on_rack,
np_random=self.np_random,
contacts=self.contacts))
self.spot.Reset(reload_urdf=False,
default_motor_angles=initial_motor_angles,
reset_time=reset_duration)
if self._env_randomizer is not None:
self._env_randomizer.randomize_env(self)
# Also update heightfield if wr are wholly randomizing
if self.height_field:
self.hf.UpdateHeightField()
if desired_velocity is not None:
self.desired_velocity = desired_velocity
if desired_rate is not None:
self.desired_rate = desired_rate
self._pybullet_client.setPhysicsEngineParameter(enableConeFriction=0)
self._env_step_counter = 0
self._last_base_position = [0, 0, 0]
self._last_base_orientation = [0, 0, 0, 1]
self._objectives = []
self._pybullet_client.resetDebugVisualizerCamera(
self._cam_dist, self._cam_yaw, self._cam_pitch, [0, 0, 0])
self._pybullet_client.configureDebugVisualizer(
self._pybullet_client.COV_ENABLE_RENDERING, 1)
return self._get_observation()
def seed(self, seed=None):
self.np_random, seed = seeding.np_random(seed)
return [seed]
def _transform_action_to_motor_command(self, action):
if self._leg_model_enabled:
for i, action_component in enumerate(action):
if not (-self._action_bound - ACTION_EPS <= action_component <=
self._action_bound + ACTION_EPS):
raise ValueError("{}th action {} out of bounds.".format(
i, action_component))
action = self.spot.ConvertFromLegModel(action)
return action
def step(self, action):
"""Step forward the simulation, given the action.
Args:
action: A list of desired motor angles for eight motors.
Returns:
observations: The angles, velocities and torques of all motors.
reward: The reward for the current state-action pair.
done: Whether the episode has ended.
info: A dictionary that stores diagnostic information.
Raises:
ValueError: The action dimension is not the same as the number of motors.
ValueError: The magnitude of actions is out of bounds.
"""
self._last_base_position = self.spot.GetBasePosition()
self._last_base_orientation = self.spot.GetBaseOrientation()
# print("ACTION:")
# print(action)
if self._is_render:
# Sleep, otherwise the computation takes less time than real time,
# which will make the visualization like a fast-forward video.
time_spent = time.time() - self._last_frame_time
self._last_frame_time = time.time()
time_to_sleep = self.control_time_step - time_spent
if time_to_sleep > 0:
time.sleep(time_to_sleep)
base_pos = self.spot.GetBasePosition()
# Keep the previous orientation of the camera set by the user.
[yaw, pitch,
dist] = self._pybullet_client.getDebugVisualizerCamera()[8:11]
self._pybullet_client.resetDebugVisualizerCamera(
dist, yaw, pitch, base_pos)
action = self._transform_action_to_motor_command(action)
self.spot.Step(action)
reward = self._reward()
done = self._termination()
self._env_step_counter += 1
# DRAW FOOT PATH
if self.draw_foot_path:
self.DrawFootPath()
return np.array(self._get_observation()), reward, done, {}
def render(self, mode="rgb_array", close=False):
if mode != "rgb_array":
return np.array([])
base_pos = self.spot.GetBasePosition()
view_matrix = self._pybullet_client.computeViewMatrixFromYawPitchRoll(
cameraTargetPosition=base_pos,
distance=self._cam_dist,
yaw=self._cam_yaw,
pitch=self._cam_pitch,
roll=0,
upAxisIndex=2)
proj_matrix = self._pybullet_client.computeProjectionMatrixFOV(
fov=60,
aspect=float(RENDER_WIDTH) / RENDER_HEIGHT,
nearVal=0.1,
farVal=100.0)
(_, _, px, _, _) = self._pybullet_client.getCameraImage(
width=RENDER_WIDTH,
height=RENDER_HEIGHT,
renderer=self._pybullet_client.ER_BULLET_HARDWARE_OPENGL,
viewMatrix=view_matrix,
projectionMatrix=proj_matrix)
rgb_array = np.array(px)
rgb_array = rgb_array[:, :, :3]
return rgb_array
def DrawFootPath(self):
# Get Foot Positions
FL = self._pybullet_client.getLinkState(self.spot.quadruped,
self.spot._foot_id_list[0])[0]
FR = self._pybullet_client.getLinkState(self.spot.quadruped,
self.spot._foot_id_list[1])[0]
BL = self._pybullet_client.getLinkState(self.spot.quadruped,
self.spot._foot_id_list[2])[0]
BR = self._pybullet_client.getLinkState(self.spot.quadruped,
self.spot._foot_id_list[3])[0]
lifetime = 3.0 # sec
self._pybullet_client.addUserDebugLine(self.prev_feet_path[0],
FL, [1, 0, 0],
lifeTime=lifetime)
self._pybullet_client.addUserDebugLine(self.prev_feet_path[1],
FR, [0, 1, 0],
lifeTime=lifetime)
self._pybullet_client.addUserDebugLine(self.prev_feet_path[2],
BL, [0, 0, 1],
lifeTime=lifetime)
self._pybullet_client.addUserDebugLine(self.prev_feet_path[3],
BR, [1, 1, 0],
lifeTime=lifetime)
self.prev_feet_path[0] = FL
self.prev_feet_path[1] = FR
self.prev_feet_path[2] = BL
self.prev_feet_path[3] = BR
def get_spot_motor_angles(self):
"""Get the spot's motor angles.
Returns:
A numpy array of motor angles.
"""
return np.array(
self._observation[MOTOR_ANGLE_OBSERVATION_INDEX:
MOTOR_ANGLE_OBSERVATION_INDEX + NUM_MOTORS])
def get_spot_motor_velocities(self):
"""Get the spot's motor velocities.
Returns:
A numpy array of motor velocities.
"""
return np.array(
self._observation[MOTOR_VELOCITY_OBSERVATION_INDEX:
MOTOR_VELOCITY_OBSERVATION_INDEX + NUM_MOTORS])
def get_spot_motor_torques(self):
"""Get the spot's motor torques.
Returns:
A numpy array of motor torques.
"""
return np.array(
self._observation[MOTOR_TORQUE_OBSERVATION_INDEX:
MOTOR_TORQUE_OBSERVATION_INDEX + NUM_MOTORS])
def get_spot_base_orientation(self):
"""Get the spot's base orientation, represented by a quaternion.
Returns:
A numpy array of spot's orientation.
"""
return np.array(self._observation[BASE_ORIENTATION_OBSERVATION_INDEX:])
def is_fallen(self):
"""Decide whether spot has fallen.
If the up directions between the base and the world is larger (the dot
product is smaller than 0.85) or the base is very low on the ground
(the height is smaller than 0.13 meter), spot is considered fallen.
Returns:
Boolean value that indicates whether spot has fallen.
"""
orientation = self.spot.GetBaseOrientation()
rot_mat = self._pybullet_client.getMatrixFromQuaternion(orientation)
local_up = rot_mat[6:]
pos = self.spot.GetBasePosition()
# or pos[2] < 0.13
return (np.dot(np.asarray([0, 0, 1]), np.asarray(local_up)) < 0.55)
def _termination(self):
position = self.spot.GetBasePosition()
distance = math.sqrt(position[0]**2 + position[1]**2)
return self.is_fallen() or distance > self._distance_limit
def _reward(self):
""" NOTE: reward now consists of:
roll, pitch at desired 0
acc (y,z) = 0
FORWARD-BACKWARD: rate(x,y,z) = 0
--> HIDDEN REWARD: x(+-) velocity reference, not incl. in obs
SPIN: acc(x) = 0, rate(x,y) = 0, rate (z) = rate reference
Also include drift, energy vanilla rewards
"""
current_base_position = self.spot.GetBasePosition()
# get observation
obs = self._get_observation()
# forward_reward = current_base_position[0] - self._last_base_position[0]
# # POSITIVE FOR FORWARD, NEGATIVE FOR BACKWARD | NOTE: HIDDEN
# GETTING TWIST IN BODY FRAME
pos = self.spot.GetBasePosition()
orn = self.spot.GetBaseOrientation()
roll, pitch, yaw = self._pybullet_client.getEulerFromQuaternion(
[orn[0], orn[1], orn[2], orn[3]])
rpy = LA.RPY(roll, pitch, yaw)
R, _ = LA.TransToRp(rpy)
T_wb = LA.RpToTrans(R, np.array([pos[0], pos[1], pos[2]]))
T_bw = LA.TransInv(T_wb)
Adj_Tbw = LA.Adjoint(T_bw)
Vw = np.concatenate(
(self.spot.prev_ang_twist, self.spot.prev_lin_twist))
Vb = np.dot(Adj_Tbw, Vw)
# New Twist in Body Frame
# POSITIVE FOR FORWARD, NEGATIVE FOR BACKWARD | NOTE: HIDDEN
fwd_speed = -Vb[3] # vx
lat_speed = -Vb[4] # vy
# fwd_speed = self.spot.prev_lin_twist[0]
# lat_speed = self.spot.prev_lin_twist[1]
# print("FORWARD SPEED: {} \t STATE SPEED: {}".format(
# fwd_speed, self.desired_velocity))
# self.desired_velocity = 0.4
# Modification for lateral/fwd rewards
reward_max = 1.0
# FORWARD
if not self.lateral:
# f(x)=-(x-desired))^(2)*((1/desired)^2)+1
# to make sure that at 0vel there is 0 reawrd.
# also squishes allowable tolerance
forward_reward = reward_max * np.exp(
-(fwd_speed - self.desired_velocity)**2 / (0.1))
# LATERAL
else:
forward_reward = reward_max * np.exp(
-(lat_speed - self.desired_velocity)**2 / (0.1))
yaw_rate = obs[4]
rot_reward = reward_max * np.exp(-(yaw_rate - self.desired_rate)**2 /
(0.1))
# Make sure that for forward-policy there is the appropriate rotation penalty
if self.desired_velocity != 0:
self._rotation_weight = self._rate_weight
rot_reward = -abs(obs[4])
elif self.desired_rate != 0:
forward_reward = 0.0
# penalty for nonzero roll, pitch
rp_reward = -(abs(obs[0]) + abs(obs[1]))
# print("ROLL: {} \t PITCH: {}".format(obs[0], obs[1]))
# penalty for nonzero acc(z)
shake_reward = -abs(obs[4])
# penalty for nonzero rate (x,y,z)
rate_reward = -(abs(obs[2]) + abs(obs[3]))
# drift_reward = -abs(current_base_position[1] -
# self._last_base_position[1])
# this penalizes absolute error, and does not penalize correction
# NOTE: for side-side, drift reward becomes in x instead
drift_reward = -abs(current_base_position[1])
# If Lateral, change drift reward
if self.lateral:
drift_reward = -abs(current_base_position[0])
# shake_reward = -abs(current_base_position[2] -
# self._last_base_position[2])
self._last_base_position = current_base_position
energy_reward = -np.abs(
np.dot(self.spot.GetMotorTorques(),
self.spot.GetMotorVelocities())) * self._time_step
reward = (self._distance_weight * forward_reward +
self._rotation_weight * rot_reward +
self._energy_weight * energy_reward +
self._drift_weight * drift_reward +
self._shake_weight * shake_reward +
self._rp_weight * rp_reward +
self._rate_weight * rate_reward)
self._objectives.append(
[forward_reward, energy_reward, drift_reward, shake_reward])
# print("REWARD: ", reward)
return reward
def get_objectives(self):
return self._objectives
@property
def objective_weights(self):
"""Accessor for the weights for all the objectives.
Returns:
List of floating points that corresponds to weights for the objectives in
the order that objectives are stored.
"""
return self._objective_weights
def _get_observation(self):
"""Get observation of this environment, including noise and latency.
spot class maintains a history of true observations. Based on the
latency, this function will find the observation at the right time,
interpolate if necessary. Then Gaussian noise is added to this observation
based on self.observation_noise_stdev.
Returns:
The noisy observation with latency.
"""
self._observation = self.spot.GetObservation()
return self._observation
def _get_realistic_observation(self):
"""Get the observations of this environment.
It includes the angles, velocities, torques and the orientation of the base.
Returns:
The observation list. observation[0:8] are motor angles. observation[8:16]
are motor velocities, observation[16:24] are motor torques.
observation[24:28] is the orientation of the base, in quaternion form.
"""
self._observation = self.spot.RealisticObservation()
return self._observation
if parse_version(gym.__version__) < parse_version('0.9.6'):
_render = render
_reset = reset
_seed = seed
_step = step
def set_time_step(self, control_step, simulation_step=0.001):
"""Sets the time step of the environment.
Args:
control_step: The time period (in seconds) between two adjacent control
actions are applied.
simulation_step: The simulation time step in PyBullet. By default, the
simulation step is 0.001s, which is a good trade-off between simulation
speed and accuracy.
Raises:
ValueError: If the control step is smaller than the simulation step.
"""
if control_step < simulation_step:
raise ValueError(
"Control step should be larger than or equal to simulation step."
)
self.control_time_step = control_step
self._time_step = simulation_step
self._action_repeat = int(round(control_step / simulation_step))
self._num_bullet_solver_iterations = (NUM_SIMULATION_ITERATION_STEPS /
self._action_repeat)
self._pybullet_client.setPhysicsEngineParameter(
numSolverIterations=self._num_bullet_solver_iterations)
self._pybullet_client.setTimeStep(self._time_step)
self.spot.SetTimeSteps(action_repeat=self._action_repeat,
simulation_step=self._time_step)
@property
def pybullet_client(self):
return self._pybullet_client
@property
def ground_id(self):
return self._ground_id
@ground_id.setter
def ground_id(self, new_ground_id):
self._ground_id = new_ground_id
@property
def env_step_counter(self):
return self._env_step_counter
| 31,142 | Python | 40.358566 | 122 | 0.598452 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/motor.py | """This file implements an accurate motor model.
Source: https://github.com/bulletphysics/bullet3/blob/master/examples/pybullet/gym/pybullet_envs/minitaur/envs/motor.py
"""
import numpy as np
VOLTAGE_CLIPPING = 8.4
OBSERVED_TORQUE_LIMIT = 5.7
MOTOR_VOLTAGE = 7.4
MOTOR_RESISTANCE = 0.086
MOTOR_TORQUE_CONSTANT = 0.00954
MOTOR_VISCOUS_DAMPING = 0.0
MOTOR_SPEED_LIMIT = 9.5
class MotorModel(object):
"""The accurate motor model, which is based on the physics of DC motors.
The motor model support two types of control: position control and torque
control. In position control mode, a desired motor angle is specified, and a
torque is computed based on the internal motor model. When the torque control
is specified, a pwm signal in the range of [-1.0, 1.0] is converted to the
torque.
The internal motor model takes the following factors into consideration:
pd gains, viscous friction, back-EMF voltage and current-torque profile.
"""
def __init__(self, torque_control_enabled=False, kp=1.2, kd=0):
self._torque_control_enabled = torque_control_enabled
self._kp = kp
self._kd = kd
self._resistance = MOTOR_RESISTANCE
self._voltage = MOTOR_VOLTAGE
self._torque_constant = MOTOR_TORQUE_CONSTANT
self._viscous_damping = MOTOR_VISCOUS_DAMPING
self._current_table = [0, 10, 20, 30, 40, 50, 60]
self._torque_table = [0, 1, 1.9, 2.45, 3.0, 3.25, 3.5]
def set_voltage(self, voltage):
self._voltage = voltage
def get_voltage(self):
return self._voltage
def set_viscous_damping(self, viscous_damping):
self._viscous_damping = viscous_damping
def get_viscous_dampling(self):
return self._viscous_damping
def convert_to_torque(self, motor_commands, current_motor_angle,
current_motor_velocity):
"""Convert the commands (position control or torque control) to torque.
Args:
motor_commands: The desired motor angle if the motor is in position
control mode. The pwm signal if the motor is in torque control mode.
current_motor_angle: The motor angle at the current time step.
current_motor_velocity: The motor velocity at the current time step.
Returns:
actual_torque: The torque that needs to be applied to the motor.
observed_torque: The torque observed by the sensor.
"""
if self._torque_control_enabled:
pwm = motor_commands
else:
pwm = (-self._kp * (current_motor_angle - motor_commands) -
self._kd * current_motor_velocity)
pwm = np.clip(pwm, -1.0, 1.0)
return self._convert_to_torque_from_pwm(pwm, current_motor_velocity)
def _convert_to_torque_from_pwm(self, pwm, current_motor_velocity):
"""Convert the pwm signal to torque.
Args:
pwm: The pulse width modulation.
current_motor_velocity: The motor velocity at the current time step.
Returns:
actual_torque: The torque that needs to be applied to the motor.
observed_torque: The torque observed by the sensor.
"""
observed_torque = np.clip(
self._torque_constant * (pwm * self._voltage / self._resistance),
-OBSERVED_TORQUE_LIMIT, OBSERVED_TORQUE_LIMIT)
# Net voltage is clipped at 50V by diodes on the motor controller.
voltage_net = np.clip(
pwm * self._voltage -
(self._torque_constant + self._viscous_damping) *
current_motor_velocity, -VOLTAGE_CLIPPING, VOLTAGE_CLIPPING)
current = voltage_net / self._resistance
current_sign = np.sign(current)
current_magnitude = np.absolute(current)
# Saturate torque based on empirical current relation.
actual_torque = np.interp(current_magnitude, self._current_table,
self._torque_table)
actual_torque = np.multiply(current_sign, actual_torque)
return actual_torque, observed_torque
| 4,012 | Python | 39.535353 | 119 | 0.661515 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/spot_env_randomizer.py | """
CODE BASED ON EXAMPLE FROM:
@misc{coumans2017pybullet,
title={Pybullet, a python module for physics simulation in robotics, games and machine learning},
author={Coumans, Erwin and Bai, Yunfei},
url={www.pybullet.org},
year={2017},
}
Example: minitaur_env_randomizer.py
https://github.com/bulletphysics/bullet3/blob/master/examples/pybullet/gym/pybullet_envs/minitaur/envs/env_randomizers/minitaur_env_randomizer.py
"""
import numpy as np
from . import env_randomizer_base
# Relative range.
spot_BASE_MASS_ERROR_RANGE = (-0.2, 0.2) # 0.2 means 20%
spot_LEG_MASS_ERROR_RANGE = (-0.2, 0.2) # 0.2 means 20%
# Absolute range.
BATTERY_VOLTAGE_RANGE = (7.0, 8.4) # Unit: Volt
MOTOR_VISCOUS_DAMPING_RANGE = (0, 0.01) # Unit: N*m*s/rad (torque/angular vel)
spot_LEG_FRICTION = (0.8, 1.5) # Unit: dimensionless
class SpotEnvRandomizer(env_randomizer_base.EnvRandomizerBase):
"""A randomizer that change the spot_gym_env during every reset."""
def __init__(self,
spot_base_mass_err_range=spot_BASE_MASS_ERROR_RANGE,
spot_leg_mass_err_range=spot_LEG_MASS_ERROR_RANGE,
battery_voltage_range=BATTERY_VOLTAGE_RANGE,
motor_viscous_damping_range=MOTOR_VISCOUS_DAMPING_RANGE):
self._spot_base_mass_err_range = spot_base_mass_err_range
self._spot_leg_mass_err_range = spot_leg_mass_err_range
self._battery_voltage_range = battery_voltage_range
self._motor_viscous_damping_range = motor_viscous_damping_range
np.random.seed(0)
def randomize_env(self, env):
self._randomize_spot(env.spot)
def _randomize_spot(self, spot):
"""Randomize various physical properties of spot.
It randomizes the mass/inertia of the base, mass/inertia of the legs,
friction coefficient of the feet, the battery voltage and the motor damping
at each reset() of the environment.
Args:
spot: the spot instance in spot_gym_env environment.
"""
base_mass = spot.GetBaseMassFromURDF()
# print("BM: ", base_mass)
randomized_base_mass = np.random.uniform(
np.array([base_mass]) * (1.0 + self._spot_base_mass_err_range[0]),
np.array([base_mass]) * (1.0 + self._spot_base_mass_err_range[1]))
spot.SetBaseMass(randomized_base_mass[0])
leg_masses = spot.GetLegMassesFromURDF()
leg_masses_lower_bound = np.array(leg_masses) * (
1.0 + self._spot_leg_mass_err_range[0])
leg_masses_upper_bound = np.array(leg_masses) * (
1.0 + self._spot_leg_mass_err_range[1])
randomized_leg_masses = [
np.random.uniform(leg_masses_lower_bound[i],
leg_masses_upper_bound[i])
for i in range(len(leg_masses))
]
spot.SetLegMasses(randomized_leg_masses)
randomized_battery_voltage = np.random.uniform(
BATTERY_VOLTAGE_RANGE[0], BATTERY_VOLTAGE_RANGE[1])
spot.SetBatteryVoltage(randomized_battery_voltage)
randomized_motor_damping = np.random.uniform(
MOTOR_VISCOUS_DAMPING_RANGE[0], MOTOR_VISCOUS_DAMPING_RANGE[1])
spot.SetMotorViscousDamping(randomized_motor_damping)
randomized_foot_friction = np.random.uniform(spot_LEG_FRICTION[0],
spot_LEG_FRICTION[1])
spot.SetFootFriction(randomized_foot_friction)
| 3,428 | Python | 40.817073 | 145 | 0.648483 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/heightfield.py | """
CODE BASED ON EXAMPLE FROM:
@misc{coumans2017pybullet,
title={Pybullet, a python module for physics simulation in robotics, games and machine learning},
author={Coumans, Erwin and Bai, Yunfei},
url={www.pybullet.org},
year={2017},
}
Example: heightfield.py
https://github.com/bulletphysics/bullet3/blob/master/examples/pybullet/examples/heightfield.py
"""
import pybullet as p
import pybullet_data as pd
import math
import time
textureId = -1
useProgrammatic = 0
useTerrainFromPNG = 1
useDeepLocoCSV = 2
updateHeightfield = False
heightfieldSource = useProgrammatic
numHeightfieldRows = 256
numHeightfieldColumns = 256
import random
random.seed(10)
class HeightField():
def __init__(self):
self.hf_id = 0
self.terrainShape = 0
self.heightfieldData = [0] * numHeightfieldRows * numHeightfieldColumns
def _generate_field(self, env, heightPerturbationRange=0.08):
env.pybullet_client.setAdditionalSearchPath(pd.getDataPath())
env.pybullet_client.configureDebugVisualizer(
env.pybullet_client.COV_ENABLE_RENDERING, 0)
heightPerturbationRange = heightPerturbationRange
if heightfieldSource == useProgrammatic:
for j in range(int(numHeightfieldColumns / 2)):
for i in range(int(numHeightfieldRows / 2)):
height = random.uniform(0, heightPerturbationRange)
self.heightfieldData[2 * i +
2 * j * numHeightfieldRows] = height
self.heightfieldData[2 * i + 1 +
2 * j * numHeightfieldRows] = height
self.heightfieldData[2 * i + (2 * j + 1) *
numHeightfieldRows] = height
self.heightfieldData[2 * i + 1 + (2 * j + 1) *
numHeightfieldRows] = height
terrainShape = env.pybullet_client.createCollisionShape(
shapeType=env.pybullet_client.GEOM_HEIGHTFIELD,
meshScale=[.07, .07, 1.6],
heightfieldTextureScaling=(numHeightfieldRows - 1) / 2,
heightfieldData=self.heightfieldData,
numHeightfieldRows=numHeightfieldRows,
numHeightfieldColumns=numHeightfieldColumns)
terrain = env.pybullet_client.createMultiBody(0, terrainShape)
env.pybullet_client.resetBasePositionAndOrientation(
terrain, [0, 0, 0.0], [0, 0, 0, 1])
env.pybullet_client.changeDynamics(terrain,
-1,
lateralFriction=1.0)
if heightfieldSource == useDeepLocoCSV:
terrainShape = env.pybullet_client.createCollisionShape(
shapeType=env.pybullet_client.GEOM_HEIGHTFIELD,
meshScale=[.5, .5, 2.5],
fileName="heightmaps/ground0.txt",
heightfieldTextureScaling=128)
terrain = env.pybullet_client.createMultiBody(0, terrainShape)
env.pybullet_client.resetBasePositionAndOrientation(
terrain, [0, 0, 0], [0, 0, 0, 1])
env.pybullet_client.changeDynamics(terrain,
-1,
lateralFriction=1.0)
if heightfieldSource == useTerrainFromPNG:
terrainShape = env.pybullet_client.createCollisionShape(
shapeType=env.pybullet_client.GEOM_HEIGHTFIELD,
meshScale=[.05, .05, 1.8],
fileName="heightmaps/wm_height_out.png")
textureId = env.pybullet_client.loadTexture(
"heightmaps/gimp_overlay_out.png")
terrain = env.pybullet_client.createMultiBody(0, terrainShape)
env.pybullet_client.changeVisualShape(terrain,
-1,
textureUniqueId=textureId)
env.pybullet_client.resetBasePositionAndOrientation(
terrain, [0, 0, 0.1], [0, 0, 0, 1])
env.pybullet_client.changeDynamics(terrain,
-1,
lateralFriction=1.0)
self.hf_id = terrainShape
self.terrainShape = terrainShape
print("TERRAIN SHAPE: {}".format(terrainShape))
env.pybullet_client.changeVisualShape(terrain,
-1,
rgbaColor=[1, 1, 1, 1])
env.pybullet_client.configureDebugVisualizer(
env.pybullet_client.COV_ENABLE_RENDERING, 1)
def UpdateHeightField(self, heightPerturbationRange=0.08):
if heightfieldSource == useProgrammatic:
for j in range(int(numHeightfieldColumns / 2)):
for i in range(int(numHeightfieldRows / 2)):
height = random.uniform(
0, heightPerturbationRange) # +math.sin(time.time())
self.heightfieldData[2 * i +
2 * j * numHeightfieldRows] = height
self.heightfieldData[2 * i + 1 +
2 * j * numHeightfieldRows] = height
self.heightfieldData[2 * i + (2 * j + 1) *
numHeightfieldRows] = height
self.heightfieldData[2 * i + 1 + (2 * j + 1) *
numHeightfieldRows] = height
#GEOM_CONCAVE_INTERNAL_EDGE may help avoid getting stuck at an internal (shared) edge of the triangle/heightfield.
#GEOM_CONCAVE_INTERNAL_EDGE is a bit slower to build though.
#flags = p.GEOM_CONCAVE_INTERNAL_EDGE
flags = 0
self.terrainShape = p.createCollisionShape(
shapeType=p.GEOM_HEIGHTFIELD,
flags=flags,
meshScale=[.05, .05, 1],
heightfieldTextureScaling=(numHeightfieldRows - 1) / 2,
heightfieldData=self.heightfieldData,
numHeightfieldRows=numHeightfieldRows,
numHeightfieldColumns=numHeightfieldColumns,
replaceHeightfieldIndex=self.terrainShape)
| 6,396 | Python | 44.368794 | 126 | 0.553627 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/Kinematics/SpotKinematics.py | #!/usr/bin/env python
import numpy as np
from spotmicro.Kinematics.LegKinematics import LegIK
from spotmicro.Kinematics.LieAlgebra import RpToTrans, TransToRp, TransInv, RPY, TransformVector
from collections import OrderedDict
class SpotModel:
def __init__(self,
shoulder_length=0.055,
elbow_length=0.10652,
wrist_length=0.145,
hip_x=0.23,
hip_y=0.075,
foot_x=0.23,
foot_y=0.185,
height=0.20,
com_offset=0.016,
shoulder_lim=[-0.548, 0.548],
elbow_lim=[-2.17, 0.97],
wrist_lim=[-0.1, 2.59]):
"""
Spot Micro Kinematics
"""
# COM offset in x direction
self.com_offset = com_offset
# Leg Parameters
self.shoulder_length = shoulder_length
self.elbow_length = elbow_length
self.wrist_length = wrist_length
# Leg Vector desired_positions
# Distance Between Hips
# Length
self.hip_x = hip_x
# Width
self.hip_y = hip_y
# Distance Between Feet
# Length
self.foot_x = foot_x
# Width
self.foot_y = foot_y
# Body Height
self.height = height
# Joint Parameters
self.shoulder_lim = shoulder_lim
self.elbow_lim = elbow_lim
self.wrist_lim = wrist_lim
# Dictionary to store Leg IK Solvers
self.Legs = OrderedDict()
self.Legs["FL"] = LegIK("LEFT", self.shoulder_length,
self.elbow_length, self.wrist_length,
self.shoulder_lim, self.elbow_lim,
self.wrist_lim)
self.Legs["FR"] = LegIK("RIGHT", self.shoulder_length,
self.elbow_length, self.wrist_length,
self.shoulder_lim, self.elbow_lim,
self.wrist_lim)
self.Legs["BL"] = LegIK("LEFT", self.shoulder_length,
self.elbow_length, self.wrist_length,
self.shoulder_lim, self.elbow_lim,
self.wrist_lim)
self.Legs["BR"] = LegIK("RIGHT", self.shoulder_length,
self.elbow_length, self.wrist_length,
self.shoulder_lim, self.elbow_lim,
self.wrist_lim)
# Dictionary to store Hip and Foot Transforms
# Transform of Hip relative to world frame
# With Body Centroid also in world frame
Rwb = np.eye(3)
self.WorldToHip = OrderedDict()
self.ph_FL = np.array([self.hip_x / 2.0, self.hip_y / 2.0, 0])
self.WorldToHip["FL"] = RpToTrans(Rwb, self.ph_FL)
self.ph_FR = np.array([self.hip_x / 2.0, -self.hip_y / 2.0, 0])
self.WorldToHip["FR"] = RpToTrans(Rwb, self.ph_FR)
self.ph_BL = np.array([-self.hip_x / 2.0, self.hip_y / 2.0, 0])
self.WorldToHip["BL"] = RpToTrans(Rwb, self.ph_BL)
self.ph_BR = np.array([-self.hip_x / 2.0, -self.hip_y / 2.0, 0])
self.WorldToHip["BR"] = RpToTrans(Rwb, self.ph_BR)
# Transform of Foot relative to world frame
# With Body Centroid also in world frame
self.WorldToFoot = OrderedDict()
self.pf_FL = np.array(
[self.foot_x / 2.0, self.foot_y / 2.0, -self.height])
self.WorldToFoot["FL"] = RpToTrans(Rwb, self.pf_FL)
self.pf_FR = np.array(
[self.foot_x / 2.0, -self.foot_y / 2.0, -self.height])
self.WorldToFoot["FR"] = RpToTrans(Rwb, self.pf_FR)
self.pf_BL = np.array(
[-self.foot_x / 2.0, self.foot_y / 2.0, -self.height])
self.WorldToFoot["BL"] = RpToTrans(Rwb, self.pf_BL)
self.pf_BR = np.array(
[-self.foot_x / 2.0, -self.foot_y / 2.0, -self.height])
self.WorldToFoot["BR"] = RpToTrans(Rwb, self.pf_BR)
def HipToFoot(self, orn, pos, T_bf):
"""
Converts a desired position and orientation wrt Spot's
home position, with a desired body-to-foot Transform
into a body-to-hip Transform, which is used to extract
and return the Hip To Foot Vector.
:param orn: A 3x1 np.array([]) with Spot's Roll, Pitch, Yaw angles
:param pos: A 3x1 np.array([]) with Spot's X, Y, Z coordinates
:param T_bf: Dictionary of desired body-to-foot Transforms.
:return: Hip To Foot Vector for each of Spot's Legs.
"""
# Following steps in attached document: SpotBodyIK.
# TODO: LINK DOC
# Only get Rot component
Rb, _ = TransToRp(RPY(orn[0], orn[1], orn[2]))
pb = pos
T_wb = RpToTrans(Rb, pb)
# Dictionary to store vectors
HipToFoot_List = OrderedDict()
for i, (key, T_wh) in enumerate(self.WorldToHip.items()):
# ORDER: FL, FR, FR, BL, BR
# Extract vector component
_, p_bf = TransToRp(T_bf[key])
# Step 1, get T_bh for each leg
T_bh = np.dot(TransInv(T_wb), T_wh)
# Step 2, get T_hf for each leg
# VECTOR ADDITION METHOD
_, p_bh = TransToRp(T_bh)
p_hf0 = p_bf - p_bh
# TRANSFORM METHOD
T_hf = np.dot(TransInv(T_bh), T_bf[key])
_, p_hf1 = TransToRp(T_hf)
# They should yield the same result
if p_hf1.all() != p_hf0.all():
print("NOT EQUAL")
p_hf = p_hf1
HipToFoot_List[key] = p_hf
return HipToFoot_List
def IK(self, orn, pos, T_bf):
"""
Uses HipToFoot() to convert a desired position
and orientation wrt Spot's home position into a
Hip To Foot Vector, which is fed into the LegIK solver.
Finally, the resultant joint angles are returned
from the LegIK solver for each leg.
:param orn: A 3x1 np.array([]) with Spot's Roll, Pitch, Yaw angles
:param pos: A 3x1 np.array([]) with Spot's X, Y, Z coordinates
:param T_bf: Dictionary of desired body-to-foot Transforms.
:return: Joint angles for each of Spot's joints.
"""
# Following steps in attached document: SpotBodyIK.
# TODO: LINK DOC
# Modify x by com offset
pos[0] += self.com_offset
# 4 legs, 3 joints per leg
joint_angles = np.zeros((4, 3))
# print("T_bf: {}".format(T_bf))
# Steps 1 and 2 of pipeline here
HipToFoot = self.HipToFoot(orn, pos, T_bf)
for i, (key, p_hf) in enumerate(HipToFoot.items()):
# ORDER: FL, FR, FR, BL, BR
# print("LEG: {} \t HipToFoot: {}".format(key, p_hf))
# Step 3, compute joint angles from T_hf for each leg
joint_angles[i, :] = self.Legs[key].solve(p_hf)
# print("-----------------------------")
return joint_angles
| 7,062 | Python | 33.120773 | 96 | 0.528887 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/Kinematics/LegKinematics.py | #!/usr/bin/env python
# https://www.researchgate.net/publication/320307716_Inverse_Kinematic_Analysis_Of_A_Quadruped_Robot
import numpy as np
class LegIK():
def __init__(self,
legtype="RIGHT",
shoulder_length=0.04,
elbow_length=0.1,
wrist_length=0.125,
hip_lim=[-0.548, 0.548],
shoulder_lim=[-2.17, 0.97],
leg_lim=[-0.1, 2.59]):
self.legtype = legtype
self.shoulder_length = shoulder_length
self.elbow_length = elbow_length
self.wrist_length = wrist_length
self.hip_lim = hip_lim
self.shoulder_lim = shoulder_lim
self.leg_lim = leg_lim
def get_domain(self, x, y, z):
"""
Calculates the leg's Domain and caps it in case of a breach
:param x,y,z: hip-to-foot distances in each dimension
:return: Leg Domain D
"""
D = (y**2 + (-z)**2 - self.shoulder_length**2 +
(-x)**2 - self.elbow_length**2 - self.wrist_length**2) / (
2 * self.wrist_length * self.elbow_length)
if D > 1 or D < -1:
# DOMAIN BREACHED
# print("---------DOMAIN BREACH---------")
D = np.clip(D, -1.0, 1.0)
return D
else:
return D
def solve(self, xyz_coord):
"""
Generic Leg Inverse Kinematics Solver
:param xyz_coord: hip-to-foot distances in each dimension
:return: Joint Angles required for desired position
"""
x = xyz_coord[0]
y = xyz_coord[1]
z = xyz_coord[2]
D = self.get_domain(x, y, z)
if self.legtype == "RIGHT":
return self.RightIK(x, y, z, D)
else:
return self.LeftIK(x, y, z, D)
def RightIK(self, x, y, z, D):
"""
Right Leg Inverse Kinematics Solver
:param x,y,z: hip-to-foot distances in each dimension
:param D: leg domain
:return: Joint Angles required for desired position
"""
wrist_angle = np.arctan2(-np.sqrt(1 - D**2), D)
sqrt_component = y**2 + (-z)**2 - self.shoulder_length**2
if sqrt_component < 0.0:
# print("NEGATIVE SQRT")
sqrt_component = 0.0
shoulder_angle = -np.arctan2(z, y) - np.arctan2(
np.sqrt(sqrt_component), -self.shoulder_length)
elbow_angle = np.arctan2(-x, np.sqrt(sqrt_component)) - np.arctan2(
self.wrist_length * np.sin(wrist_angle),
self.elbow_length + self.wrist_length * np.cos(wrist_angle))
joint_angles = np.array([-shoulder_angle, elbow_angle, wrist_angle])
return joint_angles
def LeftIK(self, x, y, z, D):
"""
Left Leg Inverse Kinematics Solver
:param x,y,z: hip-to-foot distances in each dimension
:param D: leg domain
:return: Joint Angles required for desired position
"""
wrist_angle = np.arctan2(-np.sqrt(1 - D**2), D)
sqrt_component = y**2 + (-z)**2 - self.shoulder_length**2
if sqrt_component < 0.0:
print("NEGATIVE SQRT")
sqrt_component = 0.0
shoulder_angle = -np.arctan2(z, y) - np.arctan2(
np.sqrt(sqrt_component), self.shoulder_length)
elbow_angle = np.arctan2(-x, np.sqrt(sqrt_component)) - np.arctan2(
self.wrist_length * np.sin(wrist_angle),
self.elbow_length + self.wrist_length * np.cos(wrist_angle))
joint_angles = np.array([-shoulder_angle, elbow_angle, wrist_angle])
return joint_angles
| 3,617 | Python | 35.918367 | 100 | 0.544927 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/Kinematics/LieAlgebra.py | #!/usr/bin/env python
import numpy as np
# NOTE: Code snippets from Modern Robotics at Northwestern University:
# See https://github.com/NxRLab/ModernRobotics
def RpToTrans(R, p):
"""
Converts a rotation matrix and a position vector into homogeneous
transformation matrix
:param R: A 3x3 rotation matrix
:param p: A 3-vector
:return: A homogeneous transformation matrix corresponding to the inputs
Example Input:
R = np.array([[1, 0, 0],
[0, 0, -1],
[0, 1, 0]])
p = np.array([1, 2, 5])
Output:
np.array([[1, 0, 0, 1],
[0, 0, -1, 2],
[0, 1, 0, 5],
[0, 0, 0, 1]])
"""
return np.r_[np.c_[R, p], [[0, 0, 0, 1]]]
def TransToRp(T):
"""
Converts a homogeneous transformation matrix into a rotation matrix
and position vector
:param T: A homogeneous transformation matrix
:return R: The corresponding rotation matrix,
:return p: The corresponding position vector.
Example Input:
T = np.array([[1, 0, 0, 0],
[0, 0, -1, 0],
[0, 1, 0, 3],
[0, 0, 0, 1]])
Output:
(np.array([[1, 0, 0],
[0, 0, -1],
[0, 1, 0]]),
np.array([0, 0, 3]))
"""
T = np.array(T)
return T[0:3, 0:3], T[0:3, 3]
def TransInv(T):
"""
Inverts a homogeneous transformation matrix
:param T: A homogeneous transformation matrix
:return: The inverse of T
Uses the structure of transformation matrices to avoid taking a matrix
inverse, for efficiency.
Example input:
T = np.array([[1, 0, 0, 0],
[0, 0, -1, 0],
[0, 1, 0, 3],
[0, 0, 0, 1]])
Output:
np.array([[1, 0, 0, 0],
[0, 0, 1, -3],
[0, -1, 0, 0],
[0, 0, 0, 1]])
"""
R, p = TransToRp(T)
Rt = np.array(R).T
return np.r_[np.c_[Rt, -np.dot(Rt, p)], [[0, 0, 0, 1]]]
def Adjoint(T):
"""
Computes the adjoint representation of a homogeneous transformation
matrix
:param T: A homogeneous transformation matrix
:return: The 6x6 adjoint representation [AdT] of T
Example Input:
T = np.array([[1, 0, 0, 0],
[0, 0, -1, 0],
[0, 1, 0, 3],
[0, 0, 0, 1]])
Output:
np.array([[1, 0, 0, 0, 0, 0],
[0, 0, -1, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 3, 1, 0, 0],
[3, 0, 0, 0, 0, -1],
[0, 0, 0, 0, 1, 0]])
"""
R, p = TransToRp(T)
return np.r_[np.c_[R, np.zeros((3, 3))], np.c_[np.dot(VecToso3(p), R), R]]
def VecToso3(omg):
"""
Converts a 3-vector to an so(3) representation
:param omg: A 3-vector
:return: The skew symmetric representation of omg
Example Input:
omg = np.array([1, 2, 3])
Output:
np.array([[ 0, -3, 2],
[ 3, 0, -1],
[-2, 1, 0]])
"""
return np.array([[0, -omg[2], omg[1]], [omg[2], 0, -omg[0]],
[-omg[1], omg[0], 0]])
def RPY(roll, pitch, yaw):
"""
Creates a Roll, Pitch, Yaw Transformation Matrix
:param roll: roll component of matrix
:param pitch: pitch component of matrix
:param yaw: yaw component of matrix
:return: The transformation matrix
Example Input:
roll = 0.0
pitch = 0.0
yaw = 0.0
Output:
np.array([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
"""
Roll = np.array([[1, 0, 0, 0], [0, np.cos(roll), -np.sin(roll), 0],
[0, np.sin(roll), np.cos(roll), 0], [0, 0, 0, 1]])
Pitch = np.array([[np.cos(pitch), 0, np.sin(pitch), 0], [0, 1, 0, 0],
[-np.sin(pitch), 0, np.cos(pitch), 0], [0, 0, 0, 1]])
Yaw = np.array([[np.cos(yaw), -np.sin(yaw), 0, 0],
[np.sin(yaw), np.cos(yaw), 0, 0], [0, 0, 1, 0],
[0, 0, 0, 1]])
return np.matmul(np.matmul(Roll, Pitch), Yaw)
def RotateTranslate(rotation, position):
"""
Creates a Transformation Matrix from a Rotation, THEN, a Translation
:param rotation: pure rotation matrix
:param translation: pure translation matrix
:return: The transformation matrix
"""
trans = np.eye(4)
trans[0, 3] = position[0]
trans[1, 3] = position[1]
trans[2, 3] = position[2]
return np.dot(rotation, trans)
def TransformVector(xyz_coord, rotation, translation):
"""
Transforms a vector by a specified Rotation THEN Translation Matrix
:param xyz_coord: the vector to transform
:param rotation: pure rotation matrix
:param translation: pure translation matrix
:return: The transformed vector
"""
xyz_vec = np.append(xyz_coord, 1.0)
Transformed = np.dot(RotateTranslate(rotation, translation), xyz_vec)
return Transformed[:3]
| 5,162 | Python | 27.213115 | 78 | 0.49012 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/util/gui.py | #!/usr/bin/env python
import pybullet as pb
import time
import numpy as np
import sys
class GUI:
def __init__(self, quadruped):
time.sleep(0.5)
self.cyaw = 0
self.cpitch = -7
self.cdist = 0.66
self.xId = pb.addUserDebugParameter("x", -0.10, 0.10, 0.)
self.yId = pb.addUserDebugParameter("y", -0.10, 0.10, 0.)
self.zId = pb.addUserDebugParameter("z", -0.055, 0.17, 0.)
self.rollId = pb.addUserDebugParameter("roll", -np.pi / 4, np.pi / 4,
0.)
self.pitchId = pb.addUserDebugParameter("pitch", -np.pi / 4, np.pi / 4,
0.)
self.yawId = pb.addUserDebugParameter("yaw", -np.pi / 4, np.pi / 4, 0.)
self.StepLengthID = pb.addUserDebugParameter("Step Length", -0.1, 0.1,
0.0)
self.YawRateId = pb.addUserDebugParameter("Yaw Rate", -2.0, 2.0, 0.)
self.LateralFractionId = pb.addUserDebugParameter(
"Lateral Fraction", -np.pi / 2.0, np.pi / 2.0, 0.)
self.StepVelocityId = pb.addUserDebugParameter("Step Velocity", 0.001,
3., 0.001)
self.SwingPeriodId = pb.addUserDebugParameter("Swing Period", 0.1, 0.4,
0.2)
self.ClearanceHeightId = pb.addUserDebugParameter(
"Clearance Height", 0.0, 0.1, 0.045)
self.PenetrationDepthId = pb.addUserDebugParameter(
"Penetration Depth", 0.0, 0.05, 0.003)
self.quadruped = quadruped
def UserInput(self):
quadruped_pos, _ = pb.getBasePositionAndOrientation(self.quadruped)
pb.resetDebugVisualizerCamera(cameraDistance=self.cdist,
cameraYaw=self.cyaw,
cameraPitch=self.cpitch,
cameraTargetPosition=quadruped_pos)
keys = pb.getKeyboardEvents()
# Keys to change camera
if keys.get(100): # D
self.cyaw += 1
if keys.get(97): # A
self.cyaw -= 1
if keys.get(99): # C
self.cpitch += 1
if keys.get(102): # F
self.cpitch -= 1
if keys.get(122): # Z
self.cdist += .01
if keys.get(120): # X
self.cdist -= .01
if keys.get(27): # ESC
pb.disconnect()
sys.exit()
# Read Robot Transform from GUI
pos = np.array([
pb.readUserDebugParameter(self.xId),
pb.readUserDebugParameter(self.yId),
pb.readUserDebugParameter(self.zId)
])
orn = np.array([
pb.readUserDebugParameter(self.rollId),
pb.readUserDebugParameter(self.pitchId),
pb.readUserDebugParameter(self.yawId)
])
StepLength = pb.readUserDebugParameter(self.StepLengthID)
YawRate = pb.readUserDebugParameter(self.YawRateId)
LateralFraction = pb.readUserDebugParameter(self.LateralFractionId)
StepVelocity = pb.readUserDebugParameter(self.StepVelocityId)
ClearanceHeight = pb.readUserDebugParameter(self.ClearanceHeightId)
PenetrationDepth = pb.readUserDebugParameter(self.PenetrationDepthId)
SwingPeriod = pb.readUserDebugParameter(self.SwingPeriodId)
return pos, orn, StepLength, LateralFraction, YawRate, StepVelocity, ClearanceHeight, PenetrationDepth, SwingPeriod
| 3,557 | Python | 39.431818 | 123 | 0.555243 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spotmicro/util/action_mapper.py | STATIC_ACTIONS_MAP = {
'gallop': ('rex_gym/policies/galloping/balanced', 'model.ckpt-20000000'),
'walk': ('rex_gym/policies/walking/alternating_legs', 'model.ckpt-16000000'),
'standup': ('rex_gym/policies/standup', 'model.ckpt-10000000')
}
DYNAMIC_ACTIONS_MAP = {
'turn': ('rex_gym/policies/turn', 'model.ckpt-16000000')
}
ACTIONS_TO_ENV_NAMES = {
'gallop': 'RexReactiveEnv',
'walk': 'RexWalkEnv',
'turn': 'RexTurnEnv',
'standup': 'RexStandupEnv'
}
| 483 | Python | 27.470587 | 81 | 0.648033 |
Subsets and Splits