file_path
stringlengths 21
224
| content
stringlengths 0
80.8M
|
|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/move_base_msgs/MoveBaseResult.h | #ifndef _ROS_move_base_msgs_MoveBaseResult_h
#define _ROS_move_base_msgs_MoveBaseResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace move_base_msgs
{
class MoveBaseResult : public ros::Msg
{
public:
MoveBaseResult()
{
}
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 "move_base_msgs/MoveBaseResult"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/move_base_msgs/MoveBaseFeedback.h | #ifndef _ROS_move_base_msgs_MoveBaseFeedback_h
#define _ROS_move_base_msgs_MoveBaseFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
namespace move_base_msgs
{
class MoveBaseFeedback : public ros::Msg
{
public:
typedef geometry_msgs::PoseStamped _base_position_type;
_base_position_type base_position;
MoveBaseFeedback():
base_position()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->base_position.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->base_position.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "move_base_msgs/MoveBaseFeedback"; };
const char * getMD5(){ return "3fb824c456a757373a226f6d08071bf0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/move_base_msgs/MoveBaseActionResult.h | #ifndef _ROS_move_base_msgs_MoveBaseActionResult_h
#define _ROS_move_base_msgs_MoveBaseActionResult_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 "move_base_msgs/MoveBaseResult.h"
namespace move_base_msgs
{
class MoveBaseActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef move_base_msgs::MoveBaseResult _result_type;
_result_type result;
MoveBaseActionResult():
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 "move_base_msgs/MoveBaseActionResult"; };
const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/move_base_msgs/MoveBaseActionFeedback.h | #ifndef _ROS_move_base_msgs_MoveBaseActionFeedback_h
#define _ROS_move_base_msgs_MoveBaseActionFeedback_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 "move_base_msgs/MoveBaseFeedback.h"
namespace move_base_msgs
{
class MoveBaseActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef move_base_msgs::MoveBaseFeedback _feedback_type;
_feedback_type feedback;
MoveBaseActionFeedback():
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 "move_base_msgs/MoveBaseActionFeedback"; };
const char * getMD5(){ return "7d1870ff6e0decea702b943b5af0b42e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectRecognitionAction.h | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionAction_h
#define _ROS_object_recognition_msgs_ObjectRecognitionAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "object_recognition_msgs/ObjectRecognitionActionGoal.h"
#include "object_recognition_msgs/ObjectRecognitionActionResult.h"
#include "object_recognition_msgs/ObjectRecognitionActionFeedback.h"
namespace object_recognition_msgs
{
class ObjectRecognitionAction : public ros::Msg
{
public:
typedef object_recognition_msgs::ObjectRecognitionActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef object_recognition_msgs::ObjectRecognitionActionResult _action_result_type;
_action_result_type action_result;
typedef object_recognition_msgs::ObjectRecognitionActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
ObjectRecognitionAction():
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 "object_recognition_msgs/ObjectRecognitionAction"; };
const char * getMD5(){ return "7d8979a0cf97e5078553ee3efee047d2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectRecognitionActionGoal.h | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionActionGoal_h
#define _ROS_object_recognition_msgs_ObjectRecognitionActionGoal_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 "object_recognition_msgs/ObjectRecognitionGoal.h"
namespace object_recognition_msgs
{
class ObjectRecognitionActionGoal : 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 object_recognition_msgs::ObjectRecognitionGoal _goal_type;
_goal_type goal;
ObjectRecognitionActionGoal():
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 "object_recognition_msgs/ObjectRecognitionActionGoal"; };
const char * getMD5(){ return "195eff91387a5f42dbd13be53431366b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectRecognitionGoal.h | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionGoal_h
#define _ROS_object_recognition_msgs_ObjectRecognitionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace object_recognition_msgs
{
class ObjectRecognitionGoal : public ros::Msg
{
public:
typedef bool _use_roi_type;
_use_roi_type use_roi;
uint32_t filter_limits_length;
typedef float _filter_limits_type;
_filter_limits_type st_filter_limits;
_filter_limits_type * filter_limits;
ObjectRecognitionGoal():
use_roi(0),
filter_limits_length(0), filter_limits(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_use_roi;
u_use_roi.real = this->use_roi;
*(outbuffer + offset + 0) = (u_use_roi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->use_roi);
*(outbuffer + offset + 0) = (this->filter_limits_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->filter_limits_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->filter_limits_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->filter_limits_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->filter_limits_length);
for( uint32_t i = 0; i < filter_limits_length; i++){
union {
float real;
uint32_t base;
} u_filter_limitsi;
u_filter_limitsi.real = this->filter_limits[i];
*(outbuffer + offset + 0) = (u_filter_limitsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_filter_limitsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_filter_limitsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_filter_limitsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->filter_limits[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_use_roi;
u_use_roi.base = 0;
u_use_roi.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->use_roi = u_use_roi.real;
offset += sizeof(this->use_roi);
uint32_t filter_limits_lengthT = ((uint32_t) (*(inbuffer + offset)));
filter_limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
filter_limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
filter_limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->filter_limits_length);
if(filter_limits_lengthT > filter_limits_length)
this->filter_limits = (float*)realloc(this->filter_limits, filter_limits_lengthT * sizeof(float));
filter_limits_length = filter_limits_lengthT;
for( uint32_t i = 0; i < filter_limits_length; i++){
union {
float real;
uint32_t base;
} u_st_filter_limits;
u_st_filter_limits.base = 0;
u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_filter_limits = u_st_filter_limits.real;
offset += sizeof(this->st_filter_limits);
memcpy( &(this->filter_limits[i]), &(this->st_filter_limits), sizeof(float));
}
return offset;
}
const char * getType(){ return "object_recognition_msgs/ObjectRecognitionGoal"; };
const char * getMD5(){ return "49bea2f03a1bba0ad05926e01e3525fa"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectType.h | #ifndef _ROS_object_recognition_msgs_ObjectType_h
#define _ROS_object_recognition_msgs_ObjectType_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace object_recognition_msgs
{
class ObjectType : public ros::Msg
{
public:
typedef const char* _key_type;
_key_type key;
typedef const char* _db_type;
_db_type db;
ObjectType():
key(""),
db("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_key = strlen(this->key);
varToArr(outbuffer + offset, length_key);
offset += 4;
memcpy(outbuffer + offset, this->key, length_key);
offset += length_key;
uint32_t length_db = strlen(this->db);
varToArr(outbuffer + offset, length_db);
offset += 4;
memcpy(outbuffer + offset, this->db, length_db);
offset += length_db;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_key;
arrToVar(length_key, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_key; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_key-1]=0;
this->key = (char *)(inbuffer + offset-1);
offset += length_key;
uint32_t length_db;
arrToVar(length_db, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_db; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_db-1]=0;
this->db = (char *)(inbuffer + offset-1);
offset += length_db;
return offset;
}
const char * getType(){ return "object_recognition_msgs/ObjectType"; };
const char * getMD5(){ return "ac757ec5be1998b0167e7efcda79e3cf"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/RecognizedObjectArray.h | #ifndef _ROS_object_recognition_msgs_RecognizedObjectArray_h
#define _ROS_object_recognition_msgs_RecognizedObjectArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "object_recognition_msgs/RecognizedObject.h"
namespace object_recognition_msgs
{
class RecognizedObjectArray : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t objects_length;
typedef object_recognition_msgs::RecognizedObject _objects_type;
_objects_type st_objects;
_objects_type * objects;
uint32_t cooccurrence_length;
typedef float _cooccurrence_type;
_cooccurrence_type st_cooccurrence;
_cooccurrence_type * cooccurrence;
RecognizedObjectArray():
header(),
objects_length(0), objects(NULL),
cooccurrence_length(0), cooccurrence(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->objects_length);
for( uint32_t i = 0; i < objects_length; i++){
offset += this->objects[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->cooccurrence_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cooccurrence_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cooccurrence_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cooccurrence_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cooccurrence_length);
for( uint32_t i = 0; i < cooccurrence_length; i++){
union {
float real;
uint32_t base;
} u_cooccurrencei;
u_cooccurrencei.real = this->cooccurrence[i];
*(outbuffer + offset + 0) = (u_cooccurrencei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cooccurrencei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cooccurrencei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cooccurrencei.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cooccurrence[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->objects_length);
if(objects_lengthT > objects_length)
this->objects = (object_recognition_msgs::RecognizedObject*)realloc(this->objects, objects_lengthT * sizeof(object_recognition_msgs::RecognizedObject));
objects_length = objects_lengthT;
for( uint32_t i = 0; i < objects_length; i++){
offset += this->st_objects.deserialize(inbuffer + offset);
memcpy( &(this->objects[i]), &(this->st_objects), sizeof(object_recognition_msgs::RecognizedObject));
}
uint32_t cooccurrence_lengthT = ((uint32_t) (*(inbuffer + offset)));
cooccurrence_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cooccurrence_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cooccurrence_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cooccurrence_length);
if(cooccurrence_lengthT > cooccurrence_length)
this->cooccurrence = (float*)realloc(this->cooccurrence, cooccurrence_lengthT * sizeof(float));
cooccurrence_length = cooccurrence_lengthT;
for( uint32_t i = 0; i < cooccurrence_length; i++){
union {
float real;
uint32_t base;
} u_st_cooccurrence;
u_st_cooccurrence.base = 0;
u_st_cooccurrence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_cooccurrence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_cooccurrence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_cooccurrence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_cooccurrence = u_st_cooccurrence.real;
offset += sizeof(this->st_cooccurrence);
memcpy( &(this->cooccurrence[i]), &(this->st_cooccurrence), sizeof(float));
}
return offset;
}
const char * getType(){ return "object_recognition_msgs/RecognizedObjectArray"; };
const char * getMD5(){ return "bad6b1546b9ebcabb49fb3b858d78964"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/Table.h | #ifndef _ROS_object_recognition_msgs_Table_h
#define _ROS_object_recognition_msgs_Table_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 object_recognition_msgs
{
class Table : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
uint32_t convex_hull_length;
typedef geometry_msgs::Point _convex_hull_type;
_convex_hull_type st_convex_hull;
_convex_hull_type * convex_hull;
Table():
header(),
pose(),
convex_hull_length(0), convex_hull(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->convex_hull_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->convex_hull_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->convex_hull_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->convex_hull_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->convex_hull_length);
for( uint32_t i = 0; i < convex_hull_length; i++){
offset += this->convex_hull[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 convex_hull_lengthT = ((uint32_t) (*(inbuffer + offset)));
convex_hull_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
convex_hull_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
convex_hull_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->convex_hull_length);
if(convex_hull_lengthT > convex_hull_length)
this->convex_hull = (geometry_msgs::Point*)realloc(this->convex_hull, convex_hull_lengthT * sizeof(geometry_msgs::Point));
convex_hull_length = convex_hull_lengthT;
for( uint32_t i = 0; i < convex_hull_length; i++){
offset += this->st_convex_hull.deserialize(inbuffer + offset);
memcpy( &(this->convex_hull[i]), &(this->st_convex_hull), sizeof(geometry_msgs::Point));
}
return offset;
}
const char * getType(){ return "object_recognition_msgs/Table"; };
const char * getMD5(){ return "39efebc7d51e44bd2d72f2df6c7823a2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/TableArray.h | #ifndef _ROS_object_recognition_msgs_TableArray_h
#define _ROS_object_recognition_msgs_TableArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "object_recognition_msgs/Table.h"
namespace object_recognition_msgs
{
class TableArray : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t tables_length;
typedef object_recognition_msgs::Table _tables_type;
_tables_type st_tables;
_tables_type * tables;
TableArray():
header(),
tables_length(0), tables(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->tables_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->tables_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->tables_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->tables_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->tables_length);
for( uint32_t i = 0; i < tables_length; i++){
offset += this->tables[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t tables_lengthT = ((uint32_t) (*(inbuffer + offset)));
tables_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
tables_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
tables_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->tables_length);
if(tables_lengthT > tables_length)
this->tables = (object_recognition_msgs::Table*)realloc(this->tables, tables_lengthT * sizeof(object_recognition_msgs::Table));
tables_length = tables_lengthT;
for( uint32_t i = 0; i < tables_length; i++){
offset += this->st_tables.deserialize(inbuffer + offset);
memcpy( &(this->tables[i]), &(this->st_tables), sizeof(object_recognition_msgs::Table));
}
return offset;
}
const char * getType(){ return "object_recognition_msgs/TableArray"; };
const char * getMD5(){ return "d1c853e5acd0ed273eb6682dc01ab428"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectRecognitionResult.h | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionResult_h
#define _ROS_object_recognition_msgs_ObjectRecognitionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "object_recognition_msgs/RecognizedObjectArray.h"
namespace object_recognition_msgs
{
class ObjectRecognitionResult : public ros::Msg
{
public:
typedef object_recognition_msgs::RecognizedObjectArray _recognized_objects_type;
_recognized_objects_type recognized_objects;
ObjectRecognitionResult():
recognized_objects()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->recognized_objects.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->recognized_objects.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "object_recognition_msgs/ObjectRecognitionResult"; };
const char * getMD5(){ return "868e41288f9f8636e2b6c51f1af6aa9c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/RecognizedObject.h | #ifndef _ROS_object_recognition_msgs_RecognizedObject_h
#define _ROS_object_recognition_msgs_RecognizedObject_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "object_recognition_msgs/ObjectType.h"
#include "sensor_msgs/PointCloud2.h"
#include "shape_msgs/Mesh.h"
#include "geometry_msgs/Point.h"
#include "geometry_msgs/PoseWithCovarianceStamped.h"
namespace object_recognition_msgs
{
class RecognizedObject : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef object_recognition_msgs::ObjectType _type_type;
_type_type type;
typedef float _confidence_type;
_confidence_type confidence;
uint32_t point_clouds_length;
typedef sensor_msgs::PointCloud2 _point_clouds_type;
_point_clouds_type st_point_clouds;
_point_clouds_type * point_clouds;
typedef shape_msgs::Mesh _bounding_mesh_type;
_bounding_mesh_type bounding_mesh;
uint32_t bounding_contours_length;
typedef geometry_msgs::Point _bounding_contours_type;
_bounding_contours_type st_bounding_contours;
_bounding_contours_type * bounding_contours;
typedef geometry_msgs::PoseWithCovarianceStamped _pose_type;
_pose_type pose;
RecognizedObject():
header(),
type(),
confidence(0),
point_clouds_length(0), point_clouds(NULL),
bounding_mesh(),
bounding_contours_length(0), bounding_contours(NULL),
pose()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->type.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_confidence;
u_confidence.real = this->confidence;
*(outbuffer + offset + 0) = (u_confidence.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_confidence.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_confidence.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_confidence.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->confidence);
*(outbuffer + offset + 0) = (this->point_clouds_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->point_clouds_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->point_clouds_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->point_clouds_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->point_clouds_length);
for( uint32_t i = 0; i < point_clouds_length; i++){
offset += this->point_clouds[i].serialize(outbuffer + offset);
}
offset += this->bounding_mesh.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->bounding_contours_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->bounding_contours_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->bounding_contours_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->bounding_contours_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->bounding_contours_length);
for( uint32_t i = 0; i < bounding_contours_length; i++){
offset += this->bounding_contours[i].serialize(outbuffer + offset);
}
offset += this->pose.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->type.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_confidence;
u_confidence.base = 0;
u_confidence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_confidence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_confidence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_confidence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->confidence = u_confidence.real;
offset += sizeof(this->confidence);
uint32_t point_clouds_lengthT = ((uint32_t) (*(inbuffer + offset)));
point_clouds_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
point_clouds_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
point_clouds_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->point_clouds_length);
if(point_clouds_lengthT > point_clouds_length)
this->point_clouds = (sensor_msgs::PointCloud2*)realloc(this->point_clouds, point_clouds_lengthT * sizeof(sensor_msgs::PointCloud2));
point_clouds_length = point_clouds_lengthT;
for( uint32_t i = 0; i < point_clouds_length; i++){
offset += this->st_point_clouds.deserialize(inbuffer + offset);
memcpy( &(this->point_clouds[i]), &(this->st_point_clouds), sizeof(sensor_msgs::PointCloud2));
}
offset += this->bounding_mesh.deserialize(inbuffer + offset);
uint32_t bounding_contours_lengthT = ((uint32_t) (*(inbuffer + offset)));
bounding_contours_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
bounding_contours_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
bounding_contours_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->bounding_contours_length);
if(bounding_contours_lengthT > bounding_contours_length)
this->bounding_contours = (geometry_msgs::Point*)realloc(this->bounding_contours, bounding_contours_lengthT * sizeof(geometry_msgs::Point));
bounding_contours_length = bounding_contours_lengthT;
for( uint32_t i = 0; i < bounding_contours_length; i++){
offset += this->st_bounding_contours.deserialize(inbuffer + offset);
memcpy( &(this->bounding_contours[i]), &(this->st_bounding_contours), sizeof(geometry_msgs::Point));
}
offset += this->pose.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "object_recognition_msgs/RecognizedObject"; };
const char * getMD5(){ return "f92c4cb29ba11f26c5f7219de97e900d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectRecognitionActionFeedback.h | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionActionFeedback_h
#define _ROS_object_recognition_msgs_ObjectRecognitionActionFeedback_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 "object_recognition_msgs/ObjectRecognitionFeedback.h"
namespace object_recognition_msgs
{
class ObjectRecognitionActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef object_recognition_msgs::ObjectRecognitionFeedback _feedback_type;
_feedback_type feedback;
ObjectRecognitionActionFeedback():
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 "object_recognition_msgs/ObjectRecognitionActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectRecognitionFeedback.h | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionFeedback_h
#define _ROS_object_recognition_msgs_ObjectRecognitionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace object_recognition_msgs
{
class ObjectRecognitionFeedback : public ros::Msg
{
public:
ObjectRecognitionFeedback()
{
}
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 "object_recognition_msgs/ObjectRecognitionFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/GetObjectInformation.h | #ifndef _ROS_SERVICE_GetObjectInformation_h
#define _ROS_SERVICE_GetObjectInformation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "object_recognition_msgs/ObjectType.h"
#include "object_recognition_msgs/ObjectInformation.h"
namespace object_recognition_msgs
{
static const char GETOBJECTINFORMATION[] = "object_recognition_msgs/GetObjectInformation";
class GetObjectInformationRequest : public ros::Msg
{
public:
typedef object_recognition_msgs::ObjectType _type_type;
_type_type type;
GetObjectInformationRequest():
type()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->type.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->type.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETOBJECTINFORMATION; };
const char * getMD5(){ return "0d72b69e80da0fe473b0bdcdd7a28d4d"; };
};
class GetObjectInformationResponse : public ros::Msg
{
public:
typedef object_recognition_msgs::ObjectInformation _information_type;
_information_type information;
GetObjectInformationResponse():
information()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->information.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->information.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETOBJECTINFORMATION; };
const char * getMD5(){ return "a62c5d1c41e250373b3e8e912a13a9cb"; };
};
class GetObjectInformation {
public:
typedef GetObjectInformationRequest Request;
typedef GetObjectInformationResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectInformation.h | #ifndef _ROS_object_recognition_msgs_ObjectInformation_h
#define _ROS_object_recognition_msgs_ObjectInformation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "shape_msgs/Mesh.h"
#include "sensor_msgs/PointCloud2.h"
namespace object_recognition_msgs
{
class ObjectInformation : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef shape_msgs::Mesh _ground_truth_mesh_type;
_ground_truth_mesh_type ground_truth_mesh;
typedef sensor_msgs::PointCloud2 _ground_truth_point_cloud_type;
_ground_truth_point_cloud_type ground_truth_point_cloud;
ObjectInformation():
name(""),
ground_truth_mesh(),
ground_truth_point_cloud()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
offset += this->ground_truth_mesh.serialize(outbuffer + offset);
offset += this->ground_truth_point_cloud.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
offset += this->ground_truth_mesh.deserialize(inbuffer + offset);
offset += this->ground_truth_point_cloud.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "object_recognition_msgs/ObjectInformation"; };
const char * getMD5(){ return "921ec39f51c7b927902059cf3300ecde"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/object_recognition_msgs/ObjectRecognitionActionResult.h | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionActionResult_h
#define _ROS_object_recognition_msgs_ObjectRecognitionActionResult_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 "object_recognition_msgs/ObjectRecognitionResult.h"
namespace object_recognition_msgs
{
class ObjectRecognitionActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef object_recognition_msgs::ObjectRecognitionResult _result_type;
_result_type result;
ObjectRecognitionActionResult():
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 "object_recognition_msgs/ObjectRecognitionActionResult"; };
const char * getMD5(){ return "1ef766aeca50bc1bb70773fc73d4471d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp_tutorials/TwoInts.h | #ifndef _ROS_SERVICE_TwoInts_h
#define _ROS_SERVICE_TwoInts_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace roscpp_tutorials
{
static const char TWOINTS[] = "roscpp_tutorials/TwoInts";
class TwoIntsRequest : public ros::Msg
{
public:
typedef int64_t _a_type;
_a_type a;
typedef int64_t _b_type;
_b_type b;
TwoIntsRequest():
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 TWOINTS; };
const char * getMD5(){ return "36d09b846be0b371c5f190354dd3153e"; };
};
class TwoIntsResponse : public ros::Msg
{
public:
typedef int64_t _sum_type;
_sum_type sum;
TwoIntsResponse():
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 TWOINTS; };
const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
};
class TwoInts {
public:
typedef TwoIntsRequest Request;
typedef TwoIntsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/PointStamped.h | #ifndef _ROS_geometry_msgs_PointStamped_h
#define _ROS_geometry_msgs_PointStamped_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 geometry_msgs
{
class PointStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Point _point_type;
_point_type point;
PointStamped():
header(),
point()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->point.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->point.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/PointStamped"; };
const char * getMD5(){ return "c63aecb41bfdfd6b7e1fac37c7cbe7bf"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Quaternion.h | #ifndef _ROS_geometry_msgs_Quaternion_h
#define _ROS_geometry_msgs_Quaternion_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace geometry_msgs
{
class Quaternion : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
typedef double _w_type;
_w_type w;
Quaternion():
x(0),
y(0),
z(0),
w(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->z);
union {
double real;
uint64_t base;
} u_w;
u_w.real = this->w;
*(outbuffer + offset + 0) = (u_w.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_w.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_w.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_w.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_w.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_w.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_w.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_w.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->w);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->z = u_z.real;
offset += sizeof(this->z);
union {
double real;
uint64_t base;
} u_w;
u_w.base = 0;
u_w.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_w.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_w.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_w.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_w.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_w.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_w.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_w.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->w = u_w.real;
offset += sizeof(this->w);
return offset;
}
const char * getType(){ return "geometry_msgs/Quaternion"; };
const char * getMD5(){ return "a779879fadf0160734f906b8c19c7004"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Pose2D.h | #ifndef _ROS_geometry_msgs_Pose2D_h
#define _ROS_geometry_msgs_Pose2D_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace geometry_msgs
{
class Pose2D : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _theta_type;
_theta_type theta;
Pose2D():
x(0),
y(0),
theta(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_theta;
u_theta.real = this->theta;
*(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_theta.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_theta.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_theta.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_theta.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->theta);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_theta;
u_theta.base = 0;
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_theta.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->theta = u_theta.real;
offset += sizeof(this->theta);
return offset;
}
const char * getType(){ return "geometry_msgs/Pose2D"; };
const char * getMD5(){ return "938fa65709584ad8e77d238529be13b8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Accel.h | #ifndef _ROS_geometry_msgs_Accel_h
#define _ROS_geometry_msgs_Accel_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
namespace geometry_msgs
{
class Accel : public ros::Msg
{
public:
typedef geometry_msgs::Vector3 _linear_type;
_linear_type linear;
typedef geometry_msgs::Vector3 _angular_type;
_angular_type angular;
Accel():
linear(),
angular()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->linear.serialize(outbuffer + offset);
offset += this->angular.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->linear.deserialize(inbuffer + offset);
offset += this->angular.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/Accel"; };
const char * getMD5(){ return "9f195f881246fdfa2798d1d3eebca84a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/PoseWithCovariance.h | #ifndef _ROS_geometry_msgs_PoseWithCovariance_h
#define _ROS_geometry_msgs_PoseWithCovariance_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace geometry_msgs
{
class PoseWithCovariance : public ros::Msg
{
public:
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
double covariance[36];
PoseWithCovariance():
pose(),
covariance()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->pose.serialize(outbuffer + offset);
for( uint32_t i = 0; i < 36; i++){
union {
double real;
uint64_t base;
} u_covariancei;
u_covariancei.real = this->covariance[i];
*(outbuffer + offset + 0) = (u_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->covariance[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->pose.deserialize(inbuffer + offset);
for( uint32_t i = 0; i < 36; i++){
union {
double real;
uint64_t base;
} u_covariancei;
u_covariancei.base = 0;
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->covariance[i] = u_covariancei.real;
offset += sizeof(this->covariance[i]);
}
return offset;
}
const char * getType(){ return "geometry_msgs/PoseWithCovariance"; };
const char * getMD5(){ return "c23e848cf1b7533a8d7c259073a97e6f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/PoseArray.h | #ifndef _ROS_geometry_msgs_PoseArray_h
#define _ROS_geometry_msgs_PoseArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
namespace geometry_msgs
{
class PoseArray : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t poses_length;
typedef geometry_msgs::Pose _poses_type;
_poses_type st_poses;
_poses_type * poses;
PoseArray():
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::Pose*)realloc(this->poses, poses_lengthT * sizeof(geometry_msgs::Pose));
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::Pose));
}
return offset;
}
const char * getType(){ return "geometry_msgs/PoseArray"; };
const char * getMD5(){ return "916c28c5764443f268b296bb671b9d97"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Wrench.h | #ifndef _ROS_geometry_msgs_Wrench_h
#define _ROS_geometry_msgs_Wrench_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
namespace geometry_msgs
{
class Wrench : public ros::Msg
{
public:
typedef geometry_msgs::Vector3 _force_type;
_force_type force;
typedef geometry_msgs::Vector3 _torque_type;
_torque_type torque;
Wrench():
force(),
torque()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->force.serialize(outbuffer + offset);
offset += this->torque.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->force.deserialize(inbuffer + offset);
offset += this->torque.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/Wrench"; };
const char * getMD5(){ return "4f539cf138b23283b520fd271b567936"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Point32.h | #ifndef _ROS_geometry_msgs_Point32_h
#define _ROS_geometry_msgs_Point32_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace geometry_msgs
{
class Point32 : public ros::Msg
{
public:
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _z_type;
_z_type z;
Point32():
x(0),
y(0),
z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->z = u_z.real;
offset += sizeof(this->z);
return offset;
}
const char * getType(){ return "geometry_msgs/Point32"; };
const char * getMD5(){ return "cc153912f1453b708d221682bc23d9ac"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/TwistWithCovarianceStamped.h | #ifndef _ROS_geometry_msgs_TwistWithCovarianceStamped_h
#define _ROS_geometry_msgs_TwistWithCovarianceStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/TwistWithCovariance.h"
namespace geometry_msgs
{
class TwistWithCovarianceStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::TwistWithCovariance _twist_type;
_twist_type twist;
TwistWithCovarianceStamped():
header(),
twist()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.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);
offset += this->twist.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/TwistWithCovarianceStamped"; };
const char * getMD5(){ return "8927a1a12fb2607ceea095b2dc440a96"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Twist.h | #ifndef _ROS_geometry_msgs_Twist_h
#define _ROS_geometry_msgs_Twist_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
namespace geometry_msgs
{
class Twist : public ros::Msg
{
public:
typedef geometry_msgs::Vector3 _linear_type;
_linear_type linear;
typedef geometry_msgs::Vector3 _angular_type;
_angular_type angular;
Twist():
linear(),
angular()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->linear.serialize(outbuffer + offset);
offset += this->angular.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->linear.deserialize(inbuffer + offset);
offset += this->angular.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/Twist"; };
const char * getMD5(){ return "9f195f881246fdfa2798d1d3eebca84a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Polygon.h | #ifndef _ROS_geometry_msgs_Polygon_h
#define _ROS_geometry_msgs_Polygon_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Point32.h"
namespace geometry_msgs
{
class Polygon : public ros::Msg
{
public:
uint32_t points_length;
typedef geometry_msgs::Point32 _points_type;
_points_type st_points;
_points_type * points;
Polygon():
points_length(0), points(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->points_length);
for( uint32_t i = 0; i < points_length; i++){
offset += this->points[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->points_length);
if(points_lengthT > points_length)
this->points = (geometry_msgs::Point32*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point32));
points_length = points_lengthT;
for( uint32_t i = 0; i < points_length; i++){
offset += this->st_points.deserialize(inbuffer + offset);
memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point32));
}
return offset;
}
const char * getType(){ return "geometry_msgs/Polygon"; };
const char * getMD5(){ return "cd60a26494a087f577976f0329fa120e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/WrenchStamped.h | #ifndef _ROS_geometry_msgs_WrenchStamped_h
#define _ROS_geometry_msgs_WrenchStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Wrench.h"
namespace geometry_msgs
{
class WrenchStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type wrench;
WrenchStamped():
header(),
wrench()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->wrench.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->wrench.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/WrenchStamped"; };
const char * getMD5(){ return "d78d3cb249ce23087ade7e7d0c40cfa7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/TwistStamped.h | #ifndef _ROS_geometry_msgs_TwistStamped_h
#define _ROS_geometry_msgs_TwistStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Twist.h"
namespace geometry_msgs
{
class TwistStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
TwistStamped():
header(),
twist()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.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);
offset += this->twist.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/TwistStamped"; };
const char * getMD5(){ return "98d34b0043a2093cf9d9345ab6eef12e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Point.h | #ifndef _ROS_geometry_msgs_Point_h
#define _ROS_geometry_msgs_Point_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace geometry_msgs
{
class Point : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
Point():
x(0),
y(0),
z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->z = u_z.real;
offset += sizeof(this->z);
return offset;
}
const char * getType(){ return "geometry_msgs/Point"; };
const char * getMD5(){ return "4a842b65f413084dc2b10fb484ea7f17"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/InertiaStamped.h | #ifndef _ROS_geometry_msgs_InertiaStamped_h
#define _ROS_geometry_msgs_InertiaStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Inertia.h"
namespace geometry_msgs
{
class InertiaStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Inertia _inertia_type;
_inertia_type inertia;
InertiaStamped():
header(),
inertia()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->inertia.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->inertia.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/InertiaStamped"; };
const char * getMD5(){ return "ddee48caeab5a966c5e8d166654a9ac7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/PoseStamped.h | #ifndef _ROS_geometry_msgs_PoseStamped_h
#define _ROS_geometry_msgs_PoseStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
namespace geometry_msgs
{
class PoseStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
PoseStamped():
header(),
pose()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.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);
return offset;
}
const char * getType(){ return "geometry_msgs/PoseStamped"; };
const char * getMD5(){ return "d3812c3cbc69362b77dc0b19b345f8f5"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/AccelWithCovariance.h | #ifndef _ROS_geometry_msgs_AccelWithCovariance_h
#define _ROS_geometry_msgs_AccelWithCovariance_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Accel.h"
namespace geometry_msgs
{
class AccelWithCovariance : public ros::Msg
{
public:
typedef geometry_msgs::Accel _accel_type;
_accel_type accel;
double covariance[36];
AccelWithCovariance():
accel(),
covariance()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->accel.serialize(outbuffer + offset);
for( uint32_t i = 0; i < 36; i++){
union {
double real;
uint64_t base;
} u_covariancei;
u_covariancei.real = this->covariance[i];
*(outbuffer + offset + 0) = (u_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->covariance[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->accel.deserialize(inbuffer + offset);
for( uint32_t i = 0; i < 36; i++){
union {
double real;
uint64_t base;
} u_covariancei;
u_covariancei.base = 0;
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->covariance[i] = u_covariancei.real;
offset += sizeof(this->covariance[i]);
}
return offset;
}
const char * getType(){ return "geometry_msgs/AccelWithCovariance"; };
const char * getMD5(){ return "ad5a718d699c6be72a02b8d6a139f334"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Transform.h | #ifndef _ROS_geometry_msgs_Transform_h
#define _ROS_geometry_msgs_Transform_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
#include "geometry_msgs/Quaternion.h"
namespace geometry_msgs
{
class Transform : public ros::Msg
{
public:
typedef geometry_msgs::Vector3 _translation_type;
_translation_type translation;
typedef geometry_msgs::Quaternion _rotation_type;
_rotation_type rotation;
Transform():
translation(),
rotation()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->translation.serialize(outbuffer + offset);
offset += this->rotation.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->translation.deserialize(inbuffer + offset);
offset += this->rotation.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/Transform"; };
const char * getMD5(){ return "ac9eff44abf714214112b05d54a3cf9b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/AccelWithCovarianceStamped.h | #ifndef _ROS_geometry_msgs_AccelWithCovarianceStamped_h
#define _ROS_geometry_msgs_AccelWithCovarianceStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/AccelWithCovariance.h"
namespace geometry_msgs
{
class AccelWithCovarianceStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::AccelWithCovariance _accel_type;
_accel_type accel;
AccelWithCovarianceStamped():
header(),
accel()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->accel.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->accel.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/AccelWithCovarianceStamped"; };
const char * getMD5(){ return "96adb295225031ec8d57fb4251b0a886"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Pose.h | #ifndef _ROS_geometry_msgs_Pose_h
#define _ROS_geometry_msgs_Pose_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Point.h"
#include "geometry_msgs/Quaternion.h"
namespace geometry_msgs
{
class Pose : public ros::Msg
{
public:
typedef geometry_msgs::Point _position_type;
_position_type position;
typedef geometry_msgs::Quaternion _orientation_type;
_orientation_type orientation;
Pose():
position(),
orientation()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->position.serialize(outbuffer + offset);
offset += this->orientation.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->position.deserialize(inbuffer + offset);
offset += this->orientation.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/Pose"; };
const char * getMD5(){ return "e45d45a5a1ce597b249e23fb30fc871f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/PolygonStamped.h | #ifndef _ROS_geometry_msgs_PolygonStamped_h
#define _ROS_geometry_msgs_PolygonStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Polygon.h"
namespace geometry_msgs
{
class PolygonStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Polygon _polygon_type;
_polygon_type polygon;
PolygonStamped():
header(),
polygon()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->polygon.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->polygon.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/PolygonStamped"; };
const char * getMD5(){ return "c6be8f7dc3bee7fe9e8d296070f53340"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/AccelStamped.h | #ifndef _ROS_geometry_msgs_AccelStamped_h
#define _ROS_geometry_msgs_AccelStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Accel.h"
namespace geometry_msgs
{
class AccelStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Accel _accel_type;
_accel_type accel;
AccelStamped():
header(),
accel()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->accel.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->accel.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/AccelStamped"; };
const char * getMD5(){ return "d8a98a5d81351b6eb0578c78557e7659"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/PoseWithCovarianceStamped.h | #ifndef _ROS_geometry_msgs_PoseWithCovarianceStamped_h
#define _ROS_geometry_msgs_PoseWithCovarianceStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/PoseWithCovariance.h"
namespace geometry_msgs
{
class PoseWithCovarianceStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::PoseWithCovariance _pose_type;
_pose_type pose;
PoseWithCovarianceStamped():
header(),
pose()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.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);
return offset;
}
const char * getType(){ return "geometry_msgs/PoseWithCovarianceStamped"; };
const char * getMD5(){ return "953b798c0f514ff060a53a3498ce6246"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Vector3Stamped.h | #ifndef _ROS_geometry_msgs_Vector3Stamped_h
#define _ROS_geometry_msgs_Vector3Stamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Vector3.h"
namespace geometry_msgs
{
class Vector3Stamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Vector3 _vector_type;
_vector_type vector;
Vector3Stamped():
header(),
vector()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->vector.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->vector.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/Vector3Stamped"; };
const char * getMD5(){ return "7b324c7325e683bf02a9b14b01090ec7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/TransformStamped.h | #ifndef _ROS_geometry_msgs_TransformStamped_h
#define _ROS_geometry_msgs_TransformStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Transform.h"
namespace geometry_msgs
{
class TransformStamped : 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::Transform _transform_type;
_transform_type transform;
TransformStamped():
header(),
child_frame_id(""),
transform()
{
}
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->transform.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->transform.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/TransformStamped"; };
const char * getMD5(){ return "b5764a33bfeb3588febc2682852579b0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/TwistWithCovariance.h | #ifndef _ROS_geometry_msgs_TwistWithCovariance_h
#define _ROS_geometry_msgs_TwistWithCovariance_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Twist.h"
namespace geometry_msgs
{
class TwistWithCovariance : public ros::Msg
{
public:
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
double covariance[36];
TwistWithCovariance():
twist(),
covariance()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->twist.serialize(outbuffer + offset);
for( uint32_t i = 0; i < 36; i++){
union {
double real;
uint64_t base;
} u_covariancei;
u_covariancei.real = this->covariance[i];
*(outbuffer + offset + 0) = (u_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->covariance[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->twist.deserialize(inbuffer + offset);
for( uint32_t i = 0; i < 36; i++){
union {
double real;
uint64_t base;
} u_covariancei;
u_covariancei.base = 0;
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->covariance[i] = u_covariancei.real;
offset += sizeof(this->covariance[i]);
}
return offset;
}
const char * getType(){ return "geometry_msgs/TwistWithCovariance"; };
const char * getMD5(){ return "1fe8a28e6890a4cc3ae4c3ca5c7d82e6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Vector3.h | #ifndef _ROS_geometry_msgs_Vector3_h
#define _ROS_geometry_msgs_Vector3_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace geometry_msgs
{
class Vector3 : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
Vector3():
x(0),
y(0),
z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->z = u_z.real;
offset += sizeof(this->z);
return offset;
}
const char * getType(){ return "geometry_msgs/Vector3"; };
const char * getMD5(){ return "4a842b65f413084dc2b10fb484ea7f17"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/Inertia.h | #ifndef _ROS_geometry_msgs_Inertia_h
#define _ROS_geometry_msgs_Inertia_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
namespace geometry_msgs
{
class Inertia : public ros::Msg
{
public:
typedef double _m_type;
_m_type m;
typedef geometry_msgs::Vector3 _com_type;
_com_type com;
typedef double _ixx_type;
_ixx_type ixx;
typedef double _ixy_type;
_ixy_type ixy;
typedef double _ixz_type;
_ixz_type ixz;
typedef double _iyy_type;
_iyy_type iyy;
typedef double _iyz_type;
_iyz_type iyz;
typedef double _izz_type;
_izz_type izz;
Inertia():
m(0),
com(),
ixx(0),
ixy(0),
ixz(0),
iyy(0),
iyz(0),
izz(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_m;
u_m.real = this->m;
*(outbuffer + offset + 0) = (u_m.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_m.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_m.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_m.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_m.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_m.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_m.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_m.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->m);
offset += this->com.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.real = this->ixx;
*(outbuffer + offset + 0) = (u_ixx.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixx.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixx.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixx.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixx.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixx.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixx.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixx.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.real = this->ixy;
*(outbuffer + offset + 0) = (u_ixy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.real = this->ixz;
*(outbuffer + offset + 0) = (u_ixz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.real = this->iyy;
*(outbuffer + offset + 0) = (u_iyy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.real = this->iyz;
*(outbuffer + offset + 0) = (u_iyz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.real = this->izz;
*(outbuffer + offset + 0) = (u_izz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_izz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_izz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_izz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_izz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_izz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_izz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_izz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->izz);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_m;
u_m.base = 0;
u_m.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_m.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_m.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_m.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_m.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_m.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_m.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_m.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->m = u_m.real;
offset += sizeof(this->m);
offset += this->com.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.base = 0;
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixx = u_ixx.real;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.base = 0;
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixy = u_ixy.real;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.base = 0;
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixz = u_ixz.real;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.base = 0;
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyy = u_iyy.real;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.base = 0;
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyz = u_iyz.real;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.base = 0;
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->izz = u_izz.real;
offset += sizeof(this->izz);
return offset;
}
const char * getType(){ return "geometry_msgs/Inertia"; };
const char * getMD5(){ return "1d26e4bb6c83ff141c5cf0d883c2b0fe"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/geometry_msgs/QuaternionStamped.h | #ifndef _ROS_geometry_msgs_QuaternionStamped_h
#define _ROS_geometry_msgs_QuaternionStamped_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Quaternion.h"
namespace geometry_msgs
{
class QuaternionStamped : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Quaternion _quaternion_type;
_quaternion_type quaternion;
QuaternionStamped():
header(),
quaternion()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->quaternion.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->quaternion.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "geometry_msgs/QuaternionStamped"; };
const char * getMD5(){ return "e57f1e547e0e1fd13504588ffc8334e2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/duration.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _ROS_DURATION_H_
#define _ROS_DURATION_H_
#include <math.h>
#include <stdint.h>
namespace ros
{
void normalizeSecNSecSigned(int32_t& sec, int32_t& nsec);
class Duration
{
public:
int32_t sec, nsec;
Duration() : sec(0), nsec(0) {}
Duration(int32_t _sec, int32_t _nsec) : sec(_sec), nsec(_nsec)
{
normalizeSecNSecSigned(sec, nsec);
}
double toSec() const
{
return (double)sec + 1e-9 * (double)nsec;
};
void fromSec(double t)
{
sec = (uint32_t) floor(t);
nsec = (uint32_t) round((t - sec) * 1e9);
};
Duration& operator+=(const Duration &rhs);
Duration& operator-=(const Duration &rhs);
Duration& operator*=(double scale);
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/service_client.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _ROS_SERVICE_CLIENT_H_
#define _ROS_SERVICE_CLIENT_H_
#include "rosserial_msgs/TopicInfo.h"
#include "ros/publisher.h"
#include "ros/subscriber.h"
namespace ros
{
template<typename MReq , typename MRes>
class ServiceClient : public Subscriber_
{
public:
ServiceClient(const char* topic_name) :
pub(topic_name, &req, rosserial_msgs::TopicInfo::ID_SERVICE_CLIENT + rosserial_msgs::TopicInfo::ID_PUBLISHER)
{
this->topic_ = topic_name;
this->waiting = true;
}
virtual void call(const MReq & request, MRes & response)
{
if (!pub.nh_->connected()) return;
ret = &response;
waiting = true;
pub.publish(&request);
while (waiting && pub.nh_->connected())
if (pub.nh_->spinOnce() < 0) break;
}
// these refer to the subscriber
virtual void callback(unsigned char *data)
{
ret->deserialize(data);
waiting = false;
}
virtual const char * getMsgType()
{
return this->resp.getType();
}
virtual const char * getMsgMD5()
{
return this->resp.getMD5();
}
virtual int getEndpointType()
{
return rosserial_msgs::TopicInfo::ID_SERVICE_CLIENT + rosserial_msgs::TopicInfo::ID_SUBSCRIBER;
}
MReq req;
MRes resp;
MRes * ret;
bool waiting;
Publisher pub;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/time.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ROS_TIME_H_
#define ROS_TIME_H_
#include "ros/duration.h"
#include <math.h>
#include <stdint.h>
namespace ros
{
void normalizeSecNSec(uint32_t &sec, uint32_t &nsec);
class Time
{
public:
uint32_t sec, nsec;
Time() : sec(0), nsec(0) {}
Time(uint32_t _sec, uint32_t _nsec) : sec(_sec), nsec(_nsec)
{
normalizeSecNSec(sec, nsec);
}
double toSec() const
{
return (double)sec + 1e-9 * (double)nsec;
};
void fromSec(double t)
{
sec = (uint32_t) floor(t);
nsec = (uint32_t) round((t - sec) * 1e9);
};
uint32_t toNsec()
{
return (uint32_t)sec * 1000000000ull + (uint32_t)nsec;
};
Time& fromNSec(int32_t t);
Time& operator +=(const Duration &rhs);
Time& operator -=(const Duration &rhs);
static Time now();
static void setNow(Time & new_now);
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/subscriber.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ROS_SUBSCRIBER_H_
#define ROS_SUBSCRIBER_H_
#include "rosserial_msgs/TopicInfo.h"
namespace ros
{
/* Base class for objects subscribers. */
class Subscriber_
{
public:
virtual void callback(unsigned char *data) = 0;
virtual int getEndpointType() = 0;
// id_ is set by NodeHandle when we advertise
int id_;
virtual const char * getMsgType() = 0;
virtual const char * getMsgMD5() = 0;
const char * topic_;
};
/* Bound function subscriber. */
template<typename MsgT, typename ObjT = void>
class Subscriber: public Subscriber_
{
public:
typedef void(ObjT::*CallbackT)(const MsgT&);
MsgT msg;
Subscriber(const char * topic_name, CallbackT cb, ObjT* obj, int endpoint = rosserial_msgs::TopicInfo::ID_SUBSCRIBER) :
cb_(cb),
obj_(obj),
endpoint_(endpoint)
{
topic_ = topic_name;
};
virtual void callback(unsigned char* data)
{
msg.deserialize(data);
(obj_->*cb_)(msg);
}
virtual const char * getMsgType()
{
return this->msg.getType();
}
virtual const char * getMsgMD5()
{
return this->msg.getMD5();
}
virtual int getEndpointType()
{
return endpoint_;
}
private:
CallbackT cb_;
ObjT* obj_;
int endpoint_;
};
/* Standalone function subscriber. */
template<typename MsgT>
class Subscriber<MsgT, void>: public Subscriber_
{
public:
typedef void(*CallbackT)(const MsgT&);
MsgT msg;
Subscriber(const char * topic_name, CallbackT cb, int endpoint = rosserial_msgs::TopicInfo::ID_SUBSCRIBER) :
cb_(cb),
endpoint_(endpoint)
{
topic_ = topic_name;
};
virtual void callback(unsigned char* data)
{
msg.deserialize(data);
this->cb_(msg);
}
virtual const char * getMsgType()
{
return this->msg.getType();
}
virtual const char * getMsgMD5()
{
return this->msg.getMD5();
}
virtual int getEndpointType()
{
return endpoint_;
}
private:
CallbackT cb_;
int endpoint_;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/node_handle.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ROS_NODE_HANDLE_H_
#define ROS_NODE_HANDLE_H_
#include <stdint.h>
#include "std_msgs/Time.h"
#include "rosserial_msgs/TopicInfo.h"
#include "rosserial_msgs/Log.h"
#include "rosserial_msgs/RequestParam.h"
#include "ros/msg.h"
namespace ros
{
class NodeHandleBase_
{
public:
virtual int publish(int id, const Msg* msg) = 0;
virtual int spinOnce() = 0;
virtual bool connected() = 0;
};
}
#include "ros/publisher.h"
#include "ros/subscriber.h"
#include "ros/service_server.h"
#include "ros/service_client.h"
namespace ros
{
const int SPIN_OK = 0;
const int SPIN_ERR = -1;
const int SPIN_TIMEOUT = -2;
const uint8_t SYNC_SECONDS = 5;
const uint8_t MODE_FIRST_FF = 0;
/*
* The second sync byte is a protocol version. It's value is 0xff for the first
* version of the rosserial protocol (used up to hydro), 0xfe for the second version
* (introduced in hydro), 0xfd for the next, and so on. Its purpose is to enable
* detection of mismatched protocol versions (e.g. hydro rosserial_python with groovy
* rosserial_arduino. It must be changed in both this file and in
* rosserial_python/src/rosserial_python/SerialClient.py
*/
const uint8_t MODE_PROTOCOL_VER = 1;
const uint8_t PROTOCOL_VER1 = 0xff; // through groovy
const uint8_t PROTOCOL_VER2 = 0xfe; // in hydro
const uint8_t PROTOCOL_VER = PROTOCOL_VER2;
const uint8_t MODE_SIZE_L = 2;
const uint8_t MODE_SIZE_H = 3;
const uint8_t MODE_SIZE_CHECKSUM = 4; // checksum for msg size received from size L and H
const uint8_t MODE_TOPIC_L = 5; // waiting for topic id
const uint8_t MODE_TOPIC_H = 6;
const uint8_t MODE_MESSAGE = 7;
const uint8_t MODE_MSG_CHECKSUM = 8; // checksum for msg and topic id
const uint8_t SERIAL_MSG_TIMEOUT = 20; // 20 milliseconds to recieve all of message data
using rosserial_msgs::TopicInfo;
/* Node Handle */
template<class Hardware,
int MAX_SUBSCRIBERS = 25,
int MAX_PUBLISHERS = 25,
int INPUT_SIZE = 512,
int OUTPUT_SIZE = 512>
class NodeHandle_ : public NodeHandleBase_
{
protected:
Hardware hardware_;
/* time used for syncing */
uint32_t rt_time;
/* used for computing current time */
uint32_t sec_offset, nsec_offset;
/* Spinonce maximum work timeout */
uint32_t spin_timeout_;
uint8_t message_in[INPUT_SIZE];
uint8_t message_out[OUTPUT_SIZE];
Publisher * publishers[MAX_PUBLISHERS];
Subscriber_ * subscribers[MAX_SUBSCRIBERS];
/*
* Setup Functions
*/
public:
NodeHandle_() : configured_(false)
{
for (unsigned int i = 0; i < MAX_PUBLISHERS; i++)
publishers[i] = 0;
for (unsigned int i = 0; i < MAX_SUBSCRIBERS; i++)
subscribers[i] = 0;
for (unsigned int i = 0; i < INPUT_SIZE; i++)
message_in[i] = 0;
for (unsigned int i = 0; i < OUTPUT_SIZE; i++)
message_out[i] = 0;
req_param_resp.ints_length = 0;
req_param_resp.ints = NULL;
req_param_resp.floats_length = 0;
req_param_resp.floats = NULL;
req_param_resp.ints_length = 0;
req_param_resp.ints = NULL;
spin_timeout_ = 0;
}
Hardware* getHardware()
{
return &hardware_;
}
/* Start serial, initialize buffers */
void initNode()
{
hardware_.init();
mode_ = 0;
bytes_ = 0;
index_ = 0;
topic_ = 0;
};
/* Start a named port, which may be network server IP, initialize buffers */
void initNode(char *portName)
{
hardware_.init(portName);
mode_ = 0;
bytes_ = 0;
index_ = 0;
topic_ = 0;
};
/**
* @brief Sets the maximum time in millisconds that spinOnce() can work.
* This will not effect the processing of the buffer, as spinOnce processes
* one byte at a time. It simply sets the maximum time that one call can
* process for. You can choose to clear the buffer if that is beneficial if
* SPIN_TIMEOUT is returned from spinOnce().
* @param timeout The timeout in milliseconds that spinOnce will function.
*/
void setSpinTimeout(const uint32_t& timeout)
{
spin_timeout_ = timeout;
}
protected:
//State machine variables for spinOnce
int mode_;
int bytes_;
int topic_;
int index_;
int checksum_;
bool configured_;
/* used for syncing the time */
uint32_t last_sync_time;
uint32_t last_sync_receive_time;
uint32_t last_msg_timeout_time;
public:
/* This function goes in your loop() function, it handles
* serial input and callbacks for subscribers.
*/
virtual int spinOnce()
{
/* restart if timed out */
uint32_t c_time = hardware_.time();
if ((c_time - last_sync_receive_time) > (SYNC_SECONDS * 2200))
{
configured_ = false;
}
/* reset if message has timed out */
if (mode_ != MODE_FIRST_FF)
{
if (c_time > last_msg_timeout_time)
{
mode_ = MODE_FIRST_FF;
}
}
/* while available buffer, read data */
while (true)
{
// If a timeout has been specified, check how long spinOnce has been running.
if (spin_timeout_ > 0)
{
// If the maximum processing timeout has been exceeded, exit with error.
// The next spinOnce can continue where it left off, or optionally
// based on the application in use, the hardware buffer could be flushed
// and start fresh.
if ((hardware_.time() - c_time) > spin_timeout_)
{
// Exit the spin, processing timeout exceeded.
return SPIN_TIMEOUT;
}
}
int data = hardware_.read();
if (data < 0)
break;
checksum_ += data;
if (mode_ == MODE_MESSAGE) /* message data being recieved */
{
message_in[index_++] = data;
bytes_--;
if (bytes_ == 0) /* is message complete? if so, checksum */
mode_ = MODE_MSG_CHECKSUM;
}
else if (mode_ == MODE_FIRST_FF)
{
if (data == 0xff)
{
mode_++;
last_msg_timeout_time = c_time + SERIAL_MSG_TIMEOUT;
}
else if (hardware_.time() - c_time > (SYNC_SECONDS * 1000))
{
/* We have been stuck in spinOnce too long, return error */
configured_ = false;
return SPIN_TIMEOUT;
}
}
else if (mode_ == MODE_PROTOCOL_VER)
{
if (data == PROTOCOL_VER)
{
mode_++;
}
else
{
mode_ = MODE_FIRST_FF;
if (configured_ == false)
requestSyncTime(); /* send a msg back showing our protocol version */
}
}
else if (mode_ == MODE_SIZE_L) /* bottom half of message size */
{
bytes_ = data;
index_ = 0;
mode_++;
checksum_ = data; /* first byte for calculating size checksum */
}
else if (mode_ == MODE_SIZE_H) /* top half of message size */
{
bytes_ += data << 8;
mode_++;
}
else if (mode_ == MODE_SIZE_CHECKSUM)
{
if ((checksum_ % 256) == 255)
mode_++;
else
mode_ = MODE_FIRST_FF; /* Abandon the frame if the msg len is wrong */
}
else if (mode_ == MODE_TOPIC_L) /* bottom half of topic id */
{
topic_ = data;
mode_++;
checksum_ = data; /* first byte included in checksum */
}
else if (mode_ == MODE_TOPIC_H) /* top half of topic id */
{
topic_ += data << 8;
mode_ = MODE_MESSAGE;
if (bytes_ == 0)
mode_ = MODE_MSG_CHECKSUM;
}
else if (mode_ == MODE_MSG_CHECKSUM) /* do checksum */
{
mode_ = MODE_FIRST_FF;
if ((checksum_ % 256) == 255)
{
if (topic_ == TopicInfo::ID_PUBLISHER)
{
requestSyncTime();
negotiateTopics();
last_sync_time = c_time;
last_sync_receive_time = c_time;
return SPIN_ERR;
}
else if (topic_ == TopicInfo::ID_TIME)
{
syncTime(message_in);
}
else if (topic_ == TopicInfo::ID_PARAMETER_REQUEST)
{
req_param_resp.deserialize(message_in);
param_recieved = true;
}
else if (topic_ == TopicInfo::ID_TX_STOP)
{
configured_ = false;
}
else
{
if (subscribers[topic_ - 100])
subscribers[topic_ - 100]->callback(message_in);
}
}
}
}
/* occasionally sync time */
if (configured_ && ((c_time - last_sync_time) > (SYNC_SECONDS * 500)))
{
requestSyncTime();
last_sync_time = c_time;
}
return SPIN_OK;
}
/* Are we connected to the PC? */
virtual bool connected()
{
return configured_;
};
/********************************************************************
* Time functions
*/
void requestSyncTime()
{
std_msgs::Time t;
publish(TopicInfo::ID_TIME, &t);
rt_time = hardware_.time();
}
void syncTime(uint8_t * data)
{
std_msgs::Time t;
uint32_t offset = hardware_.time() - rt_time;
t.deserialize(data);
t.data.sec += offset / 1000;
t.data.nsec += (offset % 1000) * 1000000UL;
this->setNow(t.data);
last_sync_receive_time = hardware_.time();
}
Time now()
{
uint32_t ms = hardware_.time();
Time current_time;
current_time.sec = ms / 1000 + sec_offset;
current_time.nsec = (ms % 1000) * 1000000UL + nsec_offset;
normalizeSecNSec(current_time.sec, current_time.nsec);
return current_time;
}
void setNow(Time & new_now)
{
uint32_t ms = hardware_.time();
sec_offset = new_now.sec - ms / 1000 - 1;
nsec_offset = new_now.nsec - (ms % 1000) * 1000000UL + 1000000000UL;
normalizeSecNSec(sec_offset, nsec_offset);
}
/********************************************************************
* Topic Management
*/
/* Register a new publisher */
bool advertise(Publisher & p)
{
for (int i = 0; i < MAX_PUBLISHERS; i++)
{
if (publishers[i] == 0) // empty slot
{
publishers[i] = &p;
p.id_ = i + 100 + MAX_SUBSCRIBERS;
p.nh_ = this;
return true;
}
}
return false;
}
/* Register a new subscriber */
template<typename SubscriberT>
bool subscribe(SubscriberT& s)
{
for (int i = 0; i < MAX_SUBSCRIBERS; i++)
{
if (subscribers[i] == 0) // empty slot
{
subscribers[i] = static_cast<Subscriber_*>(&s);
s.id_ = i + 100;
return true;
}
}
return false;
}
/* Register a new Service Server */
template<typename MReq, typename MRes, typename ObjT>
bool advertiseService(ServiceServer<MReq, MRes, ObjT>& srv)
{
bool v = advertise(srv.pub);
for (int i = 0; i < MAX_SUBSCRIBERS; i++)
{
if (subscribers[i] == 0) // empty slot
{
subscribers[i] = static_cast<Subscriber_*>(&srv);
srv.id_ = i + 100;
return v;
}
}
return false;
}
/* Register a new Service Client */
template<typename MReq, typename MRes>
bool serviceClient(ServiceClient<MReq, MRes>& srv)
{
bool v = advertise(srv.pub);
for (int i = 0; i < MAX_SUBSCRIBERS; i++)
{
if (subscribers[i] == 0) // empty slot
{
subscribers[i] = static_cast<Subscriber_*>(&srv);
srv.id_ = i + 100;
return v;
}
}
return false;
}
void negotiateTopics()
{
rosserial_msgs::TopicInfo ti;
int i;
for (i = 0; i < MAX_PUBLISHERS; i++)
{
if (publishers[i] != 0) // non-empty slot
{
ti.topic_id = publishers[i]->id_;
ti.topic_name = (char *) publishers[i]->topic_;
ti.message_type = (char *) publishers[i]->msg_->getType();
ti.md5sum = (char *) publishers[i]->msg_->getMD5();
ti.buffer_size = OUTPUT_SIZE;
publish(publishers[i]->getEndpointType(), &ti);
}
}
for (i = 0; i < MAX_SUBSCRIBERS; i++)
{
if (subscribers[i] != 0) // non-empty slot
{
ti.topic_id = subscribers[i]->id_;
ti.topic_name = (char *) subscribers[i]->topic_;
ti.message_type = (char *) subscribers[i]->getMsgType();
ti.md5sum = (char *) subscribers[i]->getMsgMD5();
ti.buffer_size = INPUT_SIZE;
publish(subscribers[i]->getEndpointType(), &ti);
}
}
configured_ = true;
}
virtual int publish(int id, const Msg * msg)
{
if (id >= 100 && !configured_)
return 0;
/* serialize message */
int l = msg->serialize(message_out + 7);
/* setup the header */
message_out[0] = 0xff;
message_out[1] = PROTOCOL_VER;
message_out[2] = (uint8_t)((uint16_t)l & 255);
message_out[3] = (uint8_t)((uint16_t)l >> 8);
message_out[4] = 255 - ((message_out[2] + message_out[3]) % 256);
message_out[5] = (uint8_t)((int16_t)id & 255);
message_out[6] = (uint8_t)((int16_t)id >> 8);
/* calculate checksum */
int chk = 0;
for (int i = 5; i < l + 7; i++)
chk += message_out[i];
l += 7;
message_out[l++] = 255 - (chk % 256);
if (l <= OUTPUT_SIZE)
{
hardware_.write(message_out, l);
return l;
}
else
{
logerror("Message from device dropped: message larger than buffer.");
return -1;
}
}
/********************************************************************
* Logging
*/
private:
void log(char byte, const char * msg)
{
rosserial_msgs::Log l;
l.level = byte;
l.msg = (char*)msg;
publish(rosserial_msgs::TopicInfo::ID_LOG, &l);
}
public:
void logdebug(const char* msg)
{
log(rosserial_msgs::Log::ROSDEBUG, msg);
}
void loginfo(const char * msg)
{
log(rosserial_msgs::Log::INFO, msg);
}
void logwarn(const char *msg)
{
log(rosserial_msgs::Log::WARN, msg);
}
void logerror(const char*msg)
{
log(rosserial_msgs::Log::ERROR, msg);
}
void logfatal(const char*msg)
{
log(rosserial_msgs::Log::FATAL, msg);
}
/********************************************************************
* Parameters
*/
private:
bool param_recieved;
rosserial_msgs::RequestParamResponse req_param_resp;
bool requestParam(const char * name, int time_out = 1000)
{
param_recieved = false;
rosserial_msgs::RequestParamRequest req;
req.name = (char*)name;
publish(TopicInfo::ID_PARAMETER_REQUEST, &req);
uint32_t end_time = hardware_.time() + time_out;
while (!param_recieved)
{
spinOnce();
if (hardware_.time() > end_time)
{
logwarn("Failed to get param: timeout expired");
return false;
}
}
return true;
}
public:
bool getParam(const char* name, int* param, int length = 1, int timeout = 1000)
{
if (requestParam(name, timeout))
{
if (length == req_param_resp.ints_length)
{
//copy it over
for (int i = 0; i < length; i++)
param[i] = req_param_resp.ints[i];
return true;
}
else
{
logwarn("Failed to get param: length mismatch");
}
}
return false;
}
bool getParam(const char* name, float* param, int length = 1, int timeout = 1000)
{
if (requestParam(name, timeout))
{
if (length == req_param_resp.floats_length)
{
//copy it over
for (int i = 0; i < length; i++)
param[i] = req_param_resp.floats[i];
return true;
}
else
{
logwarn("Failed to get param: length mismatch");
}
}
return false;
}
bool getParam(const char* name, char** param, int length = 1, int timeout = 1000)
{
if (requestParam(name, timeout))
{
if (length == req_param_resp.strings_length)
{
//copy it over
for (int i = 0; i < length; i++)
strcpy(param[i], req_param_resp.strings[i]);
return true;
}
else
{
logwarn("Failed to get param: length mismatch");
}
}
return false;
}
bool getParam(const char* name, bool* param, int length = 1, int timeout = 1000)
{
if (requestParam(name, timeout))
{
if (length == req_param_resp.ints_length)
{
//copy it over
for (int i = 0; i < length; i++)
param[i] = req_param_resp.ints[i];
return true;
}
else
{
logwarn("Failed to get param: length mismatch");
}
}
return false;
}
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/msg.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _ROS_MSG_H_
#define _ROS_MSG_H_
#include <stdint.h>
#include <stddef.h>
namespace ros
{
/* Base Message Type */
class Msg
{
public:
virtual int serialize(unsigned char *outbuffer) const = 0;
virtual int deserialize(unsigned char *data) = 0;
virtual const char * getType() = 0;
virtual const char * getMD5() = 0;
/**
* @brief This tricky function handles promoting a 32bit float to a 64bit
* double, so that AVR can publish messages containing float64
* fields, despite AVV having no native support for double.
*
* @param[out] outbuffer pointer for buffer to serialize to.
* @param[in] f value to serialize.
*
* @return number of bytes to advance the buffer pointer.
*
*/
static int serializeAvrFloat64(unsigned char* outbuffer, const float f)
{
const int32_t* val = (int32_t*) &f;
int32_t exp = ((*val >> 23) & 255);
if (exp != 0)
{
exp += 1023 - 127;
}
int32_t sig = *val;
*(outbuffer++) = 0;
*(outbuffer++) = 0;
*(outbuffer++) = 0;
*(outbuffer++) = (sig << 5) & 0xff;
*(outbuffer++) = (sig >> 3) & 0xff;
*(outbuffer++) = (sig >> 11) & 0xff;
*(outbuffer++) = ((exp << 4) & 0xF0) | ((sig >> 19) & 0x0F);
*(outbuffer++) = (exp >> 4) & 0x7F;
// Mark negative bit as necessary.
if (f < 0)
{
*(outbuffer - 1) |= 0x80;
}
return 8;
}
/**
* @brief This tricky function handles demoting a 64bit double to a
* 32bit float, so that AVR can understand messages containing
* float64 fields, despite AVR having no native support for double.
*
* @param[in] inbuffer pointer for buffer to deserialize from.
* @param[out] f pointer to place the deserialized value in.
*
* @return number of bytes to advance the buffer pointer.
*/
static int deserializeAvrFloat64(const unsigned char* inbuffer, float* f)
{
uint32_t* val = (uint32_t*)f;
inbuffer += 3;
// Copy truncated mantissa.
*val = ((uint32_t)(*(inbuffer++)) >> 5 & 0x07);
*val |= ((uint32_t)(*(inbuffer++)) & 0xff) << 3;
*val |= ((uint32_t)(*(inbuffer++)) & 0xff) << 11;
*val |= ((uint32_t)(*inbuffer) & 0x0f) << 19;
// Copy truncated exponent.
uint32_t exp = ((uint32_t)(*(inbuffer++)) & 0xf0) >> 4;
exp |= ((uint32_t)(*inbuffer) & 0x7f) << 4;
if (exp != 0)
{
*val |= ((exp) - 1023 + 127) << 23;
}
// Copy negative sign.
*val |= ((uint32_t)(*(inbuffer++)) & 0x80) << 24;
return 8;
}
// Copy data from variable into a byte array
template<typename A, typename V>
static void varToArr(A arr, const V var)
{
for (size_t i = 0; i < sizeof(V); i++)
arr[i] = (var >> (8 * i));
}
// Copy data from a byte array into variable
template<typename V, typename A>
static void arrToVar(V& var, const A arr)
{
var = 0;
for (size_t i = 0; i < sizeof(V); i++)
var |= (arr[i] << (8 * i));
}
};
} // namespace ros
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/service_server.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _ROS_SERVICE_SERVER_H_
#define _ROS_SERVICE_SERVER_H_
#include "rosserial_msgs/TopicInfo.h"
#include "ros/publisher.h"
#include "ros/subscriber.h"
namespace ros
{
template<typename MReq , typename MRes, typename ObjT = void>
class ServiceServer : public Subscriber_
{
public:
typedef void(ObjT::*CallbackT)(const MReq&, MRes&);
ServiceServer(const char* topic_name, CallbackT cb, ObjT* obj) :
pub(topic_name, &resp, rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_PUBLISHER),
obj_(obj)
{
this->topic_ = topic_name;
this->cb_ = cb;
}
// these refer to the subscriber
virtual void callback(unsigned char *data)
{
req.deserialize(data);
(obj_->*cb_)(req, resp);
pub.publish(&resp);
}
virtual const char * getMsgType()
{
return this->req.getType();
}
virtual const char * getMsgMD5()
{
return this->req.getMD5();
}
virtual int getEndpointType()
{
return rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_SUBSCRIBER;
}
MReq req;
MRes resp;
Publisher pub;
private:
CallbackT cb_;
ObjT* obj_;
};
template<typename MReq , typename MRes>
class ServiceServer<MReq, MRes, void> : public Subscriber_
{
public:
typedef void(*CallbackT)(const MReq&, MRes&);
ServiceServer(const char* topic_name, CallbackT cb) :
pub(topic_name, &resp, rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_PUBLISHER)
{
this->topic_ = topic_name;
this->cb_ = cb;
}
// these refer to the subscriber
virtual void callback(unsigned char *data)
{
req.deserialize(data);
cb_(req, resp);
pub.publish(&resp);
}
virtual const char * getMsgType()
{
return this->req.getType();
}
virtual const char * getMsgMD5()
{
return this->req.getMD5();
}
virtual int getEndpointType()
{
return rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_SUBSCRIBER;
}
MReq req;
MRes resp;
Publisher pub;
private:
CallbackT cb_;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ros/publisher.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _ROS_PUBLISHER_H_
#define _ROS_PUBLISHER_H_
#include "rosserial_msgs/TopicInfo.h"
#include "ros/node_handle.h"
namespace ros
{
/* Generic Publisher */
class Publisher
{
public:
Publisher(const char * topic_name, Msg * msg, int endpoint = rosserial_msgs::TopicInfo::ID_PUBLISHER) :
topic_(topic_name),
msg_(msg),
endpoint_(endpoint) {};
int publish(const Msg * msg)
{
return nh_->publish(id_, msg);
};
int getEndpointType()
{
return endpoint_;
}
const char * topic_;
Msg *msg_;
// id_ and no_ are set by NodeHandle when we advertise
int id_;
NodeHandleBase_* nh_;
private:
int endpoint_;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_msgs/VersionInfo.h | #ifndef _ROS_turtlebot3_msgs_VersionInfo_h
#define _ROS_turtlebot3_msgs_VersionInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlebot3_msgs
{
class VersionInfo : public ros::Msg
{
public:
typedef const char* _hardware_type;
_hardware_type hardware;
typedef const char* _firmware_type;
_firmware_type firmware;
typedef const char* _software_type;
_software_type software;
VersionInfo():
hardware(""),
firmware(""),
software("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_hardware = strlen(this->hardware);
varToArr(outbuffer + offset, length_hardware);
offset += 4;
memcpy(outbuffer + offset, this->hardware, length_hardware);
offset += length_hardware;
uint32_t length_firmware = strlen(this->firmware);
varToArr(outbuffer + offset, length_firmware);
offset += 4;
memcpy(outbuffer + offset, this->firmware, length_firmware);
offset += length_firmware;
uint32_t length_software = strlen(this->software);
varToArr(outbuffer + offset, length_software);
offset += 4;
memcpy(outbuffer + offset, this->software, length_software);
offset += length_software;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_hardware;
arrToVar(length_hardware, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_hardware; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_hardware-1]=0;
this->hardware = (char *)(inbuffer + offset-1);
offset += length_hardware;
uint32_t length_firmware;
arrToVar(length_firmware, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_firmware; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_firmware-1]=0;
this->firmware = (char *)(inbuffer + offset-1);
offset += length_firmware;
uint32_t length_software;
arrToVar(length_software, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_software; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_software-1]=0;
this->software = (char *)(inbuffer + offset-1);
offset += length_software;
return offset;
}
const char * getType(){ return "turtlebot3_msgs/VersionInfo"; };
const char * getMD5(){ return "43e0361461af2970a33107409403ef3c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_msgs/SensorState.h | #ifndef _ROS_turtlebot3_msgs_SensorState_h
#define _ROS_turtlebot3_msgs_SensorState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace turtlebot3_msgs
{
class SensorState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint8_t _bumper_type;
_bumper_type bumper;
typedef float _cliff_type;
_cliff_type cliff;
typedef float _sonar_type;
_sonar_type sonar;
typedef float _illumination_type;
_illumination_type illumination;
typedef uint8_t _led_type;
_led_type led;
typedef uint8_t _button_type;
_button_type button;
typedef bool _torque_type;
_torque_type torque;
typedef int32_t _left_encoder_type;
_left_encoder_type left_encoder;
typedef int32_t _right_encoder_type;
_right_encoder_type right_encoder;
typedef float _battery_type;
_battery_type battery;
enum { BUMPER_FORWARD = 1 };
enum { BUMPER_BACKWARD = 2 };
enum { CLIFF = 1 };
enum { SONAR = 1 };
enum { ILLUMINATION = 1 };
enum { BUTTON0 = 1 };
enum { BUTTON1 = 2 };
enum { ERROR_LEFT_MOTOR = 1 };
enum { ERROR_RIGHT_MOTOR = 2 };
enum { TORQUE_ON = 1 };
enum { TORQUE_OFF = 2 };
SensorState():
header(),
bumper(0),
cliff(0),
sonar(0),
illumination(0),
led(0),
button(0),
torque(0),
left_encoder(0),
right_encoder(0),
battery(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->bumper >> (8 * 0)) & 0xFF;
offset += sizeof(this->bumper);
union {
float real;
uint32_t base;
} u_cliff;
u_cliff.real = this->cliff;
*(outbuffer + offset + 0) = (u_cliff.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cliff.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cliff.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cliff.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cliff);
union {
float real;
uint32_t base;
} u_sonar;
u_sonar.real = this->sonar;
*(outbuffer + offset + 0) = (u_sonar.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sonar.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sonar.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sonar.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sonar);
union {
float real;
uint32_t base;
} u_illumination;
u_illumination.real = this->illumination;
*(outbuffer + offset + 0) = (u_illumination.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_illumination.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_illumination.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_illumination.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->illumination);
*(outbuffer + offset + 0) = (this->led >> (8 * 0)) & 0xFF;
offset += sizeof(this->led);
*(outbuffer + offset + 0) = (this->button >> (8 * 0)) & 0xFF;
offset += sizeof(this->button);
union {
bool real;
uint8_t base;
} u_torque;
u_torque.real = this->torque;
*(outbuffer + offset + 0) = (u_torque.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->torque);
union {
int32_t real;
uint32_t base;
} u_left_encoder;
u_left_encoder.real = this->left_encoder;
*(outbuffer + offset + 0) = (u_left_encoder.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_left_encoder.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_left_encoder.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_left_encoder.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->left_encoder);
union {
int32_t real;
uint32_t base;
} u_right_encoder;
u_right_encoder.real = this->right_encoder;
*(outbuffer + offset + 0) = (u_right_encoder.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_right_encoder.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_right_encoder.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_right_encoder.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->right_encoder);
union {
float real;
uint32_t base;
} u_battery;
u_battery.real = this->battery;
*(outbuffer + offset + 0) = (u_battery.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_battery.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_battery.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_battery.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->battery);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->bumper = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->bumper);
union {
float real;
uint32_t base;
} u_cliff;
u_cliff.base = 0;
u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cliff.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->cliff = u_cliff.real;
offset += sizeof(this->cliff);
union {
float real;
uint32_t base;
} u_sonar;
u_sonar.base = 0;
u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sonar.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->sonar = u_sonar.real;
offset += sizeof(this->sonar);
union {
float real;
uint32_t base;
} u_illumination;
u_illumination.base = 0;
u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_illumination.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->illumination = u_illumination.real;
offset += sizeof(this->illumination);
this->led = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->led);
this->button = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->button);
union {
bool real;
uint8_t base;
} u_torque;
u_torque.base = 0;
u_torque.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->torque = u_torque.real;
offset += sizeof(this->torque);
union {
int32_t real;
uint32_t base;
} u_left_encoder;
u_left_encoder.base = 0;
u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_left_encoder.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->left_encoder = u_left_encoder.real;
offset += sizeof(this->left_encoder);
union {
int32_t real;
uint32_t base;
} u_right_encoder;
u_right_encoder.base = 0;
u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_right_encoder.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->right_encoder = u_right_encoder.real;
offset += sizeof(this->right_encoder);
union {
float real;
uint32_t base;
} u_battery;
u_battery.base = 0;
u_battery.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_battery.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_battery.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_battery.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->battery = u_battery.real;
offset += sizeof(this->battery);
return offset;
}
const char * getType(){ return "turtlebot3_msgs/SensorState"; };
const char * getMD5(){ return "7250c1dc0b61c4190e78f528f599285f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_msgs/Sound.h | #ifndef _ROS_turtlebot3_msgs_Sound_h
#define _ROS_turtlebot3_msgs_Sound_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlebot3_msgs
{
class Sound : public ros::Msg
{
public:
typedef uint8_t _value_type;
_value_type value;
enum { OFF = 0 };
enum { ON = 1 };
enum { LOW_BATTERY = 2 };
enum { ERROR = 3 };
enum { BUTTON1 = 4 };
enum { BUTTON2 = 5 };
Sound():
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->value = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "turtlebot3_msgs/Sound"; };
const char * getMD5(){ return "e1f8c7f8a9a61383b5734fbdeca2f99a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/JoyFeedback.h | #ifndef _ROS_sensor_msgs_JoyFeedback_h
#define _ROS_sensor_msgs_JoyFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace sensor_msgs
{
class JoyFeedback : public ros::Msg
{
public:
typedef uint8_t _type_type;
_type_type type;
typedef uint8_t _id_type;
_id_type id;
typedef float _intensity_type;
_intensity_type intensity;
enum { TYPE_LED = 0 };
enum { TYPE_RUMBLE = 1 };
enum { TYPE_BUZZER = 2 };
JoyFeedback():
type(0),
id(0),
intensity(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
offset += sizeof(this->type);
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
offset += sizeof(this->id);
union {
float real;
uint32_t base;
} u_intensity;
u_intensity.real = this->intensity;
*(outbuffer + offset + 0) = (u_intensity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_intensity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_intensity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_intensity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->intensity);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->type);
this->id = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->id);
union {
float real;
uint32_t base;
} u_intensity;
u_intensity.base = 0;
u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->intensity = u_intensity.real;
offset += sizeof(this->intensity);
return offset;
}
const char * getType(){ return "sensor_msgs/JoyFeedback"; };
const char * getMD5(){ return "f4dcd73460360d98f36e55ee7f2e46f1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/MultiDOFJointState.h | #ifndef _ROS_sensor_msgs_MultiDOFJointState_h
#define _ROS_sensor_msgs_MultiDOFJointState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Transform.h"
#include "geometry_msgs/Twist.h"
#include "geometry_msgs/Wrench.h"
namespace sensor_msgs
{
class MultiDOFJointState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t transforms_length;
typedef geometry_msgs::Transform _transforms_type;
_transforms_type st_transforms;
_transforms_type * transforms;
uint32_t twist_length;
typedef geometry_msgs::Twist _twist_type;
_twist_type st_twist;
_twist_type * twist;
uint32_t wrench_length;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type st_wrench;
_wrench_type * wrench;
MultiDOFJointState():
header(),
joint_names_length(0), joint_names(NULL),
transforms_length(0), transforms(NULL),
twist_length(0), twist(NULL),
wrench_length(0), wrench(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transforms_length);
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->transforms[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->twist_length);
for( uint32_t i = 0; i < twist_length; i++){
offset += this->twist[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->wrench_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->wrench_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->wrench_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->wrench_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->wrench_length);
for( uint32_t i = 0; i < wrench_length; i++){
offset += this->wrench[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transforms_length);
if(transforms_lengthT > transforms_length)
this->transforms = (geometry_msgs::Transform*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::Transform));
transforms_length = transforms_lengthT;
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->st_transforms.deserialize(inbuffer + offset);
memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::Transform));
}
uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->twist_length);
if(twist_lengthT > twist_length)
this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
twist_length = twist_lengthT;
for( uint32_t i = 0; i < twist_length; i++){
offset += this->st_twist.deserialize(inbuffer + offset);
memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
}
uint32_t wrench_lengthT = ((uint32_t) (*(inbuffer + offset)));
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->wrench_length);
if(wrench_lengthT > wrench_length)
this->wrench = (geometry_msgs::Wrench*)realloc(this->wrench, wrench_lengthT * sizeof(geometry_msgs::Wrench));
wrench_length = wrench_lengthT;
for( uint32_t i = 0; i < wrench_length; i++){
offset += this->st_wrench.deserialize(inbuffer + offset);
memcpy( &(this->wrench[i]), &(this->st_wrench), sizeof(geometry_msgs::Wrench));
}
return offset;
}
const char * getType(){ return "sensor_msgs/MultiDOFJointState"; };
const char * getMD5(){ return "690f272f0640d2631c305eeb8301e59d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/JointState.h | #ifndef _ROS_sensor_msgs_JointState_h
#define _ROS_sensor_msgs_JointState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class JointState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t position_length;
typedef double _position_type;
_position_type st_position;
_position_type * position;
uint32_t velocity_length;
typedef double _velocity_type;
_velocity_type st_velocity;
_velocity_type * velocity;
uint32_t effort_length;
typedef double _effort_type;
_effort_type st_effort;
_effort_type * effort;
JointState():
header(),
name_length(0), name(NULL),
position_length(0), position(NULL),
velocity_length(0), velocity(NULL),
effort_length(0), effort(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_length);
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_positioni;
u_positioni.real = this->position[i];
*(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocity_length);
for( uint32_t i = 0; i < velocity_length; i++){
union {
double real;
uint64_t base;
} u_velocityi;
u_velocityi.real = this->velocity[i];
*(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity[i]);
}
*(outbuffer + offset + 0) = (this->effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->effort_length);
for( uint32_t i = 0; i < effort_length; i++){
union {
double real;
uint64_t base;
} u_efforti;
u_efforti.real = this->effort[i];
*(outbuffer + offset + 0) = (u_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->effort[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_length);
if(position_lengthT > position_length)
this->position = (double*)realloc(this->position, position_lengthT * sizeof(double));
position_length = position_lengthT;
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_st_position;
u_st_position.base = 0;
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position = u_st_position.real;
offset += sizeof(this->st_position);
memcpy( &(this->position[i]), &(this->st_position), sizeof(double));
}
uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocity_length);
if(velocity_lengthT > velocity_length)
this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double));
velocity_length = velocity_lengthT;
for( uint32_t i = 0; i < velocity_length; i++){
union {
double real;
uint64_t base;
} u_st_velocity;
u_st_velocity.base = 0;
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocity = u_st_velocity.real;
offset += sizeof(this->st_velocity);
memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double));
}
uint32_t effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->effort_length);
if(effort_lengthT > effort_length)
this->effort = (double*)realloc(this->effort, effort_lengthT * sizeof(double));
effort_length = effort_lengthT;
for( uint32_t i = 0; i < effort_length; i++){
union {
double real;
uint64_t base;
} u_st_effort;
u_st_effort.base = 0;
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_effort = u_st_effort.real;
offset += sizeof(this->st_effort);
memcpy( &(this->effort[i]), &(this->st_effort), sizeof(double));
}
return offset;
}
const char * getType(){ return "sensor_msgs/JointState"; };
const char * getMD5(){ return "3066dcd76a6cfaef579bd0f34173e9fd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/Temperature.h | #ifndef _ROS_sensor_msgs_Temperature_h
#define _ROS_sensor_msgs_Temperature_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class Temperature : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _temperature_type;
_temperature_type temperature;
typedef double _variance_type;
_variance_type variance;
Temperature():
header(),
temperature(0),
variance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_temperature;
u_temperature.real = this->temperature;
*(outbuffer + offset + 0) = (u_temperature.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_temperature.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_temperature.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_temperature.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_temperature.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_temperature.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_temperature.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_temperature.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->temperature);
union {
double real;
uint64_t base;
} u_variance;
u_variance.real = this->variance;
*(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->variance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_temperature;
u_temperature.base = 0;
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->temperature = u_temperature.real;
offset += sizeof(this->temperature);
union {
double real;
uint64_t base;
} u_variance;
u_variance.base = 0;
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->variance = u_variance.real;
offset += sizeof(this->variance);
return offset;
}
const char * getType(){ return "sensor_msgs/Temperature"; };
const char * getMD5(){ return "ff71b307acdbe7c871a5a6d7ed359100"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/TimeReference.h | #ifndef _ROS_sensor_msgs_TimeReference_h
#define _ROS_sensor_msgs_TimeReference_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "ros/time.h"
namespace sensor_msgs
{
class TimeReference : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef ros::Time _time_ref_type;
_time_ref_type time_ref;
typedef const char* _source_type;
_source_type source;
TimeReference():
header(),
time_ref(),
source("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->time_ref.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_ref.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_ref.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_ref.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_ref.sec);
*(outbuffer + offset + 0) = (this->time_ref.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_ref.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_ref.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_ref.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_ref.nsec);
uint32_t length_source = strlen(this->source);
varToArr(outbuffer + offset, length_source);
offset += 4;
memcpy(outbuffer + offset, this->source, length_source);
offset += length_source;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->time_ref.sec = ((uint32_t) (*(inbuffer + offset)));
this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_ref.sec);
this->time_ref.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_ref.nsec);
uint32_t length_source;
arrToVar(length_source, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_source; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_source-1]=0;
this->source = (char *)(inbuffer + offset-1);
offset += length_source;
return offset;
}
const char * getType(){ return "sensor_msgs/TimeReference"; };
const char * getMD5(){ return "fded64a0265108ba86c3d38fb11c0c16"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/MultiEchoLaserScan.h | #ifndef _ROS_sensor_msgs_MultiEchoLaserScan_h
#define _ROS_sensor_msgs_MultiEchoLaserScan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/LaserEcho.h"
namespace sensor_msgs
{
class MultiEchoLaserScan : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef float _angle_min_type;
_angle_min_type angle_min;
typedef float _angle_max_type;
_angle_max_type angle_max;
typedef float _angle_increment_type;
_angle_increment_type angle_increment;
typedef float _time_increment_type;
_time_increment_type time_increment;
typedef float _scan_time_type;
_scan_time_type scan_time;
typedef float _range_min_type;
_range_min_type range_min;
typedef float _range_max_type;
_range_max_type range_max;
uint32_t ranges_length;
typedef sensor_msgs::LaserEcho _ranges_type;
_ranges_type st_ranges;
_ranges_type * ranges;
uint32_t intensities_length;
typedef sensor_msgs::LaserEcho _intensities_type;
_intensities_type st_intensities;
_intensities_type * intensities;
MultiEchoLaserScan():
header(),
angle_min(0),
angle_max(0),
angle_increment(0),
time_increment(0),
scan_time(0),
range_min(0),
range_max(0),
ranges_length(0), ranges(NULL),
intensities_length(0), intensities(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_angle_min;
u_angle_min.real = this->angle_min;
*(outbuffer + offset + 0) = (u_angle_min.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angle_min.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angle_min.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angle_min.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angle_min);
union {
float real;
uint32_t base;
} u_angle_max;
u_angle_max.real = this->angle_max;
*(outbuffer + offset + 0) = (u_angle_max.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angle_max.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angle_max.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angle_max.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angle_max);
union {
float real;
uint32_t base;
} u_angle_increment;
u_angle_increment.real = this->angle_increment;
*(outbuffer + offset + 0) = (u_angle_increment.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angle_increment.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angle_increment.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angle_increment.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angle_increment);
union {
float real;
uint32_t base;
} u_time_increment;
u_time_increment.real = this->time_increment;
*(outbuffer + offset + 0) = (u_time_increment.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_increment.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_increment.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_increment.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_increment);
union {
float real;
uint32_t base;
} u_scan_time;
u_scan_time.real = this->scan_time;
*(outbuffer + offset + 0) = (u_scan_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_scan_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_scan_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_scan_time.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->scan_time);
union {
float real;
uint32_t base;
} u_range_min;
u_range_min.real = this->range_min;
*(outbuffer + offset + 0) = (u_range_min.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_range_min.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_range_min.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_range_min.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->range_min);
union {
float real;
uint32_t base;
} u_range_max;
u_range_max.real = this->range_max;
*(outbuffer + offset + 0) = (u_range_max.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_range_max.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_range_max.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_range_max.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->range_max);
*(outbuffer + offset + 0) = (this->ranges_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ranges_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ranges_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ranges_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ranges_length);
for( uint32_t i = 0; i < ranges_length; i++){
offset += this->ranges[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->intensities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->intensities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->intensities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->intensities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->intensities_length);
for( uint32_t i = 0; i < intensities_length; i++){
offset += this->intensities[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_angle_min;
u_angle_min.base = 0;
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angle_min = u_angle_min.real;
offset += sizeof(this->angle_min);
union {
float real;
uint32_t base;
} u_angle_max;
u_angle_max.base = 0;
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angle_max = u_angle_max.real;
offset += sizeof(this->angle_max);
union {
float real;
uint32_t base;
} u_angle_increment;
u_angle_increment.base = 0;
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angle_increment = u_angle_increment.real;
offset += sizeof(this->angle_increment);
union {
float real;
uint32_t base;
} u_time_increment;
u_time_increment.base = 0;
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->time_increment = u_time_increment.real;
offset += sizeof(this->time_increment);
union {
float real;
uint32_t base;
} u_scan_time;
u_scan_time.base = 0;
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->scan_time = u_scan_time.real;
offset += sizeof(this->scan_time);
union {
float real;
uint32_t base;
} u_range_min;
u_range_min.base = 0;
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->range_min = u_range_min.real;
offset += sizeof(this->range_min);
union {
float real;
uint32_t base;
} u_range_max;
u_range_max.base = 0;
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->range_max = u_range_max.real;
offset += sizeof(this->range_max);
uint32_t ranges_lengthT = ((uint32_t) (*(inbuffer + offset)));
ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ranges_length);
if(ranges_lengthT > ranges_length)
this->ranges = (sensor_msgs::LaserEcho*)realloc(this->ranges, ranges_lengthT * sizeof(sensor_msgs::LaserEcho));
ranges_length = ranges_lengthT;
for( uint32_t i = 0; i < ranges_length; i++){
offset += this->st_ranges.deserialize(inbuffer + offset);
memcpy( &(this->ranges[i]), &(this->st_ranges), sizeof(sensor_msgs::LaserEcho));
}
uint32_t intensities_lengthT = ((uint32_t) (*(inbuffer + offset)));
intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->intensities_length);
if(intensities_lengthT > intensities_length)
this->intensities = (sensor_msgs::LaserEcho*)realloc(this->intensities, intensities_lengthT * sizeof(sensor_msgs::LaserEcho));
intensities_length = intensities_lengthT;
for( uint32_t i = 0; i < intensities_length; i++){
offset += this->st_intensities.deserialize(inbuffer + offset);
memcpy( &(this->intensities[i]), &(this->st_intensities), sizeof(sensor_msgs::LaserEcho));
}
return offset;
}
const char * getType(){ return "sensor_msgs/MultiEchoLaserScan"; };
const char * getMD5(){ return "6fefb0c6da89d7c8abe4b339f5c2f8fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/SetCameraInfo.h | #ifndef _ROS_SERVICE_SetCameraInfo_h
#define _ROS_SERVICE_SetCameraInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/CameraInfo.h"
namespace sensor_msgs
{
static const char SETCAMERAINFO[] = "sensor_msgs/SetCameraInfo";
class SetCameraInfoRequest : public ros::Msg
{
public:
typedef sensor_msgs::CameraInfo _camera_info_type;
_camera_info_type camera_info;
SetCameraInfoRequest():
camera_info()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->camera_info.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->camera_info.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETCAMERAINFO; };
const char * getMD5(){ return "ee34be01fdeee563d0d99cd594d5581d"; };
};
class SetCameraInfoResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetCameraInfoResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETCAMERAINFO; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetCameraInfo {
public:
typedef SetCameraInfoRequest Request;
typedef SetCameraInfoResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/NavSatFix.h | #ifndef _ROS_sensor_msgs_NavSatFix_h
#define _ROS_sensor_msgs_NavSatFix_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/NavSatStatus.h"
namespace sensor_msgs
{
class NavSatFix : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef sensor_msgs::NavSatStatus _status_type;
_status_type status;
typedef double _latitude_type;
_latitude_type latitude;
typedef double _longitude_type;
_longitude_type longitude;
typedef double _altitude_type;
_altitude_type altitude;
double position_covariance[9];
typedef uint8_t _position_covariance_type_type;
_position_covariance_type_type position_covariance_type;
enum { COVARIANCE_TYPE_UNKNOWN = 0 };
enum { COVARIANCE_TYPE_APPROXIMATED = 1 };
enum { COVARIANCE_TYPE_DIAGONAL_KNOWN = 2 };
enum { COVARIANCE_TYPE_KNOWN = 3 };
NavSatFix():
header(),
status(),
latitude(0),
longitude(0),
altitude(0),
position_covariance(),
position_covariance_type(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_latitude;
u_latitude.real = this->latitude;
*(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->latitude);
union {
double real;
uint64_t base;
} u_longitude;
u_longitude.real = this->longitude;
*(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->longitude);
union {
double real;
uint64_t base;
} u_altitude;
u_altitude.real = this->altitude;
*(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_altitude.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_altitude.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_altitude.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_altitude.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->altitude);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_position_covariancei;
u_position_covariancei.real = this->position_covariance[i];
*(outbuffer + offset + 0) = (u_position_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position_covariance[i]);
}
*(outbuffer + offset + 0) = (this->position_covariance_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->position_covariance_type);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_latitude;
u_latitude.base = 0;
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->latitude = u_latitude.real;
offset += sizeof(this->latitude);
union {
double real;
uint64_t base;
} u_longitude;
u_longitude.base = 0;
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->longitude = u_longitude.real;
offset += sizeof(this->longitude);
union {
double real;
uint64_t base;
} u_altitude;
u_altitude.base = 0;
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->altitude = u_altitude.real;
offset += sizeof(this->altitude);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_position_covariancei;
u_position_covariancei.base = 0;
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position_covariance[i] = u_position_covariancei.real;
offset += sizeof(this->position_covariance[i]);
}
this->position_covariance_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->position_covariance_type);
return offset;
}
const char * getType(){ return "sensor_msgs/NavSatFix"; };
const char * getMD5(){ return "2d3a8cd499b9b4a0249fb98fd05cfa48"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/LaserScan.h | #ifndef _ROS_sensor_msgs_LaserScan_h
#define _ROS_sensor_msgs_LaserScan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class LaserScan : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef float _angle_min_type;
_angle_min_type angle_min;
typedef float _angle_max_type;
_angle_max_type angle_max;
typedef float _angle_increment_type;
_angle_increment_type angle_increment;
typedef float _time_increment_type;
_time_increment_type time_increment;
typedef float _scan_time_type;
_scan_time_type scan_time;
typedef float _range_min_type;
_range_min_type range_min;
typedef float _range_max_type;
_range_max_type range_max;
uint32_t ranges_length;
typedef float _ranges_type;
_ranges_type st_ranges;
_ranges_type * ranges;
uint32_t intensities_length;
typedef float _intensities_type;
_intensities_type st_intensities;
_intensities_type * intensities;
LaserScan():
header(),
angle_min(0),
angle_max(0),
angle_increment(0),
time_increment(0),
scan_time(0),
range_min(0),
range_max(0),
ranges_length(0), ranges(NULL),
intensities_length(0), intensities(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_angle_min;
u_angle_min.real = this->angle_min;
*(outbuffer + offset + 0) = (u_angle_min.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angle_min.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angle_min.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angle_min.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angle_min);
union {
float real;
uint32_t base;
} u_angle_max;
u_angle_max.real = this->angle_max;
*(outbuffer + offset + 0) = (u_angle_max.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angle_max.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angle_max.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angle_max.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angle_max);
union {
float real;
uint32_t base;
} u_angle_increment;
u_angle_increment.real = this->angle_increment;
*(outbuffer + offset + 0) = (u_angle_increment.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angle_increment.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angle_increment.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angle_increment.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angle_increment);
union {
float real;
uint32_t base;
} u_time_increment;
u_time_increment.real = this->time_increment;
*(outbuffer + offset + 0) = (u_time_increment.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_increment.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_increment.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_increment.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_increment);
union {
float real;
uint32_t base;
} u_scan_time;
u_scan_time.real = this->scan_time;
*(outbuffer + offset + 0) = (u_scan_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_scan_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_scan_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_scan_time.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->scan_time);
union {
float real;
uint32_t base;
} u_range_min;
u_range_min.real = this->range_min;
*(outbuffer + offset + 0) = (u_range_min.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_range_min.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_range_min.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_range_min.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->range_min);
union {
float real;
uint32_t base;
} u_range_max;
u_range_max.real = this->range_max;
*(outbuffer + offset + 0) = (u_range_max.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_range_max.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_range_max.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_range_max.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->range_max);
*(outbuffer + offset + 0) = (this->ranges_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ranges_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ranges_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ranges_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ranges_length);
for( uint32_t i = 0; i < ranges_length; i++){
union {
float real;
uint32_t base;
} u_rangesi;
u_rangesi.real = this->ranges[i];
*(outbuffer + offset + 0) = (u_rangesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_rangesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_rangesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_rangesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ranges[i]);
}
*(outbuffer + offset + 0) = (this->intensities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->intensities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->intensities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->intensities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->intensities_length);
for( uint32_t i = 0; i < intensities_length; i++){
union {
float real;
uint32_t base;
} u_intensitiesi;
u_intensitiesi.real = this->intensities[i];
*(outbuffer + offset + 0) = (u_intensitiesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_intensitiesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_intensitiesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_intensitiesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->intensities[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_angle_min;
u_angle_min.base = 0;
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angle_min = u_angle_min.real;
offset += sizeof(this->angle_min);
union {
float real;
uint32_t base;
} u_angle_max;
u_angle_max.base = 0;
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angle_max = u_angle_max.real;
offset += sizeof(this->angle_max);
union {
float real;
uint32_t base;
} u_angle_increment;
u_angle_increment.base = 0;
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angle_increment = u_angle_increment.real;
offset += sizeof(this->angle_increment);
union {
float real;
uint32_t base;
} u_time_increment;
u_time_increment.base = 0;
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->time_increment = u_time_increment.real;
offset += sizeof(this->time_increment);
union {
float real;
uint32_t base;
} u_scan_time;
u_scan_time.base = 0;
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->scan_time = u_scan_time.real;
offset += sizeof(this->scan_time);
union {
float real;
uint32_t base;
} u_range_min;
u_range_min.base = 0;
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->range_min = u_range_min.real;
offset += sizeof(this->range_min);
union {
float real;
uint32_t base;
} u_range_max;
u_range_max.base = 0;
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->range_max = u_range_max.real;
offset += sizeof(this->range_max);
uint32_t ranges_lengthT = ((uint32_t) (*(inbuffer + offset)));
ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ranges_length);
if(ranges_lengthT > ranges_length)
this->ranges = (float*)realloc(this->ranges, ranges_lengthT * sizeof(float));
ranges_length = ranges_lengthT;
for( uint32_t i = 0; i < ranges_length; i++){
union {
float real;
uint32_t base;
} u_st_ranges;
u_st_ranges.base = 0;
u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_ranges = u_st_ranges.real;
offset += sizeof(this->st_ranges);
memcpy( &(this->ranges[i]), &(this->st_ranges), sizeof(float));
}
uint32_t intensities_lengthT = ((uint32_t) (*(inbuffer + offset)));
intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->intensities_length);
if(intensities_lengthT > intensities_length)
this->intensities = (float*)realloc(this->intensities, intensities_lengthT * sizeof(float));
intensities_length = intensities_lengthT;
for( uint32_t i = 0; i < intensities_length; i++){
union {
float real;
uint32_t base;
} u_st_intensities;
u_st_intensities.base = 0;
u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_intensities = u_st_intensities.real;
offset += sizeof(this->st_intensities);
memcpy( &(this->intensities[i]), &(this->st_intensities), sizeof(float));
}
return offset;
}
const char * getType(){ return "sensor_msgs/LaserScan"; };
const char * getMD5(){ return "90c7ef2dc6895d81024acba2ac42f369"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/PointCloud2.h | #ifndef _ROS_sensor_msgs_PointCloud2_h
#define _ROS_sensor_msgs_PointCloud2_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/PointField.h"
namespace sensor_msgs
{
class PointCloud2 : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
uint32_t fields_length;
typedef sensor_msgs::PointField _fields_type;
_fields_type st_fields;
_fields_type * fields;
typedef bool _is_bigendian_type;
_is_bigendian_type is_bigendian;
typedef uint32_t _point_step_type;
_point_step_type point_step;
typedef uint32_t _row_step_type;
_row_step_type row_step;
uint32_t data_length;
typedef uint8_t _data_type;
_data_type st_data;
_data_type * data;
typedef bool _is_dense_type;
_is_dense_type is_dense;
PointCloud2():
header(),
height(0),
width(0),
fields_length(0), fields(NULL),
is_bigendian(0),
point_step(0),
row_step(0),
data_length(0), data(NULL),
is_dense(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
*(outbuffer + offset + 0) = (this->fields_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fields_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fields_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fields_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fields_length);
for( uint32_t i = 0; i < fields_length; i++){
offset += this->fields[i].serialize(outbuffer + offset);
}
union {
bool real;
uint8_t base;
} u_is_bigendian;
u_is_bigendian.real = this->is_bigendian;
*(outbuffer + offset + 0) = (u_is_bigendian.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_bigendian);
*(outbuffer + offset + 0) = (this->point_step >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->point_step >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->point_step >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->point_step >> (8 * 3)) & 0xFF;
offset += sizeof(this->point_step);
*(outbuffer + offset + 0) = (this->row_step >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->row_step >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->row_step >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->row_step >> (8 * 3)) & 0xFF;
offset += sizeof(this->row_step);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
union {
bool real;
uint8_t base;
} u_is_dense;
u_is_dense.real = this->is_dense;
*(outbuffer + offset + 0) = (u_is_dense.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_dense);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
uint32_t fields_lengthT = ((uint32_t) (*(inbuffer + offset)));
fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fields_length);
if(fields_lengthT > fields_length)
this->fields = (sensor_msgs::PointField*)realloc(this->fields, fields_lengthT * sizeof(sensor_msgs::PointField));
fields_length = fields_lengthT;
for( uint32_t i = 0; i < fields_length; i++){
offset += this->st_fields.deserialize(inbuffer + offset);
memcpy( &(this->fields[i]), &(this->st_fields), sizeof(sensor_msgs::PointField));
}
union {
bool real;
uint8_t base;
} u_is_bigendian;
u_is_bigendian.base = 0;
u_is_bigendian.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_bigendian = u_is_bigendian.real;
offset += sizeof(this->is_bigendian);
this->point_step = ((uint32_t) (*(inbuffer + offset)));
this->point_step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->point_step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->point_step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->point_step);
this->row_step = ((uint32_t) (*(inbuffer + offset)));
this->row_step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->row_step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->row_step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->row_step);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
}
union {
bool real;
uint8_t base;
} u_is_dense;
u_is_dense.base = 0;
u_is_dense.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_dense = u_is_dense.real;
offset += sizeof(this->is_dense);
return offset;
}
const char * getType(){ return "sensor_msgs/PointCloud2"; };
const char * getMD5(){ return "1158d486dd51d683ce2f1be655c3c181"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/Illuminance.h | #ifndef _ROS_sensor_msgs_Illuminance_h
#define _ROS_sensor_msgs_Illuminance_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class Illuminance : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _illuminance_type;
_illuminance_type illuminance;
typedef double _variance_type;
_variance_type variance;
Illuminance():
header(),
illuminance(0),
variance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_illuminance;
u_illuminance.real = this->illuminance;
*(outbuffer + offset + 0) = (u_illuminance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_illuminance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_illuminance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_illuminance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_illuminance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_illuminance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_illuminance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_illuminance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->illuminance);
union {
double real;
uint64_t base;
} u_variance;
u_variance.real = this->variance;
*(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->variance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_illuminance;
u_illuminance.base = 0;
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->illuminance = u_illuminance.real;
offset += sizeof(this->illuminance);
union {
double real;
uint64_t base;
} u_variance;
u_variance.base = 0;
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->variance = u_variance.real;
offset += sizeof(this->variance);
return offset;
}
const char * getType(){ return "sensor_msgs/Illuminance"; };
const char * getMD5(){ return "8cf5febb0952fca9d650c3d11a81a188"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/Imu.h | #ifndef _ROS_sensor_msgs_Imu_h
#define _ROS_sensor_msgs_Imu_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Quaternion.h"
#include "geometry_msgs/Vector3.h"
namespace sensor_msgs
{
class Imu : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Quaternion _orientation_type;
_orientation_type orientation;
double orientation_covariance[9];
typedef geometry_msgs::Vector3 _angular_velocity_type;
_angular_velocity_type angular_velocity;
double angular_velocity_covariance[9];
typedef geometry_msgs::Vector3 _linear_acceleration_type;
_linear_acceleration_type linear_acceleration;
double linear_acceleration_covariance[9];
Imu():
header(),
orientation(),
orientation_covariance(),
angular_velocity(),
angular_velocity_covariance(),
linear_acceleration(),
linear_acceleration_covariance()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->orientation.serialize(outbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_orientation_covariancei;
u_orientation_covariancei.real = this->orientation_covariance[i];
*(outbuffer + offset + 0) = (u_orientation_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_orientation_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_orientation_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_orientation_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_orientation_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_orientation_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_orientation_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_orientation_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->orientation_covariance[i]);
}
offset += this->angular_velocity.serialize(outbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_angular_velocity_covariancei;
u_angular_velocity_covariancei.real = this->angular_velocity_covariance[i];
*(outbuffer + offset + 0) = (u_angular_velocity_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angular_velocity_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angular_velocity_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angular_velocity_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_angular_velocity_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_angular_velocity_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_angular_velocity_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_angular_velocity_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->angular_velocity_covariance[i]);
}
offset += this->linear_acceleration.serialize(outbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_linear_acceleration_covariancei;
u_linear_acceleration_covariancei.real = this->linear_acceleration_covariance[i];
*(outbuffer + offset + 0) = (u_linear_acceleration_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_linear_acceleration_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_linear_acceleration_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_linear_acceleration_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_linear_acceleration_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_linear_acceleration_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_linear_acceleration_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_linear_acceleration_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->linear_acceleration_covariance[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->orientation.deserialize(inbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_orientation_covariancei;
u_orientation_covariancei.base = 0;
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->orientation_covariance[i] = u_orientation_covariancei.real;
offset += sizeof(this->orientation_covariance[i]);
}
offset += this->angular_velocity.deserialize(inbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_angular_velocity_covariancei;
u_angular_velocity_covariancei.base = 0;
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->angular_velocity_covariance[i] = u_angular_velocity_covariancei.real;
offset += sizeof(this->angular_velocity_covariance[i]);
}
offset += this->linear_acceleration.deserialize(inbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_linear_acceleration_covariancei;
u_linear_acceleration_covariancei.base = 0;
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->linear_acceleration_covariance[i] = u_linear_acceleration_covariancei.real;
offset += sizeof(this->linear_acceleration_covariance[i]);
}
return offset;
}
const char * getType(){ return "sensor_msgs/Imu"; };
const char * getMD5(){ return "6a62c6daae103f4ff57a132d6f95cec2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/CompressedImage.h | #ifndef _ROS_sensor_msgs_CompressedImage_h
#define _ROS_sensor_msgs_CompressedImage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class CompressedImage : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _format_type;
_format_type format;
uint32_t data_length;
typedef uint8_t _data_type;
_data_type st_data;
_data_type * data;
CompressedImage():
header(),
format(""),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_format = strlen(this->format);
varToArr(outbuffer + offset, length_format);
offset += 4;
memcpy(outbuffer + offset, this->format, length_format);
offset += length_format;
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_format;
arrToVar(length_format, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_format; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_format-1]=0;
this->format = (char *)(inbuffer + offset-1);
offset += length_format;
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
}
return offset;
}
const char * getType(){ return "sensor_msgs/CompressedImage"; };
const char * getMD5(){ return "8f7a12909da2c9d3332d540a0977563f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/PointCloud.h | #ifndef _ROS_sensor_msgs_PointCloud_h
#define _ROS_sensor_msgs_PointCloud_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point32.h"
#include "sensor_msgs/ChannelFloat32.h"
namespace sensor_msgs
{
class PointCloud : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t points_length;
typedef geometry_msgs::Point32 _points_type;
_points_type st_points;
_points_type * points;
uint32_t channels_length;
typedef sensor_msgs::ChannelFloat32 _channels_type;
_channels_type st_channels;
_channels_type * channels;
PointCloud():
header(),
points_length(0), points(NULL),
channels_length(0), channels(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->points_length);
for( uint32_t i = 0; i < points_length; i++){
offset += this->points[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->channels_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->channels_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->channels_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->channels_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->channels_length);
for( uint32_t i = 0; i < channels_length; i++){
offset += this->channels[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->points_length);
if(points_lengthT > points_length)
this->points = (geometry_msgs::Point32*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point32));
points_length = points_lengthT;
for( uint32_t i = 0; i < points_length; i++){
offset += this->st_points.deserialize(inbuffer + offset);
memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point32));
}
uint32_t channels_lengthT = ((uint32_t) (*(inbuffer + offset)));
channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->channels_length);
if(channels_lengthT > channels_length)
this->channels = (sensor_msgs::ChannelFloat32*)realloc(this->channels, channels_lengthT * sizeof(sensor_msgs::ChannelFloat32));
channels_length = channels_lengthT;
for( uint32_t i = 0; i < channels_length; i++){
offset += this->st_channels.deserialize(inbuffer + offset);
memcpy( &(this->channels[i]), &(this->st_channels), sizeof(sensor_msgs::ChannelFloat32));
}
return offset;
}
const char * getType(){ return "sensor_msgs/PointCloud"; };
const char * getMD5(){ return "d8e9c3f5afbdd8a130fd1d2763945fca"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/Image.h | #ifndef _ROS_sensor_msgs_Image_h
#define _ROS_sensor_msgs_Image_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class Image : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
typedef const char* _encoding_type;
_encoding_type encoding;
typedef uint8_t _is_bigendian_type;
_is_bigendian_type is_bigendian;
typedef uint32_t _step_type;
_step_type step;
uint32_t data_length;
typedef uint8_t _data_type;
_data_type st_data;
_data_type * data;
Image():
header(),
height(0),
width(0),
encoding(""),
is_bigendian(0),
step(0),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
uint32_t length_encoding = strlen(this->encoding);
varToArr(outbuffer + offset, length_encoding);
offset += 4;
memcpy(outbuffer + offset, this->encoding, length_encoding);
offset += length_encoding;
*(outbuffer + offset + 0) = (this->is_bigendian >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_bigendian);
*(outbuffer + offset + 0) = (this->step >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->step >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->step >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->step >> (8 * 3)) & 0xFF;
offset += sizeof(this->step);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
uint32_t length_encoding;
arrToVar(length_encoding, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_encoding; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_encoding-1]=0;
this->encoding = (char *)(inbuffer + offset-1);
offset += length_encoding;
this->is_bigendian = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->is_bigendian);
this->step = ((uint32_t) (*(inbuffer + offset)));
this->step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->step);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
}
return offset;
}
const char * getType(){ return "sensor_msgs/Image"; };
const char * getMD5(){ return "060021388200f6f0f447d0fcd9c64743"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/Range.h | #ifndef _ROS_sensor_msgs_Range_h
#define _ROS_sensor_msgs_Range_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class Range : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint8_t _radiation_type_type;
_radiation_type_type radiation_type;
typedef float _field_of_view_type;
_field_of_view_type field_of_view;
typedef float _min_range_type;
_min_range_type min_range;
typedef float _max_range_type;
_max_range_type max_range;
typedef float _range_type;
_range_type range;
enum { ULTRASOUND = 0 };
enum { INFRARED = 1 };
Range():
header(),
radiation_type(0),
field_of_view(0),
min_range(0),
max_range(0),
range(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->radiation_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->radiation_type);
union {
float real;
uint32_t base;
} u_field_of_view;
u_field_of_view.real = this->field_of_view;
*(outbuffer + offset + 0) = (u_field_of_view.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_field_of_view.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_field_of_view.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_field_of_view.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->field_of_view);
union {
float real;
uint32_t base;
} u_min_range;
u_min_range.real = this->min_range;
*(outbuffer + offset + 0) = (u_min_range.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_range.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_range.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_range.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_range);
union {
float real;
uint32_t base;
} u_max_range;
u_max_range.real = this->max_range;
*(outbuffer + offset + 0) = (u_max_range.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_range.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_range.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_range.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_range);
union {
float real;
uint32_t base;
} u_range;
u_range.real = this->range;
*(outbuffer + offset + 0) = (u_range.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_range.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_range.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_range.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->range);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->radiation_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->radiation_type);
union {
float real;
uint32_t base;
} u_field_of_view;
u_field_of_view.base = 0;
u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->field_of_view = u_field_of_view.real;
offset += sizeof(this->field_of_view);
union {
float real;
uint32_t base;
} u_min_range;
u_min_range.base = 0;
u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->min_range = u_min_range.real;
offset += sizeof(this->min_range);
union {
float real;
uint32_t base;
} u_max_range;
u_max_range.base = 0;
u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->max_range = u_max_range.real;
offset += sizeof(this->max_range);
union {
float real;
uint32_t base;
} u_range;
u_range.base = 0;
u_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->range = u_range.real;
offset += sizeof(this->range);
return offset;
}
const char * getType(){ return "sensor_msgs/Range"; };
const char * getMD5(){ return "c005c34273dc426c67a020a87bc24148"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/BatteryState.h | #ifndef _ROS_sensor_msgs_BatteryState_h
#define _ROS_sensor_msgs_BatteryState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class BatteryState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef float _voltage_type;
_voltage_type voltage;
typedef float _current_type;
_current_type current;
typedef float _charge_type;
_charge_type charge;
typedef float _capacity_type;
_capacity_type capacity;
typedef float _design_capacity_type;
_design_capacity_type design_capacity;
typedef float _percentage_type;
_percentage_type percentage;
typedef uint8_t _power_supply_status_type;
_power_supply_status_type power_supply_status;
typedef uint8_t _power_supply_health_type;
_power_supply_health_type power_supply_health;
typedef uint8_t _power_supply_technology_type;
_power_supply_technology_type power_supply_technology;
typedef bool _present_type;
_present_type present;
uint32_t cell_voltage_length;
typedef float _cell_voltage_type;
_cell_voltage_type st_cell_voltage;
_cell_voltage_type * cell_voltage;
typedef const char* _location_type;
_location_type location;
typedef const char* _serial_number_type;
_serial_number_type serial_number;
enum { POWER_SUPPLY_STATUS_UNKNOWN = 0 };
enum { POWER_SUPPLY_STATUS_CHARGING = 1 };
enum { POWER_SUPPLY_STATUS_DISCHARGING = 2 };
enum { POWER_SUPPLY_STATUS_NOT_CHARGING = 3 };
enum { POWER_SUPPLY_STATUS_FULL = 4 };
enum { POWER_SUPPLY_HEALTH_UNKNOWN = 0 };
enum { POWER_SUPPLY_HEALTH_GOOD = 1 };
enum { POWER_SUPPLY_HEALTH_OVERHEAT = 2 };
enum { POWER_SUPPLY_HEALTH_DEAD = 3 };
enum { POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4 };
enum { POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5 };
enum { POWER_SUPPLY_HEALTH_COLD = 6 };
enum { POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7 };
enum { POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8 };
enum { POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0 };
enum { POWER_SUPPLY_TECHNOLOGY_NIMH = 1 };
enum { POWER_SUPPLY_TECHNOLOGY_LION = 2 };
enum { POWER_SUPPLY_TECHNOLOGY_LIPO = 3 };
enum { POWER_SUPPLY_TECHNOLOGY_LIFE = 4 };
enum { POWER_SUPPLY_TECHNOLOGY_NICD = 5 };
enum { POWER_SUPPLY_TECHNOLOGY_LIMN = 6 };
BatteryState():
header(),
voltage(0),
current(0),
charge(0),
capacity(0),
design_capacity(0),
percentage(0),
power_supply_status(0),
power_supply_health(0),
power_supply_technology(0),
present(0),
cell_voltage_length(0), cell_voltage(NULL),
location(""),
serial_number("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_voltage;
u_voltage.real = this->voltage;
*(outbuffer + offset + 0) = (u_voltage.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_voltage.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_voltage.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_voltage.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->voltage);
union {
float real;
uint32_t base;
} u_current;
u_current.real = this->current;
*(outbuffer + offset + 0) = (u_current.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_current.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_current.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_current.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->current);
union {
float real;
uint32_t base;
} u_charge;
u_charge.real = this->charge;
*(outbuffer + offset + 0) = (u_charge.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_charge.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_charge.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_charge.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->charge);
union {
float real;
uint32_t base;
} u_capacity;
u_capacity.real = this->capacity;
*(outbuffer + offset + 0) = (u_capacity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_capacity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_capacity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_capacity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->capacity);
union {
float real;
uint32_t base;
} u_design_capacity;
u_design_capacity.real = this->design_capacity;
*(outbuffer + offset + 0) = (u_design_capacity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_design_capacity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_design_capacity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_design_capacity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->design_capacity);
union {
float real;
uint32_t base;
} u_percentage;
u_percentage.real = this->percentage;
*(outbuffer + offset + 0) = (u_percentage.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_percentage.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_percentage.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_percentage.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->percentage);
*(outbuffer + offset + 0) = (this->power_supply_status >> (8 * 0)) & 0xFF;
offset += sizeof(this->power_supply_status);
*(outbuffer + offset + 0) = (this->power_supply_health >> (8 * 0)) & 0xFF;
offset += sizeof(this->power_supply_health);
*(outbuffer + offset + 0) = (this->power_supply_technology >> (8 * 0)) & 0xFF;
offset += sizeof(this->power_supply_technology);
union {
bool real;
uint8_t base;
} u_present;
u_present.real = this->present;
*(outbuffer + offset + 0) = (u_present.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->present);
*(outbuffer + offset + 0) = (this->cell_voltage_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cell_voltage_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cell_voltage_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cell_voltage_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cell_voltage_length);
for( uint32_t i = 0; i < cell_voltage_length; i++){
union {
float real;
uint32_t base;
} u_cell_voltagei;
u_cell_voltagei.real = this->cell_voltage[i];
*(outbuffer + offset + 0) = (u_cell_voltagei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cell_voltagei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cell_voltagei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cell_voltagei.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cell_voltage[i]);
}
uint32_t length_location = strlen(this->location);
varToArr(outbuffer + offset, length_location);
offset += 4;
memcpy(outbuffer + offset, this->location, length_location);
offset += length_location;
uint32_t length_serial_number = strlen(this->serial_number);
varToArr(outbuffer + offset, length_serial_number);
offset += 4;
memcpy(outbuffer + offset, this->serial_number, length_serial_number);
offset += length_serial_number;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_voltage;
u_voltage.base = 0;
u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->voltage = u_voltage.real;
offset += sizeof(this->voltage);
union {
float real;
uint32_t base;
} u_current;
u_current.base = 0;
u_current.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_current.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_current.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_current.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->current = u_current.real;
offset += sizeof(this->current);
union {
float real;
uint32_t base;
} u_charge;
u_charge.base = 0;
u_charge.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_charge.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_charge.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_charge.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->charge = u_charge.real;
offset += sizeof(this->charge);
union {
float real;
uint32_t base;
} u_capacity;
u_capacity.base = 0;
u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->capacity = u_capacity.real;
offset += sizeof(this->capacity);
union {
float real;
uint32_t base;
} u_design_capacity;
u_design_capacity.base = 0;
u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->design_capacity = u_design_capacity.real;
offset += sizeof(this->design_capacity);
union {
float real;
uint32_t base;
} u_percentage;
u_percentage.base = 0;
u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->percentage = u_percentage.real;
offset += sizeof(this->percentage);
this->power_supply_status = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->power_supply_status);
this->power_supply_health = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->power_supply_health);
this->power_supply_technology = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->power_supply_technology);
union {
bool real;
uint8_t base;
} u_present;
u_present.base = 0;
u_present.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->present = u_present.real;
offset += sizeof(this->present);
uint32_t cell_voltage_lengthT = ((uint32_t) (*(inbuffer + offset)));
cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cell_voltage_length);
if(cell_voltage_lengthT > cell_voltage_length)
this->cell_voltage = (float*)realloc(this->cell_voltage, cell_voltage_lengthT * sizeof(float));
cell_voltage_length = cell_voltage_lengthT;
for( uint32_t i = 0; i < cell_voltage_length; i++){
union {
float real;
uint32_t base;
} u_st_cell_voltage;
u_st_cell_voltage.base = 0;
u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_cell_voltage = u_st_cell_voltage.real;
offset += sizeof(this->st_cell_voltage);
memcpy( &(this->cell_voltage[i]), &(this->st_cell_voltage), sizeof(float));
}
uint32_t length_location;
arrToVar(length_location, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_location; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_location-1]=0;
this->location = (char *)(inbuffer + offset-1);
offset += length_location;
uint32_t length_serial_number;
arrToVar(length_serial_number, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_serial_number; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_serial_number-1]=0;
this->serial_number = (char *)(inbuffer + offset-1);
offset += length_serial_number;
return offset;
}
const char * getType(){ return "sensor_msgs/BatteryState"; };
const char * getMD5(){ return "476f837fa6771f6e16e3bf4ef96f8770"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/CameraInfo.h | #ifndef _ROS_sensor_msgs_CameraInfo_h
#define _ROS_sensor_msgs_CameraInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/RegionOfInterest.h"
namespace sensor_msgs
{
class CameraInfo : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
typedef const char* _distortion_model_type;
_distortion_model_type distortion_model;
uint32_t D_length;
typedef double _D_type;
_D_type st_D;
_D_type * D;
double K[9];
double R[9];
double P[12];
typedef uint32_t _binning_x_type;
_binning_x_type binning_x;
typedef uint32_t _binning_y_type;
_binning_y_type binning_y;
typedef sensor_msgs::RegionOfInterest _roi_type;
_roi_type roi;
CameraInfo():
header(),
height(0),
width(0),
distortion_model(""),
D_length(0), D(NULL),
K(),
R(),
P(),
binning_x(0),
binning_y(0),
roi()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
uint32_t length_distortion_model = strlen(this->distortion_model);
varToArr(outbuffer + offset, length_distortion_model);
offset += 4;
memcpy(outbuffer + offset, this->distortion_model, length_distortion_model);
offset += length_distortion_model;
*(outbuffer + offset + 0) = (this->D_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->D_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->D_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->D_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->D_length);
for( uint32_t i = 0; i < D_length; i++){
union {
double real;
uint64_t base;
} u_Di;
u_Di.real = this->D[i];
*(outbuffer + offset + 0) = (u_Di.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_Di.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_Di.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_Di.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_Di.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_Di.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_Di.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_Di.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->D[i]);
}
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_Ki;
u_Ki.real = this->K[i];
*(outbuffer + offset + 0) = (u_Ki.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_Ki.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_Ki.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_Ki.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_Ki.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_Ki.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_Ki.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_Ki.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->K[i]);
}
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_Ri;
u_Ri.real = this->R[i];
*(outbuffer + offset + 0) = (u_Ri.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_Ri.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_Ri.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_Ri.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_Ri.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_Ri.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_Ri.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_Ri.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->R[i]);
}
for( uint32_t i = 0; i < 12; i++){
union {
double real;
uint64_t base;
} u_Pi;
u_Pi.real = this->P[i];
*(outbuffer + offset + 0) = (u_Pi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_Pi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_Pi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_Pi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_Pi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_Pi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_Pi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_Pi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->P[i]);
}
*(outbuffer + offset + 0) = (this->binning_x >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->binning_x >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->binning_x >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->binning_x >> (8 * 3)) & 0xFF;
offset += sizeof(this->binning_x);
*(outbuffer + offset + 0) = (this->binning_y >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->binning_y >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->binning_y >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->binning_y >> (8 * 3)) & 0xFF;
offset += sizeof(this->binning_y);
offset += this->roi.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
uint32_t length_distortion_model;
arrToVar(length_distortion_model, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_distortion_model; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_distortion_model-1]=0;
this->distortion_model = (char *)(inbuffer + offset-1);
offset += length_distortion_model;
uint32_t D_lengthT = ((uint32_t) (*(inbuffer + offset)));
D_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
D_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
D_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->D_length);
if(D_lengthT > D_length)
this->D = (double*)realloc(this->D, D_lengthT * sizeof(double));
D_length = D_lengthT;
for( uint32_t i = 0; i < D_length; i++){
union {
double real;
uint64_t base;
} u_st_D;
u_st_D.base = 0;
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_D = u_st_D.real;
offset += sizeof(this->st_D);
memcpy( &(this->D[i]), &(this->st_D), sizeof(double));
}
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_Ki;
u_Ki.base = 0;
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->K[i] = u_Ki.real;
offset += sizeof(this->K[i]);
}
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_Ri;
u_Ri.base = 0;
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->R[i] = u_Ri.real;
offset += sizeof(this->R[i]);
}
for( uint32_t i = 0; i < 12; i++){
union {
double real;
uint64_t base;
} u_Pi;
u_Pi.base = 0;
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->P[i] = u_Pi.real;
offset += sizeof(this->P[i]);
}
this->binning_x = ((uint32_t) (*(inbuffer + offset)));
this->binning_x |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->binning_x |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->binning_x |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->binning_x);
this->binning_y = ((uint32_t) (*(inbuffer + offset)));
this->binning_y |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->binning_y |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->binning_y |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->binning_y);
offset += this->roi.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "sensor_msgs/CameraInfo"; };
const char * getMD5(){ return "c9a58c1b0b154e0e6da7578cb991d214"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/Joy.h | #ifndef _ROS_sensor_msgs_Joy_h
#define _ROS_sensor_msgs_Joy_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class Joy : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t axes_length;
typedef float _axes_type;
_axes_type st_axes;
_axes_type * axes;
uint32_t buttons_length;
typedef int32_t _buttons_type;
_buttons_type st_buttons;
_buttons_type * buttons;
Joy():
header(),
axes_length(0), axes(NULL),
buttons_length(0), buttons(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->axes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->axes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->axes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->axes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->axes_length);
for( uint32_t i = 0; i < axes_length; i++){
union {
float real;
uint32_t base;
} u_axesi;
u_axesi.real = this->axes[i];
*(outbuffer + offset + 0) = (u_axesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_axesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_axesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_axesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->axes[i]);
}
*(outbuffer + offset + 0) = (this->buttons_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->buttons_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->buttons_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->buttons_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->buttons_length);
for( uint32_t i = 0; i < buttons_length; i++){
union {
int32_t real;
uint32_t base;
} u_buttonsi;
u_buttonsi.real = this->buttons[i];
*(outbuffer + offset + 0) = (u_buttonsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_buttonsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_buttonsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_buttonsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->buttons[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t axes_lengthT = ((uint32_t) (*(inbuffer + offset)));
axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->axes_length);
if(axes_lengthT > axes_length)
this->axes = (float*)realloc(this->axes, axes_lengthT * sizeof(float));
axes_length = axes_lengthT;
for( uint32_t i = 0; i < axes_length; i++){
union {
float real;
uint32_t base;
} u_st_axes;
u_st_axes.base = 0;
u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_axes = u_st_axes.real;
offset += sizeof(this->st_axes);
memcpy( &(this->axes[i]), &(this->st_axes), sizeof(float));
}
uint32_t buttons_lengthT = ((uint32_t) (*(inbuffer + offset)));
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->buttons_length);
if(buttons_lengthT > buttons_length)
this->buttons = (int32_t*)realloc(this->buttons, buttons_lengthT * sizeof(int32_t));
buttons_length = buttons_lengthT;
for( uint32_t i = 0; i < buttons_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_buttons;
u_st_buttons.base = 0;
u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_buttons = u_st_buttons.real;
offset += sizeof(this->st_buttons);
memcpy( &(this->buttons[i]), &(this->st_buttons), sizeof(int32_t));
}
return offset;
}
const char * getType(){ return "sensor_msgs/Joy"; };
const char * getMD5(){ return "5a9ea5f83505693b71e785041e67a8bb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/NavSatStatus.h | #ifndef _ROS_sensor_msgs_NavSatStatus_h
#define _ROS_sensor_msgs_NavSatStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace sensor_msgs
{
class NavSatStatus : public ros::Msg
{
public:
typedef int8_t _status_type;
_status_type status;
typedef uint16_t _service_type;
_service_type service;
enum { STATUS_NO_FIX = -1 };
enum { STATUS_FIX = 0 };
enum { STATUS_SBAS_FIX = 1 };
enum { STATUS_GBAS_FIX = 2 };
enum { SERVICE_GPS = 1 };
enum { SERVICE_GLONASS = 2 };
enum { SERVICE_COMPASS = 4 };
enum { SERVICE_GALILEO = 8 };
NavSatStatus():
status(0),
service(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_status;
u_status.real = this->status;
*(outbuffer + offset + 0) = (u_status.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->status);
*(outbuffer + offset + 0) = (this->service >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->service >> (8 * 1)) & 0xFF;
offset += sizeof(this->service);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_status;
u_status.base = 0;
u_status.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->status = u_status.real;
offset += sizeof(this->status);
this->service = ((uint16_t) (*(inbuffer + offset)));
this->service |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->service);
return offset;
}
const char * getType(){ return "sensor_msgs/NavSatStatus"; };
const char * getMD5(){ return "331cdbddfa4bc96ffc3b9ad98900a54c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/FluidPressure.h | #ifndef _ROS_sensor_msgs_FluidPressure_h
#define _ROS_sensor_msgs_FluidPressure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class FluidPressure : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _fluid_pressure_type;
_fluid_pressure_type fluid_pressure;
typedef double _variance_type;
_variance_type variance;
FluidPressure():
header(),
fluid_pressure(0),
variance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_fluid_pressure;
u_fluid_pressure.real = this->fluid_pressure;
*(outbuffer + offset + 0) = (u_fluid_pressure.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fluid_pressure.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fluid_pressure.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fluid_pressure.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fluid_pressure.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fluid_pressure.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fluid_pressure.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fluid_pressure.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fluid_pressure);
union {
double real;
uint64_t base;
} u_variance;
u_variance.real = this->variance;
*(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->variance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_fluid_pressure;
u_fluid_pressure.base = 0;
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->fluid_pressure = u_fluid_pressure.real;
offset += sizeof(this->fluid_pressure);
union {
double real;
uint64_t base;
} u_variance;
u_variance.base = 0;
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->variance = u_variance.real;
offset += sizeof(this->variance);
return offset;
}
const char * getType(){ return "sensor_msgs/FluidPressure"; };
const char * getMD5(){ return "804dc5cea1c5306d6a2eb80b9833befe"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/RelativeHumidity.h | #ifndef _ROS_sensor_msgs_RelativeHumidity_h
#define _ROS_sensor_msgs_RelativeHumidity_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace sensor_msgs
{
class RelativeHumidity : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _relative_humidity_type;
_relative_humidity_type relative_humidity;
typedef double _variance_type;
_variance_type variance;
RelativeHumidity():
header(),
relative_humidity(0),
variance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_relative_humidity;
u_relative_humidity.real = this->relative_humidity;
*(outbuffer + offset + 0) = (u_relative_humidity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_relative_humidity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_relative_humidity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_relative_humidity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_relative_humidity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_relative_humidity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_relative_humidity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_relative_humidity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->relative_humidity);
union {
double real;
uint64_t base;
} u_variance;
u_variance.real = this->variance;
*(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->variance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_relative_humidity;
u_relative_humidity.base = 0;
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->relative_humidity = u_relative_humidity.real;
offset += sizeof(this->relative_humidity);
union {
double real;
uint64_t base;
} u_variance;
u_variance.base = 0;
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->variance = u_variance.real;
offset += sizeof(this->variance);
return offset;
}
const char * getType(){ return "sensor_msgs/RelativeHumidity"; };
const char * getMD5(){ return "8730015b05955b7e992ce29a2678d90f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/ChannelFloat32.h | #ifndef _ROS_sensor_msgs_ChannelFloat32_h
#define _ROS_sensor_msgs_ChannelFloat32_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace sensor_msgs
{
class ChannelFloat32 : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
uint32_t values_length;
typedef float _values_type;
_values_type st_values;
_values_type * values;
ChannelFloat32():
name(""),
values_length(0), values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
*(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->values_length);
for( uint32_t i = 0; i < values_length; i++){
union {
float real;
uint32_t base;
} u_valuesi;
u_valuesi.real = this->values[i];
*(outbuffer + offset + 0) = (u_valuesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_valuesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_valuesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_valuesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->values[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->values_length);
if(values_lengthT > values_length)
this->values = (float*)realloc(this->values, values_lengthT * sizeof(float));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
union {
float real;
uint32_t base;
} u_st_values;
u_st_values.base = 0;
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_values = u_st_values.real;
offset += sizeof(this->st_values);
memcpy( &(this->values[i]), &(this->st_values), sizeof(float));
}
return offset;
}
const char * getType(){ return "sensor_msgs/ChannelFloat32"; };
const char * getMD5(){ return "3d40139cdd33dfedcb71ffeeeb42ae7f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/RegionOfInterest.h | #ifndef _ROS_sensor_msgs_RegionOfInterest_h
#define _ROS_sensor_msgs_RegionOfInterest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace sensor_msgs
{
class RegionOfInterest : public ros::Msg
{
public:
typedef uint32_t _x_offset_type;
_x_offset_type x_offset;
typedef uint32_t _y_offset_type;
_y_offset_type y_offset;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
typedef bool _do_rectify_type;
_do_rectify_type do_rectify;
RegionOfInterest():
x_offset(0),
y_offset(0),
height(0),
width(0),
do_rectify(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->x_offset >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->x_offset >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->x_offset >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->x_offset >> (8 * 3)) & 0xFF;
offset += sizeof(this->x_offset);
*(outbuffer + offset + 0) = (this->y_offset >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->y_offset >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->y_offset >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->y_offset >> (8 * 3)) & 0xFF;
offset += sizeof(this->y_offset);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
union {
bool real;
uint8_t base;
} u_do_rectify;
u_do_rectify.real = this->do_rectify;
*(outbuffer + offset + 0) = (u_do_rectify.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->do_rectify);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->x_offset = ((uint32_t) (*(inbuffer + offset)));
this->x_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->x_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->x_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->x_offset);
this->y_offset = ((uint32_t) (*(inbuffer + offset)));
this->y_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->y_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->y_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->y_offset);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
union {
bool real;
uint8_t base;
} u_do_rectify;
u_do_rectify.base = 0;
u_do_rectify.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->do_rectify = u_do_rectify.real;
offset += sizeof(this->do_rectify);
return offset;
}
const char * getType(){ return "sensor_msgs/RegionOfInterest"; };
const char * getMD5(){ return "bdb633039d588fcccb441a4d43ccfe09"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/MagneticField.h | #ifndef _ROS_sensor_msgs_MagneticField_h
#define _ROS_sensor_msgs_MagneticField_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Vector3.h"
namespace sensor_msgs
{
class MagneticField : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Vector3 _magnetic_field_type;
_magnetic_field_type magnetic_field;
double magnetic_field_covariance[9];
MagneticField():
header(),
magnetic_field(),
magnetic_field_covariance()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->magnetic_field.serialize(outbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_magnetic_field_covariancei;
u_magnetic_field_covariancei.real = this->magnetic_field_covariance[i];
*(outbuffer + offset + 0) = (u_magnetic_field_covariancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_magnetic_field_covariancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_magnetic_field_covariancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_magnetic_field_covariancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_magnetic_field_covariancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_magnetic_field_covariancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_magnetic_field_covariancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_magnetic_field_covariancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->magnetic_field_covariance[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->magnetic_field.deserialize(inbuffer + offset);
for( uint32_t i = 0; i < 9; i++){
union {
double real;
uint64_t base;
} u_magnetic_field_covariancei;
u_magnetic_field_covariancei.base = 0;
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->magnetic_field_covariance[i] = u_magnetic_field_covariancei.real;
offset += sizeof(this->magnetic_field_covariance[i]);
}
return offset;
}
const char * getType(){ return "sensor_msgs/MagneticField"; };
const char * getMD5(){ return "2f3b0b43eed0c9501de0fa3ff89a45aa"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/PointField.h | #ifndef _ROS_sensor_msgs_PointField_h
#define _ROS_sensor_msgs_PointField_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace sensor_msgs
{
class PointField : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef uint32_t _offset_type;
_offset_type offset;
typedef uint8_t _datatype_type;
_datatype_type datatype;
typedef uint32_t _count_type;
_count_type count;
enum { INT8 = 1 };
enum { UINT8 = 2 };
enum { INT16 = 3 };
enum { UINT16 = 4 };
enum { INT32 = 5 };
enum { UINT32 = 6 };
enum { FLOAT32 = 7 };
enum { FLOAT64 = 8 };
PointField():
name(""),
offset(0),
datatype(0),
count(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
*(outbuffer + offset + 0) = (this->offset >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->offset >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->offset >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->offset >> (8 * 3)) & 0xFF;
offset += sizeof(this->offset);
*(outbuffer + offset + 0) = (this->datatype >> (8 * 0)) & 0xFF;
offset += sizeof(this->datatype);
*(outbuffer + offset + 0) = (this->count >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->count >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->count >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->count >> (8 * 3)) & 0xFF;
offset += sizeof(this->count);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
this->offset = ((uint32_t) (*(inbuffer + offset)));
this->offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->offset);
this->datatype = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->datatype);
this->count = ((uint32_t) (*(inbuffer + offset)));
this->count |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->count |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->count |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->count);
return offset;
}
const char * getType(){ return "sensor_msgs/PointField"; };
const char * getMD5(){ return "268eacb2962780ceac86cbd17e328150"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/JoyFeedbackArray.h | #ifndef _ROS_sensor_msgs_JoyFeedbackArray_h
#define _ROS_sensor_msgs_JoyFeedbackArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/JoyFeedback.h"
namespace sensor_msgs
{
class JoyFeedbackArray : public ros::Msg
{
public:
uint32_t array_length;
typedef sensor_msgs::JoyFeedback _array_type;
_array_type st_array;
_array_type * array;
JoyFeedbackArray():
array_length(0), array(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->array_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->array_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->array_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->array_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->array_length);
for( uint32_t i = 0; i < array_length; i++){
offset += this->array[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t array_lengthT = ((uint32_t) (*(inbuffer + offset)));
array_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
array_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
array_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->array_length);
if(array_lengthT > array_length)
this->array = (sensor_msgs::JoyFeedback*)realloc(this->array, array_lengthT * sizeof(sensor_msgs::JoyFeedback));
array_length = array_lengthT;
for( uint32_t i = 0; i < array_length; i++){
offset += this->st_array.deserialize(inbuffer + offset);
memcpy( &(this->array[i]), &(this->st_array), sizeof(sensor_msgs::JoyFeedback));
}
return offset;
}
const char * getType(){ return "sensor_msgs/JoyFeedbackArray"; };
const char * getMD5(){ return "cde5730a895b1fc4dee6f91b754b213d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/sensor_msgs/LaserEcho.h | #ifndef _ROS_sensor_msgs_LaserEcho_h
#define _ROS_sensor_msgs_LaserEcho_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace sensor_msgs
{
class LaserEcho : public ros::Msg
{
public:
uint32_t echoes_length;
typedef float _echoes_type;
_echoes_type st_echoes;
_echoes_type * echoes;
LaserEcho():
echoes_length(0), echoes(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->echoes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->echoes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->echoes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->echoes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->echoes_length);
for( uint32_t i = 0; i < echoes_length; i++){
union {
float real;
uint32_t base;
} u_echoesi;
u_echoesi.real = this->echoes[i];
*(outbuffer + offset + 0) = (u_echoesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_echoesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_echoesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_echoesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->echoes[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t echoes_lengthT = ((uint32_t) (*(inbuffer + offset)));
echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->echoes_length);
if(echoes_lengthT > echoes_length)
this->echoes = (float*)realloc(this->echoes, echoes_lengthT * sizeof(float));
echoes_length = echoes_lengthT;
for( uint32_t i = 0; i < echoes_length; i++){
union {
float real;
uint32_t base;
} u_st_echoes;
u_st_echoes.base = 0;
u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_echoes = u_st_echoes.real;
offset += sizeof(this->st_echoes);
memcpy( &(this->echoes[i]), &(this->st_echoes), sizeof(float));
}
return offset;
}
const char * getType(){ return "sensor_msgs/LaserEcho"; };
const char * getMD5(){ return "8bc5ae449b200fba4d552b4225586696"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_applications_msgs/TakePanorama.h | #ifndef _ROS_SERVICE_TakePanorama_h
#define _ROS_SERVICE_TakePanorama_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlebot3_applications_msgs
{
static const char TAKEPANORAMA[] = "turtlebot3_applications_msgs/TakePanorama";
class TakePanoramaRequest : public ros::Msg
{
public:
typedef uint8_t _mode_type;
_mode_type mode;
typedef float _pano_angle_type;
_pano_angle_type pano_angle;
typedef float _snap_interval_type;
_snap_interval_type snap_interval;
typedef float _rot_vel_type;
_rot_vel_type rot_vel;
enum { SNAPANDROTATE = 0 };
enum { CONTINUOUS = 1 };
enum { STOP = 2 };
enum { STARTED = 0 };
enum { IN_PROGRESS = 1 };
enum { STOPPED = 2 };
TakePanoramaRequest():
mode(0),
pano_angle(0),
snap_interval(0),
rot_vel(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->mode);
union {
float real;
uint32_t base;
} u_pano_angle;
u_pano_angle.real = this->pano_angle;
*(outbuffer + offset + 0) = (u_pano_angle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pano_angle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pano_angle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pano_angle.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->pano_angle);
union {
float real;
uint32_t base;
} u_snap_interval;
u_snap_interval.real = this->snap_interval;
*(outbuffer + offset + 0) = (u_snap_interval.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_snap_interval.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_snap_interval.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_snap_interval.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->snap_interval);
union {
float real;
uint32_t base;
} u_rot_vel;
u_rot_vel.real = this->rot_vel;
*(outbuffer + offset + 0) = (u_rot_vel.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_rot_vel.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_rot_vel.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_rot_vel.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->rot_vel);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->mode);
union {
float real;
uint32_t base;
} u_pano_angle;
u_pano_angle.base = 0;
u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pano_angle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->pano_angle = u_pano_angle.real;
offset += sizeof(this->pano_angle);
union {
float real;
uint32_t base;
} u_snap_interval;
u_snap_interval.base = 0;
u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_snap_interval.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->snap_interval = u_snap_interval.real;
offset += sizeof(this->snap_interval);
union {
float real;
uint32_t base;
} u_rot_vel;
u_rot_vel.base = 0;
u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_rot_vel.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->rot_vel = u_rot_vel.real;
offset += sizeof(this->rot_vel);
return offset;
}
const char * getType(){ return TAKEPANORAMA; };
const char * getMD5(){ return "ee720ee47c4798b7447cb7a5755b0062"; };
};
class TakePanoramaResponse : public ros::Msg
{
public:
typedef uint8_t _status_type;
_status_type status;
TakePanoramaResponse():
status(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF;
offset += sizeof(this->status);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->status = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->status);
return offset;
}
const char * getType(){ return TAKEPANORAMA; };
const char * getMD5(){ return "284aa12dd9e9e760802ac9f38036ea5e"; };
};
class TakePanorama {
public:
typedef TakePanoramaRequest Request;
typedef TakePanoramaResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_applications_msgs/PanoramaImg.h | #ifndef _ROS_turtlebot3_applications_msgs_PanoramaImg_h
#define _ROS_turtlebot3_applications_msgs_PanoramaImg_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/Image.h"
namespace turtlebot3_applications_msgs
{
class PanoramaImg : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _pano_id_type;
_pano_id_type pano_id;
typedef double _latitude_type;
_latitude_type latitude;
typedef double _longitude_type;
_longitude_type longitude;
typedef double _heading_type;
_heading_type heading;
typedef const char* _geo_tag_type;
_geo_tag_type geo_tag;
typedef sensor_msgs::Image _image_type;
_image_type image;
PanoramaImg():
header(),
pano_id(""),
latitude(0),
longitude(0),
heading(0),
geo_tag(""),
image()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_pano_id = strlen(this->pano_id);
varToArr(outbuffer + offset, length_pano_id);
offset += 4;
memcpy(outbuffer + offset, this->pano_id, length_pano_id);
offset += length_pano_id;
union {
double real;
uint64_t base;
} u_latitude;
u_latitude.real = this->latitude;
*(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->latitude);
union {
double real;
uint64_t base;
} u_longitude;
u_longitude.real = this->longitude;
*(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->longitude);
union {
double real;
uint64_t base;
} u_heading;
u_heading.real = this->heading;
*(outbuffer + offset + 0) = (u_heading.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_heading.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_heading.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_heading.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_heading.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_heading.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_heading.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_heading.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->heading);
uint32_t length_geo_tag = strlen(this->geo_tag);
varToArr(outbuffer + offset, length_geo_tag);
offset += 4;
memcpy(outbuffer + offset, this->geo_tag, length_geo_tag);
offset += length_geo_tag;
offset += this->image.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_pano_id;
arrToVar(length_pano_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_pano_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_pano_id-1]=0;
this->pano_id = (char *)(inbuffer + offset-1);
offset += length_pano_id;
union {
double real;
uint64_t base;
} u_latitude;
u_latitude.base = 0;
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->latitude = u_latitude.real;
offset += sizeof(this->latitude);
union {
double real;
uint64_t base;
} u_longitude;
u_longitude.base = 0;
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->longitude = u_longitude.real;
offset += sizeof(this->longitude);
union {
double real;
uint64_t base;
} u_heading;
u_heading.base = 0;
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_heading.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->heading = u_heading.real;
offset += sizeof(this->heading);
uint32_t length_geo_tag;
arrToVar(length_geo_tag, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_geo_tag; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_geo_tag-1]=0;
this->geo_tag = (char *)(inbuffer + offset-1);
offset += length_geo_tag;
offset += this->image.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "turtlebot3_applications_msgs/PanoramaImg"; };
const char * getMD5(){ return "aedf66295b374a7249a786af27aecc87"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_applications_msgs/SetFollowState.h | #ifndef _ROS_SERVICE_SetFollowState_h
#define _ROS_SERVICE_SetFollowState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlebot3_applications_msgs
{
static const char SETFOLLOWSTATE[] = "turtlebot3_applications_msgs/SetFollowState";
class SetFollowStateRequest : public ros::Msg
{
public:
typedef uint8_t _state_type;
_state_type state;
enum { STOPPED = 0 };
enum { FOLLOW = 1 };
enum { OK = 0 };
enum { ERROR = 1 };
SetFollowStateRequest():
state(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF;
offset += sizeof(this->state);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->state = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->state);
return offset;
}
const char * getType(){ return SETFOLLOWSTATE; };
const char * getMD5(){ return "bf26f08bd02c8f904098849ef5e63d81"; };
};
class SetFollowStateResponse : public ros::Msg
{
public:
typedef uint8_t _result_type;
_result_type result;
SetFollowStateResponse():
result(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
offset += sizeof(this->result);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->result = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->result);
return offset;
}
const char * getType(){ return SETFOLLOWSTATE; };
const char * getMD5(){ return "25458147911545c320c4c0a299eff763"; };
};
class SetFollowState {
public:
typedef SetFollowStateRequest Request;
typedef SetFollowStateResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nodelet/NodeletUnload.h | #ifndef _ROS_SERVICE_NodeletUnload_h
#define _ROS_SERVICE_NodeletUnload_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace nodelet
{
static const char NODELETUNLOAD[] = "nodelet/NodeletUnload";
class NodeletUnloadRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
NodeletUnloadRequest():
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
return offset;
}
const char * getType(){ return NODELETUNLOAD; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class NodeletUnloadResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
NodeletUnloadResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return NODELETUNLOAD; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class NodeletUnload {
public:
typedef NodeletUnloadRequest Request;
typedef NodeletUnloadResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nodelet/NodeletList.h | #ifndef _ROS_SERVICE_NodeletList_h
#define _ROS_SERVICE_NodeletList_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace nodelet
{
static const char NODELETLIST[] = "nodelet/NodeletList";
class NodeletListRequest : public ros::Msg
{
public:
NodeletListRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return NODELETLIST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class NodeletListResponse : public ros::Msg
{
public:
uint32_t nodelets_length;
typedef char* _nodelets_type;
_nodelets_type st_nodelets;
_nodelets_type * nodelets;
NodeletListResponse():
nodelets_length(0), nodelets(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->nodelets_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->nodelets_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->nodelets_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->nodelets_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->nodelets_length);
for( uint32_t i = 0; i < nodelets_length; i++){
uint32_t length_nodeletsi = strlen(this->nodelets[i]);
varToArr(outbuffer + offset, length_nodeletsi);
offset += 4;
memcpy(outbuffer + offset, this->nodelets[i], length_nodeletsi);
offset += length_nodeletsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t nodelets_lengthT = ((uint32_t) (*(inbuffer + offset)));
nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->nodelets_length);
if(nodelets_lengthT > nodelets_length)
this->nodelets = (char**)realloc(this->nodelets, nodelets_lengthT * sizeof(char*));
nodelets_length = nodelets_lengthT;
for( uint32_t i = 0; i < nodelets_length; i++){
uint32_t length_st_nodelets;
arrToVar(length_st_nodelets, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_nodelets; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_nodelets-1]=0;
this->st_nodelets = (char *)(inbuffer + offset-1);
offset += length_st_nodelets;
memcpy( &(this->nodelets[i]), &(this->st_nodelets), sizeof(char*));
}
return offset;
}
const char * getType(){ return NODELETLIST; };
const char * getMD5(){ return "99c7b10e794f5600b8030e697e946ca7"; };
};
class NodeletList {
public:
typedef NodeletListRequest Request;
typedef NodeletListResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/nodelet/NodeletLoad.h | #ifndef _ROS_SERVICE_NodeletLoad_h
#define _ROS_SERVICE_NodeletLoad_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace nodelet
{
static const char NODELETLOAD[] = "nodelet/NodeletLoad";
class NodeletLoadRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _type_type;
_type_type type;
uint32_t remap_source_args_length;
typedef char* _remap_source_args_type;
_remap_source_args_type st_remap_source_args;
_remap_source_args_type * remap_source_args;
uint32_t remap_target_args_length;
typedef char* _remap_target_args_type;
_remap_target_args_type st_remap_target_args;
_remap_target_args_type * remap_target_args;
uint32_t my_argv_length;
typedef char* _my_argv_type;
_my_argv_type st_my_argv;
_my_argv_type * my_argv;
typedef const char* _bond_id_type;
_bond_id_type bond_id;
NodeletLoadRequest():
name(""),
type(""),
remap_source_args_length(0), remap_source_args(NULL),
remap_target_args_length(0), remap_target_args(NULL),
my_argv_length(0), my_argv(NULL),
bond_id("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
*(outbuffer + offset + 0) = (this->remap_source_args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->remap_source_args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->remap_source_args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->remap_source_args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->remap_source_args_length);
for( uint32_t i = 0; i < remap_source_args_length; i++){
uint32_t length_remap_source_argsi = strlen(this->remap_source_args[i]);
varToArr(outbuffer + offset, length_remap_source_argsi);
offset += 4;
memcpy(outbuffer + offset, this->remap_source_args[i], length_remap_source_argsi);
offset += length_remap_source_argsi;
}
*(outbuffer + offset + 0) = (this->remap_target_args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->remap_target_args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->remap_target_args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->remap_target_args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->remap_target_args_length);
for( uint32_t i = 0; i < remap_target_args_length; i++){
uint32_t length_remap_target_argsi = strlen(this->remap_target_args[i]);
varToArr(outbuffer + offset, length_remap_target_argsi);
offset += 4;
memcpy(outbuffer + offset, this->remap_target_args[i], length_remap_target_argsi);
offset += length_remap_target_argsi;
}
*(outbuffer + offset + 0) = (this->my_argv_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->my_argv_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->my_argv_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->my_argv_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->my_argv_length);
for( uint32_t i = 0; i < my_argv_length; i++){
uint32_t length_my_argvi = strlen(this->my_argv[i]);
varToArr(outbuffer + offset, length_my_argvi);
offset += 4;
memcpy(outbuffer + offset, this->my_argv[i], length_my_argvi);
offset += length_my_argvi;
}
uint32_t length_bond_id = strlen(this->bond_id);
varToArr(outbuffer + offset, length_bond_id);
offset += 4;
memcpy(outbuffer + offset, this->bond_id, length_bond_id);
offset += length_bond_id;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
uint32_t remap_source_args_lengthT = ((uint32_t) (*(inbuffer + offset)));
remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->remap_source_args_length);
if(remap_source_args_lengthT > remap_source_args_length)
this->remap_source_args = (char**)realloc(this->remap_source_args, remap_source_args_lengthT * sizeof(char*));
remap_source_args_length = remap_source_args_lengthT;
for( uint32_t i = 0; i < remap_source_args_length; i++){
uint32_t length_st_remap_source_args;
arrToVar(length_st_remap_source_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_remap_source_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_remap_source_args-1]=0;
this->st_remap_source_args = (char *)(inbuffer + offset-1);
offset += length_st_remap_source_args;
memcpy( &(this->remap_source_args[i]), &(this->st_remap_source_args), sizeof(char*));
}
uint32_t remap_target_args_lengthT = ((uint32_t) (*(inbuffer + offset)));
remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->remap_target_args_length);
if(remap_target_args_lengthT > remap_target_args_length)
this->remap_target_args = (char**)realloc(this->remap_target_args, remap_target_args_lengthT * sizeof(char*));
remap_target_args_length = remap_target_args_lengthT;
for( uint32_t i = 0; i < remap_target_args_length; i++){
uint32_t length_st_remap_target_args;
arrToVar(length_st_remap_target_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_remap_target_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_remap_target_args-1]=0;
this->st_remap_target_args = (char *)(inbuffer + offset-1);
offset += length_st_remap_target_args;
memcpy( &(this->remap_target_args[i]), &(this->st_remap_target_args), sizeof(char*));
}
uint32_t my_argv_lengthT = ((uint32_t) (*(inbuffer + offset)));
my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->my_argv_length);
if(my_argv_lengthT > my_argv_length)
this->my_argv = (char**)realloc(this->my_argv, my_argv_lengthT * sizeof(char*));
my_argv_length = my_argv_lengthT;
for( uint32_t i = 0; i < my_argv_length; i++){
uint32_t length_st_my_argv;
arrToVar(length_st_my_argv, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_my_argv; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_my_argv-1]=0;
this->st_my_argv = (char *)(inbuffer + offset-1);
offset += length_st_my_argv;
memcpy( &(this->my_argv[i]), &(this->st_my_argv), sizeof(char*));
}
uint32_t length_bond_id;
arrToVar(length_bond_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_bond_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_bond_id-1]=0;
this->bond_id = (char *)(inbuffer + offset-1);
offset += length_bond_id;
return offset;
}
const char * getType(){ return NODELETLOAD; };
const char * getMD5(){ return "c6e28cc4d2e259249d96cfb50658fbec"; };
};
class NodeletLoadResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
NodeletLoadResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return NODELETLOAD; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class NodeletLoad {
public:
typedef NodeletLoadRequest Request;
typedef NodeletLoadResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_arduino/Test.h | #ifndef _ROS_SERVICE_Test_h
#define _ROS_SERVICE_Test_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_arduino
{
static const char TEST[] = "rosserial_arduino/Test";
class TestRequest : public ros::Msg
{
public:
typedef const char* _input_type;
_input_type input;
TestRequest():
input("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_input = strlen(this->input);
varToArr(outbuffer + offset, length_input);
offset += 4;
memcpy(outbuffer + offset, this->input, length_input);
offset += length_input;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_input;
arrToVar(length_input, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_input; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_input-1]=0;
this->input = (char *)(inbuffer + offset-1);
offset += length_input;
return offset;
}
const char * getType(){ return TEST; };
const char * getMD5(){ return "39e92f1778057359c64c7b8a7d7b19de"; };
};
class TestResponse : public ros::Msg
{
public:
typedef const char* _output_type;
_output_type output;
TestResponse():
output("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_output = strlen(this->output);
varToArr(outbuffer + offset, length_output);
offset += 4;
memcpy(outbuffer + offset, this->output, length_output);
offset += length_output;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_output;
arrToVar(length_output, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_output; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_output-1]=0;
this->output = (char *)(inbuffer + offset-1);
offset += length_output;
return offset;
}
const char * getType(){ return TEST; };
const char * getMD5(){ return "0825d95fdfa2c8f4bbb4e9c74bccd3fd"; };
};
class Test {
public:
typedef TestRequest Request;
typedef TestResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_arduino/Adc.h | #ifndef _ROS_rosserial_arduino_Adc_h
#define _ROS_rosserial_arduino_Adc_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_arduino
{
class Adc : public ros::Msg
{
public:
typedef uint16_t _adc0_type;
_adc0_type adc0;
typedef uint16_t _adc1_type;
_adc1_type adc1;
typedef uint16_t _adc2_type;
_adc2_type adc2;
typedef uint16_t _adc3_type;
_adc3_type adc3;
typedef uint16_t _adc4_type;
_adc4_type adc4;
typedef uint16_t _adc5_type;
_adc5_type adc5;
Adc():
adc0(0),
adc1(0),
adc2(0),
adc3(0),
adc4(0),
adc5(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->adc0 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->adc0 >> (8 * 1)) & 0xFF;
offset += sizeof(this->adc0);
*(outbuffer + offset + 0) = (this->adc1 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->adc1 >> (8 * 1)) & 0xFF;
offset += sizeof(this->adc1);
*(outbuffer + offset + 0) = (this->adc2 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->adc2 >> (8 * 1)) & 0xFF;
offset += sizeof(this->adc2);
*(outbuffer + offset + 0) = (this->adc3 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->adc3 >> (8 * 1)) & 0xFF;
offset += sizeof(this->adc3);
*(outbuffer + offset + 0) = (this->adc4 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->adc4 >> (8 * 1)) & 0xFF;
offset += sizeof(this->adc4);
*(outbuffer + offset + 0) = (this->adc5 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->adc5 >> (8 * 1)) & 0xFF;
offset += sizeof(this->adc5);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->adc0 = ((uint16_t) (*(inbuffer + offset)));
this->adc0 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->adc0);
this->adc1 = ((uint16_t) (*(inbuffer + offset)));
this->adc1 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->adc1);
this->adc2 = ((uint16_t) (*(inbuffer + offset)));
this->adc2 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->adc2);
this->adc3 = ((uint16_t) (*(inbuffer + offset)));
this->adc3 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->adc3);
this->adc4 = ((uint16_t) (*(inbuffer + offset)));
this->adc4 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->adc4);
this->adc5 = ((uint16_t) (*(inbuffer + offset)));
this->adc5 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->adc5);
return offset;
}
const char * getType(){ return "rosserial_arduino/Adc"; };
const char * getMD5(){ return "6d7853a614e2e821319068311f2af25b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/polled_camera/GetPolledImage.h | #ifndef _ROS_SERVICE_GetPolledImage_h
#define _ROS_SERVICE_GetPolledImage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/RegionOfInterest.h"
#include "ros/duration.h"
#include "ros/time.h"
namespace polled_camera
{
static const char GETPOLLEDIMAGE[] = "polled_camera/GetPolledImage";
class GetPolledImageRequest : public ros::Msg
{
public:
typedef const char* _response_namespace_type;
_response_namespace_type response_namespace;
typedef ros::Duration _timeout_type;
_timeout_type timeout;
typedef uint32_t _binning_x_type;
_binning_x_type binning_x;
typedef uint32_t _binning_y_type;
_binning_y_type binning_y;
typedef sensor_msgs::RegionOfInterest _roi_type;
_roi_type roi;
GetPolledImageRequest():
response_namespace(""),
timeout(),
binning_x(0),
binning_y(0),
roi()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_response_namespace = strlen(this->response_namespace);
varToArr(outbuffer + offset, length_response_namespace);
offset += 4;
memcpy(outbuffer + offset, this->response_namespace, length_response_namespace);
offset += length_response_namespace;
*(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.sec);
*(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.nsec);
*(outbuffer + offset + 0) = (this->binning_x >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->binning_x >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->binning_x >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->binning_x >> (8 * 3)) & 0xFF;
offset += sizeof(this->binning_x);
*(outbuffer + offset + 0) = (this->binning_y >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->binning_y >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->binning_y >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->binning_y >> (8 * 3)) & 0xFF;
offset += sizeof(this->binning_y);
offset += this->roi.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_response_namespace;
arrToVar(length_response_namespace, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_response_namespace; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_response_namespace-1]=0;
this->response_namespace = (char *)(inbuffer + offset-1);
offset += length_response_namespace;
this->timeout.sec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.sec);
this->timeout.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.nsec);
this->binning_x = ((uint32_t) (*(inbuffer + offset)));
this->binning_x |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->binning_x |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->binning_x |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->binning_x);
this->binning_y = ((uint32_t) (*(inbuffer + offset)));
this->binning_y |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->binning_y |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->binning_y |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->binning_y);
offset += this->roi.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOLLEDIMAGE; };
const char * getMD5(){ return "c77ed43e530fd48e9e7a2a93845e154c"; };
};
class GetPolledImageResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
typedef ros::Time _stamp_type;
_stamp_type stamp;
GetPolledImageResponse():
success(0),
status_message(""),
stamp()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
*(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.sec);
*(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
this->stamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.sec);
this->stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.nsec);
return offset;
}
const char * getType(){ return GETPOLLEDIMAGE; };
const char * getMD5(){ return "dbf1f851bc511800e6129ccd5a3542ab"; };
};
class GetPolledImage {
public:
typedef GetPolledImageRequest Request;
typedef GetPolledImageResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/controller_manager_msgs/ControllersStatistics.h | #ifndef _ROS_controller_manager_msgs_ControllersStatistics_h
#define _ROS_controller_manager_msgs_ControllersStatistics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "controller_manager_msgs/ControllerStatistics.h"
namespace controller_manager_msgs
{
class ControllersStatistics : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t controller_length;
typedef controller_manager_msgs::ControllerStatistics _controller_type;
_controller_type st_controller;
_controller_type * controller;
ControllersStatistics():
header(),
controller_length(0), controller(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->controller_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->controller_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->controller_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->controller_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->controller_length);
for( uint32_t i = 0; i < controller_length; i++){
offset += this->controller[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t controller_lengthT = ((uint32_t) (*(inbuffer + offset)));
controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->controller_length);
if(controller_lengthT > controller_length)
this->controller = (controller_manager_msgs::ControllerStatistics*)realloc(this->controller, controller_lengthT * sizeof(controller_manager_msgs::ControllerStatistics));
controller_length = controller_lengthT;
for( uint32_t i = 0; i < controller_length; i++){
offset += this->st_controller.deserialize(inbuffer + offset);
memcpy( &(this->controller[i]), &(this->st_controller), sizeof(controller_manager_msgs::ControllerStatistics));
}
return offset;
}
const char * getType(){ return "controller_manager_msgs/ControllersStatistics"; };
const char * getMD5(){ return "a154c347736773e3700d1719105df29d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/controller_manager_msgs/ControllerState.h | #ifndef _ROS_controller_manager_msgs_ControllerState_h
#define _ROS_controller_manager_msgs_ControllerState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "controller_manager_msgs/HardwareInterfaceResources.h"
namespace controller_manager_msgs
{
class ControllerState : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _state_type;
_state_type state;
typedef const char* _type_type;
_type_type type;
uint32_t claimed_resources_length;
typedef controller_manager_msgs::HardwareInterfaceResources _claimed_resources_type;
_claimed_resources_type st_claimed_resources;
_claimed_resources_type * claimed_resources;
ControllerState():
name(""),
state(""),
type(""),
claimed_resources_length(0), claimed_resources(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
*(outbuffer + offset + 0) = (this->claimed_resources_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->claimed_resources_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->claimed_resources_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->claimed_resources_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->claimed_resources_length);
for( uint32_t i = 0; i < claimed_resources_length; i++){
offset += this->claimed_resources[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
uint32_t length_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
uint32_t claimed_resources_lengthT = ((uint32_t) (*(inbuffer + offset)));
claimed_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
claimed_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
claimed_resources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->claimed_resources_length);
if(claimed_resources_lengthT > claimed_resources_length)
this->claimed_resources = (controller_manager_msgs::HardwareInterfaceResources*)realloc(this->claimed_resources, claimed_resources_lengthT * sizeof(controller_manager_msgs::HardwareInterfaceResources));
claimed_resources_length = claimed_resources_lengthT;
for( uint32_t i = 0; i < claimed_resources_length; i++){
offset += this->st_claimed_resources.deserialize(inbuffer + offset);
memcpy( &(this->claimed_resources[i]), &(this->st_claimed_resources), sizeof(controller_manager_msgs::HardwareInterfaceResources));
}
return offset;
}
const char * getType(){ return "controller_manager_msgs/ControllerState"; };
const char * getMD5(){ return "aeb6b261d97793ab74099a3740245272"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/controller_manager_msgs/ListControllers.h | #ifndef _ROS_SERVICE_ListControllers_h
#define _ROS_SERVICE_ListControllers_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "controller_manager_msgs/ControllerState.h"
namespace controller_manager_msgs
{
static const char LISTCONTROLLERS[] = "controller_manager_msgs/ListControllers";
class ListControllersRequest : public ros::Msg
{
public:
ListControllersRequest()
{
}
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 LISTCONTROLLERS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class ListControllersResponse : public ros::Msg
{
public:
uint32_t controller_length;
typedef controller_manager_msgs::ControllerState _controller_type;
_controller_type st_controller;
_controller_type * controller;
ListControllersResponse():
controller_length(0), controller(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->controller_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->controller_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->controller_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->controller_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->controller_length);
for( uint32_t i = 0; i < controller_length; i++){
offset += this->controller[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t controller_lengthT = ((uint32_t) (*(inbuffer + offset)));
controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
controller_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->controller_length);
if(controller_lengthT > controller_length)
this->controller = (controller_manager_msgs::ControllerState*)realloc(this->controller, controller_lengthT * sizeof(controller_manager_msgs::ControllerState));
controller_length = controller_lengthT;
for( uint32_t i = 0; i < controller_length; i++){
offset += this->st_controller.deserialize(inbuffer + offset);
memcpy( &(this->controller[i]), &(this->st_controller), sizeof(controller_manager_msgs::ControllerState));
}
return offset;
}
const char * getType(){ return LISTCONTROLLERS; };
const char * getMD5(){ return "1341feb2e63fa791f855565d0da950d8"; };
};
class ListControllers {
public:
typedef ListControllersRequest Request;
typedef ListControllersResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/controller_manager_msgs/ListControllerTypes.h | #ifndef _ROS_SERVICE_ListControllerTypes_h
#define _ROS_SERVICE_ListControllerTypes_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace controller_manager_msgs
{
static const char LISTCONTROLLERTYPES[] = "controller_manager_msgs/ListControllerTypes";
class ListControllerTypesRequest : public ros::Msg
{
public:
ListControllerTypesRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return LISTCONTROLLERTYPES; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class ListControllerTypesResponse : public ros::Msg
{
public:
uint32_t types_length;
typedef char* _types_type;
_types_type st_types;
_types_type * types;
uint32_t base_classes_length;
typedef char* _base_classes_type;
_base_classes_type st_base_classes;
_base_classes_type * base_classes;
ListControllerTypesResponse():
types_length(0), types(NULL),
base_classes_length(0), base_classes(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->types_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->types_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->types_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->types_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->types_length);
for( uint32_t i = 0; i < types_length; i++){
uint32_t length_typesi = strlen(this->types[i]);
varToArr(outbuffer + offset, length_typesi);
offset += 4;
memcpy(outbuffer + offset, this->types[i], length_typesi);
offset += length_typesi;
}
*(outbuffer + offset + 0) = (this->base_classes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->base_classes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->base_classes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->base_classes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->base_classes_length);
for( uint32_t i = 0; i < base_classes_length; i++){
uint32_t length_base_classesi = strlen(this->base_classes[i]);
varToArr(outbuffer + offset, length_base_classesi);
offset += 4;
memcpy(outbuffer + offset, this->base_classes[i], length_base_classesi);
offset += length_base_classesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t types_lengthT = ((uint32_t) (*(inbuffer + offset)));
types_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
types_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
types_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->types_length);
if(types_lengthT > types_length)
this->types = (char**)realloc(this->types, types_lengthT * sizeof(char*));
types_length = types_lengthT;
for( uint32_t i = 0; i < types_length; i++){
uint32_t length_st_types;
arrToVar(length_st_types, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_types; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_types-1]=0;
this->st_types = (char *)(inbuffer + offset-1);
offset += length_st_types;
memcpy( &(this->types[i]), &(this->st_types), sizeof(char*));
}
uint32_t base_classes_lengthT = ((uint32_t) (*(inbuffer + offset)));
base_classes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
base_classes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
base_classes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->base_classes_length);
if(base_classes_lengthT > base_classes_length)
this->base_classes = (char**)realloc(this->base_classes, base_classes_lengthT * sizeof(char*));
base_classes_length = base_classes_lengthT;
for( uint32_t i = 0; i < base_classes_length; i++){
uint32_t length_st_base_classes;
arrToVar(length_st_base_classes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_base_classes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_base_classes-1]=0;
this->st_base_classes = (char *)(inbuffer + offset-1);
offset += length_st_base_classes;
memcpy( &(this->base_classes[i]), &(this->st_base_classes), sizeof(char*));
}
return offset;
}
const char * getType(){ return LISTCONTROLLERTYPES; };
const char * getMD5(){ return "c1d4cd11aefa9f97ba4aeb5b33987f4e"; };
};
class ListControllerTypes {
public:
typedef ListControllerTypesRequest Request;
typedef ListControllerTypesResponse Response;
};
}
#endif
|
Subsets and Splits