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/control_msgs/FollowJointTrajectoryActionGoal.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryActionGoal_h
#define _ROS_control_msgs_FollowJointTrajectoryActionGoal_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 "control_msgs/FollowJointTrajectoryGoal.h"
namespace control_msgs
{
class FollowJointTrajectoryActionGoal : 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 control_msgs::FollowJointTrajectoryGoal _goal_type;
_goal_type goal;
FollowJointTrajectoryActionGoal():
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 "control_msgs/FollowJointTrajectoryActionGoal"; };
const char * getMD5(){ return "cff5c1d533bf2f82dd0138d57f4304bb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandResult.h | #ifndef _ROS_control_msgs_GripperCommandResult_h
#define _ROS_control_msgs_GripperCommandResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class GripperCommandResult : public ros::Msg
{
public:
typedef double _position_type;
_position_type position;
typedef double _effort_type;
_effort_type effort;
typedef bool _stalled_type;
_stalled_type stalled;
typedef bool _reached_goal_type;
_reached_goal_type reached_goal;
GripperCommandResult():
position(0),
effort(0),
stalled(0),
reached_goal(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_effort;
u_effort.real = this->effort;
*(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->effort);
union {
bool real;
uint8_t base;
} u_stalled;
u_stalled.real = this->stalled;
*(outbuffer + offset + 0) = (u_stalled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->stalled);
union {
bool real;
uint8_t base;
} u_reached_goal;
u_reached_goal.real = this->reached_goal;
*(outbuffer + offset + 0) = (u_reached_goal.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->reached_goal);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_effort;
u_effort.base = 0;
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->effort = u_effort.real;
offset += sizeof(this->effort);
union {
bool real;
uint8_t base;
} u_stalled;
u_stalled.base = 0;
u_stalled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->stalled = u_stalled.real;
offset += sizeof(this->stalled);
union {
bool real;
uint8_t base;
} u_reached_goal;
u_reached_goal.base = 0;
u_reached_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->reached_goal = u_reached_goal.real;
offset += sizeof(this->reached_goal);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandResult"; };
const char * getMD5(){ return "e4cbff56d3562bcf113da5a5adeef91f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeActionFeedback.h | #ifndef _ROS_turtle_actionlib_ShapeActionFeedback_h
#define _ROS_turtle_actionlib_ShapeActionFeedback_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 "turtle_actionlib/ShapeFeedback.h"
namespace turtle_actionlib
{
class ShapeActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtle_actionlib::ShapeFeedback _feedback_type;
_feedback_type feedback;
ShapeActionFeedback():
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 "turtle_actionlib/ShapeActionFeedback"; };
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/turtle_actionlib/Velocity.h | #ifndef _ROS_turtle_actionlib_Velocity_h
#define _ROS_turtle_actionlib_Velocity_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class Velocity : public ros::Msg
{
public:
typedef float _linear_type;
_linear_type linear;
typedef float _angular_type;
_angular_type angular;
Velocity():
linear(0),
angular(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.real = this->linear;
*(outbuffer + offset + 0) = (u_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_linear.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.real = this->angular;
*(outbuffer + offset + 0) = (u_angular.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angular.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angular.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angular.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angular);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.base = 0;
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->linear = u_linear.real;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.base = 0;
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angular = u_angular.real;
offset += sizeof(this->angular);
return offset;
}
const char * getType(){ return "turtle_actionlib/Velocity"; };
const char * getMD5(){ return "9d5c2dcd348ac8f76ce2a4307bd63a13"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeFeedback.h | #ifndef _ROS_turtle_actionlib_ShapeFeedback_h
#define _ROS_turtle_actionlib_ShapeFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class ShapeFeedback : public ros::Msg
{
public:
ShapeFeedback()
{
}
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 "turtle_actionlib/ShapeFeedback"; };
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/turtle_actionlib/ShapeAction.h | #ifndef _ROS_turtle_actionlib_ShapeAction_h
#define _ROS_turtle_actionlib_ShapeAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "turtle_actionlib/ShapeActionGoal.h"
#include "turtle_actionlib/ShapeActionResult.h"
#include "turtle_actionlib/ShapeActionFeedback.h"
namespace turtle_actionlib
{
class ShapeAction : public ros::Msg
{
public:
typedef turtle_actionlib::ShapeActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef turtle_actionlib::ShapeActionResult _action_result_type;
_action_result_type action_result;
typedef turtle_actionlib::ShapeActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
ShapeAction():
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 "turtle_actionlib/ShapeAction"; };
const char * getMD5(){ return "d73b17d6237a925511f5d7727a1dc903"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeActionGoal.h | #ifndef _ROS_turtle_actionlib_ShapeActionGoal_h
#define _ROS_turtle_actionlib_ShapeActionGoal_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 "turtle_actionlib/ShapeGoal.h"
namespace turtle_actionlib
{
class ShapeActionGoal : 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 turtle_actionlib::ShapeGoal _goal_type;
_goal_type goal;
ShapeActionGoal():
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 "turtle_actionlib/ShapeActionGoal"; };
const char * getMD5(){ return "dbfccd187f2ec9c593916447ffd6cc77"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeGoal.h | #ifndef _ROS_turtle_actionlib_ShapeGoal_h
#define _ROS_turtle_actionlib_ShapeGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class ShapeGoal : public ros::Msg
{
public:
typedef int32_t _edges_type;
_edges_type edges;
typedef float _radius_type;
_radius_type radius;
ShapeGoal():
edges(0),
radius(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_edges;
u_edges.real = this->edges;
*(outbuffer + offset + 0) = (u_edges.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_edges.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_edges.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_edges.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->edges);
union {
float real;
uint32_t base;
} u_radius;
u_radius.real = this->radius;
*(outbuffer + offset + 0) = (u_radius.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_radius.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_radius.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_radius.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->radius);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_edges;
u_edges.base = 0;
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_edges.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->edges = u_edges.real;
offset += sizeof(this->edges);
union {
float real;
uint32_t base;
} u_radius;
u_radius.base = 0;
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_radius.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->radius = u_radius.real;
offset += sizeof(this->radius);
return offset;
}
const char * getType(){ return "turtle_actionlib/ShapeGoal"; };
const char * getMD5(){ return "3b9202ab7292cebe5a95ab2bf6b9c091"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeResult.h | #ifndef _ROS_turtle_actionlib_ShapeResult_h
#define _ROS_turtle_actionlib_ShapeResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtle_actionlib
{
class ShapeResult : public ros::Msg
{
public:
typedef float _interior_angle_type;
_interior_angle_type interior_angle;
typedef float _apothem_type;
_apothem_type apothem;
ShapeResult():
interior_angle(0),
apothem(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_interior_angle;
u_interior_angle.real = this->interior_angle;
*(outbuffer + offset + 0) = (u_interior_angle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_interior_angle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_interior_angle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_interior_angle.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->interior_angle);
union {
float real;
uint32_t base;
} u_apothem;
u_apothem.real = this->apothem;
*(outbuffer + offset + 0) = (u_apothem.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_apothem.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_apothem.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_apothem.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->apothem);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_interior_angle;
u_interior_angle.base = 0;
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->interior_angle = u_interior_angle.real;
offset += sizeof(this->interior_angle);
union {
float real;
uint32_t base;
} u_apothem;
u_apothem.base = 0;
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->apothem = u_apothem.real;
offset += sizeof(this->apothem);
return offset;
}
const char * getType(){ return "turtle_actionlib/ShapeResult"; };
const char * getMD5(){ return "b06c6e2225f820dbc644270387cd1a7c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtle_actionlib/ShapeActionResult.h | #ifndef _ROS_turtle_actionlib_ShapeActionResult_h
#define _ROS_turtle_actionlib_ShapeActionResult_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 "turtle_actionlib/ShapeResult.h"
namespace turtle_actionlib
{
class ShapeActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtle_actionlib::ShapeResult _result_type;
_result_type result;
ShapeActionResult():
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 "turtle_actionlib/ShapeActionResult"; };
const char * getMD5(){ return "c8d13d5d140f1047a2e4d3bf5c045822"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/trajectory_msgs/JointTrajectoryPoint.h | #ifndef _ROS_trajectory_msgs_JointTrajectoryPoint_h
#define _ROS_trajectory_msgs_JointTrajectoryPoint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
namespace trajectory_msgs
{
class JointTrajectoryPoint : public ros::Msg
{
public:
uint32_t positions_length;
typedef double _positions_type;
_positions_type st_positions;
_positions_type * positions;
uint32_t velocities_length;
typedef double _velocities_type;
_velocities_type st_velocities;
_velocities_type * velocities;
uint32_t accelerations_length;
typedef double _accelerations_type;
_accelerations_type st_accelerations;
_accelerations_type * accelerations;
uint32_t effort_length;
typedef double _effort_type;
_effort_type st_effort;
_effort_type * effort;
typedef ros::Duration _time_from_start_type;
_time_from_start_type time_from_start;
JointTrajectoryPoint():
positions_length(0), positions(NULL),
velocities_length(0), velocities(NULL),
accelerations_length(0), accelerations(NULL),
effort_length(0), effort(NULL),
time_from_start()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->positions_length);
for( uint32_t i = 0; i < positions_length; i++){
union {
double real;
uint64_t base;
} u_positionsi;
u_positionsi.real = this->positions[i];
*(outbuffer + offset + 0) = (u_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->positions[i]);
}
*(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocities_length);
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_velocitiesi;
u_velocitiesi.real = this->velocities[i];
*(outbuffer + offset + 0) = (u_velocitiesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocitiesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocitiesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocitiesi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocitiesi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocitiesi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocitiesi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocitiesi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocities[i]);
}
*(outbuffer + offset + 0) = (this->accelerations_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->accelerations_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->accelerations_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->accelerations_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->accelerations_length);
for( uint32_t i = 0; i < accelerations_length; i++){
union {
double real;
uint64_t base;
} u_accelerationsi;
u_accelerationsi.real = this->accelerations[i];
*(outbuffer + offset + 0) = (u_accelerationsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_accelerationsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_accelerationsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_accelerationsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_accelerationsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_accelerationsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_accelerationsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_accelerationsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->accelerations[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]);
}
*(outbuffer + offset + 0) = (this->time_from_start.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.sec);
*(outbuffer + offset + 0) = (this->time_from_start.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->positions_length);
if(positions_lengthT > positions_length)
this->positions = (double*)realloc(this->positions, positions_lengthT * sizeof(double));
positions_length = positions_lengthT;
for( uint32_t i = 0; i < positions_length; i++){
union {
double real;
uint64_t base;
} u_st_positions;
u_st_positions.base = 0;
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_positions = u_st_positions.real;
offset += sizeof(this->st_positions);
memcpy( &(this->positions[i]), &(this->st_positions), sizeof(double));
}
uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocities_length);
if(velocities_lengthT > velocities_length)
this->velocities = (double*)realloc(this->velocities, velocities_lengthT * sizeof(double));
velocities_length = velocities_lengthT;
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_st_velocities;
u_st_velocities.base = 0;
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocities = u_st_velocities.real;
offset += sizeof(this->st_velocities);
memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(double));
}
uint32_t accelerations_lengthT = ((uint32_t) (*(inbuffer + offset)));
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->accelerations_length);
if(accelerations_lengthT > accelerations_length)
this->accelerations = (double*)realloc(this->accelerations, accelerations_lengthT * sizeof(double));
accelerations_length = accelerations_lengthT;
for( uint32_t i = 0; i < accelerations_length; i++){
union {
double real;
uint64_t base;
} u_st_accelerations;
u_st_accelerations.base = 0;
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_accelerations = u_st_accelerations.real;
offset += sizeof(this->st_accelerations);
memcpy( &(this->accelerations[i]), &(this->st_accelerations), 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));
}
this->time_from_start.sec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.sec);
this->time_from_start.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.nsec);
return offset;
}
const char * getType(){ return "trajectory_msgs/JointTrajectoryPoint"; };
const char * getMD5(){ return "f3cd1e1c4d320c79d6985c904ae5dcd3"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/trajectory_msgs/MultiDOFJointTrajectoryPoint.h | #ifndef _ROS_trajectory_msgs_MultiDOFJointTrajectoryPoint_h
#define _ROS_trajectory_msgs_MultiDOFJointTrajectoryPoint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Transform.h"
#include "geometry_msgs/Twist.h"
#include "ros/duration.h"
namespace trajectory_msgs
{
class MultiDOFJointTrajectoryPoint : public ros::Msg
{
public:
uint32_t transforms_length;
typedef geometry_msgs::Transform _transforms_type;
_transforms_type st_transforms;
_transforms_type * transforms;
uint32_t velocities_length;
typedef geometry_msgs::Twist _velocities_type;
_velocities_type st_velocities;
_velocities_type * velocities;
uint32_t accelerations_length;
typedef geometry_msgs::Twist _accelerations_type;
_accelerations_type st_accelerations;
_accelerations_type * accelerations;
typedef ros::Duration _time_from_start_type;
_time_from_start_type time_from_start;
MultiDOFJointTrajectoryPoint():
transforms_length(0), transforms(NULL),
velocities_length(0), velocities(NULL),
accelerations_length(0), accelerations(NULL),
time_from_start()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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->velocities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocities_length);
for( uint32_t i = 0; i < velocities_length; i++){
offset += this->velocities[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->accelerations_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->accelerations_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->accelerations_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->accelerations_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->accelerations_length);
for( uint32_t i = 0; i < accelerations_length; i++){
offset += this->accelerations[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->time_from_start.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.sec);
*(outbuffer + offset + 0) = (this->time_from_start.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time_from_start.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time_from_start.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time_from_start.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time_from_start.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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 velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocities_length);
if(velocities_lengthT > velocities_length)
this->velocities = (geometry_msgs::Twist*)realloc(this->velocities, velocities_lengthT * sizeof(geometry_msgs::Twist));
velocities_length = velocities_lengthT;
for( uint32_t i = 0; i < velocities_length; i++){
offset += this->st_velocities.deserialize(inbuffer + offset);
memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(geometry_msgs::Twist));
}
uint32_t accelerations_lengthT = ((uint32_t) (*(inbuffer + offset)));
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->accelerations_length);
if(accelerations_lengthT > accelerations_length)
this->accelerations = (geometry_msgs::Twist*)realloc(this->accelerations, accelerations_lengthT * sizeof(geometry_msgs::Twist));
accelerations_length = accelerations_lengthT;
for( uint32_t i = 0; i < accelerations_length; i++){
offset += this->st_accelerations.deserialize(inbuffer + offset);
memcpy( &(this->accelerations[i]), &(this->st_accelerations), sizeof(geometry_msgs::Twist));
}
this->time_from_start.sec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.sec);
this->time_from_start.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time_from_start.nsec);
return offset;
}
const char * getType(){ return "trajectory_msgs/MultiDOFJointTrajectoryPoint"; };
const char * getMD5(){ return "3ebe08d1abd5b65862d50e09430db776"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/trajectory_msgs/MultiDOFJointTrajectory.h | #ifndef _ROS_trajectory_msgs_MultiDOFJointTrajectory_h
#define _ROS_trajectory_msgs_MultiDOFJointTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "trajectory_msgs/MultiDOFJointTrajectoryPoint.h"
namespace trajectory_msgs
{
class MultiDOFJointTrajectory : 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 points_length;
typedef trajectory_msgs::MultiDOFJointTrajectoryPoint _points_type;
_points_type st_points;
_points_type * points;
MultiDOFJointTrajectory():
header(),
joint_names_length(0), joint_names(NULL),
points_length(0), points(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->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;
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 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 = (trajectory_msgs::MultiDOFJointTrajectoryPoint*)realloc(this->points, points_lengthT * sizeof(trajectory_msgs::MultiDOFJointTrajectoryPoint));
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(trajectory_msgs::MultiDOFJointTrajectoryPoint));
}
return offset;
}
const char * getType(){ return "trajectory_msgs/MultiDOFJointTrajectory"; };
const char * getMD5(){ return "ef145a45a5f47b77b7f5cdde4b16c942"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/trajectory_msgs/JointTrajectory.h | #ifndef _ROS_trajectory_msgs_JointTrajectory_h
#define _ROS_trajectory_msgs_JointTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "trajectory_msgs/JointTrajectoryPoint.h"
namespace trajectory_msgs
{
class JointTrajectory : 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 points_length;
typedef trajectory_msgs::JointTrajectoryPoint _points_type;
_points_type st_points;
_points_type * points;
JointTrajectory():
header(),
joint_names_length(0), joint_names(NULL),
points_length(0), points(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->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;
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 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 = (trajectory_msgs::JointTrajectoryPoint*)realloc(this->points, points_lengthT * sizeof(trajectory_msgs::JointTrajectoryPoint));
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(trajectory_msgs::JointTrajectoryPoint));
}
return offset;
}
const char * getType(){ return "trajectory_msgs/JointTrajectory"; };
const char * getMD5(){ return "65b4f94a94d1ed67169da35a02f33d3f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/TrajectoryOptions.h | #ifndef _ROS_intera_motion_msgs_TrajectoryOptions_h
#define _ROS_intera_motion_msgs_TrajectoryOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "intera_core_msgs/InteractionControlCommand.h"
#include "intera_motion_msgs/TrackingOptions.h"
#include "ros/time.h"
namespace intera_motion_msgs
{
class TrajectoryOptions : public ros::Msg
{
public:
typedef const char* _interpolation_type_type;
_interpolation_type_type interpolation_type;
typedef bool _interaction_control_type;
_interaction_control_type interaction_control;
typedef intera_core_msgs::InteractionControlCommand _interaction_params_type;
_interaction_params_type interaction_params;
typedef bool _nso_start_offset_allowed_type;
_nso_start_offset_allowed_type nso_start_offset_allowed;
typedef bool _nso_check_end_offset_type;
_nso_check_end_offset_type nso_check_end_offset;
typedef intera_motion_msgs::TrackingOptions _tracking_options_type;
_tracking_options_type tracking_options;
typedef ros::Time _end_time_type;
_end_time_type end_time;
typedef double _path_interpolation_step_type;
_path_interpolation_step_type path_interpolation_step;
enum { CARTESIAN = CARTESIAN };
enum { JOINT = JOINT };
TrajectoryOptions():
interpolation_type(""),
interaction_control(0),
interaction_params(),
nso_start_offset_allowed(0),
nso_check_end_offset(0),
tracking_options(),
end_time(),
path_interpolation_step(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_interpolation_type = strlen(this->interpolation_type);
varToArr(outbuffer + offset, length_interpolation_type);
offset += 4;
memcpy(outbuffer + offset, this->interpolation_type, length_interpolation_type);
offset += length_interpolation_type;
union {
bool real;
uint8_t base;
} u_interaction_control;
u_interaction_control.real = this->interaction_control;
*(outbuffer + offset + 0) = (u_interaction_control.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->interaction_control);
offset += this->interaction_params.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_nso_start_offset_allowed;
u_nso_start_offset_allowed.real = this->nso_start_offset_allowed;
*(outbuffer + offset + 0) = (u_nso_start_offset_allowed.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->nso_start_offset_allowed);
union {
bool real;
uint8_t base;
} u_nso_check_end_offset;
u_nso_check_end_offset.real = this->nso_check_end_offset;
*(outbuffer + offset + 0) = (u_nso_check_end_offset.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->nso_check_end_offset);
offset += this->tracking_options.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->end_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end_time.sec);
*(outbuffer + offset + 0) = (this->end_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->end_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->end_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->end_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->end_time.nsec);
union {
double real;
uint64_t base;
} u_path_interpolation_step;
u_path_interpolation_step.real = this->path_interpolation_step;
*(outbuffer + offset + 0) = (u_path_interpolation_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_path_interpolation_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_path_interpolation_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_path_interpolation_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_path_interpolation_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_path_interpolation_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_path_interpolation_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_path_interpolation_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->path_interpolation_step);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_interpolation_type;
arrToVar(length_interpolation_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_interpolation_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_interpolation_type-1]=0;
this->interpolation_type = (char *)(inbuffer + offset-1);
offset += length_interpolation_type;
union {
bool real;
uint8_t base;
} u_interaction_control;
u_interaction_control.base = 0;
u_interaction_control.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->interaction_control = u_interaction_control.real;
offset += sizeof(this->interaction_control);
offset += this->interaction_params.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_nso_start_offset_allowed;
u_nso_start_offset_allowed.base = 0;
u_nso_start_offset_allowed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->nso_start_offset_allowed = u_nso_start_offset_allowed.real;
offset += sizeof(this->nso_start_offset_allowed);
union {
bool real;
uint8_t base;
} u_nso_check_end_offset;
u_nso_check_end_offset.base = 0;
u_nso_check_end_offset.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->nso_check_end_offset = u_nso_check_end_offset.real;
offset += sizeof(this->nso_check_end_offset);
offset += this->tracking_options.deserialize(inbuffer + offset);
this->end_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->end_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end_time.sec);
this->end_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->end_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->end_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->end_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->end_time.nsec);
union {
double real;
uint64_t base;
} u_path_interpolation_step;
u_path_interpolation_step.base = 0;
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_path_interpolation_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->path_interpolation_step = u_path_interpolation_step.real;
offset += sizeof(this->path_interpolation_step);
return offset;
}
const char * getType(){ return "intera_motion_msgs/TrajectoryOptions"; };
const char * getMD5(){ return "d6c6806743ac9695334265046d57235e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/TrackingOptions.h | #ifndef _ROS_intera_motion_msgs_TrackingOptions_h
#define _ROS_intera_motion_msgs_TrackingOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace intera_motion_msgs
{
class TrackingOptions : public ros::Msg
{
public:
typedef bool _use_min_time_rate_type;
_use_min_time_rate_type use_min_time_rate;
typedef double _min_time_rate_type;
_min_time_rate_type min_time_rate;
typedef bool _use_max_time_rate_type;
_use_max_time_rate_type use_max_time_rate;
typedef double _max_time_rate_type;
_max_time_rate_type max_time_rate;
uint32_t goal_joint_tolerance_length;
typedef double _goal_joint_tolerance_type;
_goal_joint_tolerance_type st_goal_joint_tolerance;
_goal_joint_tolerance_type * goal_joint_tolerance;
typedef bool _use_settling_time_at_goal_type;
_use_settling_time_at_goal_type use_settling_time_at_goal;
typedef double _settling_time_at_goal_type;
_settling_time_at_goal_type settling_time_at_goal;
TrackingOptions():
use_min_time_rate(0),
min_time_rate(0),
use_max_time_rate(0),
max_time_rate(0),
goal_joint_tolerance_length(0), goal_joint_tolerance(NULL),
use_settling_time_at_goal(0),
settling_time_at_goal(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_use_min_time_rate;
u_use_min_time_rate.real = this->use_min_time_rate;
*(outbuffer + offset + 0) = (u_use_min_time_rate.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->use_min_time_rate);
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.real = this->min_time_rate;
*(outbuffer + offset + 0) = (u_min_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_time_rate);
union {
bool real;
uint8_t base;
} u_use_max_time_rate;
u_use_max_time_rate.real = this->use_max_time_rate;
*(outbuffer + offset + 0) = (u_use_max_time_rate.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->use_max_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.real = this->max_time_rate;
*(outbuffer + offset + 0) = (u_max_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_time_rate);
*(outbuffer + offset + 0) = (this->goal_joint_tolerance_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_joint_tolerance_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_joint_tolerance_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_joint_tolerance_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_joint_tolerance_length);
for( uint32_t i = 0; i < goal_joint_tolerance_length; i++){
union {
double real;
uint64_t base;
} u_goal_joint_tolerancei;
u_goal_joint_tolerancei.real = this->goal_joint_tolerance[i];
*(outbuffer + offset + 0) = (u_goal_joint_tolerancei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_goal_joint_tolerancei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_goal_joint_tolerancei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_goal_joint_tolerancei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_goal_joint_tolerancei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_goal_joint_tolerancei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_goal_joint_tolerancei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_goal_joint_tolerancei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->goal_joint_tolerance[i]);
}
union {
bool real;
uint8_t base;
} u_use_settling_time_at_goal;
u_use_settling_time_at_goal.real = this->use_settling_time_at_goal;
*(outbuffer + offset + 0) = (u_use_settling_time_at_goal.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->use_settling_time_at_goal);
union {
double real;
uint64_t base;
} u_settling_time_at_goal;
u_settling_time_at_goal.real = this->settling_time_at_goal;
*(outbuffer + offset + 0) = (u_settling_time_at_goal.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_settling_time_at_goal.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_settling_time_at_goal.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_settling_time_at_goal.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_settling_time_at_goal.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_settling_time_at_goal.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_settling_time_at_goal.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_settling_time_at_goal.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->settling_time_at_goal);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_use_min_time_rate;
u_use_min_time_rate.base = 0;
u_use_min_time_rate.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->use_min_time_rate = u_use_min_time_rate.real;
offset += sizeof(this->use_min_time_rate);
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.base = 0;
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_time_rate = u_min_time_rate.real;
offset += sizeof(this->min_time_rate);
union {
bool real;
uint8_t base;
} u_use_max_time_rate;
u_use_max_time_rate.base = 0;
u_use_max_time_rate.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->use_max_time_rate = u_use_max_time_rate.real;
offset += sizeof(this->use_max_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.base = 0;
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_time_rate = u_max_time_rate.real;
offset += sizeof(this->max_time_rate);
uint32_t goal_joint_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
goal_joint_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
goal_joint_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
goal_joint_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_joint_tolerance_length);
if(goal_joint_tolerance_lengthT > goal_joint_tolerance_length)
this->goal_joint_tolerance = (double*)realloc(this->goal_joint_tolerance, goal_joint_tolerance_lengthT * sizeof(double));
goal_joint_tolerance_length = goal_joint_tolerance_lengthT;
for( uint32_t i = 0; i < goal_joint_tolerance_length; i++){
union {
double real;
uint64_t base;
} u_st_goal_joint_tolerance;
u_st_goal_joint_tolerance.base = 0;
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_goal_joint_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_goal_joint_tolerance = u_st_goal_joint_tolerance.real;
offset += sizeof(this->st_goal_joint_tolerance);
memcpy( &(this->goal_joint_tolerance[i]), &(this->st_goal_joint_tolerance), sizeof(double));
}
union {
bool real;
uint8_t base;
} u_use_settling_time_at_goal;
u_use_settling_time_at_goal.base = 0;
u_use_settling_time_at_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->use_settling_time_at_goal = u_use_settling_time_at_goal.real;
offset += sizeof(this->use_settling_time_at_goal);
union {
double real;
uint64_t base;
} u_settling_time_at_goal;
u_settling_time_at_goal.base = 0;
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_settling_time_at_goal.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->settling_time_at_goal = u_settling_time_at_goal.real;
offset += sizeof(this->settling_time_at_goal);
return offset;
}
const char * getType(){ return "intera_motion_msgs/TrackingOptions"; };
const char * getMD5(){ return "e848e8a266b514c3bde707d0e1859055"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/JointTrackingError.h | #ifndef _ROS_intera_motion_msgs_JointTrackingError_h
#define _ROS_intera_motion_msgs_JointTrackingError_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace intera_motion_msgs
{
class JointTrackingError : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _trajectory_id_type;
_trajectory_id_type trajectory_id;
typedef double _trajectory_time_type;
_trajectory_time_type trajectory_time;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t position_error_length;
typedef double _position_error_type;
_position_error_type st_position_error;
_position_error_type * position_error;
uint32_t velocity_error_length;
typedef double _velocity_error_type;
_velocity_error_type st_velocity_error;
_velocity_error_type * velocity_error;
uint32_t position_command_length;
typedef double _position_command_type;
_position_command_type st_position_command;
_position_command_type * position_command;
uint32_t velocity_command_length;
typedef double _velocity_command_type;
_velocity_command_type st_velocity_command;
_velocity_command_type * velocity_command;
JointTrackingError():
header(),
trajectory_id(0),
trajectory_time(0),
joint_names_length(0), joint_names(NULL),
position_error_length(0), position_error(NULL),
velocity_error_length(0), velocity_error(NULL),
position_command_length(0), position_command(NULL),
velocity_command_length(0), velocity_command(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.real = this->trajectory_time;
*(outbuffer + offset + 0) = (u_trajectory_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_trajectory_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_trajectory_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_trajectory_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_trajectory_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_trajectory_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_trajectory_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_trajectory_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->trajectory_time);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->position_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_error_length);
for( uint32_t i = 0; i < position_error_length; i++){
union {
double real;
uint64_t base;
} u_position_errori;
u_position_errori.real = this->position_error[i];
*(outbuffer + offset + 0) = (u_position_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position_error[i]);
}
*(outbuffer + offset + 0) = (this->velocity_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocity_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocity_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocity_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocity_error_length);
for( uint32_t i = 0; i < velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_velocity_errori;
u_velocity_errori.real = this->velocity_error[i];
*(outbuffer + offset + 0) = (u_velocity_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity_error[i]);
}
*(outbuffer + offset + 0) = (this->position_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_command_length);
for( uint32_t i = 0; i < position_command_length; i++){
union {
double real;
uint64_t base;
} u_position_commandi;
u_position_commandi.real = this->position_command[i];
*(outbuffer + offset + 0) = (u_position_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position_command[i]);
}
*(outbuffer + offset + 0) = (this->velocity_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocity_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocity_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocity_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocity_command_length);
for( uint32_t i = 0; i < velocity_command_length; i++){
union {
double real;
uint64_t base;
} u_velocity_commandi;
u_velocity_commandi.real = this->velocity_command[i];
*(outbuffer + offset + 0) = (u_velocity_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity_command[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->trajectory_id = ((uint32_t) (*(inbuffer + offset)));
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.base = 0;
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->trajectory_time = u_trajectory_time.real;
offset += sizeof(this->trajectory_time);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t position_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_error_length);
if(position_error_lengthT > position_error_length)
this->position_error = (double*)realloc(this->position_error, position_error_lengthT * sizeof(double));
position_error_length = position_error_lengthT;
for( uint32_t i = 0; i < position_error_length; i++){
union {
double real;
uint64_t base;
} u_st_position_error;
u_st_position_error.base = 0;
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position_error = u_st_position_error.real;
offset += sizeof(this->st_position_error);
memcpy( &(this->position_error[i]), &(this->st_position_error), sizeof(double));
}
uint32_t velocity_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocity_error_length);
if(velocity_error_lengthT > velocity_error_length)
this->velocity_error = (double*)realloc(this->velocity_error, velocity_error_lengthT * sizeof(double));
velocity_error_length = velocity_error_lengthT;
for( uint32_t i = 0; i < velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_st_velocity_error;
u_st_velocity_error.base = 0;
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocity_error = u_st_velocity_error.real;
offset += sizeof(this->st_velocity_error);
memcpy( &(this->velocity_error[i]), &(this->st_velocity_error), sizeof(double));
}
uint32_t position_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_command_length);
if(position_command_lengthT > position_command_length)
this->position_command = (double*)realloc(this->position_command, position_command_lengthT * sizeof(double));
position_command_length = position_command_lengthT;
for( uint32_t i = 0; i < position_command_length; i++){
union {
double real;
uint64_t base;
} u_st_position_command;
u_st_position_command.base = 0;
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position_command = u_st_position_command.real;
offset += sizeof(this->st_position_command);
memcpy( &(this->position_command[i]), &(this->st_position_command), sizeof(double));
}
uint32_t velocity_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocity_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocity_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocity_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocity_command_length);
if(velocity_command_lengthT > velocity_command_length)
this->velocity_command = (double*)realloc(this->velocity_command, velocity_command_lengthT * sizeof(double));
velocity_command_length = velocity_command_lengthT;
for( uint32_t i = 0; i < velocity_command_length; i++){
union {
double real;
uint64_t base;
} u_st_velocity_command;
u_st_velocity_command.base = 0;
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocity_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocity_command = u_st_velocity_command.real;
offset += sizeof(this->st_velocity_command);
memcpy( &(this->velocity_command[i]), &(this->st_velocity_command), sizeof(double));
}
return offset;
}
const char * getType(){ return "intera_motion_msgs/JointTrackingError"; };
const char * getMD5(){ return "a564fcc23df67e287d3c4c2aa3aef83b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/Trajectory.h | #ifndef _ROS_intera_motion_msgs_Trajectory_h
#define _ROS_intera_motion_msgs_Trajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "intera_motion_msgs/Waypoint.h"
#include "intera_motion_msgs/TrajectoryOptions.h"
namespace intera_motion_msgs
{
class Trajectory : public ros::Msg
{
public:
typedef const char* _label_type;
_label_type label;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t waypoints_length;
typedef intera_motion_msgs::Waypoint _waypoints_type;
_waypoints_type st_waypoints;
_waypoints_type * waypoints;
typedef intera_motion_msgs::TrajectoryOptions _trajectory_options_type;
_trajectory_options_type trajectory_options;
Trajectory():
label(""),
joint_names_length(0), joint_names(NULL),
waypoints_length(0), waypoints(NULL),
trajectory_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_label = strlen(this->label);
varToArr(outbuffer + offset, length_label);
offset += 4;
memcpy(outbuffer + offset, this->label, length_label);
offset += length_label;
*(outbuffer + offset + 0) = (this->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->waypoints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->waypoints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->waypoints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->waypoints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->waypoints_length);
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->waypoints[i].serialize(outbuffer + offset);
}
offset += this->trajectory_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_label;
arrToVar(length_label, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_label; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_label-1]=0;
this->label = (char *)(inbuffer + offset-1);
offset += length_label;
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 waypoints_lengthT = ((uint32_t) (*(inbuffer + offset)));
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->waypoints_length);
if(waypoints_lengthT > waypoints_length)
this->waypoints = (intera_motion_msgs::Waypoint*)realloc(this->waypoints, waypoints_lengthT * sizeof(intera_motion_msgs::Waypoint));
waypoints_length = waypoints_lengthT;
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->st_waypoints.deserialize(inbuffer + offset);
memcpy( &(this->waypoints[i]), &(this->st_waypoints), sizeof(intera_motion_msgs::Waypoint));
}
offset += this->trajectory_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "intera_motion_msgs/Trajectory"; };
const char * getMD5(){ return "9ab7e6d17ba67f0a6b00ab5f35f6d93e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/WaypointOptions.h | #ifndef _ROS_intera_motion_msgs_WaypointOptions_h
#define _ROS_intera_motion_msgs_WaypointOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace intera_motion_msgs
{
class WaypointOptions : public ros::Msg
{
public:
typedef const char* _label_type;
_label_type label;
typedef double _max_joint_speed_ratio_type;
_max_joint_speed_ratio_type max_joint_speed_ratio;
uint32_t joint_tolerances_length;
typedef double _joint_tolerances_type;
_joint_tolerances_type st_joint_tolerances;
_joint_tolerances_type * joint_tolerances;
uint32_t max_joint_accel_length;
typedef double _max_joint_accel_type;
_max_joint_accel_type st_max_joint_accel;
_max_joint_accel_type * max_joint_accel;
typedef double _max_linear_speed_type;
_max_linear_speed_type max_linear_speed;
typedef double _max_linear_accel_type;
_max_linear_accel_type max_linear_accel;
typedef double _max_rotational_speed_type;
_max_rotational_speed_type max_rotational_speed;
typedef double _max_rotational_accel_type;
_max_rotational_accel_type max_rotational_accel;
typedef double _corner_distance_type;
_corner_distance_type corner_distance;
WaypointOptions():
label(""),
max_joint_speed_ratio(0),
joint_tolerances_length(0), joint_tolerances(NULL),
max_joint_accel_length(0), max_joint_accel(NULL),
max_linear_speed(0),
max_linear_accel(0),
max_rotational_speed(0),
max_rotational_accel(0),
corner_distance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_label = strlen(this->label);
varToArr(outbuffer + offset, length_label);
offset += 4;
memcpy(outbuffer + offset, this->label, length_label);
offset += length_label;
union {
double real;
uint64_t base;
} u_max_joint_speed_ratio;
u_max_joint_speed_ratio.real = this->max_joint_speed_ratio;
*(outbuffer + offset + 0) = (u_max_joint_speed_ratio.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_joint_speed_ratio.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_joint_speed_ratio.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_joint_speed_ratio.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_joint_speed_ratio.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_joint_speed_ratio.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_joint_speed_ratio.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_joint_speed_ratio.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_joint_speed_ratio);
*(outbuffer + offset + 0) = (this->joint_tolerances_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_tolerances_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_tolerances_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_tolerances_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_tolerances_length);
for( uint32_t i = 0; i < joint_tolerances_length; i++){
union {
double real;
uint64_t base;
} u_joint_tolerancesi;
u_joint_tolerancesi.real = this->joint_tolerances[i];
*(outbuffer + offset + 0) = (u_joint_tolerancesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_tolerancesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_tolerancesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_tolerancesi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_tolerancesi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_tolerancesi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_tolerancesi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_tolerancesi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_tolerances[i]);
}
*(outbuffer + offset + 0) = (this->max_joint_accel_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_joint_accel_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_joint_accel_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_joint_accel_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_joint_accel_length);
for( uint32_t i = 0; i < max_joint_accel_length; i++){
union {
double real;
uint64_t base;
} u_max_joint_acceli;
u_max_joint_acceli.real = this->max_joint_accel[i];
*(outbuffer + offset + 0) = (u_max_joint_acceli.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_joint_acceli.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_joint_acceli.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_joint_acceli.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_joint_acceli.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_joint_acceli.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_joint_acceli.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_joint_acceli.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_joint_accel[i]);
}
union {
double real;
uint64_t base;
} u_max_linear_speed;
u_max_linear_speed.real = this->max_linear_speed;
*(outbuffer + offset + 0) = (u_max_linear_speed.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_linear_speed.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_linear_speed.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_linear_speed.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_linear_speed.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_linear_speed.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_linear_speed.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_linear_speed.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_linear_speed);
union {
double real;
uint64_t base;
} u_max_linear_accel;
u_max_linear_accel.real = this->max_linear_accel;
*(outbuffer + offset + 0) = (u_max_linear_accel.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_linear_accel.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_linear_accel.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_linear_accel.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_linear_accel.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_linear_accel.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_linear_accel.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_linear_accel.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_linear_accel);
union {
double real;
uint64_t base;
} u_max_rotational_speed;
u_max_rotational_speed.real = this->max_rotational_speed;
*(outbuffer + offset + 0) = (u_max_rotational_speed.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_rotational_speed.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_rotational_speed.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_rotational_speed.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_rotational_speed.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_rotational_speed.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_rotational_speed.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_rotational_speed.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_rotational_speed);
union {
double real;
uint64_t base;
} u_max_rotational_accel;
u_max_rotational_accel.real = this->max_rotational_accel;
*(outbuffer + offset + 0) = (u_max_rotational_accel.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_rotational_accel.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_rotational_accel.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_rotational_accel.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_rotational_accel.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_rotational_accel.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_rotational_accel.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_rotational_accel.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_rotational_accel);
union {
double real;
uint64_t base;
} u_corner_distance;
u_corner_distance.real = this->corner_distance;
*(outbuffer + offset + 0) = (u_corner_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_corner_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_corner_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_corner_distance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_corner_distance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_corner_distance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_corner_distance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_corner_distance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->corner_distance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_label;
arrToVar(length_label, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_label; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_label-1]=0;
this->label = (char *)(inbuffer + offset-1);
offset += length_label;
union {
double real;
uint64_t base;
} u_max_joint_speed_ratio;
u_max_joint_speed_ratio.base = 0;
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_joint_speed_ratio.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_joint_speed_ratio = u_max_joint_speed_ratio.real;
offset += sizeof(this->max_joint_speed_ratio);
uint32_t joint_tolerances_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_tolerances_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_tolerances_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_tolerances_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_tolerances_length);
if(joint_tolerances_lengthT > joint_tolerances_length)
this->joint_tolerances = (double*)realloc(this->joint_tolerances, joint_tolerances_lengthT * sizeof(double));
joint_tolerances_length = joint_tolerances_lengthT;
for( uint32_t i = 0; i < joint_tolerances_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_tolerances;
u_st_joint_tolerances.base = 0;
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_tolerances.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_tolerances = u_st_joint_tolerances.real;
offset += sizeof(this->st_joint_tolerances);
memcpy( &(this->joint_tolerances[i]), &(this->st_joint_tolerances), sizeof(double));
}
uint32_t max_joint_accel_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_joint_accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_joint_accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_joint_accel_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_joint_accel_length);
if(max_joint_accel_lengthT > max_joint_accel_length)
this->max_joint_accel = (double*)realloc(this->max_joint_accel, max_joint_accel_lengthT * sizeof(double));
max_joint_accel_length = max_joint_accel_lengthT;
for( uint32_t i = 0; i < max_joint_accel_length; i++){
union {
double real;
uint64_t base;
} u_st_max_joint_accel;
u_st_max_joint_accel.base = 0;
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_joint_accel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_joint_accel = u_st_max_joint_accel.real;
offset += sizeof(this->st_max_joint_accel);
memcpy( &(this->max_joint_accel[i]), &(this->st_max_joint_accel), sizeof(double));
}
union {
double real;
uint64_t base;
} u_max_linear_speed;
u_max_linear_speed.base = 0;
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_linear_speed.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_linear_speed = u_max_linear_speed.real;
offset += sizeof(this->max_linear_speed);
union {
double real;
uint64_t base;
} u_max_linear_accel;
u_max_linear_accel.base = 0;
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_linear_accel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_linear_accel = u_max_linear_accel.real;
offset += sizeof(this->max_linear_accel);
union {
double real;
uint64_t base;
} u_max_rotational_speed;
u_max_rotational_speed.base = 0;
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_rotational_speed.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_rotational_speed = u_max_rotational_speed.real;
offset += sizeof(this->max_rotational_speed);
union {
double real;
uint64_t base;
} u_max_rotational_accel;
u_max_rotational_accel.base = 0;
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_rotational_accel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_rotational_accel = u_max_rotational_accel.real;
offset += sizeof(this->max_rotational_accel);
union {
double real;
uint64_t base;
} u_corner_distance;
u_corner_distance.base = 0;
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_corner_distance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->corner_distance = u_corner_distance.real;
offset += sizeof(this->corner_distance);
return offset;
}
const char * getType(){ return "intera_motion_msgs/WaypointOptions"; };
const char * getMD5(){ return "1b4687d4e536269b06e629169723339f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/EndpointTrackingError.h | #ifndef _ROS_intera_motion_msgs_EndpointTrackingError_h
#define _ROS_intera_motion_msgs_EndpointTrackingError_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace intera_motion_msgs
{
class EndpointTrackingError : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _trajectory_id_type;
_trajectory_id_type trajectory_id;
typedef double _trajectory_time_type;
_trajectory_time_type trajectory_time;
typedef const char* _active_endpoint_type;
_active_endpoint_type active_endpoint;
typedef geometry_msgs::Pose _pose_error_type;
_pose_error_type pose_error;
typedef geometry_msgs::Twist _twist_error_type;
_twist_error_type twist_error;
typedef geometry_msgs::Pose _pose_command_type;
_pose_command_type pose_command;
typedef geometry_msgs::Twist _twist_command_type;
_twist_command_type twist_command;
EndpointTrackingError():
header(),
trajectory_id(0),
trajectory_time(0),
active_endpoint(""),
pose_error(),
twist_error(),
pose_command(),
twist_command()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.real = this->trajectory_time;
*(outbuffer + offset + 0) = (u_trajectory_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_trajectory_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_trajectory_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_trajectory_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_trajectory_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_trajectory_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_trajectory_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_trajectory_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->trajectory_time);
uint32_t length_active_endpoint = strlen(this->active_endpoint);
varToArr(outbuffer + offset, length_active_endpoint);
offset += 4;
memcpy(outbuffer + offset, this->active_endpoint, length_active_endpoint);
offset += length_active_endpoint;
offset += this->pose_error.serialize(outbuffer + offset);
offset += this->twist_error.serialize(outbuffer + offset);
offset += this->pose_command.serialize(outbuffer + offset);
offset += this->twist_command.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->trajectory_id = ((uint32_t) (*(inbuffer + offset)));
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->trajectory_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_id);
union {
double real;
uint64_t base;
} u_trajectory_time;
u_trajectory_time.base = 0;
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_trajectory_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->trajectory_time = u_trajectory_time.real;
offset += sizeof(this->trajectory_time);
uint32_t length_active_endpoint;
arrToVar(length_active_endpoint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_active_endpoint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_active_endpoint-1]=0;
this->active_endpoint = (char *)(inbuffer + offset-1);
offset += length_active_endpoint;
offset += this->pose_error.deserialize(inbuffer + offset);
offset += this->twist_error.deserialize(inbuffer + offset);
offset += this->pose_command.deserialize(inbuffer + offset);
offset += this->twist_command.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "intera_motion_msgs/EndpointTrackingError"; };
const char * getMD5(){ return "c266cbf60fc5f871b5909394c05032fc"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/Waypoint.h | #ifndef _ROS_intera_motion_msgs_Waypoint_h
#define _ROS_intera_motion_msgs_Waypoint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
#include "intera_motion_msgs/WaypointOptions.h"
namespace intera_motion_msgs
{
class Waypoint : public ros::Msg
{
public:
uint32_t joint_positions_length;
typedef double _joint_positions_type;
_joint_positions_type st_joint_positions;
_joint_positions_type * joint_positions;
typedef const char* _active_endpoint_type;
_active_endpoint_type active_endpoint;
typedef geometry_msgs::PoseStamped _pose_type;
_pose_type pose;
typedef intera_motion_msgs::WaypointOptions _options_type;
_options_type options;
Waypoint():
joint_positions_length(0), joint_positions(NULL),
active_endpoint(""),
pose(),
options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joint_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_positions_length);
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_joint_positionsi;
u_joint_positionsi.real = this->joint_positions[i];
*(outbuffer + offset + 0) = (u_joint_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_positions[i]);
}
uint32_t length_active_endpoint = strlen(this->active_endpoint);
varToArr(outbuffer + offset, length_active_endpoint);
offset += 4;
memcpy(outbuffer + offset, this->active_endpoint, length_active_endpoint);
offset += length_active_endpoint;
offset += this->pose.serialize(outbuffer + offset);
offset += this->options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joint_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_positions_length);
if(joint_positions_lengthT > joint_positions_length)
this->joint_positions = (double*)realloc(this->joint_positions, joint_positions_lengthT * sizeof(double));
joint_positions_length = joint_positions_lengthT;
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_positions;
u_st_joint_positions.base = 0;
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_positions = u_st_joint_positions.real;
offset += sizeof(this->st_joint_positions);
memcpy( &(this->joint_positions[i]), &(this->st_joint_positions), sizeof(double));
}
uint32_t length_active_endpoint;
arrToVar(length_active_endpoint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_active_endpoint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_active_endpoint-1]=0;
this->active_endpoint = (char *)(inbuffer + offset-1);
offset += length_active_endpoint;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "intera_motion_msgs/Waypoint"; };
const char * getMD5(){ return "8284b290b22204acc5e4d8000467b033"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/InterpolatedPath.h | #ifndef _ROS_intera_motion_msgs_InterpolatedPath_h
#define _ROS_intera_motion_msgs_InterpolatedPath_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "intera_motion_msgs/WaypointSimple.h"
namespace intera_motion_msgs
{
class InterpolatedPath : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _label_type;
_label_type label;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t interpolated_path_length;
typedef intera_motion_msgs::WaypointSimple _interpolated_path_type;
_interpolated_path_type st_interpolated_path;
_interpolated_path_type * interpolated_path;
InterpolatedPath():
header(),
label(""),
joint_names_length(0), joint_names(NULL),
interpolated_path_length(0), interpolated_path(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_label = strlen(this->label);
varToArr(outbuffer + offset, length_label);
offset += 4;
memcpy(outbuffer + offset, this->label, length_label);
offset += length_label;
*(outbuffer + offset + 0) = (this->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->interpolated_path_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->interpolated_path_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->interpolated_path_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->interpolated_path_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->interpolated_path_length);
for( uint32_t i = 0; i < interpolated_path_length; i++){
offset += this->interpolated_path[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_label;
arrToVar(length_label, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_label; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_label-1]=0;
this->label = (char *)(inbuffer + offset-1);
offset += length_label;
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 interpolated_path_lengthT = ((uint32_t) (*(inbuffer + offset)));
interpolated_path_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
interpolated_path_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
interpolated_path_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->interpolated_path_length);
if(interpolated_path_lengthT > interpolated_path_length)
this->interpolated_path = (intera_motion_msgs::WaypointSimple*)realloc(this->interpolated_path, interpolated_path_lengthT * sizeof(intera_motion_msgs::WaypointSimple));
interpolated_path_length = interpolated_path_lengthT;
for( uint32_t i = 0; i < interpolated_path_length; i++){
offset += this->st_interpolated_path.deserialize(inbuffer + offset);
memcpy( &(this->interpolated_path[i]), &(this->st_interpolated_path), sizeof(intera_motion_msgs::WaypointSimple));
}
return offset;
}
const char * getType(){ return "intera_motion_msgs/InterpolatedPath"; };
const char * getMD5(){ return "4e078bdc2ed88b86420f5b19cbd78219"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/TrajectoryAnalysis.h | #ifndef _ROS_intera_motion_msgs_TrajectoryAnalysis_h
#define _ROS_intera_motion_msgs_TrajectoryAnalysis_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace intera_motion_msgs
{
class TrajectoryAnalysis : public ros::Msg
{
public:
typedef double _planned_duration_type;
_planned_duration_type planned_duration;
typedef double _measured_duration_type;
_measured_duration_type measured_duration;
uint32_t min_angle_command_length;
typedef double _min_angle_command_type;
_min_angle_command_type st_min_angle_command;
_min_angle_command_type * min_angle_command;
uint32_t max_angle_command_length;
typedef double _max_angle_command_type;
_max_angle_command_type st_max_angle_command;
_max_angle_command_type * max_angle_command;
uint32_t peak_speed_command_length;
typedef double _peak_speed_command_type;
_peak_speed_command_type st_peak_speed_command;
_peak_speed_command_type * peak_speed_command;
uint32_t peak_accel_command_length;
typedef double _peak_accel_command_type;
_peak_accel_command_type st_peak_accel_command;
_peak_accel_command_type * peak_accel_command;
uint32_t peak_jerk_command_length;
typedef double _peak_jerk_command_type;
_peak_jerk_command_type st_peak_jerk_command;
_peak_jerk_command_type * peak_jerk_command;
typedef double _min_time_rate_type;
_min_time_rate_type min_time_rate;
typedef double _max_time_rate_type;
_max_time_rate_type max_time_rate;
uint32_t max_position_error_length;
typedef double _max_position_error_type;
_max_position_error_type st_max_position_error;
_max_position_error_type * max_position_error;
uint32_t max_velocity_error_length;
typedef double _max_velocity_error_type;
_max_velocity_error_type st_max_velocity_error;
_max_velocity_error_type * max_velocity_error;
TrajectoryAnalysis():
planned_duration(0),
measured_duration(0),
min_angle_command_length(0), min_angle_command(NULL),
max_angle_command_length(0), max_angle_command(NULL),
peak_speed_command_length(0), peak_speed_command(NULL),
peak_accel_command_length(0), peak_accel_command(NULL),
peak_jerk_command_length(0), peak_jerk_command(NULL),
min_time_rate(0),
max_time_rate(0),
max_position_error_length(0), max_position_error(NULL),
max_velocity_error_length(0), max_velocity_error(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_planned_duration;
u_planned_duration.real = this->planned_duration;
*(outbuffer + offset + 0) = (u_planned_duration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planned_duration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planned_duration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planned_duration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planned_duration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planned_duration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planned_duration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planned_duration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planned_duration);
union {
double real;
uint64_t base;
} u_measured_duration;
u_measured_duration.real = this->measured_duration;
*(outbuffer + offset + 0) = (u_measured_duration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_measured_duration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_measured_duration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_measured_duration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_measured_duration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_measured_duration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_measured_duration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_measured_duration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->measured_duration);
*(outbuffer + offset + 0) = (this->min_angle_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_angle_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_angle_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_angle_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_angle_command_length);
for( uint32_t i = 0; i < min_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_min_angle_commandi;
u_min_angle_commandi.real = this->min_angle_command[i];
*(outbuffer + offset + 0) = (u_min_angle_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_angle_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_angle_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_angle_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_angle_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_angle_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_angle_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_angle_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_angle_command[i]);
}
*(outbuffer + offset + 0) = (this->max_angle_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_angle_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_angle_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_angle_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_angle_command_length);
for( uint32_t i = 0; i < max_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_max_angle_commandi;
u_max_angle_commandi.real = this->max_angle_command[i];
*(outbuffer + offset + 0) = (u_max_angle_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_angle_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_angle_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_angle_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_angle_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_angle_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_angle_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_angle_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_angle_command[i]);
}
*(outbuffer + offset + 0) = (this->peak_speed_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->peak_speed_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->peak_speed_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->peak_speed_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->peak_speed_command_length);
for( uint32_t i = 0; i < peak_speed_command_length; i++){
union {
double real;
uint64_t base;
} u_peak_speed_commandi;
u_peak_speed_commandi.real = this->peak_speed_command[i];
*(outbuffer + offset + 0) = (u_peak_speed_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_peak_speed_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_peak_speed_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_peak_speed_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_peak_speed_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_peak_speed_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_peak_speed_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_peak_speed_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->peak_speed_command[i]);
}
*(outbuffer + offset + 0) = (this->peak_accel_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->peak_accel_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->peak_accel_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->peak_accel_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->peak_accel_command_length);
for( uint32_t i = 0; i < peak_accel_command_length; i++){
union {
double real;
uint64_t base;
} u_peak_accel_commandi;
u_peak_accel_commandi.real = this->peak_accel_command[i];
*(outbuffer + offset + 0) = (u_peak_accel_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_peak_accel_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_peak_accel_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_peak_accel_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_peak_accel_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_peak_accel_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_peak_accel_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_peak_accel_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->peak_accel_command[i]);
}
*(outbuffer + offset + 0) = (this->peak_jerk_command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->peak_jerk_command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->peak_jerk_command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->peak_jerk_command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->peak_jerk_command_length);
for( uint32_t i = 0; i < peak_jerk_command_length; i++){
union {
double real;
uint64_t base;
} u_peak_jerk_commandi;
u_peak_jerk_commandi.real = this->peak_jerk_command[i];
*(outbuffer + offset + 0) = (u_peak_jerk_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_peak_jerk_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_peak_jerk_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_peak_jerk_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_peak_jerk_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_peak_jerk_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_peak_jerk_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_peak_jerk_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->peak_jerk_command[i]);
}
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.real = this->min_time_rate;
*(outbuffer + offset + 0) = (u_min_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.real = this->max_time_rate;
*(outbuffer + offset + 0) = (u_max_time_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_time_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_time_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_time_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_time_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_time_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_time_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_time_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_time_rate);
*(outbuffer + offset + 0) = (this->max_position_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_position_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_position_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_position_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_position_error_length);
for( uint32_t i = 0; i < max_position_error_length; i++){
union {
double real;
uint64_t base;
} u_max_position_errori;
u_max_position_errori.real = this->max_position_error[i];
*(outbuffer + offset + 0) = (u_max_position_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_position_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_position_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_position_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_position_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_position_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_position_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_position_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_position_error[i]);
}
*(outbuffer + offset + 0) = (this->max_velocity_error_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_velocity_error_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_velocity_error_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_velocity_error_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_velocity_error_length);
for( uint32_t i = 0; i < max_velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_max_velocity_errori;
u_max_velocity_errori.real = this->max_velocity_error[i];
*(outbuffer + offset + 0) = (u_max_velocity_errori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity_errori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity_errori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity_errori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity_errori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity_errori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity_errori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity_errori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity_error[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_planned_duration;
u_planned_duration.base = 0;
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planned_duration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planned_duration = u_planned_duration.real;
offset += sizeof(this->planned_duration);
union {
double real;
uint64_t base;
} u_measured_duration;
u_measured_duration.base = 0;
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_measured_duration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->measured_duration = u_measured_duration.real;
offset += sizeof(this->measured_duration);
uint32_t min_angle_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
min_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
min_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
min_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_angle_command_length);
if(min_angle_command_lengthT > min_angle_command_length)
this->min_angle_command = (double*)realloc(this->min_angle_command, min_angle_command_lengthT * sizeof(double));
min_angle_command_length = min_angle_command_lengthT;
for( uint32_t i = 0; i < min_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_st_min_angle_command;
u_st_min_angle_command.base = 0;
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_min_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_min_angle_command = u_st_min_angle_command.real;
offset += sizeof(this->st_min_angle_command);
memcpy( &(this->min_angle_command[i]), &(this->st_min_angle_command), sizeof(double));
}
uint32_t max_angle_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_angle_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_angle_command_length);
if(max_angle_command_lengthT > max_angle_command_length)
this->max_angle_command = (double*)realloc(this->max_angle_command, max_angle_command_lengthT * sizeof(double));
max_angle_command_length = max_angle_command_lengthT;
for( uint32_t i = 0; i < max_angle_command_length; i++){
union {
double real;
uint64_t base;
} u_st_max_angle_command;
u_st_max_angle_command.base = 0;
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_angle_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_angle_command = u_st_max_angle_command.real;
offset += sizeof(this->st_max_angle_command);
memcpy( &(this->max_angle_command[i]), &(this->st_max_angle_command), sizeof(double));
}
uint32_t peak_speed_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
peak_speed_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
peak_speed_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
peak_speed_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->peak_speed_command_length);
if(peak_speed_command_lengthT > peak_speed_command_length)
this->peak_speed_command = (double*)realloc(this->peak_speed_command, peak_speed_command_lengthT * sizeof(double));
peak_speed_command_length = peak_speed_command_lengthT;
for( uint32_t i = 0; i < peak_speed_command_length; i++){
union {
double real;
uint64_t base;
} u_st_peak_speed_command;
u_st_peak_speed_command.base = 0;
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_peak_speed_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_peak_speed_command = u_st_peak_speed_command.real;
offset += sizeof(this->st_peak_speed_command);
memcpy( &(this->peak_speed_command[i]), &(this->st_peak_speed_command), sizeof(double));
}
uint32_t peak_accel_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
peak_accel_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
peak_accel_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
peak_accel_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->peak_accel_command_length);
if(peak_accel_command_lengthT > peak_accel_command_length)
this->peak_accel_command = (double*)realloc(this->peak_accel_command, peak_accel_command_lengthT * sizeof(double));
peak_accel_command_length = peak_accel_command_lengthT;
for( uint32_t i = 0; i < peak_accel_command_length; i++){
union {
double real;
uint64_t base;
} u_st_peak_accel_command;
u_st_peak_accel_command.base = 0;
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_peak_accel_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_peak_accel_command = u_st_peak_accel_command.real;
offset += sizeof(this->st_peak_accel_command);
memcpy( &(this->peak_accel_command[i]), &(this->st_peak_accel_command), sizeof(double));
}
uint32_t peak_jerk_command_lengthT = ((uint32_t) (*(inbuffer + offset)));
peak_jerk_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
peak_jerk_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
peak_jerk_command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->peak_jerk_command_length);
if(peak_jerk_command_lengthT > peak_jerk_command_length)
this->peak_jerk_command = (double*)realloc(this->peak_jerk_command, peak_jerk_command_lengthT * sizeof(double));
peak_jerk_command_length = peak_jerk_command_lengthT;
for( uint32_t i = 0; i < peak_jerk_command_length; i++){
union {
double real;
uint64_t base;
} u_st_peak_jerk_command;
u_st_peak_jerk_command.base = 0;
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_peak_jerk_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_peak_jerk_command = u_st_peak_jerk_command.real;
offset += sizeof(this->st_peak_jerk_command);
memcpy( &(this->peak_jerk_command[i]), &(this->st_peak_jerk_command), sizeof(double));
}
union {
double real;
uint64_t base;
} u_min_time_rate;
u_min_time_rate.base = 0;
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_time_rate = u_min_time_rate.real;
offset += sizeof(this->min_time_rate);
union {
double real;
uint64_t base;
} u_max_time_rate;
u_max_time_rate.base = 0;
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_time_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_time_rate = u_max_time_rate.real;
offset += sizeof(this->max_time_rate);
uint32_t max_position_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_position_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_position_error_length);
if(max_position_error_lengthT > max_position_error_length)
this->max_position_error = (double*)realloc(this->max_position_error, max_position_error_lengthT * sizeof(double));
max_position_error_length = max_position_error_lengthT;
for( uint32_t i = 0; i < max_position_error_length; i++){
union {
double real;
uint64_t base;
} u_st_max_position_error;
u_st_max_position_error.base = 0;
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_position_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_position_error = u_st_max_position_error.real;
offset += sizeof(this->st_max_position_error);
memcpy( &(this->max_position_error[i]), &(this->st_max_position_error), sizeof(double));
}
uint32_t max_velocity_error_lengthT = ((uint32_t) (*(inbuffer + offset)));
max_velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
max_velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
max_velocity_error_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_velocity_error_length);
if(max_velocity_error_lengthT > max_velocity_error_length)
this->max_velocity_error = (double*)realloc(this->max_velocity_error, max_velocity_error_lengthT * sizeof(double));
max_velocity_error_length = max_velocity_error_lengthT;
for( uint32_t i = 0; i < max_velocity_error_length; i++){
union {
double real;
uint64_t base;
} u_st_max_velocity_error;
u_st_max_velocity_error.base = 0;
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_max_velocity_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_max_velocity_error = u_st_max_velocity_error.real;
offset += sizeof(this->st_max_velocity_error);
memcpy( &(this->max_velocity_error[i]), &(this->st_max_velocity_error), sizeof(double));
}
return offset;
}
const char * getType(){ return "intera_motion_msgs/TrajectoryAnalysis"; };
const char * getMD5(){ return "f30ec541413b4eb2cecc0d0af7d30ad4"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/WaypointSimple.h | #ifndef _ROS_intera_motion_msgs_WaypointSimple_h
#define _ROS_intera_motion_msgs_WaypointSimple_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace intera_motion_msgs
{
class WaypointSimple : public ros::Msg
{
public:
uint32_t joint_positions_length;
typedef double _joint_positions_type;
_joint_positions_type st_joint_positions;
_joint_positions_type * joint_positions;
typedef const char* _active_endpoint_type;
_active_endpoint_type active_endpoint;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef int32_t _segment_index_type;
_segment_index_type segment_index;
typedef double _time_type;
_time_type time;
WaypointSimple():
joint_positions_length(0), joint_positions(NULL),
active_endpoint(""),
pose(),
segment_index(0),
time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joint_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_positions_length);
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_joint_positionsi;
u_joint_positionsi.real = this->joint_positions[i];
*(outbuffer + offset + 0) = (u_joint_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_positions[i]);
}
uint32_t length_active_endpoint = strlen(this->active_endpoint);
varToArr(outbuffer + offset, length_active_endpoint);
offset += 4;
memcpy(outbuffer + offset, this->active_endpoint, length_active_endpoint);
offset += length_active_endpoint;
offset += this->pose.serialize(outbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_segment_index;
u_segment_index.real = this->segment_index;
*(outbuffer + offset + 0) = (u_segment_index.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_segment_index.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_segment_index.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_segment_index.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->segment_index);
union {
double real;
uint64_t base;
} u_time;
u_time.real = this->time;
*(outbuffer + offset + 0) = (u_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joint_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_positions_length);
if(joint_positions_lengthT > joint_positions_length)
this->joint_positions = (double*)realloc(this->joint_positions, joint_positions_lengthT * sizeof(double));
joint_positions_length = joint_positions_lengthT;
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_positions;
u_st_joint_positions.base = 0;
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_positions = u_st_joint_positions.real;
offset += sizeof(this->st_joint_positions);
memcpy( &(this->joint_positions[i]), &(this->st_joint_positions), sizeof(double));
}
uint32_t length_active_endpoint;
arrToVar(length_active_endpoint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_active_endpoint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_active_endpoint-1]=0;
this->active_endpoint = (char *)(inbuffer + offset-1);
offset += length_active_endpoint;
offset += this->pose.deserialize(inbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_segment_index;
u_segment_index.base = 0;
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_segment_index.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->segment_index = u_segment_index.real;
offset += sizeof(this->segment_index);
union {
double real;
uint64_t base;
} u_time;
u_time.base = 0;
u_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time = u_time.real;
offset += sizeof(this->time);
return offset;
}
const char * getType(){ return "intera_motion_msgs/WaypointSimple"; };
const char * getMD5(){ return "f29bcd94cca5f378ef52eb965645d7ce"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/intera_motion_msgs/MotionStatus.h | #ifndef _ROS_intera_motion_msgs_MotionStatus_h
#define _ROS_intera_motion_msgs_MotionStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace intera_motion_msgs
{
class MotionStatus : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _motion_status_type;
_motion_status_type motion_status;
typedef const char* _current_trajectory_type;
_current_trajectory_type current_trajectory;
typedef uint32_t _current_waypoint_type;
_current_waypoint_type current_waypoint;
typedef uint32_t _motion_request_type;
_motion_request_type motion_request;
enum { MOTION_IDLE = idle };
enum { MOTION_PENDING = pending };
enum { MOTION_RUNNING = running };
enum { MOTION_STOPPING = stopping };
enum { MOTION_DONE = done };
enum { MOTION_PREEMPTED = preempted };
enum { MOTION_ERROR = error };
MotionStatus():
header(),
motion_status(""),
current_trajectory(""),
current_waypoint(0),
motion_request(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_motion_status = strlen(this->motion_status);
varToArr(outbuffer + offset, length_motion_status);
offset += 4;
memcpy(outbuffer + offset, this->motion_status, length_motion_status);
offset += length_motion_status;
uint32_t length_current_trajectory = strlen(this->current_trajectory);
varToArr(outbuffer + offset, length_current_trajectory);
offset += 4;
memcpy(outbuffer + offset, this->current_trajectory, length_current_trajectory);
offset += length_current_trajectory;
*(outbuffer + offset + 0) = (this->current_waypoint >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->current_waypoint >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->current_waypoint >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->current_waypoint >> (8 * 3)) & 0xFF;
offset += sizeof(this->current_waypoint);
*(outbuffer + offset + 0) = (this->motion_request >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->motion_request >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->motion_request >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->motion_request >> (8 * 3)) & 0xFF;
offset += sizeof(this->motion_request);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_motion_status;
arrToVar(length_motion_status, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_motion_status; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_motion_status-1]=0;
this->motion_status = (char *)(inbuffer + offset-1);
offset += length_motion_status;
uint32_t length_current_trajectory;
arrToVar(length_current_trajectory, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_current_trajectory; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_current_trajectory-1]=0;
this->current_trajectory = (char *)(inbuffer + offset-1);
offset += length_current_trajectory;
this->current_waypoint = ((uint32_t) (*(inbuffer + offset)));
this->current_waypoint |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->current_waypoint |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->current_waypoint |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->current_waypoint);
this->motion_request = ((uint32_t) (*(inbuffer + offset)));
this->motion_request |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->motion_request |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->motion_request |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->motion_request);
return offset;
}
const char * getType(){ return "intera_motion_msgs/MotionStatus"; };
const char * getMD5(){ return "178c2a9a52d756f9d73396be4ec1a07c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/shape_msgs/MeshTriangle.h | #ifndef _ROS_shape_msgs_MeshTriangle_h
#define _ROS_shape_msgs_MeshTriangle_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace shape_msgs
{
class MeshTriangle : public ros::Msg
{
public:
uint32_t vertex_indices[3];
MeshTriangle():
vertex_indices()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
for( uint32_t i = 0; i < 3; i++){
*(outbuffer + offset + 0) = (this->vertex_indices[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertex_indices[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertex_indices[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertex_indices[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertex_indices[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
for( uint32_t i = 0; i < 3; i++){
this->vertex_indices[i] = ((uint32_t) (*(inbuffer + offset)));
this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vertex_indices[i]);
}
return offset;
}
const char * getType(){ return "shape_msgs/MeshTriangle"; };
const char * getMD5(){ return "23688b2e6d2de3d32fe8af104a903253"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/shape_msgs/SolidPrimitive.h | #ifndef _ROS_shape_msgs_SolidPrimitive_h
#define _ROS_shape_msgs_SolidPrimitive_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace shape_msgs
{
class SolidPrimitive : public ros::Msg
{
public:
typedef uint8_t _type_type;
_type_type type;
uint32_t dimensions_length;
typedef double _dimensions_type;
_dimensions_type st_dimensions;
_dimensions_type * dimensions;
enum { BOX = 1 };
enum { SPHERE = 2 };
enum { CYLINDER = 3 };
enum { CONE = 4 };
enum { BOX_X = 0 };
enum { BOX_Y = 1 };
enum { BOX_Z = 2 };
enum { SPHERE_RADIUS = 0 };
enum { CYLINDER_HEIGHT = 0 };
enum { CYLINDER_RADIUS = 1 };
enum { CONE_HEIGHT = 0 };
enum { CONE_RADIUS = 1 };
SolidPrimitive():
type(0),
dimensions_length(0), dimensions(NULL)
{
}
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->dimensions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->dimensions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->dimensions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->dimensions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->dimensions_length);
for( uint32_t i = 0; i < dimensions_length; i++){
union {
double real;
uint64_t base;
} u_dimensionsi;
u_dimensionsi.real = this->dimensions[i];
*(outbuffer + offset + 0) = (u_dimensionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dimensionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dimensionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dimensionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_dimensionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_dimensionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_dimensionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_dimensionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->dimensions[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->type);
uint32_t dimensions_lengthT = ((uint32_t) (*(inbuffer + offset)));
dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->dimensions_length);
if(dimensions_lengthT > dimensions_length)
this->dimensions = (double*)realloc(this->dimensions, dimensions_lengthT * sizeof(double));
dimensions_length = dimensions_lengthT;
for( uint32_t i = 0; i < dimensions_length; i++){
union {
double real;
uint64_t base;
} u_st_dimensions;
u_st_dimensions.base = 0;
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_dimensions = u_st_dimensions.real;
offset += sizeof(this->st_dimensions);
memcpy( &(this->dimensions[i]), &(this->st_dimensions), sizeof(double));
}
return offset;
}
const char * getType(){ return "shape_msgs/SolidPrimitive"; };
const char * getMD5(){ return "d8f8cbc74c5ff283fca29569ccefb45d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/shape_msgs/Plane.h | #ifndef _ROS_shape_msgs_Plane_h
#define _ROS_shape_msgs_Plane_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace shape_msgs
{
class Plane : public ros::Msg
{
public:
double coef[4];
Plane():
coef()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
for( uint32_t i = 0; i < 4; i++){
union {
double real;
uint64_t base;
} u_coefi;
u_coefi.real = this->coef[i];
*(outbuffer + offset + 0) = (u_coefi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_coefi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_coefi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_coefi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_coefi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_coefi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_coefi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_coefi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->coef[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
for( uint32_t i = 0; i < 4; i++){
union {
double real;
uint64_t base;
} u_coefi;
u_coefi.base = 0;
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->coef[i] = u_coefi.real;
offset += sizeof(this->coef[i]);
}
return offset;
}
const char * getType(){ return "shape_msgs/Plane"; };
const char * getMD5(){ return "2c1b92ed8f31492f8e73f6a4a44ca796"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/shape_msgs/Mesh.h | #ifndef _ROS_shape_msgs_Mesh_h
#define _ROS_shape_msgs_Mesh_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "shape_msgs/MeshTriangle.h"
#include "geometry_msgs/Point.h"
namespace shape_msgs
{
class Mesh : public ros::Msg
{
public:
uint32_t triangles_length;
typedef shape_msgs::MeshTriangle _triangles_type;
_triangles_type st_triangles;
_triangles_type * triangles;
uint32_t vertices_length;
typedef geometry_msgs::Point _vertices_type;
_vertices_type st_vertices;
_vertices_type * vertices;
Mesh():
triangles_length(0), triangles(NULL),
vertices_length(0), vertices(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->triangles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->triangles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->triangles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->triangles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->triangles_length);
for( uint32_t i = 0; i < triangles_length; i++){
offset += this->triangles[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->vertices_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertices_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertices_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertices_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertices_length);
for( uint32_t i = 0; i < vertices_length; i++){
offset += this->vertices[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t triangles_lengthT = ((uint32_t) (*(inbuffer + offset)));
triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->triangles_length);
if(triangles_lengthT > triangles_length)
this->triangles = (shape_msgs::MeshTriangle*)realloc(this->triangles, triangles_lengthT * sizeof(shape_msgs::MeshTriangle));
triangles_length = triangles_lengthT;
for( uint32_t i = 0; i < triangles_length; i++){
offset += this->st_triangles.deserialize(inbuffer + offset);
memcpy( &(this->triangles[i]), &(this->st_triangles), sizeof(shape_msgs::MeshTriangle));
}
uint32_t vertices_lengthT = ((uint32_t) (*(inbuffer + offset)));
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vertices_length);
if(vertices_lengthT > vertices_length)
this->vertices = (geometry_msgs::Point*)realloc(this->vertices, vertices_lengthT * sizeof(geometry_msgs::Point));
vertices_length = vertices_lengthT;
for( uint32_t i = 0; i < vertices_length; i++){
offset += this->st_vertices.deserialize(inbuffer + offset);
memcpy( &(this->vertices[i]), &(this->st_vertices), sizeof(geometry_msgs::Point));
}
return offset;
}
const char * getType(){ return "shape_msgs/Mesh"; };
const char * getMD5(){ return "1ffdae9486cd3316a121c578b47a85cc"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxList.h | #ifndef _ROS_SERVICE_DemuxList_h
#define _ROS_SERVICE_DemuxList_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXLIST[] = "topic_tools/DemuxList";
class DemuxListRequest : public ros::Msg
{
public:
DemuxListRequest()
{
}
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 DEMUXLIST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DemuxListResponse : public ros::Msg
{
public:
uint32_t topics_length;
typedef char* _topics_type;
_topics_type st_topics;
_topics_type * topics;
DemuxListResponse():
topics_length(0), topics(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->topics_length);
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_topicsi = strlen(this->topics[i]);
varToArr(outbuffer + offset, length_topicsi);
offset += 4;
memcpy(outbuffer + offset, this->topics[i], length_topicsi);
offset += length_topicsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->topics_length);
if(topics_lengthT > topics_length)
this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
topics_length = topics_lengthT;
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_st_topics;
arrToVar(length_st_topics, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_topics; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_topics-1]=0;
this->st_topics = (char *)(inbuffer + offset-1);
offset += length_st_topics;
memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
}
return offset;
}
const char * getType(){ return DEMUXLIST; };
const char * getMD5(){ return "b0eef9a05d4e829092fc2f2c3c2aad3d"; };
};
class DemuxList {
public:
typedef DemuxListRequest Request;
typedef DemuxListResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxAdd.h | #ifndef _ROS_SERVICE_DemuxAdd_h
#define _ROS_SERVICE_DemuxAdd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXADD[] = "topic_tools/DemuxAdd";
class DemuxAddRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
DemuxAddRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return DEMUXADD; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class DemuxAddResponse : public ros::Msg
{
public:
DemuxAddResponse()
{
}
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 DEMUXADD; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DemuxAdd {
public:
typedef DemuxAddRequest Request;
typedef DemuxAddResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/MuxAdd.h | #ifndef _ROS_SERVICE_MuxAdd_h
#define _ROS_SERVICE_MuxAdd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXADD[] = "topic_tools/MuxAdd";
class MuxAddRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
MuxAddRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return MUXADD; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class MuxAddResponse : public ros::Msg
{
public:
MuxAddResponse()
{
}
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 MUXADD; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class MuxAdd {
public:
typedef MuxAddRequest Request;
typedef MuxAddResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxSelect.h | #ifndef _ROS_SERVICE_DemuxSelect_h
#define _ROS_SERVICE_DemuxSelect_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXSELECT[] = "topic_tools/DemuxSelect";
class DemuxSelectRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
DemuxSelectRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return DEMUXSELECT; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class DemuxSelectResponse : public ros::Msg
{
public:
typedef const char* _prev_topic_type;
_prev_topic_type prev_topic;
DemuxSelectResponse():
prev_topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_prev_topic = strlen(this->prev_topic);
varToArr(outbuffer + offset, length_prev_topic);
offset += 4;
memcpy(outbuffer + offset, this->prev_topic, length_prev_topic);
offset += length_prev_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_prev_topic;
arrToVar(length_prev_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_prev_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_prev_topic-1]=0;
this->prev_topic = (char *)(inbuffer + offset-1);
offset += length_prev_topic;
return offset;
}
const char * getType(){ return DEMUXSELECT; };
const char * getMD5(){ return "3db0a473debdbafea387c9e49358c320"; };
};
class DemuxSelect {
public:
typedef DemuxSelectRequest Request;
typedef DemuxSelectResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/MuxList.h | #ifndef _ROS_SERVICE_MuxList_h
#define _ROS_SERVICE_MuxList_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXLIST[] = "topic_tools/MuxList";
class MuxListRequest : public ros::Msg
{
public:
MuxListRequest()
{
}
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 MUXLIST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class MuxListResponse : public ros::Msg
{
public:
uint32_t topics_length;
typedef char* _topics_type;
_topics_type st_topics;
_topics_type * topics;
MuxListResponse():
topics_length(0), topics(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->topics_length);
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_topicsi = strlen(this->topics[i]);
varToArr(outbuffer + offset, length_topicsi);
offset += 4;
memcpy(outbuffer + offset, this->topics[i], length_topicsi);
offset += length_topicsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->topics_length);
if(topics_lengthT > topics_length)
this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
topics_length = topics_lengthT;
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_st_topics;
arrToVar(length_st_topics, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_topics; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_topics-1]=0;
this->st_topics = (char *)(inbuffer + offset-1);
offset += length_st_topics;
memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
}
return offset;
}
const char * getType(){ return MUXLIST; };
const char * getMD5(){ return "b0eef9a05d4e829092fc2f2c3c2aad3d"; };
};
class MuxList {
public:
typedef MuxListRequest Request;
typedef MuxListResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/MuxSelect.h | #ifndef _ROS_SERVICE_MuxSelect_h
#define _ROS_SERVICE_MuxSelect_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXSELECT[] = "topic_tools/MuxSelect";
class MuxSelectRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
MuxSelectRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return MUXSELECT; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class MuxSelectResponse : public ros::Msg
{
public:
typedef const char* _prev_topic_type;
_prev_topic_type prev_topic;
MuxSelectResponse():
prev_topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_prev_topic = strlen(this->prev_topic);
varToArr(outbuffer + offset, length_prev_topic);
offset += 4;
memcpy(outbuffer + offset, this->prev_topic, length_prev_topic);
offset += length_prev_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_prev_topic;
arrToVar(length_prev_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_prev_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_prev_topic-1]=0;
this->prev_topic = (char *)(inbuffer + offset-1);
offset += length_prev_topic;
return offset;
}
const char * getType(){ return MUXSELECT; };
const char * getMD5(){ return "3db0a473debdbafea387c9e49358c320"; };
};
class MuxSelect {
public:
typedef MuxSelectRequest Request;
typedef MuxSelectResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/MuxDelete.h | #ifndef _ROS_SERVICE_MuxDelete_h
#define _ROS_SERVICE_MuxDelete_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char MUXDELETE[] = "topic_tools/MuxDelete";
class MuxDeleteRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
MuxDeleteRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return MUXDELETE; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class MuxDeleteResponse : public ros::Msg
{
public:
MuxDeleteResponse()
{
}
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 MUXDELETE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class MuxDelete {
public:
typedef MuxDeleteRequest Request;
typedef MuxDeleteResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/topic_tools/DemuxDelete.h | #ifndef _ROS_SERVICE_DemuxDelete_h
#define _ROS_SERVICE_DemuxDelete_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace topic_tools
{
static const char DEMUXDELETE[] = "topic_tools/DemuxDelete";
class DemuxDeleteRequest : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
DemuxDeleteRequest():
topic("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
return offset;
}
const char * getType(){ return DEMUXDELETE; };
const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
};
class DemuxDeleteResponse : public ros::Msg
{
public:
DemuxDeleteResponse()
{
}
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 DEMUXDELETE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DemuxDelete {
public:
typedef DemuxDeleteRequest Request;
typedef DemuxDeleteResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/IMUdata.h | #ifndef _ROS_mini_ros_IMUdata_h
#define _ROS_mini_ros_IMUdata_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class IMUdata : public ros::Msg
{
public:
typedef float _roll_type;
_roll_type roll;
typedef float _pitch_type;
_pitch_type pitch;
typedef float _acc_x_type;
_acc_x_type acc_x;
typedef float _acc_y_type;
_acc_y_type acc_y;
typedef float _acc_z_type;
_acc_z_type acc_z;
typedef float _gyro_x_type;
_gyro_x_type gyro_x;
typedef float _gyro_y_type;
_gyro_y_type gyro_y;
typedef float _gyro_z_type;
_gyro_z_type gyro_z;
IMUdata():
roll(0),
pitch(0),
acc_x(0),
acc_y(0),
acc_z(0),
gyro_x(0),
gyro_y(0),
gyro_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_roll;
u_roll.real = this->roll;
*(outbuffer + offset + 0) = (u_roll.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_roll.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_roll.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_roll.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.real = this->pitch;
*(outbuffer + offset + 0) = (u_pitch.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pitch.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pitch.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pitch.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_acc_x;
u_acc_x.real = this->acc_x;
*(outbuffer + offset + 0) = (u_acc_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acc_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acc_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acc_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->acc_x);
union {
float real;
uint32_t base;
} u_acc_y;
u_acc_y.real = this->acc_y;
*(outbuffer + offset + 0) = (u_acc_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acc_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acc_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acc_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->acc_y);
union {
float real;
uint32_t base;
} u_acc_z;
u_acc_z.real = this->acc_z;
*(outbuffer + offset + 0) = (u_acc_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acc_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acc_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acc_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->acc_z);
union {
float real;
uint32_t base;
} u_gyro_x;
u_gyro_x.real = this->gyro_x;
*(outbuffer + offset + 0) = (u_gyro_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gyro_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gyro_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gyro_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->gyro_x);
union {
float real;
uint32_t base;
} u_gyro_y;
u_gyro_y.real = this->gyro_y;
*(outbuffer + offset + 0) = (u_gyro_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gyro_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gyro_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gyro_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->gyro_y);
union {
float real;
uint32_t base;
} u_gyro_z;
u_gyro_z.real = this->gyro_z;
*(outbuffer + offset + 0) = (u_gyro_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gyro_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gyro_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gyro_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->gyro_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_roll;
u_roll.base = 0;
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->roll = u_roll.real;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.base = 0;
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->pitch = u_pitch.real;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_acc_x;
u_acc_x.base = 0;
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acc_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->acc_x = u_acc_x.real;
offset += sizeof(this->acc_x);
union {
float real;
uint32_t base;
} u_acc_y;
u_acc_y.base = 0;
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acc_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->acc_y = u_acc_y.real;
offset += sizeof(this->acc_y);
union {
float real;
uint32_t base;
} u_acc_z;
u_acc_z.base = 0;
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acc_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->acc_z = u_acc_z.real;
offset += sizeof(this->acc_z);
union {
float real;
uint32_t base;
} u_gyro_x;
u_gyro_x.base = 0;
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_gyro_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->gyro_x = u_gyro_x.real;
offset += sizeof(this->gyro_x);
union {
float real;
uint32_t base;
} u_gyro_y;
u_gyro_y.base = 0;
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_gyro_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->gyro_y = u_gyro_y.real;
offset += sizeof(this->gyro_y);
union {
float real;
uint32_t base;
} u_gyro_z;
u_gyro_z.base = 0;
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_gyro_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->gyro_z = u_gyro_z.real;
offset += sizeof(this->gyro_z);
return offset;
}
const char * getType(){ return "mini_ros/IMUdata"; };
const char * getMD5(){ return "3a27cb61fd87ce5110e1d6a4a68a0126"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/CalibServo.h | #ifndef _ROS_SERVICE_CalibServo_h
#define _ROS_SERVICE_CalibServo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
static const char CALIBSERVO[] = "mini_ros/CalibServo";
class CalibServoRequest : public ros::Msg
{
public:
typedef int8_t _servo_num_type;
_servo_num_type servo_num;
typedef int32_t _servo_pulse_type;
_servo_pulse_type servo_pulse;
CalibServoRequest():
servo_num(0),
servo_pulse(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.real = this->servo_num;
*(outbuffer + offset + 0) = (u_servo_num.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.real = this->servo_pulse;
*(outbuffer + offset + 0) = (u_servo_pulse.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_servo_pulse.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_servo_pulse.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_servo_pulse.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->servo_pulse);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.base = 0;
u_servo_num.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->servo_num = u_servo_num.real;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.base = 0;
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->servo_pulse = u_servo_pulse.real;
offset += sizeof(this->servo_pulse);
return offset;
}
const char * getType(){ return CALIBSERVO; };
const char * getMD5(){ return "372c64510294fc8eec78b728b048d2c9"; };
};
class CalibServoResponse : public ros::Msg
{
public:
typedef const char* _Response_type;
_Response_type Response;
CalibServoResponse():
Response("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_Response = strlen(this->Response);
varToArr(outbuffer + offset, length_Response);
offset += 4;
memcpy(outbuffer + offset, this->Response, length_Response);
offset += length_Response;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_Response;
arrToVar(length_Response, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_Response; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_Response-1]=0;
this->Response = (char *)(inbuffer + offset-1);
offset += length_Response;
return offset;
}
const char * getType(){ return CALIBSERVO; };
const char * getMD5(){ return "e9ca8778f2b24ad03f8213b9fe82be44"; };
};
class CalibServo {
public:
typedef CalibServoRequest Request;
typedef CalibServoResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JointPulse.h | #ifndef _ROS_mini_ros_JointPulse_h
#define _ROS_mini_ros_JointPulse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JointPulse : public ros::Msg
{
public:
typedef int8_t _servo_num_type;
_servo_num_type servo_num;
typedef int32_t _servo_pulse_type;
_servo_pulse_type servo_pulse;
JointPulse():
servo_num(0),
servo_pulse(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.real = this->servo_num;
*(outbuffer + offset + 0) = (u_servo_num.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.real = this->servo_pulse;
*(outbuffer + offset + 0) = (u_servo_pulse.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_servo_pulse.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_servo_pulse.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_servo_pulse.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->servo_pulse);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_servo_num;
u_servo_num.base = 0;
u_servo_num.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->servo_num = u_servo_num.real;
offset += sizeof(this->servo_num);
union {
int32_t real;
uint32_t base;
} u_servo_pulse;
u_servo_pulse.base = 0;
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_servo_pulse.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->servo_pulse = u_servo_pulse.real;
offset += sizeof(this->servo_pulse);
return offset;
}
const char * getType(){ return "mini_ros/JointPulse"; };
const char * getMD5(){ return "372c64510294fc8eec78b728b048d2c9"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/BezierData.h | #ifndef _ROS_mini_ros_BezierData_h
#define _ROS_mini_ros_BezierData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class BezierData : public ros::Msg
{
public:
typedef const char* _Leg_type;
_Leg_type Leg;
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _z_type;
_z_type z;
BezierData():
Leg(""),
x(0),
y(0),
z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_Leg = strlen(this->Leg);
varToArr(outbuffer + offset, length_Leg);
offset += 4;
memcpy(outbuffer + offset, this->Leg, length_Leg);
offset += length_Leg;
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;
uint32_t length_Leg;
arrToVar(length_Leg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_Leg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_Leg-1]=0;
this->Leg = (char *)(inbuffer + offset-1);
offset += length_Leg;
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 "mini_ros/BezierData"; };
const char * getMD5(){ return "edd64deddffdf794edd8b839043b5d4e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/ContactData.h | #ifndef _ROS_mini_ros_ContactData_h
#define _ROS_mini_ros_ContactData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class ContactData : public ros::Msg
{
public:
typedef bool _FL_type;
_FL_type FL;
typedef bool _FR_type;
_FR_type FR;
typedef bool _BL_type;
_BL_type BL;
typedef bool _BR_type;
_BR_type BR;
ContactData():
FL(0),
FR(0),
BL(0),
BR(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_FL;
u_FL.real = this->FL;
*(outbuffer + offset + 0) = (u_FL.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->FL);
union {
bool real;
uint8_t base;
} u_FR;
u_FR.real = this->FR;
*(outbuffer + offset + 0) = (u_FR.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->FR);
union {
bool real;
uint8_t base;
} u_BL;
u_BL.real = this->BL;
*(outbuffer + offset + 0) = (u_BL.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->BL);
union {
bool real;
uint8_t base;
} u_BR;
u_BR.real = this->BR;
*(outbuffer + offset + 0) = (u_BR.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->BR);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_FL;
u_FL.base = 0;
u_FL.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->FL = u_FL.real;
offset += sizeof(this->FL);
union {
bool real;
uint8_t base;
} u_FR;
u_FR.base = 0;
u_FR.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->FR = u_FR.real;
offset += sizeof(this->FR);
union {
bool real;
uint8_t base;
} u_BL;
u_BL.base = 0;
u_BL.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->BL = u_BL.real;
offset += sizeof(this->BL);
union {
bool real;
uint8_t base;
} u_BR;
u_BR.base = 0;
u_BR.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->BR = u_BR.real;
offset += sizeof(this->BR);
return offset;
}
const char * getType(){ return "mini_ros/ContactData"; };
const char * getMD5(){ return "e1e8fe4de4334f7698a7f305ee06dce8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JoyButtons.h | #ifndef _ROS_mini_ros_JoyButtons_h
#define _ROS_mini_ros_JoyButtons_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JoyButtons : public ros::Msg
{
public:
typedef int8_t _updown_type;
_updown_type updown;
typedef int8_t _leftright_type;
_leftright_type leftright;
typedef int8_t _left_bump_type;
_left_bump_type left_bump;
typedef int8_t _right_bump_type;
_right_bump_type right_bump;
JoyButtons():
updown(0),
leftright(0),
left_bump(0),
right_bump(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_updown;
u_updown.real = this->updown;
*(outbuffer + offset + 0) = (u_updown.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->updown);
union {
int8_t real;
uint8_t base;
} u_leftright;
u_leftright.real = this->leftright;
*(outbuffer + offset + 0) = (u_leftright.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->leftright);
union {
int8_t real;
uint8_t base;
} u_left_bump;
u_left_bump.real = this->left_bump;
*(outbuffer + offset + 0) = (u_left_bump.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->left_bump);
union {
int8_t real;
uint8_t base;
} u_right_bump;
u_right_bump.real = this->right_bump;
*(outbuffer + offset + 0) = (u_right_bump.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->right_bump);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_updown;
u_updown.base = 0;
u_updown.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->updown = u_updown.real;
offset += sizeof(this->updown);
union {
int8_t real;
uint8_t base;
} u_leftright;
u_leftright.base = 0;
u_leftright.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->leftright = u_leftright.real;
offset += sizeof(this->leftright);
union {
int8_t real;
uint8_t base;
} u_left_bump;
u_left_bump.base = 0;
u_left_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->left_bump = u_left_bump.real;
offset += sizeof(this->left_bump);
union {
int8_t real;
uint8_t base;
} u_right_bump;
u_right_bump.base = 0;
u_right_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->right_bump = u_right_bump.real;
offset += sizeof(this->right_bump);
return offset;
}
const char * getType(){ return "mini_ros/JoyButtons"; };
const char * getMD5(){ return "be1de48c3b52ec87587be0e78c2cb8cd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/MiniCmd.h | #ifndef _ROS_mini_ros_MiniCmd_h
#define _ROS_mini_ros_MiniCmd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class MiniCmd : public ros::Msg
{
public:
typedef const char* _motion_type;
_motion_type motion;
typedef const char* _movement_type;
_movement_type movement;
typedef float _x_velocity_type;
_x_velocity_type x_velocity;
typedef float _y_velocity_type;
_y_velocity_type y_velocity;
typedef float _rate_type;
_rate_type rate;
typedef float _roll_type;
_roll_type roll;
typedef float _pitch_type;
_pitch_type pitch;
typedef float _yaw_type;
_yaw_type yaw;
typedef float _z_type;
_z_type z;
typedef float _faster_type;
_faster_type faster;
typedef float _slower_type;
_slower_type slower;
MiniCmd():
motion(""),
movement(""),
x_velocity(0),
y_velocity(0),
rate(0),
roll(0),
pitch(0),
yaw(0),
z(0),
faster(0),
slower(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_motion = strlen(this->motion);
varToArr(outbuffer + offset, length_motion);
offset += 4;
memcpy(outbuffer + offset, this->motion, length_motion);
offset += length_motion;
uint32_t length_movement = strlen(this->movement);
varToArr(outbuffer + offset, length_movement);
offset += 4;
memcpy(outbuffer + offset, this->movement, length_movement);
offset += length_movement;
union {
float real;
uint32_t base;
} u_x_velocity;
u_x_velocity.real = this->x_velocity;
*(outbuffer + offset + 0) = (u_x_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x_velocity);
union {
float real;
uint32_t base;
} u_y_velocity;
u_y_velocity.real = this->y_velocity;
*(outbuffer + offset + 0) = (u_y_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y_velocity);
union {
float real;
uint32_t base;
} u_rate;
u_rate.real = this->rate;
*(outbuffer + offset + 0) = (u_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_rate.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->rate);
union {
float real;
uint32_t base;
} u_roll;
u_roll.real = this->roll;
*(outbuffer + offset + 0) = (u_roll.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_roll.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_roll.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_roll.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.real = this->pitch;
*(outbuffer + offset + 0) = (u_pitch.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pitch.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pitch.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pitch.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_yaw;
u_yaw.real = this->yaw;
*(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->yaw);
union {
float real;
uint32_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->z);
union {
float real;
uint32_t base;
} u_faster;
u_faster.real = this->faster;
*(outbuffer + offset + 0) = (u_faster.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_faster.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_faster.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_faster.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->faster);
union {
float real;
uint32_t base;
} u_slower;
u_slower.real = this->slower;
*(outbuffer + offset + 0) = (u_slower.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_slower.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_slower.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_slower.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->slower);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_motion;
arrToVar(length_motion, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_motion; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_motion-1]=0;
this->motion = (char *)(inbuffer + offset-1);
offset += length_motion;
uint32_t length_movement;
arrToVar(length_movement, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_movement; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_movement-1]=0;
this->movement = (char *)(inbuffer + offset-1);
offset += length_movement;
union {
float real;
uint32_t base;
} u_x_velocity;
u_x_velocity.base = 0;
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x_velocity = u_x_velocity.real;
offset += sizeof(this->x_velocity);
union {
float real;
uint32_t base;
} u_y_velocity;
u_y_velocity.base = 0;
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y_velocity = u_y_velocity.real;
offset += sizeof(this->y_velocity);
union {
float real;
uint32_t base;
} u_rate;
u_rate.base = 0;
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->rate = u_rate.real;
offset += sizeof(this->rate);
union {
float real;
uint32_t base;
} u_roll;
u_roll.base = 0;
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->roll = u_roll.real;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.base = 0;
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->pitch = u_pitch.real;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_yaw;
u_yaw.base = 0;
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->yaw = u_yaw.real;
offset += sizeof(this->yaw);
union {
float real;
uint32_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->z = u_z.real;
offset += sizeof(this->z);
union {
float real;
uint32_t base;
} u_faster;
u_faster.base = 0;
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->faster = u_faster.real;
offset += sizeof(this->faster);
union {
float real;
uint32_t base;
} u_slower;
u_slower.base = 0;
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->slower = u_slower.real;
offset += sizeof(this->slower);
return offset;
}
const char * getType(){ return "mini_ros/MiniCmd"; };
const char * getMD5(){ return "83510b9a5f454bd3ceb898b52e349406"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JointAngles.h | #ifndef _ROS_mini_ros_JointAngles_h
#define _ROS_mini_ros_JointAngles_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JointAngles : public ros::Msg
{
public:
typedef float _fls_type;
_fls_type fls;
typedef float _fle_type;
_fle_type fle;
typedef float _flw_type;
_flw_type flw;
typedef float _frs_type;
_frs_type frs;
typedef float _fre_type;
_fre_type fre;
typedef float _frw_type;
_frw_type frw;
typedef float _bls_type;
_bls_type bls;
typedef float _ble_type;
_ble_type ble;
typedef float _blw_type;
_blw_type blw;
typedef float _brs_type;
_brs_type brs;
typedef float _bre_type;
_bre_type bre;
typedef float _brw_type;
_brw_type brw;
typedef bool _step_or_view_type;
_step_or_view_type step_or_view;
JointAngles():
fls(0),
fle(0),
flw(0),
frs(0),
fre(0),
frw(0),
bls(0),
ble(0),
blw(0),
brs(0),
bre(0),
brw(0),
step_or_view(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_fls;
u_fls.real = this->fls;
*(outbuffer + offset + 0) = (u_fls.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fls.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fls.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fls.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fls);
union {
float real;
uint32_t base;
} u_fle;
u_fle.real = this->fle;
*(outbuffer + offset + 0) = (u_fle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fle.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fle);
union {
float real;
uint32_t base;
} u_flw;
u_flw.real = this->flw;
*(outbuffer + offset + 0) = (u_flw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_flw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_flw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_flw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->flw);
union {
float real;
uint32_t base;
} u_frs;
u_frs.real = this->frs;
*(outbuffer + offset + 0) = (u_frs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_frs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_frs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_frs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->frs);
union {
float real;
uint32_t base;
} u_fre;
u_fre.real = this->fre;
*(outbuffer + offset + 0) = (u_fre.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fre.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fre.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fre.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fre);
union {
float real;
uint32_t base;
} u_frw;
u_frw.real = this->frw;
*(outbuffer + offset + 0) = (u_frw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_frw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_frw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_frw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->frw);
union {
float real;
uint32_t base;
} u_bls;
u_bls.real = this->bls;
*(outbuffer + offset + 0) = (u_bls.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_bls.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_bls.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_bls.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->bls);
union {
float real;
uint32_t base;
} u_ble;
u_ble.real = this->ble;
*(outbuffer + offset + 0) = (u_ble.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ble.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ble.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ble.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ble);
union {
float real;
uint32_t base;
} u_blw;
u_blw.real = this->blw;
*(outbuffer + offset + 0) = (u_blw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_blw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_blw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_blw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->blw);
union {
float real;
uint32_t base;
} u_brs;
u_brs.real = this->brs;
*(outbuffer + offset + 0) = (u_brs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_brs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_brs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_brs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->brs);
union {
float real;
uint32_t base;
} u_bre;
u_bre.real = this->bre;
*(outbuffer + offset + 0) = (u_bre.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_bre.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_bre.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_bre.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->bre);
union {
float real;
uint32_t base;
} u_brw;
u_brw.real = this->brw;
*(outbuffer + offset + 0) = (u_brw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_brw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_brw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_brw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->brw);
union {
bool real;
uint8_t base;
} u_step_or_view;
u_step_or_view.real = this->step_or_view;
*(outbuffer + offset + 0) = (u_step_or_view.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->step_or_view);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_fls;
u_fls.base = 0;
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fls = u_fls.real;
offset += sizeof(this->fls);
union {
float real;
uint32_t base;
} u_fle;
u_fle.base = 0;
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fle = u_fle.real;
offset += sizeof(this->fle);
union {
float real;
uint32_t base;
} u_flw;
u_flw.base = 0;
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->flw = u_flw.real;
offset += sizeof(this->flw);
union {
float real;
uint32_t base;
} u_frs;
u_frs.base = 0;
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->frs = u_frs.real;
offset += sizeof(this->frs);
union {
float real;
uint32_t base;
} u_fre;
u_fre.base = 0;
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fre = u_fre.real;
offset += sizeof(this->fre);
union {
float real;
uint32_t base;
} u_frw;
u_frw.base = 0;
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->frw = u_frw.real;
offset += sizeof(this->frw);
union {
float real;
uint32_t base;
} u_bls;
u_bls.base = 0;
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->bls = u_bls.real;
offset += sizeof(this->bls);
union {
float real;
uint32_t base;
} u_ble;
u_ble.base = 0;
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->ble = u_ble.real;
offset += sizeof(this->ble);
union {
float real;
uint32_t base;
} u_blw;
u_blw.base = 0;
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->blw = u_blw.real;
offset += sizeof(this->blw);
union {
float real;
uint32_t base;
} u_brs;
u_brs.base = 0;
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->brs = u_brs.real;
offset += sizeof(this->brs);
union {
float real;
uint32_t base;
} u_bre;
u_bre.base = 0;
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->bre = u_bre.real;
offset += sizeof(this->bre);
union {
float real;
uint32_t base;
} u_brw;
u_brw.base = 0;
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->brw = u_brw.real;
offset += sizeof(this->brw);
union {
bool real;
uint8_t base;
} u_step_or_view;
u_step_or_view.base = 0;
u_step_or_view.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->step_or_view = u_step_or_view.real;
offset += sizeof(this->step_or_view);
return offset;
}
const char * getType(){ return "mini_ros/JointAngles"; };
const char * getMD5(){ return "54bfcd55046a61d9df3827d322506389"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/stereo_msgs/DisparityImage.h | #ifndef _ROS_stereo_msgs_DisparityImage_h
#define _ROS_stereo_msgs_DisparityImage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/Image.h"
#include "sensor_msgs/RegionOfInterest.h"
namespace stereo_msgs
{
class DisparityImage : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef sensor_msgs::Image _image_type;
_image_type image;
typedef float _f_type;
_f_type f;
typedef float _T_type;
_T_type T;
typedef sensor_msgs::RegionOfInterest _valid_window_type;
_valid_window_type valid_window;
typedef float _min_disparity_type;
_min_disparity_type min_disparity;
typedef float _max_disparity_type;
_max_disparity_type max_disparity;
typedef float _delta_d_type;
_delta_d_type delta_d;
DisparityImage():
header(),
image(),
f(0),
T(0),
valid_window(),
min_disparity(0),
max_disparity(0),
delta_d(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->image.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_f;
u_f.real = this->f;
*(outbuffer + offset + 0) = (u_f.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_f.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_f.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_f.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->f);
union {
float real;
uint32_t base;
} u_T;
u_T.real = this->T;
*(outbuffer + offset + 0) = (u_T.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_T.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_T.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_T.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->T);
offset += this->valid_window.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_min_disparity;
u_min_disparity.real = this->min_disparity;
*(outbuffer + offset + 0) = (u_min_disparity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_disparity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_disparity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_disparity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_disparity);
union {
float real;
uint32_t base;
} u_max_disparity;
u_max_disparity.real = this->max_disparity;
*(outbuffer + offset + 0) = (u_max_disparity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_disparity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_disparity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_disparity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_disparity);
union {
float real;
uint32_t base;
} u_delta_d;
u_delta_d.real = this->delta_d;
*(outbuffer + offset + 0) = (u_delta_d.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_delta_d.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_delta_d.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_delta_d.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->delta_d);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->image.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_f;
u_f.base = 0;
u_f.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->f = u_f.real;
offset += sizeof(this->f);
union {
float real;
uint32_t base;
} u_T;
u_T.base = 0;
u_T.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->T = u_T.real;
offset += sizeof(this->T);
offset += this->valid_window.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_min_disparity;
u_min_disparity.base = 0;
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->min_disparity = u_min_disparity.real;
offset += sizeof(this->min_disparity);
union {
float real;
uint32_t base;
} u_max_disparity;
u_max_disparity.base = 0;
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->max_disparity = u_max_disparity.real;
offset += sizeof(this->max_disparity);
union {
float real;
uint32_t base;
} u_delta_d;
u_delta_d.base = 0;
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->delta_d = u_delta_d.real;
offset += sizeof(this->delta_d);
return offset;
}
const char * getType(){ return "stereo_msgs/DisparityImage"; };
const char * getMD5(){ return "04a177815f75271039fa21f16acad8c9"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/SEAJointState.h | #ifndef _ROS_baxter_core_msgs_SEAJointState_h
#define _ROS_baxter_core_msgs_SEAJointState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace baxter_core_msgs
{
class SEAJointState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t commanded_position_length;
typedef double _commanded_position_type;
_commanded_position_type st_commanded_position;
_commanded_position_type * commanded_position;
uint32_t commanded_velocity_length;
typedef double _commanded_velocity_type;
_commanded_velocity_type st_commanded_velocity;
_commanded_velocity_type * commanded_velocity;
uint32_t commanded_acceleration_length;
typedef double _commanded_acceleration_type;
_commanded_acceleration_type st_commanded_acceleration;
_commanded_acceleration_type * commanded_acceleration;
uint32_t commanded_effort_length;
typedef double _commanded_effort_type;
_commanded_effort_type st_commanded_effort;
_commanded_effort_type * commanded_effort;
uint32_t actual_position_length;
typedef double _actual_position_type;
_actual_position_type st_actual_position;
_actual_position_type * actual_position;
uint32_t actual_velocity_length;
typedef double _actual_velocity_type;
_actual_velocity_type st_actual_velocity;
_actual_velocity_type * actual_velocity;
uint32_t actual_effort_length;
typedef double _actual_effort_type;
_actual_effort_type st_actual_effort;
_actual_effort_type * actual_effort;
uint32_t gravity_model_effort_length;
typedef double _gravity_model_effort_type;
_gravity_model_effort_type st_gravity_model_effort;
_gravity_model_effort_type * gravity_model_effort;
uint32_t gravity_only_length;
typedef double _gravity_only_type;
_gravity_only_type st_gravity_only;
_gravity_only_type * gravity_only;
uint32_t hysteresis_model_effort_length;
typedef double _hysteresis_model_effort_type;
_hysteresis_model_effort_type st_hysteresis_model_effort;
_hysteresis_model_effort_type * hysteresis_model_effort;
uint32_t crosstalk_model_effort_length;
typedef double _crosstalk_model_effort_type;
_crosstalk_model_effort_type st_crosstalk_model_effort;
_crosstalk_model_effort_type * crosstalk_model_effort;
typedef double _hystState_type;
_hystState_type hystState;
SEAJointState():
header(),
name_length(0), name(NULL),
commanded_position_length(0), commanded_position(NULL),
commanded_velocity_length(0), commanded_velocity(NULL),
commanded_acceleration_length(0), commanded_acceleration(NULL),
commanded_effort_length(0), commanded_effort(NULL),
actual_position_length(0), actual_position(NULL),
actual_velocity_length(0), actual_velocity(NULL),
actual_effort_length(0), actual_effort(NULL),
gravity_model_effort_length(0), gravity_model_effort(NULL),
gravity_only_length(0), gravity_only(NULL),
hysteresis_model_effort_length(0), hysteresis_model_effort(NULL),
crosstalk_model_effort_length(0), crosstalk_model_effort(NULL),
hystState(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->commanded_position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_position_length);
for( uint32_t i = 0; i < commanded_position_length; i++){
union {
double real;
uint64_t base;
} u_commanded_positioni;
u_commanded_positioni.real = this->commanded_position[i];
*(outbuffer + offset + 0) = (u_commanded_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_position[i]);
}
*(outbuffer + offset + 0) = (this->commanded_velocity_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_velocity_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_velocity_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_velocity_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_velocity_length);
for( uint32_t i = 0; i < commanded_velocity_length; i++){
union {
double real;
uint64_t base;
} u_commanded_velocityi;
u_commanded_velocityi.real = this->commanded_velocity[i];
*(outbuffer + offset + 0) = (u_commanded_velocityi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_velocityi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_velocityi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_velocityi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_velocityi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_velocityi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_velocityi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_velocityi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_velocity[i]);
}
*(outbuffer + offset + 0) = (this->commanded_acceleration_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_acceleration_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_acceleration_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_acceleration_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_acceleration_length);
for( uint32_t i = 0; i < commanded_acceleration_length; i++){
union {
double real;
uint64_t base;
} u_commanded_accelerationi;
u_commanded_accelerationi.real = this->commanded_acceleration[i];
*(outbuffer + offset + 0) = (u_commanded_accelerationi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_accelerationi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_accelerationi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_accelerationi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_accelerationi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_accelerationi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_accelerationi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_accelerationi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_acceleration[i]);
}
*(outbuffer + offset + 0) = (this->commanded_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->commanded_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->commanded_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->commanded_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->commanded_effort_length);
for( uint32_t i = 0; i < commanded_effort_length; i++){
union {
double real;
uint64_t base;
} u_commanded_efforti;
u_commanded_efforti.real = this->commanded_effort[i];
*(outbuffer + offset + 0) = (u_commanded_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commanded_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commanded_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commanded_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commanded_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commanded_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commanded_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commanded_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->commanded_effort[i]);
}
*(outbuffer + offset + 0) = (this->actual_position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->actual_position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->actual_position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->actual_position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->actual_position_length);
for( uint32_t i = 0; i < actual_position_length; i++){
union {
double real;
uint64_t base;
} u_actual_positioni;
u_actual_positioni.real = this->actual_position[i];
*(outbuffer + offset + 0) = (u_actual_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_actual_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_actual_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_actual_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_actual_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_actual_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_actual_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_actual_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->actual_position[i]);
}
*(outbuffer + offset + 0) = (this->actual_velocity_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->actual_velocity_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->actual_velocity_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->actual_velocity_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->actual_velocity_length);
for( uint32_t i = 0; i < actual_velocity_length; i++){
union {
double real;
uint64_t base;
} u_actual_velocityi;
u_actual_velocityi.real = this->actual_velocity[i];
*(outbuffer + offset + 0) = (u_actual_velocityi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_actual_velocityi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_actual_velocityi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_actual_velocityi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_actual_velocityi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_actual_velocityi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_actual_velocityi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_actual_velocityi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->actual_velocity[i]);
}
*(outbuffer + offset + 0) = (this->actual_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->actual_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->actual_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->actual_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->actual_effort_length);
for( uint32_t i = 0; i < actual_effort_length; i++){
union {
double real;
uint64_t base;
} u_actual_efforti;
u_actual_efforti.real = this->actual_effort[i];
*(outbuffer + offset + 0) = (u_actual_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_actual_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_actual_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_actual_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_actual_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_actual_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_actual_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_actual_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->actual_effort[i]);
}
*(outbuffer + offset + 0) = (this->gravity_model_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->gravity_model_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->gravity_model_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->gravity_model_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->gravity_model_effort_length);
for( uint32_t i = 0; i < gravity_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_gravity_model_efforti;
u_gravity_model_efforti.real = this->gravity_model_effort[i];
*(outbuffer + offset + 0) = (u_gravity_model_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gravity_model_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gravity_model_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gravity_model_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_gravity_model_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_gravity_model_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_gravity_model_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_gravity_model_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->gravity_model_effort[i]);
}
*(outbuffer + offset + 0) = (this->gravity_only_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->gravity_only_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->gravity_only_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->gravity_only_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->gravity_only_length);
for( uint32_t i = 0; i < gravity_only_length; i++){
union {
double real;
uint64_t base;
} u_gravity_onlyi;
u_gravity_onlyi.real = this->gravity_only[i];
*(outbuffer + offset + 0) = (u_gravity_onlyi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_gravity_onlyi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_gravity_onlyi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_gravity_onlyi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_gravity_onlyi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_gravity_onlyi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_gravity_onlyi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_gravity_onlyi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->gravity_only[i]);
}
*(outbuffer + offset + 0) = (this->hysteresis_model_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->hysteresis_model_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->hysteresis_model_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->hysteresis_model_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->hysteresis_model_effort_length);
for( uint32_t i = 0; i < hysteresis_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_hysteresis_model_efforti;
u_hysteresis_model_efforti.real = this->hysteresis_model_effort[i];
*(outbuffer + offset + 0) = (u_hysteresis_model_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_hysteresis_model_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_hysteresis_model_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_hysteresis_model_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_hysteresis_model_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_hysteresis_model_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_hysteresis_model_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_hysteresis_model_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->hysteresis_model_effort[i]);
}
*(outbuffer + offset + 0) = (this->crosstalk_model_effort_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->crosstalk_model_effort_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->crosstalk_model_effort_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->crosstalk_model_effort_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->crosstalk_model_effort_length);
for( uint32_t i = 0; i < crosstalk_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_crosstalk_model_efforti;
u_crosstalk_model_efforti.real = this->crosstalk_model_effort[i];
*(outbuffer + offset + 0) = (u_crosstalk_model_efforti.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_crosstalk_model_efforti.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_crosstalk_model_efforti.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_crosstalk_model_efforti.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_crosstalk_model_efforti.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_crosstalk_model_efforti.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_crosstalk_model_efforti.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_crosstalk_model_efforti.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->crosstalk_model_effort[i]);
}
union {
double real;
uint64_t base;
} u_hystState;
u_hystState.real = this->hystState;
*(outbuffer + offset + 0) = (u_hystState.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_hystState.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_hystState.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_hystState.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_hystState.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_hystState.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_hystState.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_hystState.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->hystState);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t commanded_position_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_position_length);
if(commanded_position_lengthT > commanded_position_length)
this->commanded_position = (double*)realloc(this->commanded_position, commanded_position_lengthT * sizeof(double));
commanded_position_length = commanded_position_lengthT;
for( uint32_t i = 0; i < commanded_position_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_position;
u_st_commanded_position.base = 0;
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_position = u_st_commanded_position.real;
offset += sizeof(this->st_commanded_position);
memcpy( &(this->commanded_position[i]), &(this->st_commanded_position), sizeof(double));
}
uint32_t commanded_velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_velocity_length);
if(commanded_velocity_lengthT > commanded_velocity_length)
this->commanded_velocity = (double*)realloc(this->commanded_velocity, commanded_velocity_lengthT * sizeof(double));
commanded_velocity_length = commanded_velocity_lengthT;
for( uint32_t i = 0; i < commanded_velocity_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_velocity;
u_st_commanded_velocity.base = 0;
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_velocity = u_st_commanded_velocity.real;
offset += sizeof(this->st_commanded_velocity);
memcpy( &(this->commanded_velocity[i]), &(this->st_commanded_velocity), sizeof(double));
}
uint32_t commanded_acceleration_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_acceleration_length);
if(commanded_acceleration_lengthT > commanded_acceleration_length)
this->commanded_acceleration = (double*)realloc(this->commanded_acceleration, commanded_acceleration_lengthT * sizeof(double));
commanded_acceleration_length = commanded_acceleration_lengthT;
for( uint32_t i = 0; i < commanded_acceleration_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_acceleration;
u_st_commanded_acceleration.base = 0;
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_acceleration = u_st_commanded_acceleration.real;
offset += sizeof(this->st_commanded_acceleration);
memcpy( &(this->commanded_acceleration[i]), &(this->st_commanded_acceleration), sizeof(double));
}
uint32_t commanded_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
commanded_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->commanded_effort_length);
if(commanded_effort_lengthT > commanded_effort_length)
this->commanded_effort = (double*)realloc(this->commanded_effort, commanded_effort_lengthT * sizeof(double));
commanded_effort_length = commanded_effort_lengthT;
for( uint32_t i = 0; i < commanded_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_commanded_effort;
u_st_commanded_effort.base = 0;
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_commanded_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_commanded_effort = u_st_commanded_effort.real;
offset += sizeof(this->st_commanded_effort);
memcpy( &(this->commanded_effort[i]), &(this->st_commanded_effort), sizeof(double));
}
uint32_t actual_position_lengthT = ((uint32_t) (*(inbuffer + offset)));
actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
actual_position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->actual_position_length);
if(actual_position_lengthT > actual_position_length)
this->actual_position = (double*)realloc(this->actual_position, actual_position_lengthT * sizeof(double));
actual_position_length = actual_position_lengthT;
for( uint32_t i = 0; i < actual_position_length; i++){
union {
double real;
uint64_t base;
} u_st_actual_position;
u_st_actual_position.base = 0;
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_actual_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_actual_position = u_st_actual_position.real;
offset += sizeof(this->st_actual_position);
memcpy( &(this->actual_position[i]), &(this->st_actual_position), sizeof(double));
}
uint32_t actual_velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
actual_velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->actual_velocity_length);
if(actual_velocity_lengthT > actual_velocity_length)
this->actual_velocity = (double*)realloc(this->actual_velocity, actual_velocity_lengthT * sizeof(double));
actual_velocity_length = actual_velocity_lengthT;
for( uint32_t i = 0; i < actual_velocity_length; i++){
union {
double real;
uint64_t base;
} u_st_actual_velocity;
u_st_actual_velocity.base = 0;
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_actual_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_actual_velocity = u_st_actual_velocity.real;
offset += sizeof(this->st_actual_velocity);
memcpy( &(this->actual_velocity[i]), &(this->st_actual_velocity), sizeof(double));
}
uint32_t actual_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
actual_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->actual_effort_length);
if(actual_effort_lengthT > actual_effort_length)
this->actual_effort = (double*)realloc(this->actual_effort, actual_effort_lengthT * sizeof(double));
actual_effort_length = actual_effort_lengthT;
for( uint32_t i = 0; i < actual_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_actual_effort;
u_st_actual_effort.base = 0;
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_actual_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_actual_effort = u_st_actual_effort.real;
offset += sizeof(this->st_actual_effort);
memcpy( &(this->actual_effort[i]), &(this->st_actual_effort), sizeof(double));
}
uint32_t gravity_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
gravity_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->gravity_model_effort_length);
if(gravity_model_effort_lengthT > gravity_model_effort_length)
this->gravity_model_effort = (double*)realloc(this->gravity_model_effort, gravity_model_effort_lengthT * sizeof(double));
gravity_model_effort_length = gravity_model_effort_lengthT;
for( uint32_t i = 0; i < gravity_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_gravity_model_effort;
u_st_gravity_model_effort.base = 0;
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_gravity_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_gravity_model_effort = u_st_gravity_model_effort.real;
offset += sizeof(this->st_gravity_model_effort);
memcpy( &(this->gravity_model_effort[i]), &(this->st_gravity_model_effort), sizeof(double));
}
uint32_t gravity_only_lengthT = ((uint32_t) (*(inbuffer + offset)));
gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
gravity_only_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->gravity_only_length);
if(gravity_only_lengthT > gravity_only_length)
this->gravity_only = (double*)realloc(this->gravity_only, gravity_only_lengthT * sizeof(double));
gravity_only_length = gravity_only_lengthT;
for( uint32_t i = 0; i < gravity_only_length; i++){
union {
double real;
uint64_t base;
} u_st_gravity_only;
u_st_gravity_only.base = 0;
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_gravity_only.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_gravity_only = u_st_gravity_only.real;
offset += sizeof(this->st_gravity_only);
memcpy( &(this->gravity_only[i]), &(this->st_gravity_only), sizeof(double));
}
uint32_t hysteresis_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
hysteresis_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->hysteresis_model_effort_length);
if(hysteresis_model_effort_lengthT > hysteresis_model_effort_length)
this->hysteresis_model_effort = (double*)realloc(this->hysteresis_model_effort, hysteresis_model_effort_lengthT * sizeof(double));
hysteresis_model_effort_length = hysteresis_model_effort_lengthT;
for( uint32_t i = 0; i < hysteresis_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_hysteresis_model_effort;
u_st_hysteresis_model_effort.base = 0;
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_hysteresis_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_hysteresis_model_effort = u_st_hysteresis_model_effort.real;
offset += sizeof(this->st_hysteresis_model_effort);
memcpy( &(this->hysteresis_model_effort[i]), &(this->st_hysteresis_model_effort), sizeof(double));
}
uint32_t crosstalk_model_effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
crosstalk_model_effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->crosstalk_model_effort_length);
if(crosstalk_model_effort_lengthT > crosstalk_model_effort_length)
this->crosstalk_model_effort = (double*)realloc(this->crosstalk_model_effort, crosstalk_model_effort_lengthT * sizeof(double));
crosstalk_model_effort_length = crosstalk_model_effort_lengthT;
for( uint32_t i = 0; i < crosstalk_model_effort_length; i++){
union {
double real;
uint64_t base;
} u_st_crosstalk_model_effort;
u_st_crosstalk_model_effort.base = 0;
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_crosstalk_model_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_crosstalk_model_effort = u_st_crosstalk_model_effort.real;
offset += sizeof(this->st_crosstalk_model_effort);
memcpy( &(this->crosstalk_model_effort[i]), &(this->st_crosstalk_model_effort), sizeof(double));
}
union {
double real;
uint64_t base;
} u_hystState;
u_hystState.base = 0;
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_hystState.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->hystState = u_hystState.real;
offset += sizeof(this->hystState);
return offset;
}
const char * getType(){ return "baxter_core_msgs/SEAJointState"; };
const char * getMD5(){ return "d36406dcbb6d860b1b39c4e28f81352b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/RobustControllerStatus.h | #ifndef _ROS_baxter_core_msgs_RobustControllerStatus_h
#define _ROS_baxter_core_msgs_RobustControllerStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class RobustControllerStatus : public ros::Msg
{
public:
typedef bool _isEnabled_type;
_isEnabled_type isEnabled;
typedef int32_t _complete_type;
_complete_type complete;
typedef const char* _controlUid_type;
_controlUid_type controlUid;
typedef bool _timedOut_type;
_timedOut_type timedOut;
uint32_t errorCodes_length;
typedef char* _errorCodes_type;
_errorCodes_type st_errorCodes;
_errorCodes_type * errorCodes;
uint32_t labels_length;
typedef char* _labels_type;
_labels_type st_labels;
_labels_type * labels;
enum { NOT_COMPLETE = 0 };
enum { COMPLETE_W_FAILURE = 1 };
enum { COMPLETE_W_SUCCESS = 2 };
RobustControllerStatus():
isEnabled(0),
complete(0),
controlUid(""),
timedOut(0),
errorCodes_length(0), errorCodes(NULL),
labels_length(0), labels(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.real = this->isEnabled;
*(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isEnabled);
union {
int32_t real;
uint32_t base;
} u_complete;
u_complete.real = this->complete;
*(outbuffer + offset + 0) = (u_complete.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_complete.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_complete.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_complete.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->complete);
uint32_t length_controlUid = strlen(this->controlUid);
varToArr(outbuffer + offset, length_controlUid);
offset += 4;
memcpy(outbuffer + offset, this->controlUid, length_controlUid);
offset += length_controlUid;
union {
bool real;
uint8_t base;
} u_timedOut;
u_timedOut.real = this->timedOut;
*(outbuffer + offset + 0) = (u_timedOut.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->timedOut);
*(outbuffer + offset + 0) = (this->errorCodes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->errorCodes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->errorCodes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->errorCodes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->errorCodes_length);
for( uint32_t i = 0; i < errorCodes_length; i++){
uint32_t length_errorCodesi = strlen(this->errorCodes[i]);
varToArr(outbuffer + offset, length_errorCodesi);
offset += 4;
memcpy(outbuffer + offset, this->errorCodes[i], length_errorCodesi);
offset += length_errorCodesi;
}
*(outbuffer + offset + 0) = (this->labels_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->labels_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->labels_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->labels_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->labels_length);
for( uint32_t i = 0; i < labels_length; i++){
uint32_t length_labelsi = strlen(this->labels[i]);
varToArr(outbuffer + offset, length_labelsi);
offset += 4;
memcpy(outbuffer + offset, this->labels[i], length_labelsi);
offset += length_labelsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.base = 0;
u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isEnabled = u_isEnabled.real;
offset += sizeof(this->isEnabled);
union {
int32_t real;
uint32_t base;
} u_complete;
u_complete.base = 0;
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->complete = u_complete.real;
offset += sizeof(this->complete);
uint32_t length_controlUid;
arrToVar(length_controlUid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_controlUid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_controlUid-1]=0;
this->controlUid = (char *)(inbuffer + offset-1);
offset += length_controlUid;
union {
bool real;
uint8_t base;
} u_timedOut;
u_timedOut.base = 0;
u_timedOut.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->timedOut = u_timedOut.real;
offset += sizeof(this->timedOut);
uint32_t errorCodes_lengthT = ((uint32_t) (*(inbuffer + offset)));
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->errorCodes_length);
if(errorCodes_lengthT > errorCodes_length)
this->errorCodes = (char**)realloc(this->errorCodes, errorCodes_lengthT * sizeof(char*));
errorCodes_length = errorCodes_lengthT;
for( uint32_t i = 0; i < errorCodes_length; i++){
uint32_t length_st_errorCodes;
arrToVar(length_st_errorCodes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_errorCodes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_errorCodes-1]=0;
this->st_errorCodes = (char *)(inbuffer + offset-1);
offset += length_st_errorCodes;
memcpy( &(this->errorCodes[i]), &(this->st_errorCodes), sizeof(char*));
}
uint32_t labels_lengthT = ((uint32_t) (*(inbuffer + offset)));
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->labels_length);
if(labels_lengthT > labels_length)
this->labels = (char**)realloc(this->labels, labels_lengthT * sizeof(char*));
labels_length = labels_lengthT;
for( uint32_t i = 0; i < labels_length; i++){
uint32_t length_st_labels;
arrToVar(length_st_labels, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_labels; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_labels-1]=0;
this->st_labels = (char *)(inbuffer + offset-1);
offset += length_st_labels;
memcpy( &(this->labels[i]), &(this->st_labels), sizeof(char*));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/RobustControllerStatus"; };
const char * getMD5(){ return "2f15441b7285d915e7e59d3618e173f2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CloseCamera.h | #ifndef _ROS_SERVICE_CloseCamera_h
#define _ROS_SERVICE_CloseCamera_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
static const char CLOSECAMERA[] = "baxter_core_msgs/CloseCamera";
class CloseCameraRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
CloseCameraRequest():
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
return offset;
}
const char * getType(){ return CLOSECAMERA; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class CloseCameraResponse : public ros::Msg
{
public:
typedef int32_t _err_type;
_err_type err;
CloseCameraResponse():
err(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.real = this->err;
*(outbuffer + offset + 0) = (u_err.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_err.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_err.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_err.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->err);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.base = 0;
u_err.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->err = u_err.real;
offset += sizeof(this->err);
return offset;
}
const char * getType(){ return CLOSECAMERA; };
const char * getMD5(){ return "b6e094011a4dfaee5eddf447220446cf"; };
};
class CloseCamera {
public:
typedef CloseCameraRequest Request;
typedef CloseCameraResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CollisionAvoidanceState.h | #ifndef _ROS_baxter_core_msgs_CollisionAvoidanceState_h
#define _ROS_baxter_core_msgs_CollisionAvoidanceState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace baxter_core_msgs
{
class CollisionAvoidanceState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef bool _other_arm_type;
_other_arm_type other_arm;
uint32_t collision_object_length;
typedef char* _collision_object_type;
_collision_object_type st_collision_object;
_collision_object_type * collision_object;
CollisionAvoidanceState():
header(),
other_arm(0),
collision_object_length(0), collision_object(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_other_arm;
u_other_arm.real = this->other_arm;
*(outbuffer + offset + 0) = (u_other_arm.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->other_arm);
*(outbuffer + offset + 0) = (this->collision_object_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->collision_object_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->collision_object_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->collision_object_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->collision_object_length);
for( uint32_t i = 0; i < collision_object_length; i++){
uint32_t length_collision_objecti = strlen(this->collision_object[i]);
varToArr(outbuffer + offset, length_collision_objecti);
offset += 4;
memcpy(outbuffer + offset, this->collision_object[i], length_collision_objecti);
offset += length_collision_objecti;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_other_arm;
u_other_arm.base = 0;
u_other_arm.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->other_arm = u_other_arm.real;
offset += sizeof(this->other_arm);
uint32_t collision_object_lengthT = ((uint32_t) (*(inbuffer + offset)));
collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
collision_object_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->collision_object_length);
if(collision_object_lengthT > collision_object_length)
this->collision_object = (char**)realloc(this->collision_object, collision_object_lengthT * sizeof(char*));
collision_object_length = collision_object_lengthT;
for( uint32_t i = 0; i < collision_object_length; i++){
uint32_t length_st_collision_object;
arrToVar(length_st_collision_object, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_collision_object; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_collision_object-1]=0;
this->st_collision_object = (char *)(inbuffer + offset-1);
offset += length_st_collision_object;
memcpy( &(this->collision_object[i]), &(this->st_collision_object), sizeof(char*));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/CollisionAvoidanceState"; };
const char * getMD5(){ return "30f5cb8ae019f1ffe8b599e6d2e589c7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/DigitalOutputCommand.h | #ifndef _ROS_baxter_core_msgs_DigitalOutputCommand_h
#define _ROS_baxter_core_msgs_DigitalOutputCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class DigitalOutputCommand : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef bool _value_type;
_value_type value;
DigitalOutputCommand():
name(""),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
bool real;
uint8_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "baxter_core_msgs/DigitalOutputCommand"; };
const char * getMD5(){ return "23f05028c1a699fb83e22401228c3a9e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/URDFConfiguration.h | #ifndef _ROS_baxter_core_msgs_URDFConfiguration_h
#define _ROS_baxter_core_msgs_URDFConfiguration_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace baxter_core_msgs
{
class URDFConfiguration : public ros::Msg
{
public:
typedef ros::Time _time_type;
_time_type time;
typedef const char* _link_type;
_link_type link;
typedef const char* _joint_type;
_joint_type joint;
typedef const char* _urdf_type;
_urdf_type urdf;
URDFConfiguration():
time(),
link(""),
joint(""),
urdf("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time.sec);
*(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time.nsec);
uint32_t length_link = strlen(this->link);
varToArr(outbuffer + offset, length_link);
offset += 4;
memcpy(outbuffer + offset, this->link, length_link);
offset += length_link;
uint32_t length_joint = strlen(this->joint);
varToArr(outbuffer + offset, length_joint);
offset += 4;
memcpy(outbuffer + offset, this->joint, length_joint);
offset += length_joint;
uint32_t length_urdf = strlen(this->urdf);
varToArr(outbuffer + offset, length_urdf);
offset += 4;
memcpy(outbuffer + offset, this->urdf, length_urdf);
offset += length_urdf;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->time.sec = ((uint32_t) (*(inbuffer + offset)));
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time.sec);
this->time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time.nsec);
uint32_t length_link;
arrToVar(length_link, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link-1]=0;
this->link = (char *)(inbuffer + offset-1);
offset += length_link;
uint32_t length_joint;
arrToVar(length_joint, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint-1]=0;
this->joint = (char *)(inbuffer + offset-1);
offset += length_joint;
uint32_t length_urdf;
arrToVar(length_urdf, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_urdf; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_urdf-1]=0;
this->urdf = (char *)(inbuffer + offset-1);
offset += length_urdf;
return offset;
}
const char * getType(){ return "baxter_core_msgs/URDFConfiguration"; };
const char * getMD5(){ return "0c7028d878027820eed2aa0cbf1f5e4a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorProperties.h | #ifndef _ROS_baxter_core_msgs_EndEffectorProperties_h
#define _ROS_baxter_core_msgs_EndEffectorProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class EndEffectorProperties : public ros::Msg
{
public:
typedef uint32_t _id_type;
_id_type id;
typedef uint8_t _ui_type_type;
_ui_type_type ui_type;
typedef const char* _manufacturer_type;
_manufacturer_type manufacturer;
typedef const char* _product_type;
_product_type product;
typedef const char* _serial_number_type;
_serial_number_type serial_number;
typedef const char* _hardware_rev_type;
_hardware_rev_type hardware_rev;
typedef const char* _firmware_rev_type;
_firmware_rev_type firmware_rev;
typedef const char* _firmware_date_type;
_firmware_date_type firmware_date;
typedef bool _has_calibration_type;
_has_calibration_type has_calibration;
typedef bool _controls_grip_type;
_controls_grip_type controls_grip;
typedef bool _senses_grip_type;
_senses_grip_type senses_grip;
typedef bool _reverses_grip_type;
_reverses_grip_type reverses_grip;
typedef bool _controls_force_type;
_controls_force_type controls_force;
typedef bool _senses_force_type;
_senses_force_type senses_force;
typedef bool _controls_position_type;
_controls_position_type controls_position;
typedef bool _senses_position_type;
_senses_position_type senses_position;
typedef const char* _properties_type;
_properties_type properties;
enum { NO_GRIPPER = 0 };
enum { SUCTION_CUP_GRIPPER = 1 };
enum { ELECTRIC_GRIPPER = 2 };
enum { PASSIVE_GRIPPER = 3 };
EndEffectorProperties():
id(0),
ui_type(0),
manufacturer(""),
product(""),
serial_number(""),
hardware_rev(""),
firmware_rev(""),
firmware_date(""),
has_calibration(0),
controls_grip(0),
senses_grip(0),
reverses_grip(0),
controls_force(0),
senses_force(0),
controls_position(0),
senses_position(0),
properties("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
*(outbuffer + offset + 0) = (this->ui_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->ui_type);
uint32_t length_manufacturer = strlen(this->manufacturer);
varToArr(outbuffer + offset, length_manufacturer);
offset += 4;
memcpy(outbuffer + offset, this->manufacturer, length_manufacturer);
offset += length_manufacturer;
uint32_t length_product = strlen(this->product);
varToArr(outbuffer + offset, length_product);
offset += 4;
memcpy(outbuffer + offset, this->product, length_product);
offset += length_product;
uint32_t length_serial_number = strlen(this->serial_number);
varToArr(outbuffer + offset, length_serial_number);
offset += 4;
memcpy(outbuffer + offset, this->serial_number, length_serial_number);
offset += length_serial_number;
uint32_t length_hardware_rev = strlen(this->hardware_rev);
varToArr(outbuffer + offset, length_hardware_rev);
offset += 4;
memcpy(outbuffer + offset, this->hardware_rev, length_hardware_rev);
offset += length_hardware_rev;
uint32_t length_firmware_rev = strlen(this->firmware_rev);
varToArr(outbuffer + offset, length_firmware_rev);
offset += 4;
memcpy(outbuffer + offset, this->firmware_rev, length_firmware_rev);
offset += length_firmware_rev;
uint32_t length_firmware_date = strlen(this->firmware_date);
varToArr(outbuffer + offset, length_firmware_date);
offset += 4;
memcpy(outbuffer + offset, this->firmware_date, length_firmware_date);
offset += length_firmware_date;
union {
bool real;
uint8_t base;
} u_has_calibration;
u_has_calibration.real = this->has_calibration;
*(outbuffer + offset + 0) = (u_has_calibration.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_calibration);
union {
bool real;
uint8_t base;
} u_controls_grip;
u_controls_grip.real = this->controls_grip;
*(outbuffer + offset + 0) = (u_controls_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_grip);
union {
bool real;
uint8_t base;
} u_senses_grip;
u_senses_grip.real = this->senses_grip;
*(outbuffer + offset + 0) = (u_senses_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_grip);
union {
bool real;
uint8_t base;
} u_reverses_grip;
u_reverses_grip.real = this->reverses_grip;
*(outbuffer + offset + 0) = (u_reverses_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->reverses_grip);
union {
bool real;
uint8_t base;
} u_controls_force;
u_controls_force.real = this->controls_force;
*(outbuffer + offset + 0) = (u_controls_force.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_force);
union {
bool real;
uint8_t base;
} u_senses_force;
u_senses_force.real = this->senses_force;
*(outbuffer + offset + 0) = (u_senses_force.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_force);
union {
bool real;
uint8_t base;
} u_controls_position;
u_controls_position.real = this->controls_position;
*(outbuffer + offset + 0) = (u_controls_position.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_position);
union {
bool real;
uint8_t base;
} u_senses_position;
u_senses_position.real = this->senses_position;
*(outbuffer + offset + 0) = (u_senses_position.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_position);
uint32_t length_properties = strlen(this->properties);
varToArr(outbuffer + offset, length_properties);
offset += 4;
memcpy(outbuffer + offset, this->properties, length_properties);
offset += length_properties;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
this->ui_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->ui_type);
uint32_t length_manufacturer;
arrToVar(length_manufacturer, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_manufacturer; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_manufacturer-1]=0;
this->manufacturer = (char *)(inbuffer + offset-1);
offset += length_manufacturer;
uint32_t length_product;
arrToVar(length_product, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_product; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_product-1]=0;
this->product = (char *)(inbuffer + offset-1);
offset += length_product;
uint32_t length_serial_number;
arrToVar(length_serial_number, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_serial_number; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_serial_number-1]=0;
this->serial_number = (char *)(inbuffer + offset-1);
offset += length_serial_number;
uint32_t length_hardware_rev;
arrToVar(length_hardware_rev, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_hardware_rev; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_hardware_rev-1]=0;
this->hardware_rev = (char *)(inbuffer + offset-1);
offset += length_hardware_rev;
uint32_t length_firmware_rev;
arrToVar(length_firmware_rev, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_firmware_rev; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_firmware_rev-1]=0;
this->firmware_rev = (char *)(inbuffer + offset-1);
offset += length_firmware_rev;
uint32_t length_firmware_date;
arrToVar(length_firmware_date, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_firmware_date; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_firmware_date-1]=0;
this->firmware_date = (char *)(inbuffer + offset-1);
offset += length_firmware_date;
union {
bool real;
uint8_t base;
} u_has_calibration;
u_has_calibration.base = 0;
u_has_calibration.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_calibration = u_has_calibration.real;
offset += sizeof(this->has_calibration);
union {
bool real;
uint8_t base;
} u_controls_grip;
u_controls_grip.base = 0;
u_controls_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_grip = u_controls_grip.real;
offset += sizeof(this->controls_grip);
union {
bool real;
uint8_t base;
} u_senses_grip;
u_senses_grip.base = 0;
u_senses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_grip = u_senses_grip.real;
offset += sizeof(this->senses_grip);
union {
bool real;
uint8_t base;
} u_reverses_grip;
u_reverses_grip.base = 0;
u_reverses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->reverses_grip = u_reverses_grip.real;
offset += sizeof(this->reverses_grip);
union {
bool real;
uint8_t base;
} u_controls_force;
u_controls_force.base = 0;
u_controls_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_force = u_controls_force.real;
offset += sizeof(this->controls_force);
union {
bool real;
uint8_t base;
} u_senses_force;
u_senses_force.base = 0;
u_senses_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_force = u_senses_force.real;
offset += sizeof(this->senses_force);
union {
bool real;
uint8_t base;
} u_controls_position;
u_controls_position.base = 0;
u_controls_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_position = u_controls_position.real;
offset += sizeof(this->controls_position);
union {
bool real;
uint8_t base;
} u_senses_position;
u_senses_position.base = 0;
u_senses_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_position = u_senses_position.real;
offset += sizeof(this->senses_position);
uint32_t length_properties;
arrToVar(length_properties, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_properties; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_properties-1]=0;
this->properties = (char *)(inbuffer + offset-1);
offset += length_properties;
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndEffectorProperties"; };
const char * getMD5(){ return "21b83773ab9a35216d11e427573c76cc"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CollisionDetectionState.h | #ifndef _ROS_baxter_core_msgs_CollisionDetectionState_h
#define _ROS_baxter_core_msgs_CollisionDetectionState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace baxter_core_msgs
{
class CollisionDetectionState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef bool _collision_state_type;
_collision_state_type collision_state;
CollisionDetectionState():
header(),
collision_state(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_collision_state;
u_collision_state.real = this->collision_state;
*(outbuffer + offset + 0) = (u_collision_state.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->collision_state);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_collision_state;
u_collision_state.base = 0;
u_collision_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->collision_state = u_collision_state.real;
offset += sizeof(this->collision_state);
return offset;
}
const char * getType(){ return "baxter_core_msgs/CollisionDetectionState"; };
const char * getMD5(){ return "7bde38c182b4d08fdc0635b116f65d04"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndpointStates.h | #ifndef _ROS_baxter_core_msgs_EndpointStates_h
#define _ROS_baxter_core_msgs_EndpointStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/EndpointState.h"
namespace baxter_core_msgs
{
class EndpointStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::EndpointState _states_type;
_states_type st_states;
_states_type * states;
EndpointStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (baxter_core_msgs::EndpointState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::EndpointState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(baxter_core_msgs::EndpointState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndpointStates"; };
const char * getMD5(){ return "a0ca50a066809a5f065f39f37aa028fb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/SolvePositionIK.h | #ifndef _ROS_SERVICE_SolvePositionIK_h
#define _ROS_SERVICE_SolvePositionIK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
#include "sensor_msgs/JointState.h"
namespace baxter_core_msgs
{
static const char SOLVEPOSITIONIK[] = "baxter_core_msgs/SolvePositionIK";
class SolvePositionIKRequest : public ros::Msg
{
public:
uint32_t pose_stamp_length;
typedef geometry_msgs::PoseStamped _pose_stamp_type;
_pose_stamp_type st_pose_stamp;
_pose_stamp_type * pose_stamp;
uint32_t seed_angles_length;
typedef sensor_msgs::JointState _seed_angles_type;
_seed_angles_type st_seed_angles;
_seed_angles_type * seed_angles;
typedef uint8_t _seed_mode_type;
_seed_mode_type seed_mode;
enum { SEED_AUTO = 0 };
enum { SEED_USER = 1 };
enum { SEED_CURRENT = 2 };
enum { SEED_NS_MAP = 3 };
SolvePositionIKRequest():
pose_stamp_length(0), pose_stamp(NULL),
seed_angles_length(0), seed_angles(NULL),
seed_mode(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->pose_stamp_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamp_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamp_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamp_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamp_length);
for( uint32_t i = 0; i < pose_stamp_length; i++){
offset += this->pose_stamp[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->seed_angles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->seed_angles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->seed_angles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->seed_angles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->seed_angles_length);
for( uint32_t i = 0; i < seed_angles_length; i++){
offset += this->seed_angles[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->seed_mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->seed_mode);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t pose_stamp_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamp_length);
if(pose_stamp_lengthT > pose_stamp_length)
this->pose_stamp = (geometry_msgs::PoseStamped*)realloc(this->pose_stamp, pose_stamp_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamp_length = pose_stamp_lengthT;
for( uint32_t i = 0; i < pose_stamp_length; i++){
offset += this->st_pose_stamp.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamp[i]), &(this->st_pose_stamp), sizeof(geometry_msgs::PoseStamped));
}
uint32_t seed_angles_lengthT = ((uint32_t) (*(inbuffer + offset)));
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->seed_angles_length);
if(seed_angles_lengthT > seed_angles_length)
this->seed_angles = (sensor_msgs::JointState*)realloc(this->seed_angles, seed_angles_lengthT * sizeof(sensor_msgs::JointState));
seed_angles_length = seed_angles_lengthT;
for( uint32_t i = 0; i < seed_angles_length; i++){
offset += this->st_seed_angles.deserialize(inbuffer + offset);
memcpy( &(this->seed_angles[i]), &(this->st_seed_angles), sizeof(sensor_msgs::JointState));
}
this->seed_mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->seed_mode);
return offset;
}
const char * getType(){ return SOLVEPOSITIONIK; };
const char * getMD5(){ return "2587e42983d0081d0a2288230991073b"; };
};
class SolvePositionIKResponse : public ros::Msg
{
public:
uint32_t joints_length;
typedef sensor_msgs::JointState _joints_type;
_joints_type st_joints;
_joints_type * joints;
uint32_t isValid_length;
typedef bool _isValid_type;
_isValid_type st_isValid;
_isValid_type * isValid;
uint32_t result_type_length;
typedef uint8_t _result_type_type;
_result_type_type st_result_type;
_result_type_type * result_type;
enum { RESULT_INVALID = 0 };
SolvePositionIKResponse():
joints_length(0), joints(NULL),
isValid_length(0), isValid(NULL),
result_type_length(0), result_type(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joints_length);
for( uint32_t i = 0; i < joints_length; i++){
offset += this->joints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->isValid_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->isValid_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->isValid_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->isValid_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->isValid_length);
for( uint32_t i = 0; i < isValid_length; i++){
union {
bool real;
uint8_t base;
} u_isValidi;
u_isValidi.real = this->isValid[i];
*(outbuffer + offset + 0) = (u_isValidi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isValid[i]);
}
*(outbuffer + offset + 0) = (this->result_type_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->result_type_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->result_type_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->result_type_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->result_type_length);
for( uint32_t i = 0; i < result_type_length; i++){
*(outbuffer + offset + 0) = (this->result_type[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->result_type[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joints_lengthT = ((uint32_t) (*(inbuffer + offset)));
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joints_length);
if(joints_lengthT > joints_length)
this->joints = (sensor_msgs::JointState*)realloc(this->joints, joints_lengthT * sizeof(sensor_msgs::JointState));
joints_length = joints_lengthT;
for( uint32_t i = 0; i < joints_length; i++){
offset += this->st_joints.deserialize(inbuffer + offset);
memcpy( &(this->joints[i]), &(this->st_joints), sizeof(sensor_msgs::JointState));
}
uint32_t isValid_lengthT = ((uint32_t) (*(inbuffer + offset)));
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->isValid_length);
if(isValid_lengthT > isValid_length)
this->isValid = (bool*)realloc(this->isValid, isValid_lengthT * sizeof(bool));
isValid_length = isValid_lengthT;
for( uint32_t i = 0; i < isValid_length; i++){
union {
bool real;
uint8_t base;
} u_st_isValid;
u_st_isValid.base = 0;
u_st_isValid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_isValid = u_st_isValid.real;
offset += sizeof(this->st_isValid);
memcpy( &(this->isValid[i]), &(this->st_isValid), sizeof(bool));
}
uint32_t result_type_lengthT = ((uint32_t) (*(inbuffer + offset)));
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->result_type_length);
if(result_type_lengthT > result_type_length)
this->result_type = (uint8_t*)realloc(this->result_type, result_type_lengthT * sizeof(uint8_t));
result_type_length = result_type_lengthT;
for( uint32_t i = 0; i < result_type_length; i++){
this->st_result_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_result_type);
memcpy( &(this->result_type[i]), &(this->st_result_type), sizeof(uint8_t));
}
return offset;
}
const char * getType(){ return SOLVEPOSITIONIK; };
const char * getMD5(){ return "d9b0c2b3932e08421f5094cf62743b9f"; };
};
class SolvePositionIK {
public:
typedef SolvePositionIKRequest Request;
typedef SolvePositionIKResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/DigitalIOState.h | #ifndef _ROS_baxter_core_msgs_DigitalIOState_h
#define _ROS_baxter_core_msgs_DigitalIOState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class DigitalIOState : public ros::Msg
{
public:
typedef int8_t _state_type;
_state_type state;
typedef bool _isInputOnly_type;
_isInputOnly_type isInputOnly;
enum { OFF = 0 };
enum { ON = 1 };
enum { PRESSED = 1 };
enum { UNPRESSED = 0 };
DigitalIOState():
state(0),
isInputOnly(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_state;
u_state.real = this->state;
*(outbuffer + offset + 0) = (u_state.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->state);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.real = this->isInputOnly;
*(outbuffer + offset + 0) = (u_isInputOnly.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isInputOnly);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_state;
u_state.base = 0;
u_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->state = u_state.real;
offset += sizeof(this->state);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.base = 0;
u_isInputOnly.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isInputOnly = u_isInputOnly.real;
offset += sizeof(this->isInputOnly);
return offset;
}
const char * getType(){ return "baxter_core_msgs/DigitalIOState"; };
const char * getMD5(){ return "29d0be3859dae81a66b28f167ecec98c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/DigitalIOStates.h | #ifndef _ROS_baxter_core_msgs_DigitalIOStates_h
#define _ROS_baxter_core_msgs_DigitalIOStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/DigitalIOState.h"
namespace baxter_core_msgs
{
class DigitalIOStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::DigitalIOState _states_type;
_states_type st_states;
_states_type * states;
DigitalIOStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (baxter_core_msgs::DigitalIOState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::DigitalIOState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(baxter_core_msgs::DigitalIOState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/DigitalIOStates"; };
const char * getMD5(){ return "d434210c6ec20947fec667d6c13d6062"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/HeadState.h | #ifndef _ROS_baxter_core_msgs_HeadState_h
#define _ROS_baxter_core_msgs_HeadState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class HeadState : public ros::Msg
{
public:
typedef float _pan_type;
_pan_type pan;
typedef bool _isTurning_type;
_isTurning_type isTurning;
typedef bool _isNodding_type;
_isNodding_type isNodding;
typedef bool _isPanEnabled_type;
_isPanEnabled_type isPanEnabled;
HeadState():
pan(0),
isTurning(0),
isNodding(0),
isPanEnabled(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_pan;
u_pan.real = this->pan;
*(outbuffer + offset + 0) = (u_pan.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pan.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pan.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pan.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->pan);
union {
bool real;
uint8_t base;
} u_isTurning;
u_isTurning.real = this->isTurning;
*(outbuffer + offset + 0) = (u_isTurning.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isTurning);
union {
bool real;
uint8_t base;
} u_isNodding;
u_isNodding.real = this->isNodding;
*(outbuffer + offset + 0) = (u_isNodding.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isNodding);
union {
bool real;
uint8_t base;
} u_isPanEnabled;
u_isPanEnabled.real = this->isPanEnabled;
*(outbuffer + offset + 0) = (u_isPanEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isPanEnabled);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_pan;
u_pan.base = 0;
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->pan = u_pan.real;
offset += sizeof(this->pan);
union {
bool real;
uint8_t base;
} u_isTurning;
u_isTurning.base = 0;
u_isTurning.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isTurning = u_isTurning.real;
offset += sizeof(this->isTurning);
union {
bool real;
uint8_t base;
} u_isNodding;
u_isNodding.base = 0;
u_isNodding.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isNodding = u_isNodding.real;
offset += sizeof(this->isNodding);
union {
bool real;
uint8_t base;
} u_isPanEnabled;
u_isPanEnabled.base = 0;
u_isPanEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isPanEnabled = u_isPanEnabled.real;
offset += sizeof(this->isPanEnabled);
return offset;
}
const char * getType(){ return "baxter_core_msgs/HeadState"; };
const char * getMD5(){ return "71c43b264307205358e7e49be5601348"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AnalogIOStates.h | #ifndef _ROS_baxter_core_msgs_AnalogIOStates_h
#define _ROS_baxter_core_msgs_AnalogIOStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/AnalogIOState.h"
namespace baxter_core_msgs
{
class AnalogIOStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::AnalogIOState _states_type;
_states_type st_states;
_states_type * states;
AnalogIOStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (baxter_core_msgs::AnalogIOState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::AnalogIOState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(baxter_core_msgs::AnalogIOState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/AnalogIOStates"; };
const char * getMD5(){ return "0a05ba3bbb53a8a3b164e34946d619f7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/ListCameras.h | #ifndef _ROS_SERVICE_ListCameras_h
#define _ROS_SERVICE_ListCameras_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
static const char LISTCAMERAS[] = "baxter_core_msgs/ListCameras";
class ListCamerasRequest : public ros::Msg
{
public:
ListCamerasRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return LISTCAMERAS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class ListCamerasResponse : public ros::Msg
{
public:
uint32_t cameras_length;
typedef char* _cameras_type;
_cameras_type st_cameras;
_cameras_type * cameras;
ListCamerasResponse():
cameras_length(0), cameras(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->cameras_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cameras_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cameras_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cameras_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cameras_length);
for( uint32_t i = 0; i < cameras_length; i++){
uint32_t length_camerasi = strlen(this->cameras[i]);
varToArr(outbuffer + offset, length_camerasi);
offset += 4;
memcpy(outbuffer + offset, this->cameras[i], length_camerasi);
offset += length_camerasi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t cameras_lengthT = ((uint32_t) (*(inbuffer + offset)));
cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cameras_length);
if(cameras_lengthT > cameras_length)
this->cameras = (char**)realloc(this->cameras, cameras_lengthT * sizeof(char*));
cameras_length = cameras_lengthT;
for( uint32_t i = 0; i < cameras_length; i++){
uint32_t length_st_cameras;
arrToVar(length_st_cameras, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_cameras; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_cameras-1]=0;
this->st_cameras = (char *)(inbuffer + offset-1);
offset += length_st_cameras;
memcpy( &(this->cameras[i]), &(this->st_cameras), sizeof(char*));
}
return offset;
}
const char * getType(){ return LISTCAMERAS; };
const char * getMD5(){ return "855b31192ab61744e7deb992d94db7ff"; };
};
class ListCameras {
public:
typedef ListCamerasRequest Request;
typedef ListCamerasResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CameraSettings.h | #ifndef _ROS_baxter_core_msgs_CameraSettings_h
#define _ROS_baxter_core_msgs_CameraSettings_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/CameraControl.h"
namespace baxter_core_msgs
{
class CameraSettings : public ros::Msg
{
public:
typedef int32_t _width_type;
_width_type width;
typedef int32_t _height_type;
_height_type height;
typedef float _fps_type;
_fps_type fps;
uint32_t controls_length;
typedef baxter_core_msgs::CameraControl _controls_type;
_controls_type st_controls;
_controls_type * controls;
CameraSettings():
width(0),
height(0),
fps(0),
controls_length(0), controls(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_width;
u_width.real = this->width;
*(outbuffer + offset + 0) = (u_width.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_width.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_width.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_width.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
union {
int32_t real;
uint32_t base;
} u_height;
u_height.real = this->height;
*(outbuffer + offset + 0) = (u_height.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_height.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_height.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_height.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
union {
float real;
uint32_t base;
} u_fps;
u_fps.real = this->fps;
*(outbuffer + offset + 0) = (u_fps.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fps.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fps.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fps.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fps);
*(outbuffer + offset + 0) = (this->controls_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->controls_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->controls_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->controls_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->controls_length);
for( uint32_t i = 0; i < controls_length; i++){
offset += this->controls[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_width;
u_width.base = 0;
u_width.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_width.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_width.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_width.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->width = u_width.real;
offset += sizeof(this->width);
union {
int32_t real;
uint32_t base;
} u_height;
u_height.base = 0;
u_height.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_height.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_height.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_height.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->height = u_height.real;
offset += sizeof(this->height);
union {
float real;
uint32_t base;
} u_fps;
u_fps.base = 0;
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fps = u_fps.real;
offset += sizeof(this->fps);
uint32_t controls_lengthT = ((uint32_t) (*(inbuffer + offset)));
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->controls_length);
if(controls_lengthT > controls_length)
this->controls = (baxter_core_msgs::CameraControl*)realloc(this->controls, controls_lengthT * sizeof(baxter_core_msgs::CameraControl));
controls_length = controls_lengthT;
for( uint32_t i = 0; i < controls_length; i++){
offset += this->st_controls.deserialize(inbuffer + offset);
memcpy( &(this->controls[i]), &(this->st_controls), sizeof(baxter_core_msgs::CameraControl));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/CameraSettings"; };
const char * getMD5(){ return "d133bef4a3bd9a6e490a5dc91d20f429"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/NavigatorState.h | #ifndef _ROS_baxter_core_msgs_NavigatorState_h
#define _ROS_baxter_core_msgs_NavigatorState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class NavigatorState : public ros::Msg
{
public:
uint32_t button_names_length;
typedef char* _button_names_type;
_button_names_type st_button_names;
_button_names_type * button_names;
uint32_t buttons_length;
typedef bool _buttons_type;
_buttons_type st_buttons;
_buttons_type * buttons;
typedef uint8_t _wheel_type;
_wheel_type wheel;
uint32_t light_names_length;
typedef char* _light_names_type;
_light_names_type st_light_names;
_light_names_type * light_names;
uint32_t lights_length;
typedef bool _lights_type;
_lights_type st_lights;
_lights_type * lights;
NavigatorState():
button_names_length(0), button_names(NULL),
buttons_length(0), buttons(NULL),
wheel(0),
light_names_length(0), light_names(NULL),
lights_length(0), lights(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->button_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->button_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->button_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->button_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->button_names_length);
for( uint32_t i = 0; i < button_names_length; i++){
uint32_t length_button_namesi = strlen(this->button_names[i]);
varToArr(outbuffer + offset, length_button_namesi);
offset += 4;
memcpy(outbuffer + offset, this->button_names[i], length_button_namesi);
offset += length_button_namesi;
}
*(outbuffer + offset + 0) = (this->buttons_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->buttons_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->buttons_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->buttons_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->buttons_length);
for( uint32_t i = 0; i < buttons_length; i++){
union {
bool real;
uint8_t base;
} u_buttonsi;
u_buttonsi.real = this->buttons[i];
*(outbuffer + offset + 0) = (u_buttonsi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->buttons[i]);
}
*(outbuffer + offset + 0) = (this->wheel >> (8 * 0)) & 0xFF;
offset += sizeof(this->wheel);
*(outbuffer + offset + 0) = (this->light_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->light_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->light_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->light_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->light_names_length);
for( uint32_t i = 0; i < light_names_length; i++){
uint32_t length_light_namesi = strlen(this->light_names[i]);
varToArr(outbuffer + offset, length_light_namesi);
offset += 4;
memcpy(outbuffer + offset, this->light_names[i], length_light_namesi);
offset += length_light_namesi;
}
*(outbuffer + offset + 0) = (this->lights_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lights_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lights_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lights_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->lights_length);
for( uint32_t i = 0; i < lights_length; i++){
union {
bool real;
uint8_t base;
} u_lightsi;
u_lightsi.real = this->lights[i];
*(outbuffer + offset + 0) = (u_lightsi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->lights[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t button_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->button_names_length);
if(button_names_lengthT > button_names_length)
this->button_names = (char**)realloc(this->button_names, button_names_lengthT * sizeof(char*));
button_names_length = button_names_lengthT;
for( uint32_t i = 0; i < button_names_length; i++){
uint32_t length_st_button_names;
arrToVar(length_st_button_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_button_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_button_names-1]=0;
this->st_button_names = (char *)(inbuffer + offset-1);
offset += length_st_button_names;
memcpy( &(this->button_names[i]), &(this->st_button_names), sizeof(char*));
}
uint32_t buttons_lengthT = ((uint32_t) (*(inbuffer + offset)));
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->buttons_length);
if(buttons_lengthT > buttons_length)
this->buttons = (bool*)realloc(this->buttons, buttons_lengthT * sizeof(bool));
buttons_length = buttons_lengthT;
for( uint32_t i = 0; i < buttons_length; i++){
union {
bool real;
uint8_t base;
} u_st_buttons;
u_st_buttons.base = 0;
u_st_buttons.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_buttons = u_st_buttons.real;
offset += sizeof(this->st_buttons);
memcpy( &(this->buttons[i]), &(this->st_buttons), sizeof(bool));
}
this->wheel = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->wheel);
uint32_t light_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->light_names_length);
if(light_names_lengthT > light_names_length)
this->light_names = (char**)realloc(this->light_names, light_names_lengthT * sizeof(char*));
light_names_length = light_names_lengthT;
for( uint32_t i = 0; i < light_names_length; i++){
uint32_t length_st_light_names;
arrToVar(length_st_light_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_light_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_light_names-1]=0;
this->st_light_names = (char *)(inbuffer + offset-1);
offset += length_st_light_names;
memcpy( &(this->light_names[i]), &(this->st_light_names), sizeof(char*));
}
uint32_t lights_lengthT = ((uint32_t) (*(inbuffer + offset)));
lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lights_length);
if(lights_lengthT > lights_length)
this->lights = (bool*)realloc(this->lights, lights_lengthT * sizeof(bool));
lights_length = lights_lengthT;
for( uint32_t i = 0; i < lights_length; i++){
union {
bool real;
uint8_t base;
} u_st_lights;
u_st_lights.base = 0;
u_st_lights.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_lights = u_st_lights.real;
offset += sizeof(this->st_lights);
memcpy( &(this->lights[i]), &(this->st_lights), sizeof(bool));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/NavigatorState"; };
const char * getMD5(){ return "680d121a1f16a32647298b292492fffd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AnalogIOState.h | #ifndef _ROS_baxter_core_msgs_AnalogIOState_h
#define _ROS_baxter_core_msgs_AnalogIOState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace baxter_core_msgs
{
class AnalogIOState : public ros::Msg
{
public:
typedef ros::Time _timestamp_type;
_timestamp_type timestamp;
typedef double _value_type;
_value_type value;
typedef bool _isInputOnly_type;
_isInputOnly_type isInputOnly;
AnalogIOState():
timestamp(),
value(0),
isInputOnly(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->timestamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.sec);
*(outbuffer + offset + 0) = (this->timestamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.nsec);
union {
double real;
uint64_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_value.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_value.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_value.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_value.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->value);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.real = this->isInputOnly;
*(outbuffer + offset + 0) = (u_isInputOnly.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isInputOnly);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->timestamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.sec);
this->timestamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.nsec);
union {
double real;
uint64_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->value = u_value.real;
offset += sizeof(this->value);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.base = 0;
u_isInputOnly.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isInputOnly = u_isInputOnly.real;
offset += sizeof(this->isInputOnly);
return offset;
}
const char * getType(){ return "baxter_core_msgs/AnalogIOState"; };
const char * getMD5(){ return "39af371963dc9e4447e91f430c720b33"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorState.h | #ifndef _ROS_baxter_core_msgs_EndEffectorState_h
#define _ROS_baxter_core_msgs_EndEffectorState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace baxter_core_msgs
{
class EndEffectorState : public ros::Msg
{
public:
typedef ros::Time _timestamp_type;
_timestamp_type timestamp;
typedef uint32_t _id_type;
_id_type id;
typedef uint8_t _enabled_type;
_enabled_type enabled;
typedef uint8_t _calibrated_type;
_calibrated_type calibrated;
typedef uint8_t _ready_type;
_ready_type ready;
typedef uint8_t _moving_type;
_moving_type moving;
typedef uint8_t _gripping_type;
_gripping_type gripping;
typedef uint8_t _missed_type;
_missed_type missed;
typedef uint8_t _error_type;
_error_type error;
typedef uint8_t _reverse_type;
_reverse_type reverse;
typedef float _position_type;
_position_type position;
typedef float _force_type;
_force_type force;
typedef const char* _state_type;
_state_type state;
typedef const char* _command_type;
_command_type command;
typedef const char* _command_sender_type;
_command_sender_type command_sender;
typedef uint32_t _command_sequence_type;
_command_sequence_type command_sequence;
enum { STATE_FALSE = 0 };
enum { STATE_TRUE = 1 };
enum { STATE_UNKNOWN = 2 };
enum { POSITION_CLOSED = 0.0 };
enum { POSITION_OPEN = 100.0 };
enum { FORCE_MIN = 0.0 };
enum { FORCE_MAX = 100.0 };
EndEffectorState():
timestamp(),
id(0),
enabled(0),
calibrated(0),
ready(0),
moving(0),
gripping(0),
missed(0),
error(0),
reverse(0),
position(0),
force(0),
state(""),
command(""),
command_sender(""),
command_sequence(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->timestamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.sec);
*(outbuffer + offset + 0) = (this->timestamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.nsec);
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
*(outbuffer + offset + 0) = (this->enabled >> (8 * 0)) & 0xFF;
offset += sizeof(this->enabled);
*(outbuffer + offset + 0) = (this->calibrated >> (8 * 0)) & 0xFF;
offset += sizeof(this->calibrated);
*(outbuffer + offset + 0) = (this->ready >> (8 * 0)) & 0xFF;
offset += sizeof(this->ready);
*(outbuffer + offset + 0) = (this->moving >> (8 * 0)) & 0xFF;
offset += sizeof(this->moving);
*(outbuffer + offset + 0) = (this->gripping >> (8 * 0)) & 0xFF;
offset += sizeof(this->gripping);
*(outbuffer + offset + 0) = (this->missed >> (8 * 0)) & 0xFF;
offset += sizeof(this->missed);
*(outbuffer + offset + 0) = (this->error >> (8 * 0)) & 0xFF;
offset += sizeof(this->error);
*(outbuffer + offset + 0) = (this->reverse >> (8 * 0)) & 0xFF;
offset += sizeof(this->reverse);
union {
float real;
uint32_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->position);
union {
float real;
uint32_t base;
} u_force;
u_force.real = this->force;
*(outbuffer + offset + 0) = (u_force.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_force.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_force.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_force.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->force);
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
uint32_t length_command_sender = strlen(this->command_sender);
varToArr(outbuffer + offset, length_command_sender);
offset += 4;
memcpy(outbuffer + offset, this->command_sender, length_command_sender);
offset += length_command_sender;
*(outbuffer + offset + 0) = (this->command_sequence >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->command_sequence >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->command_sequence >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->command_sequence >> (8 * 3)) & 0xFF;
offset += sizeof(this->command_sequence);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->timestamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.sec);
this->timestamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.nsec);
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
this->enabled = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->enabled);
this->calibrated = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->calibrated);
this->ready = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->ready);
this->moving = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->moving);
this->gripping = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->gripping);
this->missed = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->missed);
this->error = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->error);
this->reverse = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->reverse);
union {
float real;
uint32_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->position = u_position.real;
offset += sizeof(this->position);
union {
float real;
uint32_t base;
} u_force;
u_force.base = 0;
u_force.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_force.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_force.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_force.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->force = u_force.real;
offset += sizeof(this->force);
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
uint32_t length_command;
arrToVar(length_command, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command-1]=0;
this->command = (char *)(inbuffer + offset-1);
offset += length_command;
uint32_t length_command_sender;
arrToVar(length_command_sender, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command_sender; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command_sender-1]=0;
this->command_sender = (char *)(inbuffer + offset-1);
offset += length_command_sender;
this->command_sequence = ((uint32_t) (*(inbuffer + offset)));
this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->command_sequence);
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndEffectorState"; };
const char * getMD5(){ return "ade777f069d738595bc19e246b8ec7a0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AnalogOutputCommand.h | #ifndef _ROS_baxter_core_msgs_AnalogOutputCommand_h
#define _ROS_baxter_core_msgs_AnalogOutputCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class AnalogOutputCommand : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef uint16_t _value_type;
_value_type value;
AnalogOutputCommand():
name(""),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
*(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->value >> (8 * 1)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
this->value = ((uint16_t) (*(inbuffer + offset)));
this->value |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "baxter_core_msgs/AnalogOutputCommand"; };
const char * getMD5(){ return "a7b945129a083ca4095d48aa94841d85"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CameraControl.h | #ifndef _ROS_baxter_core_msgs_CameraControl_h
#define _ROS_baxter_core_msgs_CameraControl_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class CameraControl : public ros::Msg
{
public:
typedef int32_t _id_type;
_id_type id;
typedef int32_t _value_type;
_value_type value;
enum { CAMERA_CONTROL_EXPOSURE = 100 };
enum { CAMERA_CONTROL_GAIN = 101 };
enum { CAMERA_CONTROL_WHITE_BALANCE_R = 102 };
enum { CAMERA_CONTROL_WHITE_BALANCE_G = 103 };
enum { CAMERA_CONTROL_WHITE_BALANCE_B = 104 };
enum { CAMERA_CONTROL_WINDOW_X = 105 };
enum { CAMERA_CONTROL_WINDOW_Y = 106 };
enum { CAMERA_CONTROL_FLIP = 107 };
enum { CAMERA_CONTROL_MIRROR = 108 };
enum { CAMERA_CONTROL_RESOLUTION_HALF = 109 };
CameraControl():
id(0),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "baxter_core_msgs/CameraControl"; };
const char * getMD5(){ return "01e38dd67dfb36af457f0915248629d1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorCommand.h | #ifndef _ROS_baxter_core_msgs_EndEffectorCommand_h
#define _ROS_baxter_core_msgs_EndEffectorCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class EndEffectorCommand : public ros::Msg
{
public:
typedef uint32_t _id_type;
_id_type id;
typedef const char* _command_type;
_command_type command;
typedef const char* _args_type;
_args_type args;
typedef const char* _sender_type;
_sender_type sender;
typedef uint32_t _sequence_type;
_sequence_type sequence;
enum { CMD_NO_OP = no_op };
enum { CMD_SET = set };
enum { CMD_CONFIGURE = configure };
enum { CMD_REBOOT = reboot };
enum { CMD_RESET = reset };
enum { CMD_CALIBRATE = calibrate };
enum { CMD_CLEAR_CALIBRATION = clear_calibration };
enum { CMD_PREPARE_TO_GRIP = prepare_to_grip };
enum { CMD_GRIP = grip };
enum { CMD_RELEASE = release };
enum { CMD_GO = go };
enum { CMD_STOP = stop };
EndEffectorCommand():
id(0),
command(""),
args(""),
sender(""),
sequence(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
uint32_t length_args = strlen(this->args);
varToArr(outbuffer + offset, length_args);
offset += 4;
memcpy(outbuffer + offset, this->args, length_args);
offset += length_args;
uint32_t length_sender = strlen(this->sender);
varToArr(outbuffer + offset, length_sender);
offset += 4;
memcpy(outbuffer + offset, this->sender, length_sender);
offset += length_sender;
*(outbuffer + offset + 0) = (this->sequence >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sequence >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sequence >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sequence >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
uint32_t length_command;
arrToVar(length_command, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command-1]=0;
this->command = (char *)(inbuffer + offset-1);
offset += length_command;
uint32_t length_args;
arrToVar(length_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_args-1]=0;
this->args = (char *)(inbuffer + offset-1);
offset += length_args;
uint32_t length_sender;
arrToVar(length_sender, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_sender; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_sender-1]=0;
this->sender = (char *)(inbuffer + offset-1);
offset += length_sender;
this->sequence = ((uint32_t) (*(inbuffer + offset)));
this->sequence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->sequence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->sequence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sequence);
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndEffectorCommand"; };
const char * getMD5(){ return "c003234e90416f2ca02ac7837c42cbb7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndpointState.h | #ifndef _ROS_baxter_core_msgs_EndpointState_h
#define _ROS_baxter_core_msgs_EndpointState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
#include "geometry_msgs/Wrench.h"
namespace baxter_core_msgs
{
class EndpointState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type wrench;
EndpointState():
header(),
pose(),
twist(),
wrench()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
offset += this->wrench.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
offset += this->wrench.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndpointState"; };
const char * getMD5(){ return "44bea01d596ff699fa1447bec34167ac"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/HeadPanCommand.h | #ifndef _ROS_baxter_core_msgs_HeadPanCommand_h
#define _ROS_baxter_core_msgs_HeadPanCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class HeadPanCommand : public ros::Msg
{
public:
typedef float _target_type;
_target_type target;
typedef float _speed_ratio_type;
_speed_ratio_type speed_ratio;
typedef uint8_t _enable_pan_request_type;
_enable_pan_request_type enable_pan_request;
enum { MAX_SPEED_RATIO = 1.0 };
enum { MIN_SPEED_RATIO = 0.0 };
enum { REQUEST_PAN_DISABLE = 0 };
enum { REQUEST_PAN_ENABLE = 1 };
enum { REQUEST_PAN_VOID = 2 };
HeadPanCommand():
target(0),
speed_ratio(0),
enable_pan_request(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_target;
u_target.real = this->target;
*(outbuffer + offset + 0) = (u_target.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_target.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_target.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_target.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->target);
union {
float real;
uint32_t base;
} u_speed_ratio;
u_speed_ratio.real = this->speed_ratio;
*(outbuffer + offset + 0) = (u_speed_ratio.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_speed_ratio.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_speed_ratio.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_speed_ratio.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->speed_ratio);
*(outbuffer + offset + 0) = (this->enable_pan_request >> (8 * 0)) & 0xFF;
offset += sizeof(this->enable_pan_request);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_target;
u_target.base = 0;
u_target.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_target.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_target.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_target.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->target = u_target.real;
offset += sizeof(this->target);
union {
float real;
uint32_t base;
} u_speed_ratio;
u_speed_ratio.base = 0;
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->speed_ratio = u_speed_ratio.real;
offset += sizeof(this->speed_ratio);
this->enable_pan_request = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->enable_pan_request);
return offset;
}
const char * getType(){ return "baxter_core_msgs/HeadPanCommand"; };
const char * getMD5(){ return "23b8a3f4b7ee9de7099d029e57660a8c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AssemblyStates.h | #ifndef _ROS_baxter_core_msgs_AssemblyStates_h
#define _ROS_baxter_core_msgs_AssemblyStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/AssemblyState.h"
namespace baxter_core_msgs
{
class AssemblyStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::AssemblyState _states_type;
_states_type st_states;
_states_type * states;
AssemblyStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (baxter_core_msgs::AssemblyState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::AssemblyState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(baxter_core_msgs::AssemblyState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/AssemblyStates"; };
const char * getMD5(){ return "63427318d41dbd2077c105027ad82a2b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AssemblyState.h | #ifndef _ROS_baxter_core_msgs_AssemblyState_h
#define _ROS_baxter_core_msgs_AssemblyState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class AssemblyState : public ros::Msg
{
public:
typedef bool _ready_type;
_ready_type ready;
typedef bool _enabled_type;
_enabled_type enabled;
typedef bool _stopped_type;
_stopped_type stopped;
typedef bool _error_type;
_error_type error;
typedef uint8_t _estop_button_type;
_estop_button_type estop_button;
typedef uint8_t _estop_source_type;
_estop_source_type estop_source;
enum { ESTOP_BUTTON_UNPRESSED = 0 };
enum { ESTOP_BUTTON_PRESSED = 1 };
enum { ESTOP_BUTTON_UNKNOWN = 2 };
enum { ESTOP_BUTTON_RELEASED = 3 };
enum { ESTOP_SOURCE_NONE = 0 };
enum { ESTOP_SOURCE_USER = 1 };
enum { ESTOP_SOURCE_UNKNOWN = 2 };
enum { ESTOP_SOURCE_FAULT = 3 };
enum { ESTOP_SOURCE_BRAIN = 4 };
AssemblyState():
ready(0),
enabled(0),
stopped(0),
error(0),
estop_button(0),
estop_source(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_ready;
u_ready.real = this->ready;
*(outbuffer + offset + 0) = (u_ready.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->ready);
union {
bool real;
uint8_t base;
} u_enabled;
u_enabled.real = this->enabled;
*(outbuffer + offset + 0) = (u_enabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->enabled);
union {
bool real;
uint8_t base;
} u_stopped;
u_stopped.real = this->stopped;
*(outbuffer + offset + 0) = (u_stopped.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->stopped);
union {
bool real;
uint8_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->error);
*(outbuffer + offset + 0) = (this->estop_button >> (8 * 0)) & 0xFF;
offset += sizeof(this->estop_button);
*(outbuffer + offset + 0) = (this->estop_source >> (8 * 0)) & 0xFF;
offset += sizeof(this->estop_source);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_ready;
u_ready.base = 0;
u_ready.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->ready = u_ready.real;
offset += sizeof(this->ready);
union {
bool real;
uint8_t base;
} u_enabled;
u_enabled.base = 0;
u_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->enabled = u_enabled.real;
offset += sizeof(this->enabled);
union {
bool real;
uint8_t base;
} u_stopped;
u_stopped.base = 0;
u_stopped.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->stopped = u_stopped.real;
offset += sizeof(this->stopped);
union {
bool real;
uint8_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->error = u_error.real;
offset += sizeof(this->error);
this->estop_button = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->estop_button);
this->estop_source = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->estop_source);
return offset;
}
const char * getType(){ return "baxter_core_msgs/AssemblyState"; };
const char * getMD5(){ return "356d9dd237ce73b2667da9235f541933"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/JointCommand.h | #ifndef _ROS_baxter_core_msgs_JointCommand_h
#define _ROS_baxter_core_msgs_JointCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class JointCommand : public ros::Msg
{
public:
typedef int32_t _mode_type;
_mode_type mode;
uint32_t command_length;
typedef double _command_type;
_command_type st_command;
_command_type * command;
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
enum { POSITION_MODE = 1 };
enum { VELOCITY_MODE = 2 };
enum { TORQUE_MODE = 3 };
enum { RAW_POSITION_MODE = 4 };
JointCommand():
mode(0),
command_length(0), command(NULL),
names_length(0), names(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_mode;
u_mode.real = this->mode;
*(outbuffer + offset + 0) = (u_mode.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mode.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mode.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mode.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->mode);
*(outbuffer + offset + 0) = (this->command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->command_length);
for( uint32_t i = 0; i < command_length; i++){
union {
double real;
uint64_t base;
} u_commandi;
u_commandi.real = this->command[i];
*(outbuffer + offset + 0) = (u_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->command[i]);
}
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_mode;
u_mode.base = 0;
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->mode = u_mode.real;
offset += sizeof(this->mode);
uint32_t command_lengthT = ((uint32_t) (*(inbuffer + offset)));
command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->command_length);
if(command_lengthT > command_length)
this->command = (double*)realloc(this->command, command_lengthT * sizeof(double));
command_length = command_lengthT;
for( uint32_t i = 0; i < command_length; i++){
union {
double real;
uint64_t base;
} u_st_command;
u_st_command.base = 0;
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_command = u_st_command.real;
offset += sizeof(this->st_command);
memcpy( &(this->command[i]), &(this->st_command), sizeof(double));
}
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/JointCommand"; };
const char * getMD5(){ return "19bfec8434dd568ab3c633d187c36f2e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/OpenCamera.h | #ifndef _ROS_SERVICE_OpenCamera_h
#define _ROS_SERVICE_OpenCamera_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/CameraSettings.h"
namespace baxter_core_msgs
{
static const char OPENCAMERA[] = "baxter_core_msgs/OpenCamera";
class OpenCameraRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef baxter_core_msgs::CameraSettings _settings_type;
_settings_type settings;
OpenCameraRequest():
name(""),
settings()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
offset += this->settings.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
offset += this->settings.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return OPENCAMERA; };
const char * getMD5(){ return "c4194eee32741c5a98ef8da9666fa6c9"; };
};
class OpenCameraResponse : public ros::Msg
{
public:
typedef int32_t _err_type;
_err_type err;
OpenCameraResponse():
err(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.real = this->err;
*(outbuffer + offset + 0) = (u_err.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_err.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_err.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_err.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->err);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.base = 0;
u_err.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->err = u_err.real;
offset += sizeof(this->err);
return offset;
}
const char * getType(){ return OPENCAMERA; };
const char * getMD5(){ return "b6e094011a4dfaee5eddf447220446cf"; };
};
class OpenCamera {
public:
typedef OpenCameraRequest Request;
typedef OpenCameraResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/NavigatorStates.h | #ifndef _ROS_baxter_core_msgs_NavigatorStates_h
#define _ROS_baxter_core_msgs_NavigatorStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/NavigatorState.h"
namespace baxter_core_msgs
{
class NavigatorStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::NavigatorState _states_type;
_states_type st_states;
_states_type * states;
NavigatorStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (baxter_core_msgs::NavigatorState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::NavigatorState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(baxter_core_msgs::NavigatorState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/NavigatorStates"; };
const char * getMD5(){ return "2c2eeb02fbbaa6f1ab6c680887f2db78"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/bond/Status.h | #ifndef _ROS_bond_Status_h
#define _ROS_bond_Status_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace bond
{
class Status : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _id_type;
_id_type id;
typedef const char* _instance_id_type;
_instance_id_type instance_id;
typedef bool _active_type;
_active_type active;
typedef float _heartbeat_timeout_type;
_heartbeat_timeout_type heartbeat_timeout;
typedef float _heartbeat_period_type;
_heartbeat_period_type heartbeat_period;
Status():
header(),
id(""),
instance_id(""),
active(0),
heartbeat_timeout(0),
heartbeat_period(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
uint32_t length_instance_id = strlen(this->instance_id);
varToArr(outbuffer + offset, length_instance_id);
offset += 4;
memcpy(outbuffer + offset, this->instance_id, length_instance_id);
offset += length_instance_id;
union {
bool real;
uint8_t base;
} u_active;
u_active.real = this->active;
*(outbuffer + offset + 0) = (u_active.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->active);
union {
float real;
uint32_t base;
} u_heartbeat_timeout;
u_heartbeat_timeout.real = this->heartbeat_timeout;
*(outbuffer + offset + 0) = (u_heartbeat_timeout.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_heartbeat_timeout.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_heartbeat_timeout.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_heartbeat_timeout.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->heartbeat_timeout);
union {
float real;
uint32_t base;
} u_heartbeat_period;
u_heartbeat_period.real = this->heartbeat_period;
*(outbuffer + offset + 0) = (u_heartbeat_period.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_heartbeat_period.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_heartbeat_period.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_heartbeat_period.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->heartbeat_period);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
uint32_t length_instance_id;
arrToVar(length_instance_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_instance_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_instance_id-1]=0;
this->instance_id = (char *)(inbuffer + offset-1);
offset += length_instance_id;
union {
bool real;
uint8_t base;
} u_active;
u_active.base = 0;
u_active.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->active = u_active.real;
offset += sizeof(this->active);
union {
float real;
uint32_t base;
} u_heartbeat_timeout;
u_heartbeat_timeout.base = 0;
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->heartbeat_timeout = u_heartbeat_timeout.real;
offset += sizeof(this->heartbeat_timeout);
union {
float real;
uint32_t base;
} u_heartbeat_period;
u_heartbeat_period.base = 0;
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->heartbeat_period = u_heartbeat_period.real;
offset += sizeof(this->heartbeat_period);
return offset;
}
const char * getType(){ return "bond/Status"; };
const char * getMD5(){ return "eacc84bf5d65b6777d4c50f463dfb9c8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/bond/Constants.h | #ifndef _ROS_bond_Constants_h
#define _ROS_bond_Constants_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace bond
{
class Constants : public ros::Msg
{
public:
enum { DEAD_PUBLISH_PERIOD = 0.05 };
enum { DEFAULT_CONNECT_TIMEOUT = 10.0 };
enum { DEFAULT_HEARTBEAT_TIMEOUT = 4.0 };
enum { DEFAULT_DISCONNECT_TIMEOUT = 2.0 };
enum { DEFAULT_HEARTBEAT_PERIOD = 1.0 };
enum { DISABLE_HEARTBEAT_TIMEOUT_PARAM = /bond_disable_heartbeat_timeout };
Constants()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "bond/Constants"; };
const char * getMD5(){ return "6fc594dc1d7bd7919077042712f8c8b0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/TeleportAbsolute.h | #ifndef _ROS_SERVICE_TeleportAbsolute_h
#define _ROS_SERVICE_TeleportAbsolute_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char TELEPORTABSOLUTE[] = "turtlesim/TeleportAbsolute";
class TeleportAbsoluteRequest : public ros::Msg
{
public:
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _theta_type;
_theta_type theta;
TeleportAbsoluteRequest():
x(0),
y(0),
theta(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.real = this->theta;
*(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->theta);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.base = 0;
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->theta = u_theta.real;
offset += sizeof(this->theta);
return offset;
}
const char * getType(){ return TELEPORTABSOLUTE; };
const char * getMD5(){ return "a130bc60ee6513855dc62ea83fcc5b20"; };
};
class TeleportAbsoluteResponse : public ros::Msg
{
public:
TeleportAbsoluteResponse()
{
}
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 TELEPORTABSOLUTE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class TeleportAbsolute {
public:
typedef TeleportAbsoluteRequest Request;
typedef TeleportAbsoluteResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Color.h | #ifndef _ROS_turtlesim_Color_h
#define _ROS_turtlesim_Color_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
class Color : public ros::Msg
{
public:
typedef uint8_t _r_type;
_r_type r;
typedef uint8_t _g_type;
_g_type g;
typedef uint8_t _b_type;
_b_type b;
Color():
r(0),
g(0),
b(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF;
offset += sizeof(this->r);
*(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF;
offset += sizeof(this->g);
*(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF;
offset += sizeof(this->b);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->r = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->r);
this->g = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->g);
this->b = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->b);
return offset;
}
const char * getType(){ return "turtlesim/Color"; };
const char * getMD5(){ return "353891e354491c51aabe32df673fb446"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/SetPen.h | #ifndef _ROS_SERVICE_SetPen_h
#define _ROS_SERVICE_SetPen_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char SETPEN[] = "turtlesim/SetPen";
class SetPenRequest : public ros::Msg
{
public:
typedef uint8_t _r_type;
_r_type r;
typedef uint8_t _g_type;
_g_type g;
typedef uint8_t _b_type;
_b_type b;
typedef uint8_t _width_type;
_width_type width;
typedef uint8_t _off_type;
_off_type off;
SetPenRequest():
r(0),
g(0),
b(0),
width(0),
off(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF;
offset += sizeof(this->r);
*(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF;
offset += sizeof(this->g);
*(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF;
offset += sizeof(this->b);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
offset += sizeof(this->width);
*(outbuffer + offset + 0) = (this->off >> (8 * 0)) & 0xFF;
offset += sizeof(this->off);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->r = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->r);
this->g = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->g);
this->b = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->b);
this->width = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->width);
this->off = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->off);
return offset;
}
const char * getType(){ return SETPEN; };
const char * getMD5(){ return "9f452acce566bf0c0954594f69a8e41b"; };
};
class SetPenResponse : public ros::Msg
{
public:
SetPenResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return SETPEN; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetPen {
public:
typedef SetPenRequest Request;
typedef SetPenResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Pose.h | #ifndef _ROS_turtlesim_Pose_h
#define _ROS_turtlesim_Pose_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
class Pose : public ros::Msg
{
public:
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _theta_type;
_theta_type theta;
typedef float _linear_velocity_type;
_linear_velocity_type linear_velocity;
typedef float _angular_velocity_type;
_angular_velocity_type angular_velocity;
Pose():
x(0),
y(0),
theta(0),
linear_velocity(0),
angular_velocity(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.real = this->theta;
*(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->theta);
union {
float real;
uint32_t base;
} u_linear_velocity;
u_linear_velocity.real = this->linear_velocity;
*(outbuffer + offset + 0) = (u_linear_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_linear_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_linear_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_linear_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->linear_velocity);
union {
float real;
uint32_t base;
} u_angular_velocity;
u_angular_velocity.real = this->angular_velocity;
*(outbuffer + offset + 0) = (u_angular_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angular_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angular_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angular_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angular_velocity);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.base = 0;
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->theta = u_theta.real;
offset += sizeof(this->theta);
union {
float real;
uint32_t base;
} u_linear_velocity;
u_linear_velocity.base = 0;
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->linear_velocity = u_linear_velocity.real;
offset += sizeof(this->linear_velocity);
union {
float real;
uint32_t base;
} u_angular_velocity;
u_angular_velocity.base = 0;
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angular_velocity = u_angular_velocity.real;
offset += sizeof(this->angular_velocity);
return offset;
}
const char * getType(){ return "turtlesim/Pose"; };
const char * getMD5(){ return "863b248d5016ca62ea2e895ae5265cf9"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Kill.h | #ifndef _ROS_SERVICE_Kill_h
#define _ROS_SERVICE_Kill_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char KILL[] = "turtlesim/Kill";
class KillRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
KillRequest():
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 KILL; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class KillResponse : public ros::Msg
{
public:
KillResponse()
{
}
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 KILL; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class Kill {
public:
typedef KillRequest Request;
typedef KillResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/TeleportRelative.h | #ifndef _ROS_SERVICE_TeleportRelative_h
#define _ROS_SERVICE_TeleportRelative_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char TELEPORTRELATIVE[] = "turtlesim/TeleportRelative";
class TeleportRelativeRequest : public ros::Msg
{
public:
typedef float _linear_type;
_linear_type linear;
typedef float _angular_type;
_angular_type angular;
TeleportRelativeRequest():
linear(0),
angular(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.real = this->linear;
*(outbuffer + offset + 0) = (u_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_linear.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.real = this->angular;
*(outbuffer + offset + 0) = (u_angular.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angular.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angular.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angular.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angular);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.base = 0;
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->linear = u_linear.real;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.base = 0;
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angular = u_angular.real;
offset += sizeof(this->angular);
return offset;
}
const char * getType(){ return TELEPORTRELATIVE; };
const char * getMD5(){ return "9d5c2dcd348ac8f76ce2a4307bd63a13"; };
};
class TeleportRelativeResponse : public ros::Msg
{
public:
TeleportRelativeResponse()
{
}
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 TELEPORTRELATIVE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class TeleportRelative {
public:
typedef TeleportRelativeRequest Request;
typedef TeleportRelativeResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Spawn.h | #ifndef _ROS_SERVICE_Spawn_h
#define _ROS_SERVICE_Spawn_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char SPAWN[] = "turtlesim/Spawn";
class SpawnRequest : public ros::Msg
{
public:
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _theta_type;
_theta_type theta;
typedef const char* _name_type;
_name_type name;
SpawnRequest():
x(0),
y(0),
theta(0),
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.real = this->theta;
*(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->theta);
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;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.base = 0;
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->theta = u_theta.real;
offset += sizeof(this->theta);
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 SPAWN; };
const char * getMD5(){ return "57f001c49ab7b11d699f8606c1f4f7ff"; };
};
class SpawnResponse : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
SpawnResponse():
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 SPAWN; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class Spawn {
public:
typedef SpawnRequest Request;
typedef SpawnResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_toolbox/SetPidGains.h | #ifndef _ROS_SERVICE_SetPidGains_h
#define _ROS_SERVICE_SetPidGains_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_toolbox
{
static const char SETPIDGAINS[] = "control_toolbox/SetPidGains";
class SetPidGainsRequest : public ros::Msg
{
public:
typedef double _p_type;
_p_type p;
typedef double _i_type;
_i_type i;
typedef double _d_type;
_d_type d;
typedef double _i_clamp_type;
_i_clamp_type i_clamp;
typedef bool _antiwindup_type;
_antiwindup_type antiwindup;
SetPidGainsRequest():
p(0),
i(0),
d(0),
i_clamp(0),
antiwindup(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_p;
u_p.real = this->p;
*(outbuffer + offset + 0) = (u_p.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_p.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_p.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_p.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_p.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_p.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_p.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_p.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->p);
union {
double real;
uint64_t base;
} u_i;
u_i.real = this->i;
*(outbuffer + offset + 0) = (u_i.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i);
union {
double real;
uint64_t base;
} u_d;
u_d.real = this->d;
*(outbuffer + offset + 0) = (u_d.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_d.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_d.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_d.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_d.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_d.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_d.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_d.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->d);
union {
double real;
uint64_t base;
} u_i_clamp;
u_i_clamp.real = this->i_clamp;
*(outbuffer + offset + 0) = (u_i_clamp.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_clamp.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_clamp.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_clamp.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_clamp.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_clamp.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_clamp.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_clamp.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_clamp);
union {
bool real;
uint8_t base;
} u_antiwindup;
u_antiwindup.real = this->antiwindup;
*(outbuffer + offset + 0) = (u_antiwindup.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->antiwindup);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_p;
u_p.base = 0;
u_p.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->p = u_p.real;
offset += sizeof(this->p);
union {
double real;
uint64_t base;
} u_i;
u_i.base = 0;
u_i.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i = u_i.real;
offset += sizeof(this->i);
union {
double real;
uint64_t base;
} u_d;
u_d.base = 0;
u_d.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->d = u_d.real;
offset += sizeof(this->d);
union {
double real;
uint64_t base;
} u_i_clamp;
u_i_clamp.base = 0;
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_clamp = u_i_clamp.real;
offset += sizeof(this->i_clamp);
union {
bool real;
uint8_t base;
} u_antiwindup;
u_antiwindup.base = 0;
u_antiwindup.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->antiwindup = u_antiwindup.real;
offset += sizeof(this->antiwindup);
return offset;
}
const char * getType(){ return SETPIDGAINS; };
const char * getMD5(){ return "4a43159879643e60937bf2893b633607"; };
};
class SetPidGainsResponse : public ros::Msg
{
public:
SetPidGainsResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return SETPIDGAINS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetPidGains {
public:
typedef SetPidGainsRequest Request;
typedef SetPidGainsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/GetOctomap.h | #ifndef _ROS_SERVICE_GetOctomap_h
#define _ROS_SERVICE_GetOctomap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "octomap_msgs/Octomap.h"
namespace octomap_msgs
{
static const char GETOCTOMAP[] = "octomap_msgs/GetOctomap";
class GetOctomapRequest : public ros::Msg
{
public:
GetOctomapRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return GETOCTOMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetOctomapResponse : public ros::Msg
{
public:
typedef octomap_msgs::Octomap _map_type;
_map_type map;
GetOctomapResponse():
map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETOCTOMAP; };
const char * getMD5(){ return "be9d2869d24fe40d6bc21ac21f6bb2c5"; };
};
class GetOctomap {
public:
typedef GetOctomapRequest Request;
typedef GetOctomapResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/OctomapWithPose.h | #ifndef _ROS_octomap_msgs_OctomapWithPose_h
#define _ROS_octomap_msgs_OctomapWithPose_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "octomap_msgs/Octomap.h"
namespace octomap_msgs
{
class OctomapWithPose : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _origin_type;
_origin_type origin;
typedef octomap_msgs::Octomap _octomap_type;
_octomap_type octomap;
OctomapWithPose():
header(),
origin(),
octomap()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->origin.serialize(outbuffer + offset);
offset += this->octomap.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->origin.deserialize(inbuffer + offset);
offset += this->octomap.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "octomap_msgs/OctomapWithPose"; };
const char * getMD5(){ return "20b380aca6a508a657e95526cddaf618"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/BoundingBoxQuery.h | #ifndef _ROS_SERVICE_BoundingBoxQuery_h
#define _ROS_SERVICE_BoundingBoxQuery_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Point.h"
namespace octomap_msgs
{
static const char BOUNDINGBOXQUERY[] = "octomap_msgs/BoundingBoxQuery";
class BoundingBoxQueryRequest : public ros::Msg
{
public:
typedef geometry_msgs::Point _min_type;
_min_type min;
typedef geometry_msgs::Point _max_type;
_max_type max;
BoundingBoxQueryRequest():
min(),
max()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->min.serialize(outbuffer + offset);
offset += this->max.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->min.deserialize(inbuffer + offset);
offset += this->max.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return BOUNDINGBOXQUERY; };
const char * getMD5(){ return "93aa3d73b866f04880927745f4aab303"; };
};
class BoundingBoxQueryResponse : public ros::Msg
{
public:
BoundingBoxQueryResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return BOUNDINGBOXQUERY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class BoundingBoxQuery {
public:
typedef BoundingBoxQueryRequest Request;
typedef BoundingBoxQueryResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/Octomap.h | #ifndef _ROS_octomap_msgs_Octomap_h
#define _ROS_octomap_msgs_Octomap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace octomap_msgs
{
class Octomap : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef bool _binary_type;
_binary_type binary;
typedef const char* _id_type;
_id_type id;
typedef double _resolution_type;
_resolution_type resolution;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
Octomap():
header(),
binary(0),
id(""),
resolution(0),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_binary;
u_binary.real = this->binary;
*(outbuffer + offset + 0) = (u_binary.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->binary);
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
union {
double real;
uint64_t base;
} u_resolution;
u_resolution.real = this->resolution;
*(outbuffer + offset + 0) = (u_resolution.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_resolution.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_resolution.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_resolution.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_resolution.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_resolution.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_resolution.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_resolution.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->resolution);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_binary;
u_binary.base = 0;
u_binary.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->binary = u_binary.real;
offset += sizeof(this->binary);
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
union {
double real;
uint64_t base;
} u_resolution;
u_resolution.base = 0;
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->resolution = u_resolution.real;
offset += sizeof(this->resolution);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "octomap_msgs/Octomap"; };
const char * getMD5(){ return "9a45536b45c5e409cd49f04bb2d9999f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/tf.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_TF_H_
#define ROS_TF_H_
#include "geometry_msgs/TransformStamped.h"
namespace tf
{
static inline geometry_msgs::Quaternion createQuaternionFromYaw(double yaw)
{
geometry_msgs::Quaternion q;
q.x = 0;
q.y = 0;
q.z = sin(yaw * 0.5);
q.w = cos(yaw * 0.5);
return q;
}
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/FrameGraph.h | #ifndef _ROS_SERVICE_FrameGraph_h
#define _ROS_SERVICE_FrameGraph_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf
{
static const char FRAMEGRAPH[] = "tf/FrameGraph";
class FrameGraphRequest : public ros::Msg
{
public:
FrameGraphRequest()
{
}
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 FRAMEGRAPH; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class FrameGraphResponse : public ros::Msg
{
public:
typedef const char* _dot_graph_type;
_dot_graph_type dot_graph;
FrameGraphResponse():
dot_graph("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_dot_graph = strlen(this->dot_graph);
varToArr(outbuffer + offset, length_dot_graph);
offset += 4;
memcpy(outbuffer + offset, this->dot_graph, length_dot_graph);
offset += length_dot_graph;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_dot_graph;
arrToVar(length_dot_graph, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_dot_graph; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_dot_graph-1]=0;
this->dot_graph = (char *)(inbuffer + offset-1);
offset += length_dot_graph;
return offset;
}
const char * getType(){ return FRAMEGRAPH; };
const char * getMD5(){ return "c4af9ac907e58e906eb0b6e3c58478c0"; };
};
class FrameGraph {
public:
typedef FrameGraphRequest Request;
typedef FrameGraphResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/transform_broadcaster.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ROS_TRANSFORM_BROADCASTER_H_
#define ROS_TRANSFORM_BROADCASTER_H_
#include "ros.h"
#include "tfMessage.h"
namespace tf
{
class TransformBroadcaster
{
public:
TransformBroadcaster() : publisher_("/tf", &internal_msg) {}
void init(ros::NodeHandle &nh)
{
nh.advertise(publisher_);
}
void sendTransform(geometry_msgs::TransformStamped &transform)
{
internal_msg.transforms_length = 1;
internal_msg.transforms = &transform;
publisher_.publish(&internal_msg);
}
private:
tf::tfMessage internal_msg;
ros::Publisher publisher_;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/tfMessage.h | #ifndef _ROS_tf_tfMessage_h
#define _ROS_tf_tfMessage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
namespace tf
{
class tfMessage : public ros::Msg
{
public:
uint32_t transforms_length;
typedef geometry_msgs::TransformStamped _transforms_type;
_transforms_type st_transforms;
_transforms_type * transforms;
tfMessage():
transforms_length(0), transforms(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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::TransformStamped*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
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::TransformStamped));
}
return offset;
}
const char * getType(){ return "tf/tfMessage"; };
const char * getMD5(){ return "94810edda583a504dfda3829e70d7eec"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateStatus.h | #ifndef _ROS_baxter_maintenance_msgs_UpdateStatus_h
#define _ROS_baxter_maintenance_msgs_UpdateStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class UpdateStatus : public ros::Msg
{
public:
typedef uint16_t _status_type;
_status_type status;
typedef float _progress_type;
_progress_type progress;
typedef const char* _long_description_type;
_long_description_type long_description;
enum { STS_IDLE = 0 };
enum { STS_INVALID = 1 };
enum { STS_BUSY = 2 };
enum { STS_CANCELLED = 3 };
enum { STS_ERR = 4 };
enum { STS_MOUNT_UPDATE = 5 };
enum { STS_VERIFY_UPDATE = 6 };
enum { STS_PREP_STAGING = 7 };
enum { STS_MOUNT_STAGING = 8 };
enum { STS_EXTRACT_UPDATE = 9 };
enum { STS_LOAD_KEXEC = 10 };
UpdateStatus():
status(0),
progress(0),
long_description("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status >> (8 * 1)) & 0xFF;
offset += sizeof(this->status);
union {
float real;
uint32_t base;
} u_progress;
u_progress.real = this->progress;
*(outbuffer + offset + 0) = (u_progress.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_progress.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_progress.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_progress.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->progress);
uint32_t length_long_description = strlen(this->long_description);
varToArr(outbuffer + offset, length_long_description);
offset += 4;
memcpy(outbuffer + offset, this->long_description, length_long_description);
offset += length_long_description;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->status = ((uint16_t) (*(inbuffer + offset)));
this->status |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->status);
union {
float real;
uint32_t base;
} u_progress;
u_progress.base = 0;
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->progress = u_progress.real;
offset += sizeof(this->progress);
uint32_t length_long_description;
arrToVar(length_long_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_long_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_long_description-1]=0;
this->long_description = (char *)(inbuffer + offset-1);
offset += length_long_description;
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/UpdateStatus"; };
const char * getMD5(){ return "74e246350421569590252c39e8aa7b85"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/CalibrateArmData.h | #ifndef _ROS_baxter_maintenance_msgs_CalibrateArmData_h
#define _ROS_baxter_maintenance_msgs_CalibrateArmData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class CalibrateArmData : public ros::Msg
{
public:
typedef bool _suppressWriteToFile_type;
_suppressWriteToFile_type suppressWriteToFile;
CalibrateArmData():
suppressWriteToFile(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_suppressWriteToFile;
u_suppressWriteToFile.real = this->suppressWriteToFile;
*(outbuffer + offset + 0) = (u_suppressWriteToFile.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->suppressWriteToFile);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_suppressWriteToFile;
u_suppressWriteToFile.base = 0;
u_suppressWriteToFile.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->suppressWriteToFile = u_suppressWriteToFile.real;
offset += sizeof(this->suppressWriteToFile);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/CalibrateArmData"; };
const char * getMD5(){ return "ba9ee949ea363f7bcfc8cc74e0bcb69d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/CalibrateArmEnable.h | #ifndef _ROS_baxter_maintenance_msgs_CalibrateArmEnable_h
#define _ROS_baxter_maintenance_msgs_CalibrateArmEnable_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_maintenance_msgs/CalibrateArmData.h"
namespace baxter_maintenance_msgs
{
class CalibrateArmEnable : public ros::Msg
{
public:
typedef bool _isEnabled_type;
_isEnabled_type isEnabled;
typedef const char* _uid_type;
_uid_type uid;
typedef baxter_maintenance_msgs::CalibrateArmData _data_type;
_data_type data;
CalibrateArmEnable():
isEnabled(0),
uid(""),
data()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.real = this->isEnabled;
*(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isEnabled);
uint32_t length_uid = strlen(this->uid);
varToArr(outbuffer + offset, length_uid);
offset += 4;
memcpy(outbuffer + offset, this->uid, length_uid);
offset += length_uid;
offset += this->data.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.base = 0;
u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isEnabled = u_isEnabled.real;
offset += sizeof(this->isEnabled);
uint32_t length_uid;
arrToVar(length_uid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uid-1]=0;
this->uid = (char *)(inbuffer + offset-1);
offset += length_uid;
offset += this->data.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/CalibrateArmEnable"; };
const char * getMD5(){ return "d7ff300fd410d4ac849664ab8143da39"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateSources.h | #ifndef _ROS_baxter_maintenance_msgs_UpdateSources_h
#define _ROS_baxter_maintenance_msgs_UpdateSources_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_maintenance_msgs/UpdateSource.h"
namespace baxter_maintenance_msgs
{
class UpdateSources : public ros::Msg
{
public:
typedef const char* _uuid_type;
_uuid_type uuid;
uint32_t sources_length;
typedef baxter_maintenance_msgs::UpdateSource _sources_type;
_sources_type st_sources;
_sources_type * sources;
UpdateSources():
uuid(""),
sources_length(0), sources(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_uuid = strlen(this->uuid);
varToArr(outbuffer + offset, length_uuid);
offset += 4;
memcpy(outbuffer + offset, this->uuid, length_uuid);
offset += length_uuid;
*(outbuffer + offset + 0) = (this->sources_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sources_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sources_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sources_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sources_length);
for( uint32_t i = 0; i < sources_length; i++){
offset += this->sources[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_uuid;
arrToVar(length_uuid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uuid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uuid-1]=0;
this->uuid = (char *)(inbuffer + offset-1);
offset += length_uuid;
uint32_t sources_lengthT = ((uint32_t) (*(inbuffer + offset)));
sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sources_length);
if(sources_lengthT > sources_length)
this->sources = (baxter_maintenance_msgs::UpdateSource*)realloc(this->sources, sources_lengthT * sizeof(baxter_maintenance_msgs::UpdateSource));
sources_length = sources_lengthT;
for( uint32_t i = 0; i < sources_length; i++){
offset += this->st_sources.deserialize(inbuffer + offset);
memcpy( &(this->sources[i]), &(this->st_sources), sizeof(baxter_maintenance_msgs::UpdateSource));
}
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/UpdateSources"; };
const char * getMD5(){ return "b3b428bf55e80e83d378830c33b3405b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateSource.h | #ifndef _ROS_baxter_maintenance_msgs_UpdateSource_h
#define _ROS_baxter_maintenance_msgs_UpdateSource_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class UpdateSource : public ros::Msg
{
public:
typedef const char* _devname_type;
_devname_type devname;
typedef const char* _filename_type;
_filename_type filename;
typedef const char* _version_type;
_version_type version;
typedef const char* _uuid_type;
_uuid_type uuid;
UpdateSource():
devname(""),
filename(""),
version(""),
uuid("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_devname = strlen(this->devname);
varToArr(outbuffer + offset, length_devname);
offset += 4;
memcpy(outbuffer + offset, this->devname, length_devname);
offset += length_devname;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
uint32_t length_version = strlen(this->version);
varToArr(outbuffer + offset, length_version);
offset += 4;
memcpy(outbuffer + offset, this->version, length_version);
offset += length_version;
uint32_t length_uuid = strlen(this->uuid);
varToArr(outbuffer + offset, length_uuid);
offset += 4;
memcpy(outbuffer + offset, this->uuid, length_uuid);
offset += length_uuid;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_devname;
arrToVar(length_devname, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_devname; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_devname-1]=0;
this->devname = (char *)(inbuffer + offset-1);
offset += length_devname;
uint32_t length_filename;
arrToVar(length_filename, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_filename; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_filename-1]=0;
this->filename = (char *)(inbuffer + offset-1);
offset += length_filename;
uint32_t length_version;
arrToVar(length_version, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_version; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_version-1]=0;
this->version = (char *)(inbuffer + offset-1);
offset += length_version;
uint32_t length_uuid;
arrToVar(length_uuid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uuid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uuid-1]=0;
this->uuid = (char *)(inbuffer + offset-1);
offset += length_uuid;
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/UpdateSource"; };
const char * getMD5(){ return "88ad69e3ed4d619e167c9d83e6d9310f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/TareEnable.h | #ifndef _ROS_baxter_maintenance_msgs_TareEnable_h
#define _ROS_baxter_maintenance_msgs_TareEnable_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_maintenance_msgs/TareData.h"
namespace baxter_maintenance_msgs
{
class TareEnable : public ros::Msg
{
public:
typedef bool _isEnabled_type;
_isEnabled_type isEnabled;
typedef const char* _uid_type;
_uid_type uid;
typedef baxter_maintenance_msgs::TareData _data_type;
_data_type data;
TareEnable():
isEnabled(0),
uid(""),
data()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.real = this->isEnabled;
*(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isEnabled);
uint32_t length_uid = strlen(this->uid);
varToArr(outbuffer + offset, length_uid);
offset += 4;
memcpy(outbuffer + offset, this->uid, length_uid);
offset += length_uid;
offset += this->data.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.base = 0;
u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isEnabled = u_isEnabled.real;
offset += sizeof(this->isEnabled);
uint32_t length_uid;
arrToVar(length_uid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uid-1]=0;
this->uid = (char *)(inbuffer + offset-1);
offset += length_uid;
offset += this->data.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/TareEnable"; };
const char * getMD5(){ return "1d38ec0923789ab928453d933bef8c51"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/TareData.h | #ifndef _ROS_baxter_maintenance_msgs_TareData_h
#define _ROS_baxter_maintenance_msgs_TareData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class TareData : public ros::Msg
{
public:
typedef bool _tuneGravitySpring_type;
_tuneGravitySpring_type tuneGravitySpring;
TareData():
tuneGravitySpring(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_tuneGravitySpring;
u_tuneGravitySpring.real = this->tuneGravitySpring;
*(outbuffer + offset + 0) = (u_tuneGravitySpring.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->tuneGravitySpring);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_tuneGravitySpring;
u_tuneGravitySpring.base = 0;
u_tuneGravitySpring.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->tuneGravitySpring = u_tuneGravitySpring.real;
offset += sizeof(this->tuneGravitySpring);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/TareData"; };
const char * getMD5(){ return "241e9c2ceee7da9db50693da0b3f2741"; };
};
}
#endif
|
Subsets and Splits