00001
00002 #ifndef UBLOX_MSGS_MESSAGE_CFGNAV5_H
00003 #define UBLOX_MSGS_MESSAGE_CFGNAV5_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
00018 namespace ublox_msgs
00019 {
00020 template <class ContainerAllocator>
00021 struct CfgNAV5_ {
00022 typedef CfgNAV5_<ContainerAllocator> Type;
00023
00024 CfgNAV5_()
00025 : mask(0)
00026 , dynModel(0)
00027 , fixMode(0)
00028 , fixedAlt(0)
00029 , fixedAltVar(0)
00030 , minElev(0)
00031 , drLimit(0)
00032 , pDop(0)
00033 , tDop(0)
00034 , pAcc(0)
00035 , tAcc(0)
00036 , staticHoldThresh(0)
00037 , dgpsTimeOut(0)
00038 , reserved2(0)
00039 , reserved3(0)
00040 , reserved4(0)
00041 {
00042 }
00043
00044 CfgNAV5_(const ContainerAllocator& _alloc)
00045 : mask(0)
00046 , dynModel(0)
00047 , fixMode(0)
00048 , fixedAlt(0)
00049 , fixedAltVar(0)
00050 , minElev(0)
00051 , drLimit(0)
00052 , pDop(0)
00053 , tDop(0)
00054 , pAcc(0)
00055 , tAcc(0)
00056 , staticHoldThresh(0)
00057 , dgpsTimeOut(0)
00058 , reserved2(0)
00059 , reserved3(0)
00060 , reserved4(0)
00061 {
00062 }
00063
00064 typedef uint16_t _mask_type;
00065 uint16_t mask;
00066
00067 typedef uint8_t _dynModel_type;
00068 uint8_t dynModel;
00069
00070 typedef uint8_t _fixMode_type;
00071 uint8_t fixMode;
00072
00073 typedef int32_t _fixedAlt_type;
00074 int32_t fixedAlt;
00075
00076 typedef uint32_t _fixedAltVar_type;
00077 uint32_t fixedAltVar;
00078
00079 typedef int8_t _minElev_type;
00080 int8_t minElev;
00081
00082 typedef uint8_t _drLimit_type;
00083 uint8_t drLimit;
00084
00085 typedef uint16_t _pDop_type;
00086 uint16_t pDop;
00087
00088 typedef uint16_t _tDop_type;
00089 uint16_t tDop;
00090
00091 typedef uint16_t _pAcc_type;
00092 uint16_t pAcc;
00093
00094 typedef uint16_t _tAcc_type;
00095 uint16_t tAcc;
00096
00097 typedef uint8_t _staticHoldThresh_type;
00098 uint8_t staticHoldThresh;
00099
00100 typedef uint8_t _dgpsTimeOut_type;
00101 uint8_t dgpsTimeOut;
00102
00103 typedef uint32_t _reserved2_type;
00104 uint32_t reserved2;
00105
00106 typedef uint32_t _reserved3_type;
00107 uint32_t reserved3;
00108
00109 typedef uint32_t _reserved4_type;
00110 uint32_t reserved4;
00111
00112 enum { CLASS_ID = 6 };
00113 enum { MESSAGE_ID = 36 };
00114 enum { MASK_DYN = 1 };
00115 enum { MASK_MIN_EL = 2 };
00116 enum { MASK_FIX_MODE = 4 };
00117 enum { MASK_DR_LIM = 8 };
00118 enum { MASK_POS_MASK = 16 };
00119 enum { MASK_TIME_MASK = 32 };
00120 enum { MASK_STATIC_HOLD_MASK = 64 };
00121 enum { MASK_DGPS_MASK = 128 };
00122 enum { DYN_MODEL_PORTABLE = 0 };
00123 enum { DYN_MODEL_STATIONARY = 2 };
00124 enum { DYN_MODEL_PEDESTRIAN = 3 };
00125 enum { DYN_MODEL_AUTOMOTIVE = 4 };
00126 enum { DYN_MODEL_SEA = 5 };
00127 enum { DYN_MODEL_AIRBORNE_1G = 6 };
00128 enum { DYN_MODEL_AIRBORNE_2G = 7 };
00129 enum { DYN_MODEL_AIRBORNE_4G = 8 };
00130 enum { FIX_MODE_2D_ONLY = 1 };
00131 enum { FIX_MODE_3D_ONLY = 2 };
00132 enum { FIX_MODE_AUTO = 3 };
00133
00134 typedef boost::shared_ptr< ::ublox_msgs::CfgNAV5_<ContainerAllocator> > Ptr;
00135 typedef boost::shared_ptr< ::ublox_msgs::CfgNAV5_<ContainerAllocator> const> ConstPtr;
00136 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00137 };
00138 typedef ::ublox_msgs::CfgNAV5_<std::allocator<void> > CfgNAV5;
00139
00140 typedef boost::shared_ptr< ::ublox_msgs::CfgNAV5> CfgNAV5Ptr;
00141 typedef boost::shared_ptr< ::ublox_msgs::CfgNAV5 const> CfgNAV5ConstPtr;
00142
00143
00144 template<typename ContainerAllocator>
00145 std::ostream& operator<<(std::ostream& s, const ::ublox_msgs::CfgNAV5_<ContainerAllocator> & v)
00146 {
00147 ros::message_operations::Printer< ::ublox_msgs::CfgNAV5_<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< ::ublox_msgs::CfgNAV5_<ContainerAllocator> > : public TrueType {};
00157 template<class ContainerAllocator> struct IsMessage< ::ublox_msgs::CfgNAV5_<ContainerAllocator> const> : public TrueType {};
00158 template<class ContainerAllocator>
00159 struct MD5Sum< ::ublox_msgs::CfgNAV5_<ContainerAllocator> > {
00160 static const char* value()
00161 {
00162 return "7c6e2419d1dd6532b8f09e39a02e167c";
00163 }
00164
00165 static const char* value(const ::ublox_msgs::CfgNAV5_<ContainerAllocator> &) { return value(); }
00166 static const uint64_t static_value1 = 0x7c6e2419d1dd6532ULL;
00167 static const uint64_t static_value2 = 0xb8f09e39a02e167cULL;
00168 };
00169
00170 template<class ContainerAllocator>
00171 struct DataType< ::ublox_msgs::CfgNAV5_<ContainerAllocator> > {
00172 static const char* value()
00173 {
00174 return "ublox_msgs/CfgNAV5";
00175 }
00176
00177 static const char* value(const ::ublox_msgs::CfgNAV5_<ContainerAllocator> &) { return value(); }
00178 };
00179
00180 template<class ContainerAllocator>
00181 struct Definition< ::ublox_msgs::CfgNAV5_<ContainerAllocator> > {
00182 static const char* value()
00183 {
00184 return "# CFG-NAV5 (0x06 0x24)\n\
00185 # Navigation Engine Settings\n\
00186 #\n\
00187 \n\
00188 uint8 CLASS_ID = 6\n\
00189 uint8 MESSAGE_ID = 36\n\
00190 \n\
00191 uint16 mask # Parameters Bitmask. Only the masked\n\
00192 # parameters will be applied.\n\
00193 uint16 MASK_DYN = 1 # Apply dynamic model settings\n\
00194 uint16 MASK_MIN_EL = 2 # Apply minimum elevation settings\n\
00195 uint16 MASK_FIX_MODE = 4 # Apply fix mode settings\n\
00196 uint16 MASK_DR_LIM = 8 # Apply DR limit settings\n\
00197 uint16 MASK_POS_MASK = 16 # Apply position mask settings\n\
00198 uint16 MASK_TIME_MASK = 32 # Apply time mask settings\n\
00199 uint16 MASK_STATIC_HOLD_MASK = 64 # Apply static hold settings\n\
00200 uint16 MASK_DGPS_MASK = 128 # Apply DGPS settings, firmware 7 and newer only\n\
00201 \n\
00202 uint8 dynModel # Dynamic Platform model:\n\
00203 uint8 DYN_MODEL_PORTABLE = 0 # Portable\n\
00204 uint8 DYN_MODEL_STATIONARY = 2 # Stationary\n\
00205 uint8 DYN_MODEL_PEDESTRIAN = 3 # Pedestrian\n\
00206 uint8 DYN_MODEL_AUTOMOTIVE = 4 # Automotive\n\
00207 uint8 DYN_MODEL_SEA = 5 # Sea\n\
00208 uint8 DYN_MODEL_AIRBORNE_1G = 6 # Airborne with <1g Acceleration\n\
00209 uint8 DYN_MODEL_AIRBORNE_2G = 7 # Airborne with <2g Acceleration\n\
00210 uint8 DYN_MODEL_AIRBORNE_4G = 8 # Airborne with <4g Acceleration\n\
00211 \n\
00212 uint8 fixMode # Position Fixing Mode.\n\
00213 uint8 FIX_MODE_2D_ONLY = 1 # 2D only\n\
00214 uint8 FIX_MODE_3D_ONLY = 2 # 3D only\n\
00215 uint8 FIX_MODE_AUTO = 3 # Auto 2D/3D\n\
00216 \n\
00217 int32 fixedAlt # Fixed altitude (mean sea level) for 2D fix mode. [m / 0.01]\n\
00218 uint32 fixedAltVar # Fixed altitude variance for 2D mode. [m^2 / 0.0001]\n\
00219 int8 minElev # Minimum Elevation for a GNSS satellite to be used in NAV [deg]\n\
00220 uint8 drLimit # Maximum time to perform dead reckoning [s]\n\
00221 # (linear extrapolation) in case of GPS signal loss\n\
00222 uint16 pDop # Position DOP Mask to use [1 / 0.1]\n\
00223 uint16 tDop # Time DOP Mask to use [1 / 0.1]\n\
00224 uint16 pAcc # Position Accuracy Mask [m]\n\
00225 uint16 tAcc # Time Accuracy Mask [m]\n\
00226 uint8 staticHoldThresh # Static hold threshold [cm/s]\n\
00227 uint8 dgpsTimeOut # DGPS timeout, firmware 7 and newer only [s]\n\
00228 uint32 reserved2 # Always set to zero\n\
00229 uint32 reserved3 # Always set to zero\n\
00230 uint32 reserved4 # Always set to zero\n\
00231 \n\
00232 ";
00233 }
00234
00235 static const char* value(const ::ublox_msgs::CfgNAV5_<ContainerAllocator> &) { return value(); }
00236 };
00237
00238 template<class ContainerAllocator> struct IsFixedSize< ::ublox_msgs::CfgNAV5_<ContainerAllocator> > : public TrueType {};
00239 }
00240 }
00241
00242 namespace ros
00243 {
00244 namespace serialization
00245 {
00246
00247 template<class ContainerAllocator> struct Serializer< ::ublox_msgs::CfgNAV5_<ContainerAllocator> >
00248 {
00249 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00250 {
00251 stream.next(m.mask);
00252 stream.next(m.dynModel);
00253 stream.next(m.fixMode);
00254 stream.next(m.fixedAlt);
00255 stream.next(m.fixedAltVar);
00256 stream.next(m.minElev);
00257 stream.next(m.drLimit);
00258 stream.next(m.pDop);
00259 stream.next(m.tDop);
00260 stream.next(m.pAcc);
00261 stream.next(m.tAcc);
00262 stream.next(m.staticHoldThresh);
00263 stream.next(m.dgpsTimeOut);
00264 stream.next(m.reserved2);
00265 stream.next(m.reserved3);
00266 stream.next(m.reserved4);
00267 }
00268
00269 ROS_DECLARE_ALLINONE_SERIALIZER;
00270 };
00271 }
00272 }
00273
00274 namespace ros
00275 {
00276 namespace message_operations
00277 {
00278
00279 template<class ContainerAllocator>
00280 struct Printer< ::ublox_msgs::CfgNAV5_<ContainerAllocator> >
00281 {
00282 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ublox_msgs::CfgNAV5_<ContainerAllocator> & v)
00283 {
00284 s << indent << "mask: ";
00285 Printer<uint16_t>::stream(s, indent + " ", v.mask);
00286 s << indent << "dynModel: ";
00287 Printer<uint8_t>::stream(s, indent + " ", v.dynModel);
00288 s << indent << "fixMode: ";
00289 Printer<uint8_t>::stream(s, indent + " ", v.fixMode);
00290 s << indent << "fixedAlt: ";
00291 Printer<int32_t>::stream(s, indent + " ", v.fixedAlt);
00292 s << indent << "fixedAltVar: ";
00293 Printer<uint32_t>::stream(s, indent + " ", v.fixedAltVar);
00294 s << indent << "minElev: ";
00295 Printer<int8_t>::stream(s, indent + " ", v.minElev);
00296 s << indent << "drLimit: ";
00297 Printer<uint8_t>::stream(s, indent + " ", v.drLimit);
00298 s << indent << "pDop: ";
00299 Printer<uint16_t>::stream(s, indent + " ", v.pDop);
00300 s << indent << "tDop: ";
00301 Printer<uint16_t>::stream(s, indent + " ", v.tDop);
00302 s << indent << "pAcc: ";
00303 Printer<uint16_t>::stream(s, indent + " ", v.pAcc);
00304 s << indent << "tAcc: ";
00305 Printer<uint16_t>::stream(s, indent + " ", v.tAcc);
00306 s << indent << "staticHoldThresh: ";
00307 Printer<uint8_t>::stream(s, indent + " ", v.staticHoldThresh);
00308 s << indent << "dgpsTimeOut: ";
00309 Printer<uint8_t>::stream(s, indent + " ", v.dgpsTimeOut);
00310 s << indent << "reserved2: ";
00311 Printer<uint32_t>::stream(s, indent + " ", v.reserved2);
00312 s << indent << "reserved3: ";
00313 Printer<uint32_t>::stream(s, indent + " ", v.reserved3);
00314 s << indent << "reserved4: ";
00315 Printer<uint32_t>::stream(s, indent + " ", v.reserved4);
00316 }
00317 };
00318
00319
00320 }
00321 }
00322
00323 #endif // UBLOX_MSGS_MESSAGE_CFGNAV5_H
00324
