00001
00002 #ifndef ART_MSGS_MESSAGE_PILOTSTATE_H
00003 #define ART_MSGS_MESSAGE_PILOTSTATE_H
00004 #include <string>
00005 #include <vector>
00006 #include <map>
00007 #include <ostream>
00008 #include "ros/serialization.h"
00009 #include "ros/builtin_message_traits.h"
00010 #include "ros/message_operations.h"
00011 #include "ros/time.h"
00012
00013 #include "ros/macros.h"
00014
00015 #include "ros/assert.h"
00016
00017 #include "std_msgs/Header.h"
00018 #include "art_msgs/DriverState.h"
00019 #include "art_msgs/DriverState.h"
00020 #include "art_msgs/DriverState.h"
00021 #include "art_msgs/DriverState.h"
00022 #include "art_msgs/DriverState.h"
00023 #include "art_msgs/DriverState.h"
00024 #include "art_msgs/DriverState.h"
00025 #include "art_msgs/CarDrive.h"
00026 #include "art_msgs/CarDrive.h"
00027 #include "art_msgs/CarDrive.h"
00028
00029 namespace art_msgs
00030 {
00031 template <class ContainerAllocator>
00032 struct PilotState_ {
00033 typedef PilotState_<ContainerAllocator> Type;
00034
00035 PilotState_()
00036 : header()
00037 , pilot()
00038 , brake()
00039 , imu()
00040 , odom()
00041 , shifter()
00042 , steering()
00043 , throttle()
00044 , preempted(false)
00045 , target()
00046 , plan()
00047 , current()
00048 {
00049 }
00050
00051 PilotState_(const ContainerAllocator& _alloc)
00052 : header(_alloc)
00053 , pilot(_alloc)
00054 , brake(_alloc)
00055 , imu(_alloc)
00056 , odom(_alloc)
00057 , shifter(_alloc)
00058 , steering(_alloc)
00059 , throttle(_alloc)
00060 , preempted(false)
00061 , target(_alloc)
00062 , plan(_alloc)
00063 , current(_alloc)
00064 {
00065 }
00066
00067 typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
00068 ::std_msgs::Header_<ContainerAllocator> header;
00069
00070 typedef ::art_msgs::DriverState_<ContainerAllocator> _pilot_type;
00071 ::art_msgs::DriverState_<ContainerAllocator> pilot;
00072
00073 typedef ::art_msgs::DriverState_<ContainerAllocator> _brake_type;
00074 ::art_msgs::DriverState_<ContainerAllocator> brake;
00075
00076 typedef ::art_msgs::DriverState_<ContainerAllocator> _imu_type;
00077 ::art_msgs::DriverState_<ContainerAllocator> imu;
00078
00079 typedef ::art_msgs::DriverState_<ContainerAllocator> _odom_type;
00080 ::art_msgs::DriverState_<ContainerAllocator> odom;
00081
00082 typedef ::art_msgs::DriverState_<ContainerAllocator> _shifter_type;
00083 ::art_msgs::DriverState_<ContainerAllocator> shifter;
00084
00085 typedef ::art_msgs::DriverState_<ContainerAllocator> _steering_type;
00086 ::art_msgs::DriverState_<ContainerAllocator> steering;
00087
00088 typedef ::art_msgs::DriverState_<ContainerAllocator> _throttle_type;
00089 ::art_msgs::DriverState_<ContainerAllocator> throttle;
00090
00091 typedef uint8_t _preempted_type;
00092 uint8_t preempted;
00093
00094 typedef ::art_msgs::CarDrive_<ContainerAllocator> _target_type;
00095 ::art_msgs::CarDrive_<ContainerAllocator> target;
00096
00097 typedef ::art_msgs::CarDrive_<ContainerAllocator> _plan_type;
00098 ::art_msgs::CarDrive_<ContainerAllocator> plan;
00099
00100 typedef ::art_msgs::CarDrive_<ContainerAllocator> _current_type;
00101 ::art_msgs::CarDrive_<ContainerAllocator> current;
00102
00103
00104 typedef boost::shared_ptr< ::art_msgs::PilotState_<ContainerAllocator> > Ptr;
00105 typedef boost::shared_ptr< ::art_msgs::PilotState_<ContainerAllocator> const> ConstPtr;
00106 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00107 };
00108 typedef ::art_msgs::PilotState_<std::allocator<void> > PilotState;
00109
00110 typedef boost::shared_ptr< ::art_msgs::PilotState> PilotStatePtr;
00111 typedef boost::shared_ptr< ::art_msgs::PilotState const> PilotStateConstPtr;
00112
00113
00114 template<typename ContainerAllocator>
00115 std::ostream& operator<<(std::ostream& s, const ::art_msgs::PilotState_<ContainerAllocator> & v)
00116 {
00117 ros::message_operations::Printer< ::art_msgs::PilotState_<ContainerAllocator> >::stream(s, "", v);
00118 return s;}
00119
00120 }
00121
00122 namespace ros
00123 {
00124 namespace message_traits
00125 {
00126 template<class ContainerAllocator> struct IsMessage< ::art_msgs::PilotState_<ContainerAllocator> > : public TrueType {};
00127 template<class ContainerAllocator> struct IsMessage< ::art_msgs::PilotState_<ContainerAllocator> const> : public TrueType {};
00128 template<class ContainerAllocator>
00129 struct MD5Sum< ::art_msgs::PilotState_<ContainerAllocator> > {
00130 static const char* value()
00131 {
00132 return "c177b89612055fab019341d1fcc8bc65";
00133 }
00134
00135 static const char* value(const ::art_msgs::PilotState_<ContainerAllocator> &) { return value(); }
00136 static const uint64_t static_value1 = 0xc177b89612055fabULL;
00137 static const uint64_t static_value2 = 0x019341d1fcc8bc65ULL;
00138 };
00139
00140 template<class ContainerAllocator>
00141 struct DataType< ::art_msgs::PilotState_<ContainerAllocator> > {
00142 static const char* value()
00143 {
00144 return "art_msgs/PilotState";
00145 }
00146
00147 static const char* value(const ::art_msgs::PilotState_<ContainerAllocator> &) { return value(); }
00148 };
00149
00150 template<class ContainerAllocator>
00151 struct Definition< ::art_msgs::PilotState_<ContainerAllocator> > {
00152 static const char* value()
00153 {
00154 return "# ART pilot state message\n\
00155 \n\
00156 # $Id: PilotState.msg 1541 2011-05-09 19:07:23Z jack.oquin $\n\
00157 \n\
00158 Header header\n\
00159 \n\
00160 DriverState pilot # pilot state\n\
00161 \n\
00162 # current states of individual devices\n\
00163 # (considered CLOSED if device not publishing)\n\
00164 DriverState brake\n\
00165 DriverState imu\n\
00166 DriverState odom\n\
00167 DriverState shifter\n\
00168 DriverState steering\n\
00169 DriverState throttle\n\
00170 \n\
00171 # true if pilot preempted for learning speed control\n\
00172 bool preempted\n\
00173 \n\
00174 # latest commanded goal and current status\n\
00175 CarDrive target # current command\n\
00176 CarDrive plan # intermediate goal\n\
00177 CarDrive current # current status\n\
00178 \n\
00179 ================================================================================\n\
00180 MSG: std_msgs/Header\n\
00181 # Standard metadata for higher-level stamped data types.\n\
00182 # This is generally used to communicate timestamped data \n\
00183 # in a particular coordinate frame.\n\
00184 # \n\
00185 # sequence ID: consecutively increasing ID \n\
00186 uint32 seq\n\
00187 #Two-integer timestamp that is expressed as:\n\
00188 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00189 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00190 # time-handling sugar is provided by the client library\n\
00191 time stamp\n\
00192 #Frame this data is associated with\n\
00193 # 0: no frame\n\
00194 # 1: global frame\n\
00195 string frame_id\n\
00196 \n\
00197 ================================================================================\n\
00198 MSG: art_msgs/DriverState\n\
00199 # ART driver states -- similar to those in driver_base.\n\
00200 \n\
00201 # $Id: DriverState.msg 1161 2011-03-26 02:10:49Z jack.oquin $\n\
00202 \n\
00203 # constants\n\
00204 uint32 CLOSED = 0 # Not connected to the hardware\n\
00205 uint32 OPENED = 1 # Passively connected to the hardware\n\
00206 uint32 RUNNING = 2 # Sending hardware commands\n\
00207 \n\
00208 uint32 state\n\
00209 \n\
00210 ================================================================================\n\
00211 MSG: art_msgs/CarDrive\n\
00212 # Driving command for a car-like vehicle using Ackermann steering.\n\
00213 # $Id: CarDrive.msg 1539 2011-05-09 04:09:20Z jack.oquin $\n\
00214 \n\
00215 # Drive at requested speed, acceleration and jerk (the 1st, 2nd and\n\
00216 # 3rd derivatives of position). All are non-negative scalars. \n\
00217 #\n\
00218 # Speed is defined as the scalar magnitude of the velocity\n\
00219 # vector. Direction (forwards or backwards) is determined by the gear.\n\
00220 #\n\
00221 # Zero acceleration means change speed as quickly as\n\
00222 # possible. Positive acceleration may include deceleration as needed\n\
00223 # to match the desired speed. It represents a desired rate and also a\n\
00224 # limit not to exceed.\n\
00225 #\n\
00226 # Zero jerk means change acceleration as quickly as possible. Positive\n\
00227 # jerk describes the desired rate of acceleration change in both\n\
00228 # directions (positive and negative).\n\
00229 #\n\
00230 float32 speed # magnitude of velocity vector (m/s)\n\
00231 float32 acceleration # desired acceleration (m/s^2)\n\
00232 float32 jerk # desired jerk (m/s^3)\n\
00233 \n\
00234 # Assumes Ackermann (front-wheel) steering. This angle is the average\n\
00235 # yaw of the two front wheels in the vehicle frame of reference\n\
00236 # (positive left), ignoring their slightly differing angles as if it\n\
00237 # were a tricycle. This is *not* the angle of the steering wheel\n\
00238 # inside the passenger compartment.\n\
00239 #\n\
00240 float32 steering_angle # steering angle (radians)\n\
00241 \n\
00242 Gear gear # requested gear (no change if Naught)\n\
00243 PilotBehavior behavior # requested pilot behavior\n\
00244 \n\
00245 ================================================================================\n\
00246 MSG: art_msgs/Gear\n\
00247 # ART vehicle transmission gear numbers\n\
00248 #\n\
00249 # Used by several different messages.\n\
00250 \n\
00251 # $Id: Gear.msg 1539 2011-05-09 04:09:20Z jack.oquin $\n\
00252 \n\
00253 # Gear numbers. \n\
00254 #\n\
00255 # Naught means: reset all Shifter relays; no change of CarDrive gear.\n\
00256 uint8 Naught = 0\n\
00257 uint8 Park = 1\n\
00258 uint8 Reverse = 2\n\
00259 uint8 Neutral = 3\n\
00260 uint8 Drive = 4\n\
00261 uint8 N_gears = 5\n\
00262 \n\
00263 uint8 value # requested or reported gear number\n\
00264 \n\
00265 ================================================================================\n\
00266 MSG: art_msgs/PilotBehavior\n\
00267 # ART autonomous vehicle pilot node behaviors.\n\
00268 #\n\
00269 # Normally, the pilot node does Run, continually sending commands to\n\
00270 # the servo device actuators and monitoring their state. With Pause,\n\
00271 # the pilot becomes passive, allowing a learning algorithm or human\n\
00272 # controller direct access to those devices. In the Off state,\n\
00273 # various devices are shut down: the transmission in Park, the brake\n\
00274 # released, the throttle at idle. The engine is not turned off, but\n\
00275 # it could be.\n\
00276 \n\
00277 # $Id: PilotBehavior.msg 1539 2011-05-09 04:09:20Z jack.oquin $\n\
00278 \n\
00279 # Behavior value\n\
00280 uint8 value\n\
00281 \n\
00282 # Behavior numbers:\n\
00283 uint8 Run = 0 # normal driving\n\
00284 uint8 Pause = 1 # stop issuing servo commands\n\
00285 uint8 Off = 2 # turn off devices\n\
00286 uint8 N_behaviors = 3\n\
00287 \n\
00288 ";
00289 }
00290
00291 static const char* value(const ::art_msgs::PilotState_<ContainerAllocator> &) { return value(); }
00292 };
00293
00294 template<class ContainerAllocator> struct HasHeader< ::art_msgs::PilotState_<ContainerAllocator> > : public TrueType {};
00295 template<class ContainerAllocator> struct HasHeader< const ::art_msgs::PilotState_<ContainerAllocator> > : public TrueType {};
00296 }
00297 }
00298
00299 namespace ros
00300 {
00301 namespace serialization
00302 {
00303
00304 template<class ContainerAllocator> struct Serializer< ::art_msgs::PilotState_<ContainerAllocator> >
00305 {
00306 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00307 {
00308 stream.next(m.header);
00309 stream.next(m.pilot);
00310 stream.next(m.brake);
00311 stream.next(m.imu);
00312 stream.next(m.odom);
00313 stream.next(m.shifter);
00314 stream.next(m.steering);
00315 stream.next(m.throttle);
00316 stream.next(m.preempted);
00317 stream.next(m.target);
00318 stream.next(m.plan);
00319 stream.next(m.current);
00320 }
00321
00322 ROS_DECLARE_ALLINONE_SERIALIZER;
00323 };
00324 }
00325 }
00326
00327 namespace ros
00328 {
00329 namespace message_operations
00330 {
00331
00332 template<class ContainerAllocator>
00333 struct Printer< ::art_msgs::PilotState_<ContainerAllocator> >
00334 {
00335 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::art_msgs::PilotState_<ContainerAllocator> & v)
00336 {
00337 s << indent << "header: ";
00338 s << std::endl;
00339 Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
00340 s << indent << "pilot: ";
00341 s << std::endl;
00342 Printer< ::art_msgs::DriverState_<ContainerAllocator> >::stream(s, indent + " ", v.pilot);
00343 s << indent << "brake: ";
00344 s << std::endl;
00345 Printer< ::art_msgs::DriverState_<ContainerAllocator> >::stream(s, indent + " ", v.brake);
00346 s << indent << "imu: ";
00347 s << std::endl;
00348 Printer< ::art_msgs::DriverState_<ContainerAllocator> >::stream(s, indent + " ", v.imu);
00349 s << indent << "odom: ";
00350 s << std::endl;
00351 Printer< ::art_msgs::DriverState_<ContainerAllocator> >::stream(s, indent + " ", v.odom);
00352 s << indent << "shifter: ";
00353 s << std::endl;
00354 Printer< ::art_msgs::DriverState_<ContainerAllocator> >::stream(s, indent + " ", v.shifter);
00355 s << indent << "steering: ";
00356 s << std::endl;
00357 Printer< ::art_msgs::DriverState_<ContainerAllocator> >::stream(s, indent + " ", v.steering);
00358 s << indent << "throttle: ";
00359 s << std::endl;
00360 Printer< ::art_msgs::DriverState_<ContainerAllocator> >::stream(s, indent + " ", v.throttle);
00361 s << indent << "preempted: ";
00362 Printer<uint8_t>::stream(s, indent + " ", v.preempted);
00363 s << indent << "target: ";
00364 s << std::endl;
00365 Printer< ::art_msgs::CarDrive_<ContainerAllocator> >::stream(s, indent + " ", v.target);
00366 s << indent << "plan: ";
00367 s << std::endl;
00368 Printer< ::art_msgs::CarDrive_<ContainerAllocator> >::stream(s, indent + " ", v.plan);
00369 s << indent << "current: ";
00370 s << std::endl;
00371 Printer< ::art_msgs::CarDrive_<ContainerAllocator> >::stream(s, indent + " ", v.current);
00372 }
00373 };
00374
00375
00376 }
00377 }
00378
00379 #endif // ART_MSGS_MESSAGE_PILOTSTATE_H
00380