00001
00002 #ifndef ASCTEC_HL_COMM_MESSAGE_MAV_STATUS_H
00003 #define ASCTEC_HL_COMM_MESSAGE_MAV_STATUS_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
00019 namespace asctec_hl_comm
00020 {
00021 template <class ContainerAllocator>
00022 struct mav_status_ {
00023 typedef mav_status_<ContainerAllocator> Type;
00024
00025 mav_status_()
00026 : header()
00027 , battery_voltage(0.0)
00028 , flight_mode_ll()
00029 , state_estimation()
00030 , position_control()
00031 , serial_interface_enabled(false)
00032 , serial_interface_active(false)
00033 , flight_time(0.0)
00034 , cpu_load(0.0)
00035 , motor_status()
00036 , gps_status()
00037 , gps_num_satellites(0)
00038 , debug1(0)
00039 , debug2(0)
00040 , have_SSDK_parameters(false)
00041 , tx_packets(0)
00042 , tx_packets_good(0)
00043 , rx_packets(0)
00044 , rx_packets_good(0)
00045 , timesync_offset(0.0)
00046 {
00047 }
00048
00049 mav_status_(const ContainerAllocator& _alloc)
00050 : header(_alloc)
00051 , battery_voltage(0.0)
00052 , flight_mode_ll(_alloc)
00053 , state_estimation(_alloc)
00054 , position_control(_alloc)
00055 , serial_interface_enabled(false)
00056 , serial_interface_active(false)
00057 , flight_time(0.0)
00058 , cpu_load(0.0)
00059 , motor_status(_alloc)
00060 , gps_status(_alloc)
00061 , gps_num_satellites(0)
00062 , debug1(0)
00063 , debug2(0)
00064 , have_SSDK_parameters(false)
00065 , tx_packets(0)
00066 , tx_packets_good(0)
00067 , rx_packets(0)
00068 , rx_packets_good(0)
00069 , timesync_offset(0.0)
00070 {
00071 }
00072
00073 typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
00074 ::std_msgs::Header_<ContainerAllocator> header;
00075
00076 typedef float _battery_voltage_type;
00077 float battery_voltage;
00078
00079 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _flight_mode_ll_type;
00080 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > flight_mode_ll;
00081
00082 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _state_estimation_type;
00083 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > state_estimation;
00084
00085 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _position_control_type;
00086 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > position_control;
00087
00088 typedef uint8_t _serial_interface_enabled_type;
00089 uint8_t serial_interface_enabled;
00090
00091 typedef uint8_t _serial_interface_active_type;
00092 uint8_t serial_interface_active;
00093
00094 typedef float _flight_time_type;
00095 float flight_time;
00096
00097 typedef float _cpu_load_type;
00098 float cpu_load;
00099
00100 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _motor_status_type;
00101 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > motor_status;
00102
00103 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _gps_status_type;
00104 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > gps_status;
00105
00106 typedef int32_t _gps_num_satellites_type;
00107 int32_t gps_num_satellites;
00108
00109 typedef int32_t _debug1_type;
00110 int32_t debug1;
00111
00112 typedef int32_t _debug2_type;
00113 int32_t debug2;
00114
00115 typedef uint8_t _have_SSDK_parameters_type;
00116 uint8_t have_SSDK_parameters;
00117
00118 typedef uint32_t _tx_packets_type;
00119 uint32_t tx_packets;
00120
00121 typedef uint32_t _tx_packets_good_type;
00122 uint32_t tx_packets_good;
00123
00124 typedef uint32_t _rx_packets_type;
00125 uint32_t rx_packets;
00126
00127 typedef uint32_t _rx_packets_good_type;
00128 uint32_t rx_packets_good;
00129
00130 typedef float _timesync_offset_type;
00131 float timesync_offset;
00132
00133
00134 typedef boost::shared_ptr< ::asctec_hl_comm::mav_status_<ContainerAllocator> > Ptr;
00135 typedef boost::shared_ptr< ::asctec_hl_comm::mav_status_<ContainerAllocator> const> ConstPtr;
00136 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00137 };
00138 typedef ::asctec_hl_comm::mav_status_<std::allocator<void> > mav_status;
00139
00140 typedef boost::shared_ptr< ::asctec_hl_comm::mav_status> mav_statusPtr;
00141 typedef boost::shared_ptr< ::asctec_hl_comm::mav_status const> mav_statusConstPtr;
00142
00143
00144 template<typename ContainerAllocator>
00145 std::ostream& operator<<(std::ostream& s, const ::asctec_hl_comm::mav_status_<ContainerAllocator> & v)
00146 {
00147 ros::message_operations::Printer< ::asctec_hl_comm::mav_status_<ContainerAllocator> >::stream(s, "", v);
00148 return s;}
00149
00150 }
00151
00152 namespace ros
00153 {
00154 namespace message_traits
00155 {
00156 template<class ContainerAllocator> struct IsMessage< ::asctec_hl_comm::mav_status_<ContainerAllocator> > : public TrueType {};
00157 template<class ContainerAllocator> struct IsMessage< ::asctec_hl_comm::mav_status_<ContainerAllocator> const> : public TrueType {};
00158 template<class ContainerAllocator>
00159 struct MD5Sum< ::asctec_hl_comm::mav_status_<ContainerAllocator> > {
00160 static const char* value()
00161 {
00162 return "f975cbdf223868931f194323c62d7be5";
00163 }
00164
00165 static const char* value(const ::asctec_hl_comm::mav_status_<ContainerAllocator> &) { return value(); }
00166 static const uint64_t static_value1 = 0xf975cbdf22386893ULL;
00167 static const uint64_t static_value2 = 0x1f194323c62d7be5ULL;
00168 };
00169
00170 template<class ContainerAllocator>
00171 struct DataType< ::asctec_hl_comm::mav_status_<ContainerAllocator> > {
00172 static const char* value()
00173 {
00174 return "asctec_hl_comm/mav_status";
00175 }
00176
00177 static const char* value(const ::asctec_hl_comm::mav_status_<ContainerAllocator> &) { return value(); }
00178 };
00179
00180 template<class ContainerAllocator>
00181 struct Definition< ::asctec_hl_comm::mav_status_<ContainerAllocator> > {
00182 static const char* value()
00183 {
00184 return "Header header\n\
00185 \n\
00186 float32 battery_voltage\n\
00187 string flight_mode_ll\n\
00188 string state_estimation\n\
00189 string position_control\n\
00190 bool serial_interface_enabled\n\
00191 bool serial_interface_active\n\
00192 float32 flight_time\n\
00193 float32 cpu_load\n\
00194 \n\
00195 string motor_status\n\
00196 \n\
00197 string gps_status\n\
00198 int32 gps_num_satellites \n\
00199 \n\
00200 int32 debug1\n\
00201 int32 debug2\n\
00202 \n\
00203 bool have_SSDK_parameters\n\
00204 \n\
00205 uint32 tx_packets\n\
00206 uint32 tx_packets_good\n\
00207 uint32 rx_packets\n\
00208 uint32 rx_packets_good\n\
00209 \n\
00210 float32 timesync_offset\n\
00211 ================================================================================\n\
00212 MSG: std_msgs/Header\n\
00213 # Standard metadata for higher-level stamped data types.\n\
00214 # This is generally used to communicate timestamped data \n\
00215 # in a particular coordinate frame.\n\
00216 # \n\
00217 # sequence ID: consecutively increasing ID \n\
00218 uint32 seq\n\
00219 #Two-integer timestamp that is expressed as:\n\
00220 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00221 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00222 # time-handling sugar is provided by the client library\n\
00223 time stamp\n\
00224 #Frame this data is associated with\n\
00225 # 0: no frame\n\
00226 # 1: global frame\n\
00227 string frame_id\n\
00228 \n\
00229 ";
00230 }
00231
00232 static const char* value(const ::asctec_hl_comm::mav_status_<ContainerAllocator> &) { return value(); }
00233 };
00234
00235 template<class ContainerAllocator> struct HasHeader< ::asctec_hl_comm::mav_status_<ContainerAllocator> > : public TrueType {};
00236 template<class ContainerAllocator> struct HasHeader< const ::asctec_hl_comm::mav_status_<ContainerAllocator> > : public TrueType {};
00237 }
00238 }
00239
00240 namespace ros
00241 {
00242 namespace serialization
00243 {
00244
00245 template<class ContainerAllocator> struct Serializer< ::asctec_hl_comm::mav_status_<ContainerAllocator> >
00246 {
00247 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00248 {
00249 stream.next(m.header);
00250 stream.next(m.battery_voltage);
00251 stream.next(m.flight_mode_ll);
00252 stream.next(m.state_estimation);
00253 stream.next(m.position_control);
00254 stream.next(m.serial_interface_enabled);
00255 stream.next(m.serial_interface_active);
00256 stream.next(m.flight_time);
00257 stream.next(m.cpu_load);
00258 stream.next(m.motor_status);
00259 stream.next(m.gps_status);
00260 stream.next(m.gps_num_satellites);
00261 stream.next(m.debug1);
00262 stream.next(m.debug2);
00263 stream.next(m.have_SSDK_parameters);
00264 stream.next(m.tx_packets);
00265 stream.next(m.tx_packets_good);
00266 stream.next(m.rx_packets);
00267 stream.next(m.rx_packets_good);
00268 stream.next(m.timesync_offset);
00269 }
00270
00271 ROS_DECLARE_ALLINONE_SERIALIZER;
00272 };
00273 }
00274 }
00275
00276 namespace ros
00277 {
00278 namespace message_operations
00279 {
00280
00281 template<class ContainerAllocator>
00282 struct Printer< ::asctec_hl_comm::mav_status_<ContainerAllocator> >
00283 {
00284 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::asctec_hl_comm::mav_status_<ContainerAllocator> & v)
00285 {
00286 s << indent << "header: ";
00287 s << std::endl;
00288 Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
00289 s << indent << "battery_voltage: ";
00290 Printer<float>::stream(s, indent + " ", v.battery_voltage);
00291 s << indent << "flight_mode_ll: ";
00292 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.flight_mode_ll);
00293 s << indent << "state_estimation: ";
00294 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.state_estimation);
00295 s << indent << "position_control: ";
00296 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.position_control);
00297 s << indent << "serial_interface_enabled: ";
00298 Printer<uint8_t>::stream(s, indent + " ", v.serial_interface_enabled);
00299 s << indent << "serial_interface_active: ";
00300 Printer<uint8_t>::stream(s, indent + " ", v.serial_interface_active);
00301 s << indent << "flight_time: ";
00302 Printer<float>::stream(s, indent + " ", v.flight_time);
00303 s << indent << "cpu_load: ";
00304 Printer<float>::stream(s, indent + " ", v.cpu_load);
00305 s << indent << "motor_status: ";
00306 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.motor_status);
00307 s << indent << "gps_status: ";
00308 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.gps_status);
00309 s << indent << "gps_num_satellites: ";
00310 Printer<int32_t>::stream(s, indent + " ", v.gps_num_satellites);
00311 s << indent << "debug1: ";
00312 Printer<int32_t>::stream(s, indent + " ", v.debug1);
00313 s << indent << "debug2: ";
00314 Printer<int32_t>::stream(s, indent + " ", v.debug2);
00315 s << indent << "have_SSDK_parameters: ";
00316 Printer<uint8_t>::stream(s, indent + " ", v.have_SSDK_parameters);
00317 s << indent << "tx_packets: ";
00318 Printer<uint32_t>::stream(s, indent + " ", v.tx_packets);
00319 s << indent << "tx_packets_good: ";
00320 Printer<uint32_t>::stream(s, indent + " ", v.tx_packets_good);
00321 s << indent << "rx_packets: ";
00322 Printer<uint32_t>::stream(s, indent + " ", v.rx_packets);
00323 s << indent << "rx_packets_good: ";
00324 Printer<uint32_t>::stream(s, indent + " ", v.rx_packets_good);
00325 s << indent << "timesync_offset: ";
00326 Printer<float>::stream(s, indent + " ", v.timesync_offset);
00327 }
00328 };
00329
00330
00331 }
00332 }
00333
00334 #endif // ASCTEC_HL_COMM_MESSAGE_MAV_STATUS_H
00335