MRPT  1.9.9
gnss_messages_novatel.h
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 #pragma once
10 
11 #include "gnss_messages_common.h"
12 
13 namespace mrpt::obs::gnss
14 {
15 // Pragma to ensure we can safely serialize some of these structures
16 #pragma pack(push, 1)
17 
18 /** Novatel OEM6 regular header structure \sa mrpt::obs::CObservationGPS */
20 {
21  enum : uint8_t
22  {
23  SYNCH0 = 0xAA,
24  SYNCH1 = 0X44,
25  SYNCH2 = 0x12
26  };
27 
28  uint8_t synch[3]{0, 0, 0};
29  uint8_t hdr_len{0};
30  uint16_t msg_id{0};
31  uint8_t msg_type{0};
32  uint8_t port_addr{0};
33  uint16_t msg_len{0};
34  uint16_t seq_number{0};
35  uint8_t idle_percent{0};
36  uint8_t time_status{0};
37  uint16_t week{0};
38  uint32_t ms_in_week{0};
39  uint32_t receiver_status{0};
40  uint16_t reserved{0};
41  uint16_t receiver_sw_version{0};
42 
44  {
45 #if MRPT_IS_BIG_ENDIAN
54 #endif
55  }
56 };
57 
58 /** Novatel OEM6 short header structure \sa mrpt::obs::CObservationGPS */
60 {
61  enum : uint8_t
62  {
63  SYNCH0 = 0xAA,
64  SYNCH1 = 0X44,
65  SYNCH2 = 0x13
66  };
67  uint8_t synch[3]{0, 0, 0};
68  uint8_t msg_len{0};
69  uint16_t msg_id{0};
70  uint16_t week{0};
71  uint32_t ms_in_week{0};
72 
74  {
75 #if MRPT_IS_BIG_ENDIAN
80 #endif
81  }
82 };
83 
84 namespace nv_oem6_position_type
85 {
86 /** Novatel OEM6 firmware reference, table 84; Novatel SPAN on OEM6 firmware
87  * manual, table 26. */
88 enum nv_position_type_t : uint32_t
89 {
90  NONE = 0,
91  FIXEDPOS = 1,
93  Reserved = 3,
94  FLOATCONV = 4,
95  WIDELANE = 5,
98  SINGLE = 16,
99  PSRDIFF = 17,
100  WAAS = 18,
102  OMNISTAR = 20,
103  L1_FLOAT = 32,
106  L1_INT = 48,
107  WIDE_INT = 49,
110  INS = 52,
111  INS_PSRSP = 53,
117  CDGPS = 66
118 };
119 /** for nv_position_type_t */
120 const std::string& enum2str(int val);
121 } // namespace nv_oem6_position_type
122 
123 namespace nv_oem6_solution_status
124 {
125 /** Novatel OEM6 firmware reference, table 85 */
126 enum nv_solution_status_t : uint32_t
127 {
128  /** solution computed */
130  /** insufficient observations */
132  /** noconvergence */
134  /** singularity at parameters matrix */
136  /** covariance trace exceeds maximum (trace>1000m) */
138  /** test distance exceeded (max of 3 rejections if distance > 10km) */
140  /** not yet converged from cold start */
142  /** height or velocity limits exceeded */
144  /** variance exceeds limits */
146  /** residuals are too large */
148  /** delta position is too large */
150  /** negative variance */
152  /** large residuals make position unreliable */
154  /** ins has not started yet */
156  /** ins doing its coarse alignment */
158  /** ins position is bad */
160  /** no imu detected */
162  /** when a fix position command is entered, the receiver computes its own
163  position and determines if the fixed position is valid */
164  PENDING = 18,
165  /** the fixed position entered using the fix position command is not valid
166  */
168 };
169 /** for nv_solution_status_t */
170 const std::string& enum2str(int val);
171 } // namespace nv_oem6_solution_status
172 namespace nv_oem6_ins_status_type
173 {
174 /** Novatel SPAN on OEM6 firmware reference, table 33 */
175 enum nv_ins_status_type_t : uint32_t
176 {
177  INS_INACTIVE = 0, // IMU logs are present, but the alignment routine has
178  // not started; INS is inactive.
179  INS_ALIGNING = 1, // INS is in alignment mode.
180  INS_HIGH_VARIANCE = 2, // The INS solution is in navigation mode but the
181  // azimuth solution uncertainty has exceeded the
182  // threshold.
183  INS_SOLUTION_GOOD = 3, // The INS filter is in navigation mode and the INS
184  // solution is good.
185  INS_SOLUTION_FREE = 6, // The INS filter is in navigation mode and the GNSS
186  // solution is suspected to be in error.
187  INS_ALIGNMENT_COMPLETE = 7, // The INS filter is in navigation mode, but
188  // not enough vehicle dynamics have been
189  // experienced for the system to be within
190  // specifications.
192  8, // INS is determining the IMU axis aligned with gravity.
193  WAITING_INITIALPOS = 9 // The INS filter has determined the IMU orientation
194  // and is awaiting an initial position estimate to
195  // begin the alignment process.
196 };
197 /** for nv_ins_status_type_t */
198 const std::string& enum2str(int val);
199 } // namespace nv_oem6_ins_status_type
200 
201 /** Novatel generic frame (to store frames without a parser at the present
202  * time). \sa mrpt::obs::CObservationGPS */
204 {
207  {
208  }
209  /** Frame header */
211  std::vector<uint8_t> msg_body;
212 
213  void fixEndianness() override { header.fixEndianness(); }
214 
215  void dumpToStream(std::ostream& out) const override; // See docs in base
216  protected:
218  mrpt::serialization::CArchive& out) const override;
220 };
221 
222 /** Novatel generic short-header frame (to store frames without a parser at the
223  * present time). \sa mrpt::obs::CObservationGPS */
225 {
228  {
229  }
230  /** Frame header */
232  std::vector<uint8_t> msg_body;
233 
234  void fixEndianness() override { header.fixEndianness(); }
235 
236  void dumpToStream(std::ostream& out) const override; // See docs in base
237  protected:
239  mrpt::serialization::CArchive& out) const override;
241 };
242 
243 /** Novatel frame: NV_OEM6_BESTPOS. \sa mrpt::obs::CObservationGPS */
245 /** Frame header */
247 nv_oem6_solution_status::nv_solution_status_t solution_stat =
248  nv_oem6_solution_status::INVALID_FIX;
249 nv_oem6_position_type::nv_position_type_t position_type =
250  nv_oem6_position_type::NONE;
251 /** [deg], [deg], hgt over sea level[m] */
252 double lat = 0, lon = 0, hgt = 0;
253 float undulation = 0;
254 uint32_t datum_id = 0;
255 /** Uncertainties (all in [m]) */
256 float lat_sigma = 0, lon_sigma = 0, hgt_sigma = 0;
257 char base_station_id[4]{0, 0, 0, 0};
258 float diff_age = 0, sol_age = 0;
261 uint8_t reserved = 0;
262 uint8_t ext_sol_stat = 0;
264 uint8_t gps_glonass_mask = 0;
265 uint32_t crc = 0;
267 /** Return the geodetic coords as a mrpt::topography::TGeodeticCoords structure
268  * (requires linking against mrpt-topography)
269  * Call as: getAsStruct<TGeodeticCoords>(); */
270 template <class TGEODETICCOORDS>
271 inline TGEODETICCOORDS getAsStruct() const
272 {
273  return TGEODETICCOORDS(fields.lat, fields.lon, fields.hgt);
274 }
275 bool getAllFieldDescriptions(std::ostream& o) const override;
276 bool getAllFieldValues(std::ostream& o) const override;
277 void fixEndianness() override
278 {
279 #if MRPT_IS_BIG_ENDIAN
280  fields.header.fixEndianness();
281  mrpt::reverseBytesInPlace_enum(fields.solution_stat);
282  mrpt::reverseBytesInPlace_enum(fields.position_type);
283  mrpt::reverseBytesInPlace(fields.lat);
284  mrpt::reverseBytesInPlace(fields.lon);
285  mrpt::reverseBytesInPlace(fields.hgt);
286  mrpt::reverseBytesInPlace(fields.undulation);
287  mrpt::reverseBytesInPlace(fields.datum_id);
288  mrpt::reverseBytesInPlace(fields.lat_sigma);
289  mrpt::reverseBytesInPlace(fields.lon_sigma);
290  mrpt::reverseBytesInPlace(fields.hgt_sigma);
291  mrpt::reverseBytesInPlace(fields.diff_age);
292  mrpt::reverseBytesInPlace(fields.sol_age);
293  mrpt::reverseBytesInPlace(fields.crc);
294 #endif
295 }
297 
298 /** Novatel frame: NV_OEM6_INSPVAS. \sa mrpt::obs::CObservationGPS */
300 /** Frame header */
301 nv_oem6_short_header_t header;
302 uint32_t week = 0;
303 double seconds_in_week = 0;
304 double lat = 0, lon = 0, hgt = 0;
305 double vel_north = 0, vel_east = 0, vel_up = 0;
306 double roll = 0, pitch = 0, azimuth = 0;
309 uint32_t crc = 0;
311 /** Return the geodetic coords as a mrpt::topography::TGeodeticCoords structure
312  * (requires linking against mrpt-topography)
313  * Call as: getAsStruct<TGeodeticCoords>(); */
314 template <class TGEODETICCOORDS>
315 inline TGEODETICCOORDS getAsStruct() const
316 {
317  return TGEODETICCOORDS(fields.lat, fields.lon, fields.hgt);
318 }
319 bool getAllFieldDescriptions(std::ostream& o) const override;
320 bool getAllFieldValues(std::ostream& o) const override;
321 void fixEndianness() override
322 {
323 #if MRPT_IS_BIG_ENDIAN
324  fields.header.fixEndianness();
325  mrpt::reverseBytesInPlace(fields.week);
326  mrpt::reverseBytesInPlace(fields.seconds_in_week);
327  mrpt::reverseBytesInPlace(fields.lat);
328  mrpt::reverseBytesInPlace(fields.lon);
329  mrpt::reverseBytesInPlace(fields.hgt);
330  mrpt::reverseBytesInPlace(fields.vel_north);
331  mrpt::reverseBytesInPlace(fields.vel_east);
332  mrpt::reverseBytesInPlace(fields.vel_up);
333  mrpt::reverseBytesInPlace(fields.roll);
334  mrpt::reverseBytesInPlace(fields.pitch);
335  mrpt::reverseBytesInPlace(fields.azimuth);
336  mrpt::reverseBytesInPlace_enum(fields.ins_status);
337  mrpt::reverseBytesInPlace(fields.crc);
338 #endif
339 }
341 
342 /** Novatel frame: NV_OEM6_INSCOVS. \sa mrpt::obs::CObservationGPS */
344 /** Frame header */
345 nv_oem6_short_header_t header;
346 uint32_t week = 0;
347 double seconds_in_week = 0;
348 /** Position covariance matrix in local level frame (metres squared)
349  * xx,xy,xz,yx,yy,yz,zx,zy,zz */
350 double pos_cov[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
351 /** Attitude covariance matrix of the SPAN frame to the local level frame. (deg
352  * sq) xx,xy,xz,yx,yy,yz,zx,zy,zz */
353 double att_cov[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
354 /** Velocity covariance matrix in local level frame. (metres/second squared)
355  * xx,xy,xz,yx,yy,yz,zx,zy,zz */
356 double vel_cov[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
357 uint32_t crc = 0;
359 bool getAllFieldDescriptions(std::ostream& o) const override;
360 bool getAllFieldValues(std::ostream& o) const override;
361 void fixEndianness() override
362 {
363 #if MRPT_IS_BIG_ENDIAN
364  fields.header.fixEndianness();
365  mrpt::reverseBytesInPlace(fields.week);
366  mrpt::reverseBytesInPlace(fields.seconds_in_week);
367  for (int i = 0; i < 9; i++)
368  {
369  mrpt::reverseBytesInPlace(fields.pos_cov[i]);
370  mrpt::reverseBytesInPlace(fields.att_cov[i]);
371  mrpt::reverseBytesInPlace(fields.vel_cov[i]);
372  }
373  mrpt::reverseBytesInPlace(fields.crc);
374 #endif
375 }
377 
378 /** Novatel frame: NV_OEM6_RANGECMP. \sa mrpt::obs::CObservationGPS */
380 {
383  {
384  }
386  {
387  uint8_t data[24];
388  };
389 
390  /** Frame header */
392  uint32_t num_obs{0};
393  std::vector<TCompressedRangeLog> obs_data;
394  uint32_t crc;
395 
396  void dumpToStream(std::ostream& out) const override; // See docs in base
397  protected:
399  mrpt::serialization::CArchive& out) const override;
401 };
402 
403 /** Novatel frame: NV_OEM6_RXSTATUS. \sa mrpt::obs::CObservationGPS */
405 /** Frame header */
407 uint32_t error = 0, num_stats = 0;
408 uint32_t rxstat = 0, rxstat_pri = 0, rxstat_set = 0, rxstat_clear = 0;
409 uint32_t aux1stat = 0, aux1stat_pri = 0, aux1stat_set = 0, aux1stat_clear = 0;
410 uint32_t aux2stat = 0, aux2stat_pri = 0, aux2stat_set = 0, aux2stat_clear = 0;
411 uint32_t aux3stat = 0, aux3stat_pri = 0, aux3stat_set = 0, aux3stat_clear = 0;
412 uint32_t crc = 0;
414 void fixEndianness() override
415 {
416 #if MRPT_IS_BIG_ENDIAN
417  fields.header.fixEndianness();
418  mrpt::reverseBytesInPlace(fields.error);
419  mrpt::reverseBytesInPlace(fields.num_stats);
420  mrpt::reverseBytesInPlace(fields.rxstat);
421  mrpt::reverseBytesInPlace(fields.rxstat_pri);
422  mrpt::reverseBytesInPlace(fields.rxstat_set);
423  mrpt::reverseBytesInPlace(fields.rxstat_clear);
424  mrpt::reverseBytesInPlace(fields.aux1stat);
425  mrpt::reverseBytesInPlace(fields.aux1stat_pri);
426  mrpt::reverseBytesInPlace(fields.aux1stat_set);
427  mrpt::reverseBytesInPlace(fields.aux1stat_clear);
428  mrpt::reverseBytesInPlace(fields.aux2stat);
429  mrpt::reverseBytesInPlace(fields.aux2stat_pri);
430  mrpt::reverseBytesInPlace(fields.aux2stat_set);
431  mrpt::reverseBytesInPlace(fields.aux2stat_clear);
432  mrpt::reverseBytesInPlace(fields.aux3stat);
433  mrpt::reverseBytesInPlace(fields.aux3stat_pri);
434  mrpt::reverseBytesInPlace(fields.aux3stat_set);
435  mrpt::reverseBytesInPlace(fields.aux3stat_clear);
436  mrpt::reverseBytesInPlace(fields.crc);
437 #endif
438 }
440 
441 /** Novatel frame: NV_OEM6_RAWEPHEM. \sa mrpt::obs::CObservationGPS */
443 /** Frame header */
444 nv_oem6_header_t header;
445 uint32_t sat_prn = 0, ref_week = 0, ref_secs = 0;
446 uint8_t subframe1[30], subframe2[30], subframe3[30];
447 uint32_t crc = 0;
449 void fixEndianness() override
450 {
451 #if MRPT_IS_BIG_ENDIAN
452  fields.header.fixEndianness();
453  mrpt::reverseBytesInPlace(fields.sat_prn);
454  mrpt::reverseBytesInPlace(fields.ref_week);
455  mrpt::reverseBytesInPlace(fields.ref_secs);
456  mrpt::reverseBytesInPlace(fields.crc);
457 #endif
458 }
460 
461 /** Novatel frame: NV_OEM6_VERSION. \sa mrpt::obs::CObservationGPS */
463 {
466  {
467  }
469  {
470  uint32_t type;
471  char model[16], serial[16];
472  char hwversion[16], swversion[16], bootversion[16];
473  char compdate[12], comptime[12];
474  };
475 
476  /** Frame header */
478  uint32_t num_comps{0};
479  std::vector<TComponentVersion> components;
480  uint32_t crc;
481 
482  void dumpToStream(std::ostream& out) const override; // See docs in base
483  void fixEndianness() override
484  {
485 #if MRPT_IS_BIG_ENDIAN
487  for (auto& c : components) mrpt::reverseBytesInPlace(c.type);
489 #endif
490  }
491 
492  protected:
494  mrpt::serialization::CArchive& out) const override;
496 };
497 
498 /** Novatel frame: NV_OEM6_RAWIMUS. \sa mrpt::obs::CObservationGPS */
500 /** Frame header */
501 nv_oem6_short_header_t header;
502 uint32_t week = 0;
503 double week_seconds = 0;
504 uint32_t imu_status = 0;
507 uint32_t crc = 0;
509 bool getAllFieldDescriptions(std::ostream& o) const override;
510 bool getAllFieldValues(std::ostream& o) const override;
511 void fixEndianness() override
512 {
513 #if MRPT_IS_BIG_ENDIAN
514  fields.header.fixEndianness();
515  mrpt::reverseBytesInPlace(fields.week);
516  mrpt::reverseBytesInPlace(fields.week_seconds);
517  mrpt::reverseBytesInPlace(fields.imu_status);
518  mrpt::reverseBytesInPlace(fields.accel_z);
519  mrpt::reverseBytesInPlace(fields.accel_y_neg);
520  mrpt::reverseBytesInPlace(fields.accel_x);
521  mrpt::reverseBytesInPlace(fields.gyro_z);
522  mrpt::reverseBytesInPlace(fields.gyro_y_neg);
523  mrpt::reverseBytesInPlace(fields.gyro_x);
524  mrpt::reverseBytesInPlace(fields.crc);
525 #endif
526 }
528 
529 /** Novatel frame: NV_OEM6_MARKPOS. \sa mrpt::obs::CObservationGPS */
531 /** Frame header */
532 nv_oem6_header_t header;
537 /** [deg], [deg], hgt over sea level[m] */
538 double lat = 0, lon = 0, hgt = 0;
539 float undulation = 0;
540 uint32_t datum_id = 0;
541 float lat_sigma = 0, lon_sigma = 0, hgt_sigma = 0;
542 char base_station_id[4] = {0, 0, 0, 0};
543 float diff_age = 0, sol_age = 0;
544 uint8_t num_sats_tracked = 0, num_sats_sol = 0, num_sats_sol_L1 = 0,
545  num_sats_sol_multi = 0;
546 uint8_t reserved = 0;
547 uint8_t ext_sol_stat = 0;
548 uint8_t galileo_beidou_mask = 0;
549 uint8_t gps_glonass_mask = 0;
550 uint32_t crc = 0;
552 /** Return the geodetic coords as a mrpt::topography::TGeodeticCoords structure
553  * (requires linking against mrpt-topography)
554  * Call as: getAsStruct<TGeodeticCoords>(); */
555 template <class TGEODETICCOORDS>
556 inline TGEODETICCOORDS getAsStruct() const
557 {
558  return TGEODETICCOORDS(fields.lat, fields.lon, fields.hgt);
559 }
560 void fixEndianness() override
561 {
562 #if MRPT_IS_BIG_ENDIAN
563  fields.header.fixEndianness();
564  mrpt::reverseBytesInPlace_enum(fields.solution_stat);
565  mrpt::reverseBytesInPlace_enum(fields.position_type);
566  mrpt::reverseBytesInPlace(fields.lat);
567  mrpt::reverseBytesInPlace(fields.lon);
568  mrpt::reverseBytesInPlace(fields.hgt);
569  mrpt::reverseBytesInPlace(fields.undulation);
570  mrpt::reverseBytesInPlace(fields.datum_id);
571  mrpt::reverseBytesInPlace(fields.lat_sigma);
572  mrpt::reverseBytesInPlace(fields.lon_sigma);
573  mrpt::reverseBytesInPlace(fields.hgt_sigma);
574  mrpt::reverseBytesInPlace(fields.diff_age);
575  mrpt::reverseBytesInPlace(fields.sol_age);
576  mrpt::reverseBytesInPlace(fields.crc);
577 #endif
578 }
580 
581 /** Novatel frame: NV_OEM6_MARKTIME. \sa mrpt::obs::CObservationGPS */
583 /** Frame header */
584 nv_oem6_header_t header;
585 uint32_t week = 0;
586 double week_seconds = 0;
588 double utc_offset = 0;
589 uint32_t clock_status = 0;
590 uint32_t crc = 0;
592 bool getAllFieldDescriptions(std::ostream& o) const override;
593 bool getAllFieldValues(std::ostream& o) const override;
594 void fixEndianness() override
595 {
596 #if MRPT_IS_BIG_ENDIAN
597  fields.header.fixEndianness();
598  mrpt::reverseBytesInPlace(fields.week);
599  mrpt::reverseBytesInPlace(fields.week_seconds);
600  mrpt::reverseBytesInPlace(fields.clock_offset);
601  mrpt::reverseBytesInPlace(fields.clock_offset_std);
602  mrpt::reverseBytesInPlace(fields.utc_offset);
603  mrpt::reverseBytesInPlace(fields.clock_status);
604  mrpt::reverseBytesInPlace(fields.crc);
605 #endif
606 }
608 
609 /** Novatel frame: NV_OEM6_MARK2TIME. \sa mrpt::obs::CObservationGPS */
611 /** Frame header */
612 nv_oem6_header_t header;
613 uint32_t week = 0;
614 double week_seconds = 0;
615 double clock_offset = 0, clock_offset_std = 0;
616 double utc_offset = 0;
617 uint32_t clock_status = 0;
618 uint32_t crc = 0;
620 bool getAllFieldDescriptions(std::ostream& o) const override;
621 bool getAllFieldValues(std::ostream& o) const override;
622 void fixEndianness() override
623 {
624 #if MRPT_IS_BIG_ENDIAN
625  fields.header.fixEndianness();
626  mrpt::reverseBytesInPlace(fields.week);
627  mrpt::reverseBytesInPlace(fields.week_seconds);
628  mrpt::reverseBytesInPlace(fields.clock_offset);
629  mrpt::reverseBytesInPlace(fields.clock_offset_std);
630  mrpt::reverseBytesInPlace(fields.utc_offset);
631  mrpt::reverseBytesInPlace(fields.clock_status);
632  mrpt::reverseBytesInPlace(fields.crc);
633 #endif
634 }
636 
637 /** Novatel frame: NV_OEM6_IONUTC. \sa mrpt::obs::CObservationGPS */
639 /** Frame header */
640 nv_oem6_header_t header;
641 /** Ionospheric alpha and beta constant terms parameters */
642 double a0 = 0, a1 = 0, a2 = 0, a3 = 0, b0 = 0, b1 = 0, b2 = 0, b3 = 0;
643 /** UTC reference week number */
644 uint32_t utc_wn = 0;
645 /** Reference time of UTC params */
646 uint32_t tot = 0;
647 /** UTC constant and 1st order terms */
648 double A0 = 0, A1 = 0;
649 /** Future week number */
650 uint32_t wn_lsf = 0;
651 /** Day number (1=sunday, 7=saturday) */
652 uint32_t dn = 0;
653 /** Delta time due to leap seconds */
654 uint32_t deltat_ls = 0;
655 /** Delta time due to leap seconds (future) */
656 uint32_t deltat_lsf = 0;
657 uint32_t reserved = 0;
658 uint32_t crc = 0;
660 void fixEndianness() override
661 {
662 #if MRPT_IS_BIG_ENDIAN
663  fields.header.fixEndianness();
664  mrpt::reverseBytesInPlace(fields.a0);
665  mrpt::reverseBytesInPlace(fields.a1);
666  mrpt::reverseBytesInPlace(fields.a2);
667  mrpt::reverseBytesInPlace(fields.a3);
668  mrpt::reverseBytesInPlace(fields.b0);
669  mrpt::reverseBytesInPlace(fields.b1);
670  mrpt::reverseBytesInPlace(fields.b2);
671  mrpt::reverseBytesInPlace(fields.b3);
672  mrpt::reverseBytesInPlace(fields.utc_wn);
673  mrpt::reverseBytesInPlace(fields.tot);
674  mrpt::reverseBytesInPlace(fields.A0);
675  mrpt::reverseBytesInPlace(fields.A1);
676  mrpt::reverseBytesInPlace(fields.wn_lsf);
677  mrpt::reverseBytesInPlace(fields.dn);
678  mrpt::reverseBytesInPlace(fields.deltat_ls);
679  mrpt::reverseBytesInPlace(fields.deltat_lsf);
680  mrpt::reverseBytesInPlace(fields.reserved);
681  mrpt::reverseBytesInPlace(fields.crc);
682 #endif
683 }
685 
686 #pragma pack(pop) // End of pack = 1
687 } // namespace mrpt::obs::gnss
void internal_readFromStream(mrpt::serialization::CArchive &in) override
Save to binary stream.
const std::string & enum2str(int val)
for nv_ins_status_type_t
void dumpToStream(std::ostream &out) const override
Dumps the contents of the observation in a human-readable form to a given output stream.
void dumpToStream(std::ostream &out) const override
Dumps the contents of the observation in a human-readable form to a given output stream.
#define GNSS_BINARY_MSG_DEFINITION_START(_MSG_ID)
uint32_t wn_lsf
Future week number.
test distance exceeded (max of 3 rejections if distance > 10km)
Novatel generic frame (to store frames without a parser at the present time).
uint32_t utc_wn
UTC reference week number.
#define GNSS_BINARY_MSG_DEFINITION_MID_END
uint32_t dn
Day number (1=sunday, 7=saturday)
when a fix position command is entered, the receiver computes its own position and determines if the ...
gnss_message_type_t
List of all known GNSS message types.
void fixEndianness() override
If we are in a big endian system, reverse all fields >1 byte to fix its representation.
void dumpToStream(std::ostream &out) const override
Dumps the contents of the observation in a human-readable form to a given output stream.
double vel_cov[9]
Velocity covariance matrix in local level frame.
uint32_t tot
Reference time of UTC params.
const std::string & enum2str(int val)
for nv_position_type_t
GLenum GLenum GLuint components
Definition: glext.h:7401
Novatel OEM6 regular header structure.
void internal_writeToStream(mrpt::serialization::CArchive &out) const override
Save to binary stream.
GNSS_BINARY_MSG_DEFINITION_MID TGEODETICCOORDS getAsStruct() const
Return the geodetic coords as a mrpt::topography::TGeodeticCoords structure (requires linking against...
void reverseBytesInPlace(bool &v_in_out)
Reverse the order of the bytes of a given type (useful for transforming btw little/big endian) ...
nv_oem6_solution_status::nv_solution_status_t solution_stat
const std::string & enum2str(int val)
for nv_solution_status_t
void fixEndianness() override
void internal_readFromStream(mrpt::serialization::CArchive &in) override
Save to binary stream.
#define GNSS_BINARY_MSG_DEFINITION_MID
void internal_writeToStream(mrpt::serialization::CArchive &out) const override
Save to binary stream.
nv_oem6_position_type::nv_position_type_t position_type
double a0
Ionospheric alpha and beta constant terms parameters.
void internal_writeToStream(mrpt::serialization::CArchive &out) const override
Save to binary stream.
void fixEndianness() override
If we are in a big endian system, reverse all fields >1 byte to fix its representation.
void fixEndianness() override
If we are in a big endian system, reverse all fields >1 byte to fix its representation.
const GLubyte * c
Definition: glext.h:6406
nv_oem6_header_t header
Novatel frame: NV_OEM6_BESTPOS.
nv_solution_status_t
Novatel OEM6 firmware reference, table 85.
uint32_t deltat_lsf
Delta time due to leap seconds (future)
Novatel generic short-header frame (to store frames without a parser at the present time)...
double att_cov[9]
Attitude covariance matrix of the SPAN frame to the local level frame.
int val
Definition: mrpt_jpeglib.h:957
double lat
[deg], [deg], hgt over sea level[m]
void internal_readFromStream(mrpt::serialization::CArchive &in) override
Save to binary stream.
__int32 int32_t
Definition: glext.h:3455
GLsizei const GLchar ** string
Definition: glext.h:4116
Novatel OEM6 short header structure.
uint32_t deltat_ls
Delta time due to leap seconds.
GNSS (GPS) data structures, mainly for use within mrpt::obs::CObservationGPS.
std::vector< TCompressedRangeLog > obs_data
bool getAllFieldDescriptions(std::ostream &o) const override
double pos_cov[9]
Position covariance matrix in local level frame (metres squared) xx,xy,xz,yx,yy,yz,zx,zy,zz.
Virtual base class for "archives": classes abstracting I/O streams.
Definition: CArchive.h:54
nv_oem6_ins_status_type::nv_ins_status_type_t ins_status
mrpt::vision::TStereoCalibResults out
Pure virtual base for all message types.
GLuint in
Definition: glext.h:7391
float lat_sigma
Uncertainties (all in [m])
nv_position_type_t
Novatel OEM6 firmware reference, table 84; Novatel SPAN on OEM6 firmware manual, table 26...
void reverseBytesInPlace_enum(enum_t &v)
Definition: reverse_bytes.h:68
covariance trace exceeds maximum (trace>1000m)
the fixed position entered using the fix position command is not valid
double A0
UTC constant and 1st order terms.
void internal_writeToStream(mrpt::serialization::CArchive &out) const override
Save to binary stream.
bool getAllFieldValues(std::ostream &o) const override
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: glext.h:3550
std::vector< TComponentVersion > components
void internal_readFromStream(mrpt::serialization::CArchive &in) override
Save to binary stream.
void dumpToStream(std::ostream &out) const override
Dumps the contents of the observation in a human-readable form to a given output stream.
nv_ins_status_type_t
Novatel SPAN on OEM6 firmware reference, table 33.



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: cb8dd5fc8 Sat Dec 7 21:55:39 2019 +0100 at sáb dic 7 22:00:13 CET 2019