Filet temporaei eliminati prima della ricompilazione

This commit is contained in:
2019-11-14 16:10:59 +01:00
parent e3b88fe742
commit c9108aaa54
54 changed files with 0 additions and 11303 deletions

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

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

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

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

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

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

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

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

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

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