00001
00002 #ifndef PR2_CONTROLLERS_MSGS_MESSAGE_JOINTCONTROLLERSTATE_H
00003 #define PR2_CONTROLLERS_MSGS_MESSAGE_JOINTCONTROLLERSTATE_H
00004 #include <string>
00005 #include <vector>
00006 #include <ostream>
00007 #include "ros/serialization.h"
00008 #include "ros/builtin_message_traits.h"
00009 #include "ros/message_operations.h"
00010 #include "ros/message.h"
00011 #include "ros/time.h"
00012
00013 #include "std_msgs/Header.h"
00014
00015 namespace pr2_controllers_msgs
00016 {
00017 template <class ContainerAllocator>
00018 struct JointControllerState_ : public ros::Message
00019 {
00020 typedef JointControllerState_<ContainerAllocator> Type;
00021
00022 JointControllerState_()
00023 : header()
00024 , set_point(0.0)
00025 , process_value(0.0)
00026 , process_value_dot(0.0)
00027 , error(0.0)
00028 , time_step(0.0)
00029 , command(0.0)
00030 , p(0.0)
00031 , i(0.0)
00032 , d(0.0)
00033 , i_clamp(0.0)
00034 {
00035 }
00036
00037 JointControllerState_(const ContainerAllocator& _alloc)
00038 : header(_alloc)
00039 , set_point(0.0)
00040 , process_value(0.0)
00041 , process_value_dot(0.0)
00042 , error(0.0)
00043 , time_step(0.0)
00044 , command(0.0)
00045 , p(0.0)
00046 , i(0.0)
00047 , d(0.0)
00048 , i_clamp(0.0)
00049 {
00050 }
00051
00052 typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
00053 ::std_msgs::Header_<ContainerAllocator> header;
00054
00055 typedef double _set_point_type;
00056 double set_point;
00057
00058 typedef double _process_value_type;
00059 double process_value;
00060
00061 typedef double _process_value_dot_type;
00062 double process_value_dot;
00063
00064 typedef double _error_type;
00065 double error;
00066
00067 typedef double _time_step_type;
00068 double time_step;
00069
00070 typedef double _command_type;
00071 double command;
00072
00073 typedef double _p_type;
00074 double p;
00075
00076 typedef double _i_type;
00077 double i;
00078
00079 typedef double _d_type;
00080 double d;
00081
00082 typedef double _i_clamp_type;
00083 double i_clamp;
00084
00085
00086 private:
00087 static const char* __s_getDataType_() { return "pr2_controllers_msgs/JointControllerState"; }
00088 public:
00089 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00090
00091 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00092
00093 private:
00094 static const char* __s_getMD5Sum_() { return "c0d034a7bf20aeb1c37f3eccb7992b69"; }
00095 public:
00096 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00097
00098 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00099
00100 private:
00101 static const char* __s_getMessageDefinition_() { return "Header header\n\
00102 float64 set_point\n\
00103 float64 process_value\n\
00104 float64 process_value_dot\n\
00105 float64 error\n\
00106 float64 time_step\n\
00107 float64 command\n\
00108 float64 p\n\
00109 float64 i\n\
00110 float64 d\n\
00111 float64 i_clamp\n\
00112 \n\
00113 \n\
00114 ================================================================================\n\
00115 MSG: std_msgs/Header\n\
00116 # Standard metadata for higher-level stamped data types.\n\
00117 # This is generally used to communicate timestamped data \n\
00118 # in a particular coordinate frame.\n\
00119 # \n\
00120 # sequence ID: consecutively increasing ID \n\
00121 uint32 seq\n\
00122 #Two-integer timestamp that is expressed as:\n\
00123 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00124 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00125 # time-handling sugar is provided by the client library\n\
00126 time stamp\n\
00127 #Frame this data is associated with\n\
00128 # 0: no frame\n\
00129 # 1: global frame\n\
00130 string frame_id\n\
00131 \n\
00132 "; }
00133 public:
00134 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00135
00136 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00137
00138 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00139 {
00140 ros::serialization::OStream stream(write_ptr, 1000000000);
00141 ros::serialization::serialize(stream, header);
00142 ros::serialization::serialize(stream, set_point);
00143 ros::serialization::serialize(stream, process_value);
00144 ros::serialization::serialize(stream, process_value_dot);
00145 ros::serialization::serialize(stream, error);
00146 ros::serialization::serialize(stream, time_step);
00147 ros::serialization::serialize(stream, command);
00148 ros::serialization::serialize(stream, p);
00149 ros::serialization::serialize(stream, i);
00150 ros::serialization::serialize(stream, d);
00151 ros::serialization::serialize(stream, i_clamp);
00152 return stream.getData();
00153 }
00154
00155 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00156 {
00157 ros::serialization::IStream stream(read_ptr, 1000000000);
00158 ros::serialization::deserialize(stream, header);
00159 ros::serialization::deserialize(stream, set_point);
00160 ros::serialization::deserialize(stream, process_value);
00161 ros::serialization::deserialize(stream, process_value_dot);
00162 ros::serialization::deserialize(stream, error);
00163 ros::serialization::deserialize(stream, time_step);
00164 ros::serialization::deserialize(stream, command);
00165 ros::serialization::deserialize(stream, p);
00166 ros::serialization::deserialize(stream, i);
00167 ros::serialization::deserialize(stream, d);
00168 ros::serialization::deserialize(stream, i_clamp);
00169 return stream.getData();
00170 }
00171
00172 ROS_DEPRECATED virtual uint32_t serializationLength() const
00173 {
00174 uint32_t size = 0;
00175 size += ros::serialization::serializationLength(header);
00176 size += ros::serialization::serializationLength(set_point);
00177 size += ros::serialization::serializationLength(process_value);
00178 size += ros::serialization::serializationLength(process_value_dot);
00179 size += ros::serialization::serializationLength(error);
00180 size += ros::serialization::serializationLength(time_step);
00181 size += ros::serialization::serializationLength(command);
00182 size += ros::serialization::serializationLength(p);
00183 size += ros::serialization::serializationLength(i);
00184 size += ros::serialization::serializationLength(d);
00185 size += ros::serialization::serializationLength(i_clamp);
00186 return size;
00187 }
00188
00189 typedef boost::shared_ptr< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> > Ptr;
00190 typedef boost::shared_ptr< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> const> ConstPtr;
00191 };
00192 typedef ::pr2_controllers_msgs::JointControllerState_<std::allocator<void> > JointControllerState;
00193
00194 typedef boost::shared_ptr< ::pr2_controllers_msgs::JointControllerState> JointControllerStatePtr;
00195 typedef boost::shared_ptr< ::pr2_controllers_msgs::JointControllerState const> JointControllerStateConstPtr;
00196
00197
00198 template<typename ContainerAllocator>
00199 std::ostream& operator<<(std::ostream& s, const ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> & v)
00200 {
00201 ros::message_operations::Printer< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> >::stream(s, "", v);
00202 return s;}
00203
00204 }
00205
00206 namespace ros
00207 {
00208 namespace message_traits
00209 {
00210 template<class ContainerAllocator>
00211 struct MD5Sum< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> > {
00212 static const char* value()
00213 {
00214 return "c0d034a7bf20aeb1c37f3eccb7992b69";
00215 }
00216
00217 static const char* value(const ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> &) { return value(); }
00218 static const uint64_t static_value1 = 0xc0d034a7bf20aeb1ULL;
00219 static const uint64_t static_value2 = 0xc37f3eccb7992b69ULL;
00220 };
00221
00222 template<class ContainerAllocator>
00223 struct DataType< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> > {
00224 static const char* value()
00225 {
00226 return "pr2_controllers_msgs/JointControllerState";
00227 }
00228
00229 static const char* value(const ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> &) { return value(); }
00230 };
00231
00232 template<class ContainerAllocator>
00233 struct Definition< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> > {
00234 static const char* value()
00235 {
00236 return "Header header\n\
00237 float64 set_point\n\
00238 float64 process_value\n\
00239 float64 process_value_dot\n\
00240 float64 error\n\
00241 float64 time_step\n\
00242 float64 command\n\
00243 float64 p\n\
00244 float64 i\n\
00245 float64 d\n\
00246 float64 i_clamp\n\
00247 \n\
00248 \n\
00249 ================================================================================\n\
00250 MSG: std_msgs/Header\n\
00251 # Standard metadata for higher-level stamped data types.\n\
00252 # This is generally used to communicate timestamped data \n\
00253 # in a particular coordinate frame.\n\
00254 # \n\
00255 # sequence ID: consecutively increasing ID \n\
00256 uint32 seq\n\
00257 #Two-integer timestamp that is expressed as:\n\
00258 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00259 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00260 # time-handling sugar is provided by the client library\n\
00261 time stamp\n\
00262 #Frame this data is associated with\n\
00263 # 0: no frame\n\
00264 # 1: global frame\n\
00265 string frame_id\n\
00266 \n\
00267 ";
00268 }
00269
00270 static const char* value(const ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> &) { return value(); }
00271 };
00272
00273 template<class ContainerAllocator> struct HasHeader< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> > : public TrueType {};
00274 template<class ContainerAllocator> struct HasHeader< const ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> > : public TrueType {};
00275 }
00276 }
00277
00278 namespace ros
00279 {
00280 namespace serialization
00281 {
00282
00283 template<class ContainerAllocator> struct Serializer< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> >
00284 {
00285 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00286 {
00287 stream.next(m.header);
00288 stream.next(m.set_point);
00289 stream.next(m.process_value);
00290 stream.next(m.process_value_dot);
00291 stream.next(m.error);
00292 stream.next(m.time_step);
00293 stream.next(m.command);
00294 stream.next(m.p);
00295 stream.next(m.i);
00296 stream.next(m.d);
00297 stream.next(m.i_clamp);
00298 }
00299
00300 ROS_DECLARE_ALLINONE_SERIALIZER;
00301 };
00302 }
00303 }
00304
00305 namespace ros
00306 {
00307 namespace message_operations
00308 {
00309
00310 template<class ContainerAllocator>
00311 struct Printer< ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> >
00312 {
00313 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::pr2_controllers_msgs::JointControllerState_<ContainerAllocator> & v)
00314 {
00315 s << indent << "header: ";
00316 s << std::endl;
00317 Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
00318 s << indent << "set_point: ";
00319 Printer<double>::stream(s, indent + " ", v.set_point);
00320 s << indent << "process_value: ";
00321 Printer<double>::stream(s, indent + " ", v.process_value);
00322 s << indent << "process_value_dot: ";
00323 Printer<double>::stream(s, indent + " ", v.process_value_dot);
00324 s << indent << "error: ";
00325 Printer<double>::stream(s, indent + " ", v.error);
00326 s << indent << "time_step: ";
00327 Printer<double>::stream(s, indent + " ", v.time_step);
00328 s << indent << "command: ";
00329 Printer<double>::stream(s, indent + " ", v.command);
00330 s << indent << "p: ";
00331 Printer<double>::stream(s, indent + " ", v.p);
00332 s << indent << "i: ";
00333 Printer<double>::stream(s, indent + " ", v.i);
00334 s << indent << "d: ";
00335 Printer<double>::stream(s, indent + " ", v.d);
00336 s << indent << "i_clamp: ";
00337 Printer<double>::stream(s, indent + " ", v.i_clamp);
00338 }
00339 };
00340
00341
00342 }
00343 }
00344
00345 #endif // PR2_CONTROLLERS_MSGS_MESSAGE_JOINTCONTROLLERSTATE_H
00346