Obbart/RoboGlue_ROS
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Filet temporaei eliminati prima della ricompilazione

Browse Source
This commit is contained in:
Emanuele
2019-11-14 16:10:59 +01:00
parent e3b88fe742
commit c9108aaa54
54 changed files with 0 additions and 11303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

289
devel/include/jog_msgs/JogFrame.h
View File

@@ -1,289 +0,0 @@
// Generated by gencpp from file jog_msgs/JogFrame.msg
// DO NOT EDIT!
#ifndef JOG_MSGS_MESSAGE_JOGFRAME_H
#define JOG_MSGS_MESSAGE_JOGFRAME_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Vector3.h>
namespace jog_msgs
{
template <class ContainerAllocator>
struct JogFrame_
{
typedef JogFrame_<ContainerAllocator> Type;
JogFrame_()
: header()
, group_name()
, link_name()
, linear_delta()
, angular_delta()
, avoid_collisions(false) {
}
JogFrame_(const ContainerAllocator& _alloc)
: header(_alloc)
, group_name(_alloc)
, link_name(_alloc)
, linear_delta(_alloc)
, angular_delta(_alloc)
, avoid_collisions(false) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _group_name_type;
_group_name_type group_name;
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _link_name_type;
_link_name_type link_name;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _linear_delta_type;
_linear_delta_type linear_delta;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _angular_delta_type;
_angular_delta_type angular_delta;
typedef uint8_t _avoid_collisions_type;
_avoid_collisions_type avoid_collisions;
typedef boost::shared_ptr< ::jog_msgs::JogFrame_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::jog_msgs::JogFrame_<ContainerAllocator> const> ConstPtr;
}; // struct JogFrame_
typedef ::jog_msgs::JogFrame_<std::allocator<void> > JogFrame;
typedef boost::shared_ptr< ::jog_msgs::JogFrame > JogFramePtr;
typedef boost::shared_ptr< ::jog_msgs::JogFrame const> JogFrameConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::jog_msgs::JogFrame_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::jog_msgs::JogFrame_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace jog_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True}
// {'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'jog_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/jog_arm/jog_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::jog_msgs::JogFrame_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::jog_msgs::JogFrame_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::jog_msgs::JogFrame_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::jog_msgs::JogFrame_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::jog_msgs::JogFrame_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::jog_msgs::JogFrame_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::jog_msgs::JogFrame_<ContainerAllocator> >
{
static const char* value()
{
return "e342f29bf6beaf00261bdae365abfff9";
}
static const char* value(const ::jog_msgs::JogFrame_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xe342f29bf6beaf00ULL;
static const uint64_t static_value2 = 0x261bdae365abfff9ULL;
};
template<class ContainerAllocator>
struct DataType< ::jog_msgs::JogFrame_<ContainerAllocator> >
{
static const char* value()
{
return "jog_msgs/JogFrame";
}
static const char* value(const ::jog_msgs::JogFrame_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::jog_msgs::JogFrame_<ContainerAllocator> >
{
static const char* value()
{
return "# This is a message to hold data to jog by specifying a target\n\
# frame. It uses MoveIt! kinematics, so you need to specify the\n\
# JointGroup name to use in group_name. (lienar|angular)_delta is the\n\
# amount of displacement.\n\
\n\
# header message. You must set frame_id to define the reference\n\
# coordinate system of the displacament\n\
Header header\n\
\n\
# Name of JointGroup of MoveIt!\n\
string group_name\n\
\n\
# Target link name to jog. The link must be in the JoingGroup\n\
string link_name\n\
\n\
# Linear displacement vector to jog. The refrence frame is defined by\n\
# frame_id in header. Unit is in meter.\n\
geometry_msgs/Vector3 linear_delta\n\
\n\
# Angular displacement vector to jog. The refrence frame is defined by\n\
# frame_id in header. Unit is in radian.\n\
geometry_msgs/Vector3 angular_delta\n\
\n\
# It uses avoid_collisions option of MoveIt! kinematics. If it is\n\
# true, the robot doesn't move if any collisions occured.\n\
bool avoid_collisions\n\
\n\
================================================================================\n\
MSG: std_msgs/Header\n\
# Standard metadata for higher-level stamped data types.\n\
# This is generally used to communicate timestamped data \n\
# in a particular coordinate frame.\n\
# \n\
# sequence ID: consecutively increasing ID \n\
uint32 seq\n\
#Two-integer timestamp that is expressed as:\n\
# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
# time-handling sugar is provided by the client library\n\
time stamp\n\
#Frame this data is associated with\n\
# 0: no frame\n\
# 1: global frame\n\
string frame_id\n\
\n\
================================================================================\n\
MSG: geometry_msgs/Vector3\n\
# This represents a vector in free space. \n\
# It is only meant to represent a direction. Therefore, it does not\n\
# make sense to apply a translation to it (e.g., when applying a \n\
# generic rigid transformation to a Vector3, tf2 will only apply the\n\
# rotation). If you want your data to be translatable too, use the\n\
# geometry_msgs/Point message instead.\n\
\n\
float64 x\n\
float64 y\n\
float64 z\n\
";
}
static const char* value(const ::jog_msgs::JogFrame_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::jog_msgs::JogFrame_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.group_name);
stream.next(m.link_name);
stream.next(m.linear_delta);
stream.next(m.angular_delta);
stream.next(m.avoid_collisions);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct JogFrame_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::jog_msgs::JogFrame_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::jog_msgs::JogFrame_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "group_name: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.group_name);
s << indent << "link_name: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.link_name);
s << indent << "linear_delta: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.linear_delta);
s << indent << "angular_delta: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.angular_delta);
s << indent << "avoid_collisions: ";
Printer<uint8_t>::stream(s, indent + " ", v.avoid_collisions);
}
};
} // namespace message_operations
} // namespace ros
#endif // JOG_MSGS_MESSAGE_JOGFRAME_H

246
devel/include/jog_msgs/JogJoint.h
View File

@@ -1,246 +0,0 @@
// Generated by gencpp from file jog_msgs/JogJoint.msg
// DO NOT EDIT!
#ifndef JOG_MSGS_MESSAGE_JOGJOINT_H
#define JOG_MSGS_MESSAGE_JOGJOINT_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
namespace jog_msgs
{
template <class ContainerAllocator>
struct JogJoint_
{
typedef JogJoint_<ContainerAllocator> Type;
JogJoint_()
: header()
, joint_names()
, deltas() {
}
JogJoint_(const ContainerAllocator& _alloc)
: header(_alloc)
, joint_names(_alloc)
, deltas(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > _joint_names_type;
_joint_names_type joint_names;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _deltas_type;
_deltas_type deltas;
typedef boost::shared_ptr< ::jog_msgs::JogJoint_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::jog_msgs::JogJoint_<ContainerAllocator> const> ConstPtr;
}; // struct JogJoint_
typedef ::jog_msgs::JogJoint_<std::allocator<void> > JogJoint;
typedef boost::shared_ptr< ::jog_msgs::JogJoint > JogJointPtr;
typedef boost::shared_ptr< ::jog_msgs::JogJoint const> JogJointConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::jog_msgs::JogJoint_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::jog_msgs::JogJoint_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace jog_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True}
// {'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'jog_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/jog_arm/jog_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::jog_msgs::JogJoint_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::jog_msgs::JogJoint_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::jog_msgs::JogJoint_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::jog_msgs::JogJoint_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::jog_msgs::JogJoint_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::jog_msgs::JogJoint_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::jog_msgs::JogJoint_<ContainerAllocator> >
{
static const char* value()
{
return "8d2aa14be64b51cf6374d198bfd489b2";
}
static const char* value(const ::jog_msgs::JogJoint_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8d2aa14be64b51cfULL;
static const uint64_t static_value2 = 0x6374d198bfd489b2ULL;
};
template<class ContainerAllocator>
struct DataType< ::jog_msgs::JogJoint_<ContainerAllocator> >
{
static const char* value()
{
return "jog_msgs/JogJoint";
}
static const char* value(const ::jog_msgs::JogJoint_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::jog_msgs::JogJoint_<ContainerAllocator> >
{
static const char* value()
{
return "# This is a message to hold data to jog by specifying joint\n\
# displacement. You only need to set relative displacement to joint\n\
# angles (or displacements for linear joints).\n\
\n\
# header message. You must set frame_id to define the reference\n\
# coordinate system of the displacament\n\
Header header\n\
\n\
# Name list of the joints. You don't need to specify all joint of the\n\
# robot. Joint names are case-sensitive.\n\
string[] joint_names\n\
\n\
# Relative displacement of the joints to jog. The order must be\n\
# identical to joint_names. Unit is in radian for revolutive joints,\n\
# meter for linear joints.\n\
float64[] deltas\n\
\n\
================================================================================\n\
MSG: std_msgs/Header\n\
# Standard metadata for higher-level stamped data types.\n\
# This is generally used to communicate timestamped data \n\
# in a particular coordinate frame.\n\
# \n\
# sequence ID: consecutively increasing ID \n\
uint32 seq\n\
#Two-integer timestamp that is expressed as:\n\
# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
# time-handling sugar is provided by the client library\n\
time stamp\n\
#Frame this data is associated with\n\
# 0: no frame\n\
# 1: global frame\n\
string frame_id\n\
";
}
static const char* value(const ::jog_msgs::JogJoint_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::jog_msgs::JogJoint_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.joint_names);
stream.next(m.deltas);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct JogJoint_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::jog_msgs::JogJoint_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::jog_msgs::JogJoint_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "joint_names[]" << std::endl;
for (size_t i = 0; i < v.joint_names.size(); ++i)
{
s << indent << " joint_names[" << i << "]: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.joint_names[i]);
}
s << indent << "deltas[]" << std::endl;
for (size_t i = 0; i < v.deltas.size(); ++i)
{
s << indent << " deltas[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.deltas[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // JOG_MSGS_MESSAGE_JOGJOINT_H

487
devel/include/ur_driver/URDriverConfig.h
View File

@@ -1,487 +0,0 @@
//#line 2 "/opt/ros/kinetic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
// *********************************************************
//
// File autogenerated for the ur_driver package
// by the dynamic_reconfigure package.
// Please do not edit.
//
// ********************************************************/
#ifndef __ur_driver__URDRIVERCONFIG_H__
#define __ur_driver__URDRIVERCONFIG_H__
#if __cplusplus >= 201103L
#define DYNAMIC_RECONFIGURE_FINAL final
#else
#define DYNAMIC_RECONFIGURE_FINAL
#endif
#include <dynamic_reconfigure/config_tools.h>
#include <limits>
#include <ros/node_handle.h>
#include <dynamic_reconfigure/ConfigDescription.h>
#include <dynamic_reconfigure/ParamDescription.h>
#include <dynamic_reconfigure/Group.h>
#include <dynamic_reconfigure/config_init_mutex.h>
#include <boost/any.hpp>
namespace ur_driver
{
class URDriverConfigStatics;
class URDriverConfig
{
public:
class AbstractParamDescription : public dynamic_reconfigure::ParamDescription
{
public:
AbstractParamDescription(std::string n, std::string t, uint32_t l,
std::string d, std::string e)
{
name = n;
type = t;
level = l;
description = d;
edit_method = e;
}
virtual void clamp(URDriverConfig &config, const URDriverConfig &max, const URDriverConfig &min) const = 0;
virtual void calcLevel(uint32_t &level, const URDriverConfig &config1, const URDriverConfig &config2) const = 0;
virtual void fromServer(const ros::NodeHandle &nh, URDriverConfig &config) const = 0;
virtual void toServer(const ros::NodeHandle &nh, const URDriverConfig &config) const = 0;
virtual bool fromMessage(const dynamic_reconfigure::Config &msg, URDriverConfig &config) const = 0;
virtual void toMessage(dynamic_reconfigure::Config &msg, const URDriverConfig &config) const = 0;
virtual void getValue(const URDriverConfig &config, boost::any &val) const = 0;
};
typedef boost::shared_ptr<AbstractParamDescription> AbstractParamDescriptionPtr;
typedef boost::shared_ptr<const AbstractParamDescription> AbstractParamDescriptionConstPtr;
// Final keyword added to class because it has virtual methods and inherits
// from a class with a non-virtual destructor.
template <class T>
class ParamDescription DYNAMIC_RECONFIGURE_FINAL : public AbstractParamDescription
{
public:
ParamDescription(std::string a_name, std::string a_type, uint32_t a_level,
std::string a_description, std::string a_edit_method, T URDriverConfig::* a_f) :
AbstractParamDescription(a_name, a_type, a_level, a_description, a_edit_method),
field(a_f)
{}
T (URDriverConfig::* field);
virtual void clamp(URDriverConfig &config, const URDriverConfig &max, const URDriverConfig &min) const
{
if (config.*field > max.*field)
config.*field = max.*field;
if (config.*field < min.*field)
config.*field = min.*field;
}
virtual void calcLevel(uint32_t &comb_level, const URDriverConfig &config1, const URDriverConfig &config2) const
{
if (config1.*field != config2.*field)
comb_level |= level;
}
virtual void fromServer(const ros::NodeHandle &nh, URDriverConfig &config) const
{
nh.getParam(name, config.*field);
}
virtual void toServer(const ros::NodeHandle &nh, const URDriverConfig &config) const
{
nh.setParam(name, config.*field);
}
virtual bool fromMessage(const dynamic_reconfigure::Config &msg, URDriverConfig &config) const
{
return dynamic_reconfigure::ConfigTools::getParameter(msg, name, config.*field);
}
virtual void toMessage(dynamic_reconfigure::Config &msg, const URDriverConfig &config) const
{
dynamic_reconfigure::ConfigTools::appendParameter(msg, name, config.*field);
}
virtual void getValue(const URDriverConfig &config, boost::any &val) const
{
val = config.*field;
}
};
class AbstractGroupDescription : public dynamic_reconfigure::Group
{
public:
AbstractGroupDescription(std::string n, std::string t, int p, int i, bool s)
{
name = n;
type = t;
parent = p;
state = s;
id = i;
}
std::vector<AbstractParamDescriptionConstPtr> abstract_parameters;
bool state;
virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &config) const = 0;
virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &config) const =0;
virtual void updateParams(boost::any &cfg, URDriverConfig &top) const= 0;
virtual void setInitialState(boost::any &cfg) const = 0;
void convertParams()
{
for(std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = abstract_parameters.begin(); i != abstract_parameters.end(); ++i)
{
parameters.push_back(dynamic_reconfigure::ParamDescription(**i));
}
}
};
typedef boost::shared_ptr<AbstractGroupDescription> AbstractGroupDescriptionPtr;
typedef boost::shared_ptr<const AbstractGroupDescription> AbstractGroupDescriptionConstPtr;
// Final keyword added to class because it has virtual methods and inherits
// from a class with a non-virtual destructor.
template<class T, class PT>
class GroupDescription DYNAMIC_RECONFIGURE_FINAL : public AbstractGroupDescription
{
public:
GroupDescription(std::string a_name, std::string a_type, int a_parent, int a_id, bool a_s, T PT::* a_f) : AbstractGroupDescription(a_name, a_type, a_parent, a_id, a_s), field(a_f)
{
}
GroupDescription(const GroupDescription<T, PT>& g): AbstractGroupDescription(g.name, g.type, g.parent, g.id, g.state), field(g.field), groups(g.groups)
{
parameters = g.parameters;
abstract_parameters = g.abstract_parameters;
}
virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &cfg) const
{
PT* config = boost::any_cast<PT*>(cfg);
if(!dynamic_reconfigure::ConfigTools::getGroupState(msg, name, (*config).*field))
return false;
for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
{
boost::any n = &((*config).*field);
if(!(*i)->fromMessage(msg, n))
return false;
}
return true;
}
virtual void setInitialState(boost::any &cfg) const
{
PT* config = boost::any_cast<PT*>(cfg);
T* group = &((*config).*field);
group->state = state;
for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
{
boost::any n = boost::any(&((*config).*field));
(*i)->setInitialState(n);
}
}
virtual void updateParams(boost::any &cfg, URDriverConfig &top) const
{
PT* config = boost::any_cast<PT*>(cfg);
T* f = &((*config).*field);
f->setParams(top, abstract_parameters);
for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
{
boost::any n = &((*config).*field);
(*i)->updateParams(n, top);
}
}
virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &cfg) const
{
const PT config = boost::any_cast<PT>(cfg);
dynamic_reconfigure::ConfigTools::appendGroup<T>(msg, name, id, parent, config.*field);
for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
{
(*i)->toMessage(msg, config.*field);
}
}
T (PT::* field);
std::vector<URDriverConfig::AbstractGroupDescriptionConstPtr> groups;
};
class DEFAULT
{
public:
DEFAULT()
{
state = true;
name = "Default";
}
void setParams(URDriverConfig &config, const std::vector<AbstractParamDescriptionConstPtr> params)
{
for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator _i = params.begin(); _i != params.end(); ++_i)
{
boost::any val;
(*_i)->getValue(config, val);
if("prevent_programming"==(*_i)->name){prevent_programming = boost::any_cast<bool>(val);}
}
}
bool prevent_programming;
bool state;
std::string name;
}groups;
//#line 290 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
bool prevent_programming;
//#line 228 "/opt/ros/kinetic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
bool __fromMessage__(dynamic_reconfigure::Config &msg)
{
const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
int count = 0;
for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
if ((*i)->fromMessage(msg, *this))
count++;
for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i ++)
{
if ((*i)->id == 0)
{
boost::any n = boost::any(this);
(*i)->updateParams(n, *this);
(*i)->fromMessage(msg, n);
}
}
if (count != dynamic_reconfigure::ConfigTools::size(msg))
{
ROS_ERROR("URDriverConfig::__fromMessage__ called with an unexpected parameter.");
ROS_ERROR("Booleans:");
for (unsigned int i = 0; i < msg.bools.size(); i++)
ROS_ERROR(" %s", msg.bools[i].name.c_str());
ROS_ERROR("Integers:");
for (unsigned int i = 0; i < msg.ints.size(); i++)
ROS_ERROR(" %s", msg.ints[i].name.c_str());
ROS_ERROR("Doubles:");
for (unsigned int i = 0; i < msg.doubles.size(); i++)
ROS_ERROR(" %s", msg.doubles[i].name.c_str());
ROS_ERROR("Strings:");
for (unsigned int i = 0; i < msg.strs.size(); i++)
ROS_ERROR(" %s", msg.strs[i].name.c_str());
// @todo Check that there are no duplicates. Make this error more
// explicit.
return false;
}
return true;
}
// This version of __toMessage__ is used during initialization of
// statics when __getParamDescriptions__ can't be called yet.
void __toMessage__(dynamic_reconfigure::Config &msg, const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__, const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__) const
{
dynamic_reconfigure::ConfigTools::clear(msg);
for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
(*i)->toMessage(msg, *this);
for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
{
if((*i)->id == 0)
{
(*i)->toMessage(msg, *this);
}
}
}
void __toMessage__(dynamic_reconfigure::Config &msg) const
{
const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
__toMessage__(msg, __param_descriptions__, __group_descriptions__);
}
void __toServer__(const ros::NodeHandle &nh) const
{
const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
(*i)->toServer(nh, *this);
}
void __fromServer__(const ros::NodeHandle &nh)
{
static bool setup=false;
const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
(*i)->fromServer(nh, *this);
const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i++){
if (!setup && (*i)->id == 0) {
setup = true;
boost::any n = boost::any(this);
(*i)->setInitialState(n);
}
}
}
void __clamp__()
{
const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
const URDriverConfig &__max__ = __getMax__();
const URDriverConfig &__min__ = __getMin__();
for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
(*i)->clamp(*this, __max__, __min__);
}
uint32_t __level__(const URDriverConfig &config) const
{
const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
uint32_t level = 0;
for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
(*i)->calcLevel(level, config, *this);
return level;
}
static const dynamic_reconfigure::ConfigDescription &__getDescriptionMessage__();
static const URDriverConfig &__getDefault__();
static const URDriverConfig &__getMax__();
static const URDriverConfig &__getMin__();
static const std::vector<AbstractParamDescriptionConstPtr> &__getParamDescriptions__();
static const std::vector<AbstractGroupDescriptionConstPtr> &__getGroupDescriptions__();
private:
static const URDriverConfigStatics *__get_statics__();
};
template <> // Max and min are ignored for strings.
inline void URDriverConfig::ParamDescription<std::string>::clamp(URDriverConfig &config, const URDriverConfig &max, const URDriverConfig &min) const
{
(void) config;
(void) min;
(void) max;
return;
}
class URDriverConfigStatics
{
friend class URDriverConfig;
URDriverConfigStatics()
{
URDriverConfig::GroupDescription<URDriverConfig::DEFAULT, URDriverConfig> Default("Default", "", 0, 0, true, &URDriverConfig::groups);
//#line 290 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
__min__.prevent_programming = 0;
//#line 290 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
__max__.prevent_programming = 1;
//#line 290 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
__default__.prevent_programming = 0;
//#line 290 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
Default.abstract_parameters.push_back(URDriverConfig::AbstractParamDescriptionConstPtr(new URDriverConfig::ParamDescription<bool>("prevent_programming", "bool", 0, "Prevent driver from continuously uploading 'prog'", "", &URDriverConfig::prevent_programming)));
//#line 290 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
__param_descriptions__.push_back(URDriverConfig::AbstractParamDescriptionConstPtr(new URDriverConfig::ParamDescription<bool>("prevent_programming", "bool", 0, "Prevent driver from continuously uploading 'prog'", "", &URDriverConfig::prevent_programming)));
//#line 245 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
Default.convertParams();
//#line 245 "/opt/ros/kinetic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
__group_descriptions__.push_back(URDriverConfig::AbstractGroupDescriptionConstPtr(new URDriverConfig::GroupDescription<URDriverConfig::DEFAULT, URDriverConfig>(Default)));
//#line 366 "/opt/ros/kinetic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
for (std::vector<URDriverConfig::AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
{
__description_message__.groups.push_back(**i);
}
__max__.__toMessage__(__description_message__.max, __param_descriptions__, __group_descriptions__);
__min__.__toMessage__(__description_message__.min, __param_descriptions__, __group_descriptions__);
__default__.__toMessage__(__description_message__.dflt, __param_descriptions__, __group_descriptions__);
}
std::vector<URDriverConfig::AbstractParamDescriptionConstPtr> __param_descriptions__;
std::vector<URDriverConfig::AbstractGroupDescriptionConstPtr> __group_descriptions__;
URDriverConfig __max__;
URDriverConfig __min__;
URDriverConfig __default__;
dynamic_reconfigure::ConfigDescription __description_message__;
static const URDriverConfigStatics *get_instance()
{
// Split this off in a separate function because I know that
// instance will get initialized the first time get_instance is
// called, and I am guaranteeing that get_instance gets called at
// most once.
static URDriverConfigStatics instance;
return &instance;
}
};
inline const dynamic_reconfigure::ConfigDescription &URDriverConfig::__getDescriptionMessage__()
{
return __get_statics__()->__description_message__;
}
inline const URDriverConfig &URDriverConfig::__getDefault__()
{
return __get_statics__()->__default__;
}
inline const URDriverConfig &URDriverConfig::__getMax__()
{
return __get_statics__()->__max__;
}
inline const URDriverConfig &URDriverConfig::__getMin__()
{
return __get_statics__()->__min__;
}
inline const std::vector<URDriverConfig::AbstractParamDescriptionConstPtr> &URDriverConfig::__getParamDescriptions__()
{
return __get_statics__()->__param_descriptions__;
}
inline const std::vector<URDriverConfig::AbstractGroupDescriptionConstPtr> &URDriverConfig::__getGroupDescriptions__()
{
return __get_statics__()->__group_descriptions__;
}
inline const URDriverConfigStatics *URDriverConfig::__get_statics__()
{
const static URDriverConfigStatics *statics;
if (statics) // Common case
return statics;
boost::mutex::scoped_lock lock(dynamic_reconfigure::__init_mutex__);
if (statics) // In case we lost a race.
return statics;
statics = URDriverConfigStatics::get_instance();
return statics;
}
}
#undef DYNAMIC_RECONFIGURE_FINAL
#endif // __URDRIVERRECONFIGURATOR_H__

216
devel/include/ur_msgs/Analog.h
View File

@@ -1,216 +0,0 @@
// Generated by gencpp from file ur_msgs/Analog.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_ANALOG_H
#define UR_MSGS_MESSAGE_ANALOG_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace ur_msgs
{
template <class ContainerAllocator>
struct Analog_
{
typedef Analog_<ContainerAllocator> Type;
Analog_()
: pin(0)
, domain(0)
, state(0.0) {
}
Analog_(const ContainerAllocator& _alloc)
: pin(0)
, domain(0)
, state(0.0) {
(void)_alloc;
}
typedef uint8_t _pin_type;
_pin_type pin;
typedef uint8_t _domain_type;
_domain_type domain;
typedef float _state_type;
_state_type state;
enum {
VOLTAGE = 0u,
CURRENT = 1u,
};
typedef boost::shared_ptr< ::ur_msgs::Analog_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ur_msgs::Analog_<ContainerAllocator> const> ConstPtr;
}; // struct Analog_
typedef ::ur_msgs::Analog_<std::allocator<void> > Analog;
typedef boost::shared_ptr< ::ur_msgs::Analog > AnalogPtr;
typedef boost::shared_ptr< ::ur_msgs::Analog const> AnalogConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ur_msgs::Analog_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ur_msgs::Analog_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ur_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'ur_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/universal_robot/ur_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::Analog_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::Analog_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::Analog_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::Analog_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::Analog_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::Analog_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ur_msgs::Analog_<ContainerAllocator> >
{
static const char* value()
{
return "f41c08a810adf63713aec88712cd553d";
}
static const char* value(const ::ur_msgs::Analog_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xf41c08a810adf637ULL;
static const uint64_t static_value2 = 0x13aec88712cd553dULL;
};
template<class ContainerAllocator>
struct DataType< ::ur_msgs::Analog_<ContainerAllocator> >
{
static const char* value()
{
return "ur_msgs/Analog";
}
static const char* value(const ::ur_msgs::Analog_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ur_msgs::Analog_<ContainerAllocator> >
{
static const char* value()
{
return "uint8 VOLTAGE=0\n\
uint8 CURRENT=1\n\
\n\
uint8 pin\n\
uint8 domain # can be VOLTAGE or CURRENT\n\
float32 state\n\
";
}
static const char* value(const ::ur_msgs::Analog_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ur_msgs::Analog_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.pin);
stream.next(m.domain);
stream.next(m.state);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Analog_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ur_msgs::Analog_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ur_msgs::Analog_<ContainerAllocator>& v)
{
s << indent << "pin: ";
Printer<uint8_t>::stream(s, indent + " ", v.pin);
s << indent << "domain: ";
Printer<uint8_t>::stream(s, indent + " ", v.domain);
s << indent << "state: ";
Printer<float>::stream(s, indent + " ", v.state);
}
};
} // namespace message_operations
} // namespace ros
#endif // UR_MSGS_MESSAGE_ANALOG_H

196
devel/include/ur_msgs/Digital.h
View File

@@ -1,196 +0,0 @@
// Generated by gencpp from file ur_msgs/Digital.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_DIGITAL_H
#define UR_MSGS_MESSAGE_DIGITAL_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace ur_msgs
{
template <class ContainerAllocator>
struct Digital_
{
typedef Digital_<ContainerAllocator> Type;
Digital_()
: pin(0)
, state(false) {
}
Digital_(const ContainerAllocator& _alloc)
: pin(0)
, state(false) {
(void)_alloc;
}
typedef uint8_t _pin_type;
_pin_type pin;
typedef uint8_t _state_type;
_state_type state;
typedef boost::shared_ptr< ::ur_msgs::Digital_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ur_msgs::Digital_<ContainerAllocator> const> ConstPtr;
}; // struct Digital_
typedef ::ur_msgs::Digital_<std::allocator<void> > Digital;
typedef boost::shared_ptr< ::ur_msgs::Digital > DigitalPtr;
typedef boost::shared_ptr< ::ur_msgs::Digital const> DigitalConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ur_msgs::Digital_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ur_msgs::Digital_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ur_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'ur_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/universal_robot/ur_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::Digital_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::Digital_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::Digital_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::Digital_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::Digital_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::Digital_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ur_msgs::Digital_<ContainerAllocator> >
{
static const char* value()
{
return "83707be3fa18d2ffe57381ea034aa262";
}
static const char* value(const ::ur_msgs::Digital_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x83707be3fa18d2ffULL;
static const uint64_t static_value2 = 0xe57381ea034aa262ULL;
};
template<class ContainerAllocator>
struct DataType< ::ur_msgs::Digital_<ContainerAllocator> >
{
static const char* value()
{
return "ur_msgs/Digital";
}
static const char* value(const ::ur_msgs::Digital_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ur_msgs::Digital_<ContainerAllocator> >
{
static const char* value()
{
return "uint8 pin\n\
bool state\n\
";
}
static const char* value(const ::ur_msgs::Digital_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ur_msgs::Digital_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.pin);
stream.next(m.state);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Digital_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ur_msgs::Digital_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ur_msgs::Digital_<ContainerAllocator>& v)
{
s << indent << "pin: ";
Printer<uint8_t>::stream(s, indent + " ", v.pin);
s << indent << "state: ";
Printer<uint8_t>::stream(s, indent + " ", v.state);
}
};
} // namespace message_operations
} // namespace ros
#endif // UR_MSGS_MESSAGE_DIGITAL_H

272
devel/include/ur_msgs/IOStates.h
View File

@@ -1,272 +0,0 @@
// Generated by gencpp from file ur_msgs/IOStates.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_IOSTATES_H
#define UR_MSGS_MESSAGE_IOSTATES_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <ur_msgs/Digital.h>
#include <ur_msgs/Digital.h>
#include <ur_msgs/Digital.h>
#include <ur_msgs/Analog.h>
#include <ur_msgs/Analog.h>
namespace ur_msgs
{
template <class ContainerAllocator>
struct IOStates_
{
typedef IOStates_<ContainerAllocator> Type;
IOStates_()
: digital_in_states()
, digital_out_states()
, flag_states()
, analog_in_states()
, analog_out_states() {
}
IOStates_(const ContainerAllocator& _alloc)
: digital_in_states(_alloc)
, digital_out_states(_alloc)
, flag_states(_alloc)
, analog_in_states(_alloc)
, analog_out_states(_alloc) {
(void)_alloc;
}
typedef std::vector< ::ur_msgs::Digital_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::ur_msgs::Digital_<ContainerAllocator> >::other > _digital_in_states_type;
_digital_in_states_type digital_in_states;
typedef std::vector< ::ur_msgs::Digital_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::ur_msgs::Digital_<ContainerAllocator> >::other > _digital_out_states_type;
_digital_out_states_type digital_out_states;
typedef std::vector< ::ur_msgs::Digital_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::ur_msgs::Digital_<ContainerAllocator> >::other > _flag_states_type;
_flag_states_type flag_states;
typedef std::vector< ::ur_msgs::Analog_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::ur_msgs::Analog_<ContainerAllocator> >::other > _analog_in_states_type;
_analog_in_states_type analog_in_states;
typedef std::vector< ::ur_msgs::Analog_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::ur_msgs::Analog_<ContainerAllocator> >::other > _analog_out_states_type;
_analog_out_states_type analog_out_states;
typedef boost::shared_ptr< ::ur_msgs::IOStates_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ur_msgs::IOStates_<ContainerAllocator> const> ConstPtr;
}; // struct IOStates_
typedef ::ur_msgs::IOStates_<std::allocator<void> > IOStates;
typedef boost::shared_ptr< ::ur_msgs::IOStates > IOStatesPtr;
typedef boost::shared_ptr< ::ur_msgs::IOStates const> IOStatesConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ur_msgs::IOStates_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ur_msgs::IOStates_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ur_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'ur_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/universal_robot/ur_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::IOStates_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::IOStates_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::IOStates_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::IOStates_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::IOStates_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::IOStates_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ur_msgs::IOStates_<ContainerAllocator> >
{
static const char* value()
{
return "3033784e7041da89491b97cc4c1105b5";
}
static const char* value(const ::ur_msgs::IOStates_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x3033784e7041da89ULL;
static const uint64_t static_value2 = 0x491b97cc4c1105b5ULL;
};
template<class ContainerAllocator>
struct DataType< ::ur_msgs::IOStates_<ContainerAllocator> >
{
static const char* value()
{
return "ur_msgs/IOStates";
}
static const char* value(const ::ur_msgs::IOStates_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ur_msgs::IOStates_<ContainerAllocator> >
{
static const char* value()
{
return "Digital[] digital_in_states\n\
Digital[] digital_out_states\n\
Digital[] flag_states\n\
Analog[] analog_in_states\n\
Analog[] analog_out_states\n\
\n\
================================================================================\n\
MSG: ur_msgs/Digital\n\
uint8 pin\n\
bool state\n\
\n\
================================================================================\n\
MSG: ur_msgs/Analog\n\
uint8 VOLTAGE=0\n\
uint8 CURRENT=1\n\
\n\
uint8 pin\n\
uint8 domain # can be VOLTAGE or CURRENT\n\
float32 state\n\
";
}
static const char* value(const ::ur_msgs::IOStates_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ur_msgs::IOStates_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.digital_in_states);
stream.next(m.digital_out_states);
stream.next(m.flag_states);
stream.next(m.analog_in_states);
stream.next(m.analog_out_states);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct IOStates_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ur_msgs::IOStates_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ur_msgs::IOStates_<ContainerAllocator>& v)
{
s << indent << "digital_in_states[]" << std::endl;
for (size_t i = 0; i < v.digital_in_states.size(); ++i)
{
s << indent << " digital_in_states[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::ur_msgs::Digital_<ContainerAllocator> >::stream(s, indent + " ", v.digital_in_states[i]);
}
s << indent << "digital_out_states[]" << std::endl;
for (size_t i = 0; i < v.digital_out_states.size(); ++i)
{
s << indent << " digital_out_states[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::ur_msgs::Digital_<ContainerAllocator> >::stream(s, indent + " ", v.digital_out_states[i]);
}
s << indent << "flag_states[]" << std::endl;
for (size_t i = 0; i < v.flag_states.size(); ++i)
{
s << indent << " flag_states[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::ur_msgs::Digital_<ContainerAllocator> >::stream(s, indent + " ", v.flag_states[i]);
}
s << indent << "analog_in_states[]" << std::endl;
for (size_t i = 0; i < v.analog_in_states.size(); ++i)
{
s << indent << " analog_in_states[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::ur_msgs::Analog_<ContainerAllocator> >::stream(s, indent + " ", v.analog_in_states[i]);
}
s << indent << "analog_out_states[]" << std::endl;
for (size_t i = 0; i < v.analog_out_states.size(); ++i)
{
s << indent << " analog_out_states[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::ur_msgs::Analog_<ContainerAllocator> >::stream(s, indent + " ", v.analog_out_states[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // UR_MSGS_MESSAGE_IOSTATES_H

333
devel/include/ur_msgs/MasterboardDataMsg.h
View File

@@ -1,333 +0,0 @@
// Generated by gencpp from file ur_msgs/MasterboardDataMsg.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_MASTERBOARDDATAMSG_H
#define UR_MSGS_MESSAGE_MASTERBOARDDATAMSG_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace ur_msgs
{
template <class ContainerAllocator>
struct MasterboardDataMsg_
{
typedef MasterboardDataMsg_<ContainerAllocator> Type;
MasterboardDataMsg_()
: digital_input_bits(0)
, digital_output_bits(0)
, analog_input_range0(0)
, analog_input_range1(0)
, analog_input0(0.0)
, analog_input1(0.0)
, analog_output_domain0(0)
, analog_output_domain1(0)
, analog_output0(0.0)
, analog_output1(0.0)
, masterboard_temperature(0.0)
, robot_voltage_48V(0.0)
, robot_current(0.0)
, master_io_current(0.0)
, master_safety_state(0)
, master_onoff_state(0) {
}
MasterboardDataMsg_(const ContainerAllocator& _alloc)
: digital_input_bits(0)
, digital_output_bits(0)
, analog_input_range0(0)
, analog_input_range1(0)
, analog_input0(0.0)
, analog_input1(0.0)
, analog_output_domain0(0)
, analog_output_domain1(0)
, analog_output0(0.0)
, analog_output1(0.0)
, masterboard_temperature(0.0)
, robot_voltage_48V(0.0)
, robot_current(0.0)
, master_io_current(0.0)
, master_safety_state(0)
, master_onoff_state(0) {
(void)_alloc;
}
typedef uint32_t _digital_input_bits_type;
_digital_input_bits_type digital_input_bits;
typedef uint32_t _digital_output_bits_type;
_digital_output_bits_type digital_output_bits;
typedef int8_t _analog_input_range0_type;
_analog_input_range0_type analog_input_range0;
typedef int8_t _analog_input_range1_type;
_analog_input_range1_type analog_input_range1;
typedef double _analog_input0_type;
_analog_input0_type analog_input0;
typedef double _analog_input1_type;
_analog_input1_type analog_input1;
typedef int8_t _analog_output_domain0_type;
_analog_output_domain0_type analog_output_domain0;
typedef int8_t _analog_output_domain1_type;
_analog_output_domain1_type analog_output_domain1;
typedef double _analog_output0_type;
_analog_output0_type analog_output0;
typedef double _analog_output1_type;
_analog_output1_type analog_output1;
typedef float _masterboard_temperature_type;
_masterboard_temperature_type masterboard_temperature;
typedef float _robot_voltage_48V_type;
_robot_voltage_48V_type robot_voltage_48V;
typedef float _robot_current_type;
_robot_current_type robot_current;
typedef float _master_io_current_type;
_master_io_current_type master_io_current;
typedef uint8_t _master_safety_state_type;
_master_safety_state_type master_safety_state;
typedef uint8_t _master_onoff_state_type;
_master_onoff_state_type master_onoff_state;
typedef boost::shared_ptr< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> const> ConstPtr;
}; // struct MasterboardDataMsg_
typedef ::ur_msgs::MasterboardDataMsg_<std::allocator<void> > MasterboardDataMsg;
typedef boost::shared_ptr< ::ur_msgs::MasterboardDataMsg > MasterboardDataMsgPtr;
typedef boost::shared_ptr< ::ur_msgs::MasterboardDataMsg const> MasterboardDataMsgConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ur_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'ur_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/universal_robot/ur_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "807af5dc427082b111fa23d1fd2cd585";
}
static const char* value(const ::ur_msgs::MasterboardDataMsg_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x807af5dc427082b1ULL;
static const uint64_t static_value2 = 0x11fa23d1fd2cd585ULL;
};
template<class ContainerAllocator>
struct DataType< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "ur_msgs/MasterboardDataMsg";
}
static const char* value(const ::ur_msgs::MasterboardDataMsg_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "# This data structure contains the MasterboardData structure\n\
# used by the Universal Robots controller\n\
#\n\
# MasterboardData is part of the data structure being send on the \n\
# secondary client communications interface\n\
# \n\
# This data structure is send at 10 Hz on TCP port 30002\n\
# \n\
# Documentation can be found on the Universal Robots Support site, article\n\
# number 16496.\n\
\n\
uint32 digital_input_bits\n\
uint32 digital_output_bits\n\
int8 analog_input_range0\n\
int8 analog_input_range1\n\
float64 analog_input0\n\
float64 analog_input1\n\
int8 analog_output_domain0\n\
int8 analog_output_domain1\n\
float64 analog_output0\n\
float64 analog_output1\n\
float32 masterboard_temperature\n\
float32 robot_voltage_48V\n\
float32 robot_current\n\
float32 master_io_current\n\
uint8 master_safety_state\n\
uint8 master_onoff_state\n\
";
}
static const char* value(const ::ur_msgs::MasterboardDataMsg_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.digital_input_bits);
stream.next(m.digital_output_bits);
stream.next(m.analog_input_range0);
stream.next(m.analog_input_range1);
stream.next(m.analog_input0);
stream.next(m.analog_input1);
stream.next(m.analog_output_domain0);
stream.next(m.analog_output_domain1);
stream.next(m.analog_output0);
stream.next(m.analog_output1);
stream.next(m.masterboard_temperature);
stream.next(m.robot_voltage_48V);
stream.next(m.robot_current);
stream.next(m.master_io_current);
stream.next(m.master_safety_state);
stream.next(m.master_onoff_state);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MasterboardDataMsg_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ur_msgs::MasterboardDataMsg_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ur_msgs::MasterboardDataMsg_<ContainerAllocator>& v)
{
s << indent << "digital_input_bits: ";
Printer<uint32_t>::stream(s, indent + " ", v.digital_input_bits);
s << indent << "digital_output_bits: ";
Printer<uint32_t>::stream(s, indent + " ", v.digital_output_bits);
s << indent << "analog_input_range0: ";
Printer<int8_t>::stream(s, indent + " ", v.analog_input_range0);
s << indent << "analog_input_range1: ";
Printer<int8_t>::stream(s, indent + " ", v.analog_input_range1);
s << indent << "analog_input0: ";
Printer<double>::stream(s, indent + " ", v.analog_input0);
s << indent << "analog_input1: ";
Printer<double>::stream(s, indent + " ", v.analog_input1);
s << indent << "analog_output_domain0: ";
Printer<int8_t>::stream(s, indent + " ", v.analog_output_domain0);
s << indent << "analog_output_domain1: ";
Printer<int8_t>::stream(s, indent + " ", v.analog_output_domain1);
s << indent << "analog_output0: ";
Printer<double>::stream(s, indent + " ", v.analog_output0);
s << indent << "analog_output1: ";
Printer<double>::stream(s, indent + " ", v.analog_output1);
s << indent << "masterboard_temperature: ";
Printer<float>::stream(s, indent + " ", v.masterboard_temperature);
s << indent << "robot_voltage_48V: ";
Printer<float>::stream(s, indent + " ", v.robot_voltage_48V);
s << indent << "robot_current: ";
Printer<float>::stream(s, indent + " ", v.robot_current);
s << indent << "master_io_current: ";
Printer<float>::stream(s, indent + " ", v.master_io_current);
s << indent << "master_safety_state: ";
Printer<uint8_t>::stream(s, indent + " ", v.master_safety_state);
s << indent << "master_onoff_state: ";
Printer<uint8_t>::stream(s, indent + " ", v.master_onoff_state);
}
};
} // namespace message_operations
} // namespace ros
#endif // UR_MSGS_MESSAGE_MASTERBOARDDATAMSG_H

257
devel/include/ur_msgs/RobotModeDataMsg.h
View File

@@ -1,257 +0,0 @@
// Generated by gencpp from file ur_msgs/RobotModeDataMsg.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_ROBOTMODEDATAMSG_H
#define UR_MSGS_MESSAGE_ROBOTMODEDATAMSG_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace ur_msgs
{
template <class ContainerAllocator>
struct RobotModeDataMsg_
{
typedef RobotModeDataMsg_<ContainerAllocator> Type;
RobotModeDataMsg_()
: timestamp(0)
, is_robot_connected(false)
, is_real_robot_enabled(false)
, is_power_on_robot(false)
, is_emergency_stopped(false)
, is_protective_stopped(false)
, is_program_running(false)
, is_program_paused(false) {
}
RobotModeDataMsg_(const ContainerAllocator& _alloc)
: timestamp(0)
, is_robot_connected(false)
, is_real_robot_enabled(false)
, is_power_on_robot(false)
, is_emergency_stopped(false)
, is_protective_stopped(false)
, is_program_running(false)
, is_program_paused(false) {
(void)_alloc;
}
typedef uint64_t _timestamp_type;
_timestamp_type timestamp;
typedef uint8_t _is_robot_connected_type;
_is_robot_connected_type is_robot_connected;
typedef uint8_t _is_real_robot_enabled_type;
_is_real_robot_enabled_type is_real_robot_enabled;
typedef uint8_t _is_power_on_robot_type;
_is_power_on_robot_type is_power_on_robot;
typedef uint8_t _is_emergency_stopped_type;
_is_emergency_stopped_type is_emergency_stopped;
typedef uint8_t _is_protective_stopped_type;
_is_protective_stopped_type is_protective_stopped;
typedef uint8_t _is_program_running_type;
_is_program_running_type is_program_running;
typedef uint8_t _is_program_paused_type;
_is_program_paused_type is_program_paused;
typedef boost::shared_ptr< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> const> ConstPtr;
}; // struct RobotModeDataMsg_
typedef ::ur_msgs::RobotModeDataMsg_<std::allocator<void> > RobotModeDataMsg;
typedef boost::shared_ptr< ::ur_msgs::RobotModeDataMsg > RobotModeDataMsgPtr;
typedef boost::shared_ptr< ::ur_msgs::RobotModeDataMsg const> RobotModeDataMsgConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ur_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'ur_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/universal_robot/ur_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "867308ca39e2cc0644b50db27deb661f";
}
static const char* value(const ::ur_msgs::RobotModeDataMsg_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x867308ca39e2cc06ULL;
static const uint64_t static_value2 = 0x44b50db27deb661fULL;
};
template<class ContainerAllocator>
struct DataType< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "ur_msgs/RobotModeDataMsg";
}
static const char* value(const ::ur_msgs::RobotModeDataMsg_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "# This data structure contains the RobotModeData structure\n\
# used by the Universal Robots controller\n\
#\n\
# This data structure is send at 10 Hz on TCP port 30002\n\
#\n\
# Note: this message does not carry all fields from the RobotModeData structure as broadcast by the robot controller, but a subset.\n\
\n\
uint64 timestamp\n\
bool is_robot_connected\n\
bool is_real_robot_enabled\n\
bool is_power_on_robot\n\
bool is_emergency_stopped\n\
bool is_protective_stopped\n\
bool is_program_running\n\
bool is_program_paused\n\
";
}
static const char* value(const ::ur_msgs::RobotModeDataMsg_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.timestamp);
stream.next(m.is_robot_connected);
stream.next(m.is_real_robot_enabled);
stream.next(m.is_power_on_robot);
stream.next(m.is_emergency_stopped);
stream.next(m.is_protective_stopped);
stream.next(m.is_program_running);
stream.next(m.is_program_paused);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct RobotModeDataMsg_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ur_msgs::RobotModeDataMsg_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ur_msgs::RobotModeDataMsg_<ContainerAllocator>& v)
{
s << indent << "timestamp: ";
Printer<uint64_t>::stream(s, indent + " ", v.timestamp);
s << indent << "is_robot_connected: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_robot_connected);
s << indent << "is_real_robot_enabled: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_real_robot_enabled);
s << indent << "is_power_on_robot: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_power_on_robot);
s << indent << "is_emergency_stopped: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_emergency_stopped);
s << indent << "is_protective_stopped: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_protective_stopped);
s << indent << "is_program_running: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_program_running);
s << indent << "is_program_paused: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_program_paused);
}
};
} // namespace message_operations
} // namespace ros
#endif // UR_MSGS_MESSAGE_ROBOTMODEDATAMSG_H

413
devel/include/ur_msgs/RobotStateRTMsg.h
View File

@@ -1,413 +0,0 @@
// Generated by gencpp from file ur_msgs/RobotStateRTMsg.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_ROBOTSTATERTMSG_H
#define UR_MSGS_MESSAGE_ROBOTSTATERTMSG_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace ur_msgs
{
template <class ContainerAllocator>
struct RobotStateRTMsg_
{
typedef RobotStateRTMsg_<ContainerAllocator> Type;
RobotStateRTMsg_()
: time(0.0)
, q_target()
, qd_target()
, qdd_target()
, i_target()
, m_target()
, q_actual()
, qd_actual()
, i_actual()
, tool_acc_values()
, tcp_force()
, tool_vector()
, tcp_speed()
, digital_input_bits(0.0)
, motor_temperatures()
, controller_timer(0.0)
, test_value(0.0)
, robot_mode(0.0)
, joint_modes() {
}
RobotStateRTMsg_(const ContainerAllocator& _alloc)
: time(0.0)
, q_target(_alloc)
, qd_target(_alloc)
, qdd_target(_alloc)
, i_target(_alloc)
, m_target(_alloc)
, q_actual(_alloc)
, qd_actual(_alloc)
, i_actual(_alloc)
, tool_acc_values(_alloc)
, tcp_force(_alloc)
, tool_vector(_alloc)
, tcp_speed(_alloc)
, digital_input_bits(0.0)
, motor_temperatures(_alloc)
, controller_timer(0.0)
, test_value(0.0)
, robot_mode(0.0)
, joint_modes(_alloc) {
(void)_alloc;
}
typedef double _time_type;
_time_type time;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _q_target_type;
_q_target_type q_target;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _qd_target_type;
_qd_target_type qd_target;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _qdd_target_type;
_qdd_target_type qdd_target;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _i_target_type;
_i_target_type i_target;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _m_target_type;
_m_target_type m_target;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _q_actual_type;
_q_actual_type q_actual;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _qd_actual_type;
_qd_actual_type qd_actual;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _i_actual_type;
_i_actual_type i_actual;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _tool_acc_values_type;
_tool_acc_values_type tool_acc_values;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _tcp_force_type;
_tcp_force_type tcp_force;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _tool_vector_type;
_tool_vector_type tool_vector;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _tcp_speed_type;
_tcp_speed_type tcp_speed;
typedef double _digital_input_bits_type;
_digital_input_bits_type digital_input_bits;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _motor_temperatures_type;
_motor_temperatures_type motor_temperatures;
typedef double _controller_timer_type;
_controller_timer_type controller_timer;
typedef double _test_value_type;
_test_value_type test_value;
typedef double _robot_mode_type;
_robot_mode_type robot_mode;
typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _joint_modes_type;
_joint_modes_type joint_modes;
typedef boost::shared_ptr< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> const> ConstPtr;
}; // struct RobotStateRTMsg_
typedef ::ur_msgs::RobotStateRTMsg_<std::allocator<void> > RobotStateRTMsg;
typedef boost::shared_ptr< ::ur_msgs::RobotStateRTMsg > RobotStateRTMsgPtr;
typedef boost::shared_ptr< ::ur_msgs::RobotStateRTMsg const> RobotStateRTMsgConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ur_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'ur_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/universal_robot/ur_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
{
static const char* value()
{
return "ce6feddd3ccb4ca7dbcd0ff105b603c7";
}
static const char* value(const ::ur_msgs::RobotStateRTMsg_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xce6feddd3ccb4ca7ULL;
static const uint64_t static_value2 = 0xdbcd0ff105b603c7ULL;
};
template<class ContainerAllocator>
struct DataType< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
{
static const char* value()
{
return "ur_msgs/RobotStateRTMsg";
}
static const char* value(const ::ur_msgs::RobotStateRTMsg_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
{
static const char* value()
{
return "# Data structure for the realtime communications interface (aka Matlab interface)\n\
# used by the Universal Robots controller\n\
# \n\
# This data structure is send at 125 Hz on TCP port 30003\n\
# \n\
# Dokumentation can be found on the Universal Robots Support Wiki\n\
# (http://wiki03.lynero.net/Technical/RealTimeClientInterface?rev=9)\n\
\n\
float64 time\n\
float64[] q_target\n\
float64[] qd_target\n\
float64[] qdd_target\n\
float64[] i_target\n\
float64[] m_target\n\
float64[] q_actual\n\
float64[] qd_actual\n\
float64[] i_actual\n\
float64[] tool_acc_values\n\
float64[] tcp_force\n\
float64[] tool_vector\n\
float64[] tcp_speed\n\
float64 digital_input_bits\n\
float64[] motor_temperatures\n\
float64 controller_timer\n\
float64 test_value\n\
float64 robot_mode\n\
float64[] joint_modes\n\
";
}
static const char* value(const ::ur_msgs::RobotStateRTMsg_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.time);
stream.next(m.q_target);
stream.next(m.qd_target);
stream.next(m.qdd_target);
stream.next(m.i_target);
stream.next(m.m_target);
stream.next(m.q_actual);
stream.next(m.qd_actual);
stream.next(m.i_actual);
stream.next(m.tool_acc_values);
stream.next(m.tcp_force);
stream.next(m.tool_vector);
stream.next(m.tcp_speed);
stream.next(m.digital_input_bits);
stream.next(m.motor_temperatures);
stream.next(m.controller_timer);
stream.next(m.test_value);
stream.next(m.robot_mode);
stream.next(m.joint_modes);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct RobotStateRTMsg_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ur_msgs::RobotStateRTMsg_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ur_msgs::RobotStateRTMsg_<ContainerAllocator>& v)
{
s << indent << "time: ";
Printer<double>::stream(s, indent + " ", v.time);
s << indent << "q_target[]" << std::endl;
for (size_t i = 0; i < v.q_target.size(); ++i)
{
s << indent << " q_target[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.q_target[i]);
}
s << indent << "qd_target[]" << std::endl;
for (size_t i = 0; i < v.qd_target.size(); ++i)
{
s << indent << " qd_target[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.qd_target[i]);
}
s << indent << "qdd_target[]" << std::endl;
for (size_t i = 0; i < v.qdd_target.size(); ++i)
{
s << indent << " qdd_target[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.qdd_target[i]);
}
s << indent << "i_target[]" << std::endl;
for (size_t i = 0; i < v.i_target.size(); ++i)
{
s << indent << " i_target[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.i_target[i]);
}
s << indent << "m_target[]" << std::endl;
for (size_t i = 0; i < v.m_target.size(); ++i)
{
s << indent << " m_target[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.m_target[i]);
}
s << indent << "q_actual[]" << std::endl;
for (size_t i = 0; i < v.q_actual.size(); ++i)
{
s << indent << " q_actual[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.q_actual[i]);
}
s << indent << "qd_actual[]" << std::endl;
for (size_t i = 0; i < v.qd_actual.size(); ++i)
{
s << indent << " qd_actual[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.qd_actual[i]);
}
s << indent << "i_actual[]" << std::endl;
for (size_t i = 0; i < v.i_actual.size(); ++i)
{
s << indent << " i_actual[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.i_actual[i]);
}
s << indent << "tool_acc_values[]" << std::endl;
for (size_t i = 0; i < v.tool_acc_values.size(); ++i)
{
s << indent << " tool_acc_values[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.tool_acc_values[i]);
}
s << indent << "tcp_force[]" << std::endl;
for (size_t i = 0; i < v.tcp_force.size(); ++i)
{
s << indent << " tcp_force[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.tcp_force[i]);
}
s << indent << "tool_vector[]" << std::endl;
for (size_t i = 0; i < v.tool_vector.size(); ++i)
{
s << indent << " tool_vector[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.tool_vector[i]);
}
s << indent << "tcp_speed[]" << std::endl;
for (size_t i = 0; i < v.tcp_speed.size(); ++i)
{
s << indent << " tcp_speed[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.tcp_speed[i]);
}
s << indent << "digital_input_bits: ";
Printer<double>::stream(s, indent + " ", v.digital_input_bits);
s << indent << "motor_temperatures[]" << std::endl;
for (size_t i = 0; i < v.motor_temperatures.size(); ++i)
{
s << indent << " motor_temperatures[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.motor_temperatures[i]);
}
s << indent << "controller_timer: ";
Printer<double>::stream(s, indent + " ", v.controller_timer);
s << indent << "test_value: ";
Printer<double>::stream(s, indent + " ", v.test_value);
s << indent << "robot_mode: ";
Printer<double>::stream(s, indent + " ", v.robot_mode);
s << indent << "joint_modes[]" << std::endl;
for (size_t i = 0; i < v.joint_modes.size(); ++i)
{
s << indent << " joint_modes[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.joint_modes[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // UR_MSGS_MESSAGE_ROBOTSTATERTMSG_H

123
devel/include/ur_msgs/SetIO.h
View File

@@ -1,123 +0,0 @@
// Generated by gencpp from file ur_msgs/SetIO.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_SETIO_H
#define UR_MSGS_MESSAGE_SETIO_H
#include <ros/service_traits.h>
#include <ur_msgs/SetIORequest.h>
#include <ur_msgs/SetIOResponse.h>
namespace ur_msgs
{
struct SetIO
{
typedef SetIORequest Request;
typedef SetIOResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct SetIO
} // namespace ur_msgs
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::ur_msgs::SetIO > {
static const char* value()
{
return "e1b580ccf43a938f2efbbb98bbe3e277";
}
static const char* value(const ::ur_msgs::SetIO&) { return value(); }
};
template<>
struct DataType< ::ur_msgs::SetIO > {
static const char* value()
{
return "ur_msgs/SetIO";
}
static const char* value(const ::ur_msgs::SetIO&) { return value(); }
};
// service_traits::MD5Sum< ::ur_msgs::SetIORequest> should match
// service_traits::MD5Sum< ::ur_msgs::SetIO >
template<>
struct MD5Sum< ::ur_msgs::SetIORequest>
{
static const char* value()
{
return MD5Sum< ::ur_msgs::SetIO >::value();
}
static const char* value(const ::ur_msgs::SetIORequest&)
{
return value();
}
};
// service_traits::DataType< ::ur_msgs::SetIORequest> should match
// service_traits::DataType< ::ur_msgs::SetIO >
template<>
struct DataType< ::ur_msgs::SetIORequest>
{
static const char* value()
{
return DataType< ::ur_msgs::SetIO >::value();
}
static const char* value(const ::ur_msgs::SetIORequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::ur_msgs::SetIOResponse> should match
// service_traits::MD5Sum< ::ur_msgs::SetIO >
template<>
struct MD5Sum< ::ur_msgs::SetIOResponse>
{
static const char* value()
{
return MD5Sum< ::ur_msgs::SetIO >::value();
}
static const char* value(const ::ur_msgs::SetIOResponse&)
{
return value();
}
};
// service_traits::DataType< ::ur_msgs::SetIOResponse> should match
// service_traits::DataType< ::ur_msgs::SetIO >
template<>
struct DataType< ::ur_msgs::SetIOResponse>
{
static const char* value()
{
return DataType< ::ur_msgs::SetIO >::value();
}
static const char* value(const ::ur_msgs::SetIOResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // UR_MSGS_MESSAGE_SETIO_H

123
devel/include/ur_msgs/SetPayload.h
View File

@@ -1,123 +0,0 @@
// Generated by gencpp from file ur_msgs/SetPayload.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_SETPAYLOAD_H
#define UR_MSGS_MESSAGE_SETPAYLOAD_H
#include <ros/service_traits.h>
#include <ur_msgs/SetPayloadRequest.h>
#include <ur_msgs/SetPayloadResponse.h>
namespace ur_msgs
{
struct SetPayload
{
typedef SetPayloadRequest Request;
typedef SetPayloadResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct SetPayload
} // namespace ur_msgs
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::ur_msgs::SetPayload > {
static const char* value()
{
return "7f12eb632882cb73e5721178d0073e39";
}
static const char* value(const ::ur_msgs::SetPayload&) { return value(); }
};
template<>
struct DataType< ::ur_msgs::SetPayload > {
static const char* value()
{
return "ur_msgs/SetPayload";
}
static const char* value(const ::ur_msgs::SetPayload&) { return value(); }
};
// service_traits::MD5Sum< ::ur_msgs::SetPayloadRequest> should match
// service_traits::MD5Sum< ::ur_msgs::SetPayload >
template<>
struct MD5Sum< ::ur_msgs::SetPayloadRequest>
{
static const char* value()
{
return MD5Sum< ::ur_msgs::SetPayload >::value();
}
static const char* value(const ::ur_msgs::SetPayloadRequest&)
{
return value();
}
};
// service_traits::DataType< ::ur_msgs::SetPayloadRequest> should match
// service_traits::DataType< ::ur_msgs::SetPayload >
template<>
struct DataType< ::ur_msgs::SetPayloadRequest>
{
static const char* value()
{
return DataType< ::ur_msgs::SetPayload >::value();
}
static const char* value(const ::ur_msgs::SetPayloadRequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::ur_msgs::SetPayloadResponse> should match
// service_traits::MD5Sum< ::ur_msgs::SetPayload >
template<>
struct MD5Sum< ::ur_msgs::SetPayloadResponse>
{
static const char* value()
{
return MD5Sum< ::ur_msgs::SetPayload >::value();
}
static const char* value(const ::ur_msgs::SetPayloadResponse&)
{
return value();
}
};
// service_traits::DataType< ::ur_msgs::SetPayloadResponse> should match
// service_traits::DataType< ::ur_msgs::SetPayload >
template<>
struct DataType< ::ur_msgs::SetPayloadResponse>
{
static const char* value()
{
return DataType< ::ur_msgs::SetPayload >::value();
}
static const char* value(const ::ur_msgs::SetPayloadResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // UR_MSGS_MESSAGE_SETPAYLOAD_H

123
devel/include/ur_msgs/SetSpeedSliderFraction.h
View File

@@ -1,123 +0,0 @@
// Generated by gencpp from file ur_msgs/SetSpeedSliderFraction.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_SETSPEEDSLIDERFRACTION_H
#define UR_MSGS_MESSAGE_SETSPEEDSLIDERFRACTION_H
#include <ros/service_traits.h>
#include <ur_msgs/SetSpeedSliderFractionRequest.h>
#include <ur_msgs/SetSpeedSliderFractionResponse.h>
namespace ur_msgs
{
struct SetSpeedSliderFraction
{
typedef SetSpeedSliderFractionRequest Request;
typedef SetSpeedSliderFractionResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct SetSpeedSliderFraction
} // namespace ur_msgs
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::ur_msgs::SetSpeedSliderFraction > {
static const char* value()
{
return "172aeb6c49379a44cf68480fa5bfad3c";
}
static const char* value(const ::ur_msgs::SetSpeedSliderFraction&) { return value(); }
};
template<>
struct DataType< ::ur_msgs::SetSpeedSliderFraction > {
static const char* value()
{
return "ur_msgs/SetSpeedSliderFraction";
}
static const char* value(const ::ur_msgs::SetSpeedSliderFraction&) { return value(); }
};
// service_traits::MD5Sum< ::ur_msgs::SetSpeedSliderFractionRequest> should match
// service_traits::MD5Sum< ::ur_msgs::SetSpeedSliderFraction >
template<>
struct MD5Sum< ::ur_msgs::SetSpeedSliderFractionRequest>
{
static const char* value()
{
return MD5Sum< ::ur_msgs::SetSpeedSliderFraction >::value();
}
static const char* value(const ::ur_msgs::SetSpeedSliderFractionRequest&)
{
return value();
}
};
// service_traits::DataType< ::ur_msgs::SetSpeedSliderFractionRequest> should match
// service_traits::DataType< ::ur_msgs::SetSpeedSliderFraction >
template<>
struct DataType< ::ur_msgs::SetSpeedSliderFractionRequest>
{
static const char* value()
{
return DataType< ::ur_msgs::SetSpeedSliderFraction >::value();
}
static const char* value(const ::ur_msgs::SetSpeedSliderFractionRequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::ur_msgs::SetSpeedSliderFractionResponse> should match
// service_traits::MD5Sum< ::ur_msgs::SetSpeedSliderFraction >
template<>
struct MD5Sum< ::ur_msgs::SetSpeedSliderFractionResponse>
{
static const char* value()
{
return MD5Sum< ::ur_msgs::SetSpeedSliderFraction >::value();
}
static const char* value(const ::ur_msgs::SetSpeedSliderFractionResponse&)
{
return value();
}
};
// service_traits::DataType< ::ur_msgs::SetSpeedSliderFractionResponse> should match
// service_traits::DataType< ::ur_msgs::SetSpeedSliderFraction >
template<>
struct DataType< ::ur_msgs::SetSpeedSliderFractionResponse>
{
static const char* value()
{
return DataType< ::ur_msgs::SetSpeedSliderFraction >::value();
}
static const char* value(const ::ur_msgs::SetSpeedSliderFractionResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // UR_MSGS_MESSAGE_SETSPEEDSLIDERFRACTION_H

287
devel/include/ur_msgs/ToolDataMsg.h
View File

@@ -1,287 +0,0 @@
// Generated by gencpp from file ur_msgs/ToolDataMsg.msg
// DO NOT EDIT!
#ifndef UR_MSGS_MESSAGE_TOOLDATAMSG_H
#define UR_MSGS_MESSAGE_TOOLDATAMSG_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace ur_msgs
{
template <class ContainerAllocator>
struct ToolDataMsg_
{
typedef ToolDataMsg_<ContainerAllocator> Type;
ToolDataMsg_()
: analog_input_range2(0)
, analog_input_range3(0)
, analog_input2(0.0)
, analog_input3(0.0)
, tool_voltage_48v(0.0)
, tool_output_voltage(0)
, tool_current(0.0)
, tool_temperature(0.0)
, tool_mode(0) {
}
ToolDataMsg_(const ContainerAllocator& _alloc)
: analog_input_range2(0)
, analog_input_range3(0)
, analog_input2(0.0)
, analog_input3(0.0)
, tool_voltage_48v(0.0)
, tool_output_voltage(0)
, tool_current(0.0)
, tool_temperature(0.0)
, tool_mode(0) {
(void)_alloc;
}
typedef int8_t _analog_input_range2_type;
_analog_input_range2_type analog_input_range2;
typedef int8_t _analog_input_range3_type;
_analog_input_range3_type analog_input_range3;
typedef double _analog_input2_type;
_analog_input2_type analog_input2;
typedef double _analog_input3_type;
_analog_input3_type analog_input3;
typedef float _tool_voltage_48v_type;
_tool_voltage_48v_type tool_voltage_48v;
typedef uint8_t _tool_output_voltage_type;
_tool_output_voltage_type tool_output_voltage;
typedef float _tool_current_type;
_tool_current_type tool_current;
typedef float _tool_temperature_type;
_tool_temperature_type tool_temperature;
typedef uint8_t _tool_mode_type;
_tool_mode_type tool_mode;
enum {
ANALOG_INPUT_RANGE_CURRENT = 0,
ANALOG_INPUT_RANGE_VOLTAGE = 1,
TOOL_BOOTLOADER_MODE = 249u,
TOOL_RUNNING_MODE = 253u,
TOOL_IDLE_MODE = 255u,
};
typedef boost::shared_ptr< ::ur_msgs::ToolDataMsg_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ur_msgs::ToolDataMsg_<ContainerAllocator> const> ConstPtr;
}; // struct ToolDataMsg_
typedef ::ur_msgs::ToolDataMsg_<std::allocator<void> > ToolDataMsg;
typedef boost::shared_ptr< ::ur_msgs::ToolDataMsg > ToolDataMsgPtr;
typedef boost::shared_ptr< ::ur_msgs::ToolDataMsg const> ToolDataMsgConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ur_msgs::ToolDataMsg_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ur_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'ur_msgs': ['/home/emanuele/Documents/GestioneMacchine/Robot_Incollaggio/Software/roboglue_ros_ws/src/universal_robot/ur_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ur_msgs::ToolDataMsg_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ur_msgs::ToolDataMsg_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ur_msgs::ToolDataMsg_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "404fc266f37d89f75b372d12fa94a122";
}
static const char* value(const ::ur_msgs::ToolDataMsg_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x404fc266f37d89f7ULL;
static const uint64_t static_value2 = 0x5b372d12fa94a122ULL;
};
template<class ContainerAllocator>
struct DataType< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "ur_msgs/ToolDataMsg";
}
static const char* value(const ::ur_msgs::ToolDataMsg_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
{
static const char* value()
{
return "# This data structure contains the ToolData structure\n\
# used by the Universal Robots controller\n\
\n\
int8 ANALOG_INPUT_RANGE_CURRENT = 0\n\
int8 ANALOG_INPUT_RANGE_VOLTAGE = 1\n\
\n\
int8 analog_input_range2 # one of ANALOG_INPUT_RANGE_*\n\
int8 analog_input_range3 # one of ANALOG_INPUT_RANGE_*\n\
float64 analog_input2\n\
float64 analog_input3\n\
float32 tool_voltage_48v\n\
uint8 tool_output_voltage\n\
float32 tool_current\n\
float32 tool_temperature\n\
\n\
uint8 TOOL_BOOTLOADER_MODE = 249\n\
uint8 TOOL_RUNNING_MODE = 253\n\
uint8 TOOL_IDLE_MODE = 255\n\
\n\
uint8 tool_mode # one of TOOL_*\n\
";
}
static const char* value(const ::ur_msgs::ToolDataMsg_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.analog_input_range2);
stream.next(m.analog_input_range3);
stream.next(m.analog_input2);
stream.next(m.analog_input3);
stream.next(m.tool_voltage_48v);
stream.next(m.tool_output_voltage);
stream.next(m.tool_current);
stream.next(m.tool_temperature);
stream.next(m.tool_mode);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct ToolDataMsg_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ur_msgs::ToolDataMsg_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ur_msgs::ToolDataMsg_<ContainerAllocator>& v)
{
s << indent << "analog_input_range2: ";
Printer<int8_t>::stream(s, indent + " ", v.analog_input_range2);
s << indent << "analog_input_range3: ";
Printer<int8_t>::stream(s, indent + " ", v.analog_input_range3);
s << indent << "analog_input2: ";
Printer<double>::stream(s, indent + " ", v.analog_input2);
s << indent << "analog_input3: ";
Printer<double>::stream(s, indent + " ", v.analog_input3);
s << indent << "tool_voltage_48v: ";
Printer<float>::stream(s, indent + " ", v.tool_voltage_48v);
s << indent << "tool_output_voltage: ";
Printer<uint8_t>::stream(s, indent + " ", v.tool_output_voltage);
s << indent << "tool_current: ";
Printer<float>::stream(s, indent + " ", v.tool_current);
s << indent << "tool_temperature: ";
Printer<float>::stream(s, indent + " ", v.tool_temperature);
s << indent << "tool_mode: ";
Printer<uint8_t>::stream(s, indent + " ", v.tool_mode);
}
};
} // namespace message_operations
} // namespace ros
#endif // UR_MSGS_MESSAGE_TOOLDATAMSG_H