MRPT  1.9.9
xsdatapacket.h
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 #ifndef XSDATAPACKET_H
10 #define XSDATAPACKET_H
11 
12 #include "xstypedefs.h"
13 #include "pstdint.h"
14 #include "xsmessage.h"
15 #include "xstimestamp.h"
16 #include "xsdataidentifier.h"
17 #include "xsushortvector.h"
18 #include "xsscrdata.h"
19 #include "xscalibrateddata.h"
20 #include "xsgpspvtdata.h"
21 #include "xspressure.h"
22 #include "xssdidata.h"
23 #include "xsvector.h"
24 #include "xsquaternion.h"
25 #include "xsmatrix.h"
26 #include "xseuler.h"
27 #include "xsanalogindata.h"
28 #include "xsutctime.h"
29 #include "xsrawgpsdop.h"
30 #include "xsrawgpssol.h"
31 #include "xsrawgpssvinfo.h"
32 #include "xsrawgpstimeutc.h"
33 #include "xsdeviceid.h"
34 #include "xsrange.h"
36 
37 struct XsDataPacket;
38 #ifdef __cplusplus
39 extern "C" {
40 #else
41 typedef struct XsDataPacket XsDataPacket;
42 #define XSDATAPACKET_INITIALIZER \
43  { \
44  XSMESSAGE_INITIALIZER, XSMESSAGE_INITIALIZER, XSDEVICEID_INITIALIZER, \
45  XDI_None, -1, 0, 0, XSTIMESTAMP_INITIALIZER, \
46  XSTIMESTAMP_INITIALIZER \
47  }
48 #endif
49 
53  XsDataPacket* copy, XsDataPacket const* src);
57  const XsDataPacket* thisPtr, XsDataIdentifier id);
59  const XsDataPacket* thisPtr, XsDataIdentifier id);
63  XsDataPacket* thisPtr, const XsMessage* msg);
65  const XsDataPacket* thisPtr, XsMessage* returnVal);
70  const XsDataPacket* thisPtr, XsUShortVector* returnVal);
72  const XsDataPacket* thisPtr);
74  XsDataPacket* thisPtr, const XsUShortVector* vec);
76  const XsDataPacket* thisPtr, XsUShortVector* returnVal);
78  const XsDataPacket* thisPtr);
80  XsDataPacket* thisPtr, const XsUShortVector* vec);
82  const XsDataPacket* thisPtr, XsUShortVector* returnVal);
84  const XsDataPacket* thisPtr);
86  XsDataPacket* thisPtr, const XsUShortVector* vec);
88  const XsDataPacket* thisPtr, XsUShortVector* returnVal);
90  const XsDataPacket* thisPtr);
92  XsDataPacket* thisPtr, const XsUShortVector* vec);
96  const XsDataPacket* thisPtr);
98  XsDataPacket* thisPtr, uint16_t temp);
100  const XsDataPacket* thisPtr, XsScrData* returnVal);
103  XsDataPacket* thisPtr, const XsScrData* data);
105  const XsDataPacket* thisPtr, XsVector* returnVal);
107  const XsDataPacket* thisPtr);
109  XsDataPacket* thisPtr, const XsVector* vec);
111  const XsDataPacket* thisPtr, XsVector* returnVal);
113  const XsDataPacket* thisPtr);
115  XsDataPacket* thisPtr, const XsVector* vec);
117  const XsDataPacket* thisPtr, XsVector* returnVal);
119  const XsDataPacket* thisPtr);
121  XsDataPacket* thisPtr, const XsVector* vec);
123  const XsDataPacket* thisPtr, XsCalibratedData* returnVal);
125  const XsDataPacket* thisPtr);
127  XsDataPacket* thisPtr, const XsCalibratedData* data);
129  const XsDataPacket* thisPtr, XsQuaternion* returnVal,
130  XsDataIdentifier coordinateSystem);
132  XsDataPacket* thisPtr, const XsQuaternion* data,
133  XsDataIdentifier coordinateSystem);
135  const XsDataPacket* thisPtr, XsEuler* returnVal,
136  XsDataIdentifier coordinateSystem);
138  XsDataPacket* thisPtr, const XsEuler* data,
139  XsDataIdentifier coordinateSystem);
141  const XsDataPacket* thisPtr, XsMatrix* returnVal,
142  XsDataIdentifier coordinateSystem);
144  XsDataPacket* thisPtr, const XsMatrix* data,
145  XsDataIdentifier coordinateSystem);
147  const XsDataPacket* thisPtr);
153  const XsDataPacket* thisPtr, XsSdiData* returnVal);
156  XsDataPacket* thisPtr, const XsSdiData* data);
160  const XsDataPacket* thisPtr);
162  const XsDataPacket* thisPtr);
164  XsDataPacket* thisPtr, uint32_t data);
166  XsDataPacket* thisPtr, uint8_t data);
170  const XsDataPacket* thisPtr);
172  XsDataPacket* thisPtr, uint8_t counter);
176  const XsDataPacket* thisPtr);
178  XsDataPacket* thisPtr, uint16_t counter);
182  const XsDataPacket* thisPtr);
184  XsDataPacket* thisPtr, uint32_t counter);
188  const XsDataPacket* thisPtr);
190  XsDataPacket* thisPtr, uint32_t counter);
193  const XsDataPacket* thisPtr);
195  XsDataPacket* thisPtr, uint64_t counter);
197  const XsDataPacket* thisPtr, XsVector* returnVal);
199  const XsDataPacket* thisPtr);
201  XsDataPacket* thisPtr, const XsVector* g);
204  const XsDataPacket* thisPtr);
206  XsDataPacket* thisPtr, double temp);
208  const XsDataPacket* thisPtr, XsGpsPvtData* returnVal);
210  const XsDataPacket* thisPtr);
212  XsDataPacket* thisPtr, const XsGpsPvtData* data);
215  const XsDataPacket* thisPtr, XsPressure* returnVal);
217  const XsDataPacket* thisPtr);
219  XsDataPacket* thisPtr, const XsPressure* data);
221  const XsDataPacket* thisPtr, XsAnalogInData* returnVal);
223  const XsDataPacket* thisPtr);
225  XsDataPacket* thisPtr, const XsAnalogInData* data);
227  const XsDataPacket* thisPtr, XsAnalogInData* returnVal);
229  const XsDataPacket* thisPtr);
231  XsDataPacket* thisPtr, const XsAnalogInData* data);
233  const XsDataPacket* thisPtr, XsVector* returnVal);
235  const XsDataPacket* thisPtr);
237  XsDataPacket* thisPtr, const XsVector* data);
239  const XsDataPacket* thisPtr, XsVector* returnVal);
241  const XsDataPacket* thisPtr);
243  XsDataPacket* thisPtr, const XsVector* data);
244 XSTYPES_DLL_API double XsDataPacket_altitude(const XsDataPacket* thisPtr);
247  XsDataPacket* thisPtr, double data);
249  const XsDataPacket* thisPtr, XsVector* returnVal,
250  XsDataIdentifier coordinateSystem);
253  XsDataPacket* thisPtr, const XsVector* data,
254  XsDataIdentifier coordinateSystem);
260  const XsDataPacket* thisPtr, XsUtcTime* returnVal);
263  XsDataPacket* thisPtr, const XsUtcTime* data);
265  const XsDataPacket* thisPtr, XsRange* returnVal);
267  const XsDataPacket* thisPtr);
269  XsDataPacket* thisPtr, const XsRange* r);
274  const XsDataPacket* thisPtr, XsRawGpsDop* returnVal);
277  const XsDataPacket* thisPtr, XsRawGpsSol* returnVal);
280  const XsDataPacket* thisPtr, XsRawGpsTimeUtc* returnVal);
282  const XsDataPacket* thisPtr);
284  const XsDataPacket* thisPtr, XsRawGpsSvInfo* returnVal);
286  const XsDataPacket* thisPtr);
288  XsDataPacket* thisPtr, const XsDataPacket* other);
290  XsDataPacket* thisPtr, XsDataIdentifier triggerId,
291  XsTriggerIndicationData const* triggerIndicationData);
293  XsDataPacket const* thisPtr, XsDataIdentifier triggerId,
294  XsTriggerIndicationData* returnVal);
296  XsDataPacket const* thisPtr, XsDataIdentifier triggerId);
297 
298 #ifdef __cplusplus
299 } // extern "C"
300 #endif
301 
303 {
304 #ifdef __cplusplus
305  /*! \brief Default constructor, initializes empty data packet or from the
306  supplied \a msg
307  \param msg Either 0 to create an empty object or a pointer to a valid
308  %XsMessage containing
309  MTData2 data.
310  */
311  explicit XsDataPacket(const XsMessage* msg = 0)
313  m_lastFoundOffset(-1),
314  m_itemCount(0),
316  m_toa(0),
317  m_packetId(0)
318  {
321 
322  if (msg) XsDataPacket_setMessage(this, msg);
323  }
324 
325  /*! \brief Copy constructor
326  \param pack The packet to copy from
327  */
328  XsDataPacket(const XsDataPacket& pack)
330  m_lastFoundOffset(-1),
331  m_itemCount(0),
333  m_toa(0),
334  m_packetId(0)
335  {
336  *this = pack;
337  }
338 
339  //! \copydoc XsDataPacket_destruct
340  ~XsDataPacket() { XsDataPacket_destruct(this); }
341  /*! \brief Assignment operator
342  \param other The packet to copy from
343  \returns A reference to this %XsDataPacket
344  \sa XsDataPacket_copy
345  */
346  const XsDataPacket& operator=(const XsDataPacket& other)
347  {
348  if (this != &other) XsDataPacket_copy(this, &other);
349  return *this;
350  }
351 
352  /*! \brief \copybrief XsDataPacket_empty */
353  inline bool empty(void) const { return 0 != XsDataPacket_empty(this); }
354  /*! \copydoc XsDataPacket_itemOffsetExact */
355  inline int itemOffsetExact(XsDataIdentifier id) const
356  {
357  return XsDataPacket_itemOffsetExact(this, id);
358  }
359 
360  /*! \copydoc XsDataPacket_itemOffsetLoose */
361  inline int itemOffsetLoose(XsDataIdentifier id) const
362  {
363  return XsDataPacket_itemOffsetLoose(this, id);
364  }
365 
366  /*! \brief Return the id that was last found successfully by itemOffsetLoose
367  or itemOffsetExact
368  \details When the last search didn't find anything, XDI_None will be
369  returned.
370  \returns The id that was last found successfully by itemOffsetLoose or
371  itemOffsetExact or XDI_None
372  \sa itemOffsetExact \sa itemOffsetLoose \sa lastFoundOffset
373  */
374  inline XsDataIdentifier lastFoundId() const { return m_lastFoundId; }
375  /*! \brief Return the offset that was last returned by itemOffsetLoose or
376  itemOffsetExact
377  \details When the last search didn't find anything, -1 will be returned.
378  \returns The offset that was last returned by itemOffsetLoose or
379  itemOffsetExact
380  \sa itemOffsetExact \sa itemOffsetLoose \sa lastFoundId
381  */
382  inline int lastFoundOffset() const { return m_lastFoundOffset; }
383  //! \brief Return the device ID associated with the data packet
384  inline XsDeviceId deviceId() const { return m_deviceId; }
385  //! \brief Return the number of data items in the packet
386  inline uint16_t itemCount() const { return m_itemCount; }
387  //! \copydoc XsDataPacket_setMessage
388  inline void setMessage(const XsMessage& msg)
389  {
390  XsDataPacket_setMessage(this, &msg);
391  }
392 
393  /*! \brief Returns a const reference to the message that contains the data
394  * packet
395  */
396  inline const XsMessage& XSNOCOMEXPORT message() const { return m_msg; }
397  /*! \brief Returns a reference to the message that contains the data packet
398  \returns A reference to the message that contains the data packet
399  \note Modifying this message directly can cause %XsDataPacket to break
400  */
401  inline XsMessage& XSNOCOMEXPORT message()
402  {
403  return m_msg; // lint !e1536
404  }
405 
406  //! \brief Set the device ID associated with this data packet
407  inline void setDeviceId(const XsDeviceId id) { m_deviceId = id; }
408  /*! \brief Returns a copy the original message of the data packet
409  \details This returns the original message that was last set with
410  setMessage,
411  or in the constructor. Note that if existing data was updated, the
412  original data may have been
413  overwritten, only added data will not be returned in this message.
414  When the packet was constructed from a legacy message, the legacy
415  message will be returned.
416  \sa XsDataPacket_originalMessage
417  \returns An XsMessage containing a copy of the original message
418  */
419  inline XsMessage XSNOCOMEXPORT originalMessage(void) const
420  {
421  XsMessage returnVal;
422  return *XsDataPacket_originalMessage(this, &returnVal);
423  }
424 
425  /*! \copydoc XsDataPacket_dataFormat */
426  inline XsDataIdentifier dataFormat(XsDataIdentifier id) const
427  {
428  return XsDataPacket_dataFormat(this, id);
429  }
430 
431  /*! \copydoc XsDataPacket_getFPValueSize */
432  inline static uint8_t getFPValueSize(XsDataIdentifier id)
433  {
434  return XsDataPacket_getFPValueSize(id);
435  }
436 
437  /*! \brief \copybrief XsDataPacket_rawAcceleration */
438  inline XsUShortVector rawAcceleration(void) const
439  {
440  XsUShortVector returnVal;
441  return *XsDataPacket_rawAcceleration(this, &returnVal);
442  }
443 
444  /*! \copydoc XsDataPacket_containsRawAcceleration */
445  inline bool containsRawAcceleration(void) const
446  {
447  return 0 != XsDataPacket_containsRawAcceleration(this);
448  }
449 
450  /*! \copydoc XsDataPacket_setRawAcceleration */
451  inline void setRawAcceleration(const XsUShortVector& vec)
452  {
454  }
455 
456  /*! \brief \copybrief XsDataPacket_rawGyroscopeData */
457  inline XsUShortVector rawGyroscopeData(void) const
458  {
459  XsUShortVector returnVal;
460  return *XsDataPacket_rawGyroscopeData(this, &returnVal);
461  }
462 
463  /*! \copydoc XsDataPacket_containsRawGyroscopeData */
464  inline bool containsRawGyroscopeData(void) const
465  {
466  return 0 != XsDataPacket_containsRawGyroscopeData(this);
467  }
468 
469  /*! \brief \copybrief XsDataPacket_setRawGyroscopeData */
470  inline void setRawGyroscopeData(const XsUShortVector& vec)
471  {
473  }
474 
475  /*! \brief \copybrief XsDataPacket_rawGyroscopeTemperatureData */
476  inline XsUShortVector rawGyroscopeTemperatureData(void) const
477  {
478  XsUShortVector returnVal;
479  return *XsDataPacket_rawGyroscopeTemperatureData(this, &returnVal);
480  }
481 
482  /*! \copydoc XsDataPacket_containsRawGyroscopeTemperatureData */
483  inline bool containsRawGyroscopeTemperatureData(void) const
484  {
486  }
487 
488  /*! \brief \copybrief XsDataPacket_setRawGyroscopeTemperatureData */
489  inline void setRawGyroscopeTemperatureData(const XsUShortVector& vec)
490  {
492  }
493 
494  /*! \brief \copybrief XsDataPacket_rawMagneticField */
495  inline XsUShortVector rawMagneticField(void) const
496  {
497  XsUShortVector returnVal;
498  return *XsDataPacket_rawMagneticField(this, &returnVal);
499  }
500 
501  /*! \copydoc XsDataPacket_containsRawMagneticField */
502  inline bool containsRawMagneticField(void) const
503  {
504  return 0 != XsDataPacket_containsRawMagneticField(this);
505  }
506 
507  /*! \brief \copybrief XsDataPacket_setRawMagneticField */
508  inline void setRawMagneticField(const XsUShortVector& vec)
509  {
511  }
512 
513  /*! \brief \copybrief XsDataPacket_rawTemperature */
514  inline uint16_t rawTemperature(void) const
515  {
516  return XsDataPacket_rawTemperature(this);
517  }
518 
519  /*! \copydoc XsDataPacket_containsRawTemperature */
520  inline bool containsRawTemperature(void) const
521  {
522  return 0 != XsDataPacket_containsRawTemperature(this);
523  }
524 
525  /*! \brief \copybrief XsDataPacket_setRawTemperature */
526  inline void setRawTemperature(uint16_t temp)
527  {
528  XsDataPacket_setRawTemperature(this, temp);
529  }
530 
531  /*! \brief \copybrief XsDataPacket_rawData */
532  inline XsScrData rawData(void) const
533  {
534  XsScrData returnVal;
535  return *XsDataPacket_rawData(this, &returnVal);
536  }
537 
538  /*! \copydoc XsDataPacket_containsRawData */
539  inline bool containsRawData(void) const
540  {
541  return 0 != XsDataPacket_containsRawData(this);
542  }
543 
544  /*! \brief \copybrief XsDataPacket_setRawData */
545  inline void setRawData(const XsScrData& data)
546  {
548  }
549 
550  /*! \brief \copybrief XsDataPacket_calibratedAcceleration */
551  inline XsVector calibratedAcceleration(void) const
552  {
553  XsVector returnVal;
554  return *XsDataPacket_calibratedAcceleration(this, &returnVal);
555  }
556 
557  /*! \copydoc XsDataPacket_containsCalibratedAcceleration */
558  inline bool containsCalibratedAcceleration(void) const
559  {
561  }
562 
563  /*! \brief \copybrief XsDataPacket_setCalibratedAcceleration */
564  inline void setCalibratedAcceleration(const XsVector& vec)
565  {
567  }
568 
569  /*! \brief \copybrief XsDataPacket_calibratedGyroscopeData */
570  inline XsVector calibratedGyroscopeData(void) const
571  {
572  XsVector returnVal;
573  return *XsDataPacket_calibratedGyroscopeData(this, &returnVal);
574  }
575 
576  /*! \copydoc XsDataPacket_containsCalibratedGyroscopeData */
577  inline bool containsCalibratedGyroscopeData(void) const
578  {
580  }
581 
582  /*! \brief \copybrief XsDataPacket_setCalibratedGyroscopeData */
583  inline void setCalibratedGyroscopeData(const XsVector& vec)
584  {
586  }
587 
588  /*! \brief \copybrief XsDataPacket_calibratedMagneticField */
589  inline XsVector calibratedMagneticField(void) const
590  {
591  XsVector returnVal;
592  return *XsDataPacket_calibratedMagneticField(this, &returnVal);
593  }
594 
595  /*! \copydoc XsDataPacket_containsCalibratedMagneticField */
596  inline bool containsCalibratedMagneticField(void) const
597  {
599  }
600 
601  /*! \brief \copybrief XsDataPacket_setCalibratedMagneticField */
602  inline void setCalibratedMagneticField(const XsVector& vec)
603  {
605  }
606 
607  /*! \brief \copybrief XsDataPacket_calibratedData */
608  inline XsCalibratedData calibratedData(void) const
609  {
610  XsCalibratedData returnVal;
611  return *XsDataPacket_calibratedData(this, &returnVal);
612  }
613 
614  /*! \copydoc XsDataPacket_containsCalibratedData */
615  inline bool containsCalibratedData(void) const
616  {
617  return 0 != XsDataPacket_containsCalibratedData(this);
618  }
619 
620  /*! \brief \copybrief XsDataPacket_setCalibratedData */
621  inline void setCalibratedData(const XsCalibratedData& data)
622  {
624  }
625 
626  /*! \brief \copybrief XsDataPacket_orientationQuaternion */
627  inline XsQuaternion orientationQuaternion(
628  XsDataIdentifier coordinateSystem) const
629  {
630  XsQuaternion returnVal;
632  this, &returnVal, coordinateSystem);
633  }
634 
635  /*! \brief returns the orientation as a quaternion with the current
636  * coordinate system*/
637  inline XsQuaternion orientationQuaternion() const
638  {
639  XsQuaternion returnVal;
641  this, &returnVal, coordinateSystemOrientation());
642  }
643 
644  /*! \brief \copybrief XsDataPacket_setOrientationQuaternion */
645  inline void setOrientationQuaternion(
646  const XsQuaternion& data, XsDataIdentifier coordinateSystem)
647  {
648  XsDataPacket_setOrientationQuaternion(this, &data, coordinateSystem);
649  }
650 
651  /*! \brief \copybrief XsDataPacket_orientationEuler */
652  inline XsEuler orientationEuler(XsDataIdentifier coordinateSystem) const
653  {
654  XsEuler returnVal;
656  this, &returnVal, coordinateSystem);
657  }
658 
659  /*! \brief returns the orientation as an XsEuler with the current coordinate
660  * system*/
661  inline XsEuler orientationEuler() const
662  {
663  XsEuler returnVal;
665  this, &returnVal, coordinateSystemOrientation());
666  }
667 
668  /*! \brief \copybrief XsDataPacket_setOrientationEuler */
669  inline void setOrientationEuler(
670  const XsEuler& data, XsDataIdentifier coordinateSystem)
671  {
672  XsDataPacket_setOrientationEuler(this, &data, coordinateSystem);
673  }
674 
675  /*! \brief \copybrief XsDataPacket_orientationMatrix */
676  inline XsMatrix orientationMatrix(XsDataIdentifier coordinateSystem) const
677  {
678  XsMatrix returnVal;
680  this, &returnVal, coordinateSystem);
681  }
682 
683  /*! \brief returns the orientation as an orientation matrix with the current
684  * coordinate system*/
685  inline XsMatrix orientationMatrix() const
686  {
687  XsMatrix returnVal;
689  this, &returnVal, coordinateSystemOrientation());
690  }
691 
692  /*! \brief \copybrief XsDataPacket_setOrientationMatrix */
693  inline void setOrientationMatrix(
694  const XsMatrix& data, XsDataIdentifier coordinateSystem)
695  {
696  XsDataPacket_setOrientationMatrix(this, &data, coordinateSystem);
697  }
698 
699  /*! \copydoc XsDataPacket_containsOrientation */
700  inline bool containsOrientation(void) const
701  {
702  return 0 != XsDataPacket_containsOrientation(this);
703  }
704 
705  /*! \copydoc XsDataPacket_orientationIdentifier */
706  inline XsDataIdentifier orientationIdentifier() const
707  {
709  }
710 
711  /*! \copydoc XsDataPacket_coordinateSystemOrientation */
712  inline XsDataIdentifier coordinateSystemOrientation() const
713  {
715  }
716 
717  /*! \brief \copybrief XsDataPacket_sdiData */
718  inline XsSdiData sdiData(void) const
719  {
720  XsSdiData returnVal;
721  return *XsDataPacket_sdiData(this, &returnVal);
722  }
723 
724  /*! \copydoc XsDataPacket_containsSdiData */
725  inline bool containsSdiData(void) const
726  {
727  return 0 != XsDataPacket_containsSdiData(this);
728  }
729 
730  /*! \copydoc XsDataPacket_setSdiData */
731  inline void setSdiData(const XsSdiData& data)
732  {
734  }
735 
736  /*! \brief \copybrief XsDataPacket_status */
737  inline uint32_t status(void) const { return XsDataPacket_status(this); }
738  /*! \copydoc XsDataPacket_containsStatus */
739  inline bool containsStatus(void) const
740  {
741  return 0 != XsDataPacket_containsStatus(this);
742  }
743 
744  /*! \copydoc XsDataPacket_containsStatusByte */
745  inline bool containsStatusByte(void) const
746  {
747  return 0 != XsDataPacket_containsStatusByte(this);
748  }
749 
750  /*! \copydoc XsDataPacket_containsDetailedStatus */
751  inline bool containsDetailedStatus(void) const
752  {
753  return 0 != XsDataPacket_containsDetailedStatus(this);
754  }
755 
756  /*! \brief \copybrief XsDataPacket_setStatus */
757  inline void setStatus(const uint32_t data)
758  {
760  }
761 
762  /*! \brief \copybrief XsDataPacket_setStatusByte */
763  inline void setStatusByte(const uint8_t data)
764  {
766  }
767 
768  /*! \brief \copybrief XsDataPacket_packetCounter8 */
769  inline uint8_t packetCounter8(void) const
770  {
771  return XsDataPacket_packetCounter8(this);
772  }
773 
774  /*! \copydoc XsDataPacket_containsPacketCounter8 */
775  inline bool containsPacketCounter8(void) const
776  {
777  return 0 != XsDataPacket_containsPacketCounter8(this);
778  }
779 
780  /*! \brief \copybrief XsDataPacket_setPacketCounter8 */
781  inline void setPacketCounter8(uint8_t counter)
782  {
784  }
785 
786  /*! \brief \copybrief XsDataPacket_packetCounter */
787  inline uint16_t packetCounter(void) const
788  {
789  return XsDataPacket_packetCounter(this);
790  }
791 
792  /*! \copydoc XsDataPacket_containsPacketCounter */
793  inline bool containsPacketCounter(void) const
794  {
795  return 0 != XsDataPacket_containsPacketCounter(this);
796  }
797 
798  /*! \brief \copybrief XsDataPacket_setPacketCounter */
799  inline void setPacketCounter(uint16_t counter)
800  {
802  }
803 
804  /*! \brief \copybrief XsDataPacket_sampleTimeFine */
805  inline uint32_t sampleTimeFine(void) const
806  {
807  return XsDataPacket_sampleTimeFine(this);
808  }
809 
810  /*! \copydoc XsDataPacket_containsSampleTimeFine */
811  inline bool containsSampleTimeFine(void) const
812  {
813  return 0 != XsDataPacket_containsSampleTimeFine(this);
814  }
815 
816  /*! \brief \copybrief XsDataPacket_setSampleTimeFine */
817  inline void setSampleTimeFine(uint32_t counter)
818  {
820  }
821 
822  /*! \brief \copybrief XsDataPacket_sampleTimeCoarse */
823  inline uint32_t sampleTimeCoarse(void) const
824  {
825  return XsDataPacket_sampleTimeCoarse(this);
826  }
827 
828  /*! \copydoc XsDataPacket_containsSampleTimeCoarse */
829  inline bool containsSampleTimeCoarse(void) const
830  {
831  return 0 != XsDataPacket_containsSampleTimeCoarse(this);
832  }
833 
834  /*! \brief \copybrief XsDataPacket_setSampleTimeCoarse */
835  inline void setSampleTimeCoarse(uint32_t counter)
836  {
838  }
839 
840  /*! \brief \copybrief XsDataPacket_sampleTime64 */
841  inline uint64_t sampleTime64(void) const
842  {
843  return XsDataPacket_sampleTime64(this);
844  }
845 
846  /*! \copydoc XsDataPacket_containsSampleTime64 */
847  inline bool containsSampleTime64(void) const
848  {
849  return 0 != XsDataPacket_containsSampleTime64(this);
850  }
851 
852  /*! \brief \copybrief XsDataPacket_setSampleTime64 */
853  inline void setSampleTime64(uint64_t counter)
854  {
856  }
857 
858  /*! \brief \copybrief XsDataPacket_freeAcceleration */
859  inline XsVector freeAcceleration(void) const
860  {
861  XsVector returnVal;
862  return *XsDataPacket_freeAcceleration(this, &returnVal);
863  }
864 
865  /*! \copydoc XsDataPacket_containsFreeAcceleration */
866  inline bool containsFreeAcceleration(void) const
867  {
868  return 0 != XsDataPacket_containsFreeAcceleration(this);
869  }
870 
871  /*! \brief \copybrief XsDataPacket_setFreeAcceleration */
872  inline void setFreeAcceleration(const XsVector& g)
873  {
875  }
876 
877  /*! \brief \copybrief XsDataPacket_temperature */
878  inline double temperature(void) const
879  {
880  return XsDataPacket_temperature(this);
881  }
882 
883  /*! \copydoc XsDataPacket_containsTemperature */
884  inline bool containsTemperature(void) const
885  {
886  return 0 != XsDataPacket_containsTemperature(this);
887  }
888 
889  /*! \brief \copybrief XsDataPacket_setTemperature */
890  inline void setTemperature(double temp)
891  {
892  XsDataPacket_setTemperature(this, temp);
893  }
894 
895  /*! \brief \copybrief XsDataPacket_gpsPvtData */
896  inline XsGpsPvtData gpsPvtData(void) const
897  {
898  XsGpsPvtData returnVal;
899  return *XsDataPacket_gpsPvtData(this, &returnVal);
900  }
901 
902  /*! \copydoc XsDataPacket_containsGpsPvtData */
903  inline bool containsGpsPvtData(void) const
904  {
905  return 0 != XsDataPacket_containsGpsPvtData(this);
906  }
907 
908  /*! \copydoc XsDataPacket_setGpsPvtData */
909  inline void setGpsPvtData(const XsGpsPvtData& data)
910  {
912  }
913 
914  /*! \brief \copybrief XsDataPacket_pressure */
915  inline XsPressure pressure(void) const
916  {
917  XsPressure returnVal;
918  return *XsDataPacket_pressure(this, &returnVal);
919  }
920 
921  /*! \copydoc XsDataPacket_containsPressure */
922  inline bool containsPressure(void) const
923  {
924  return 0 != XsDataPacket_containsPressure(this);
925  }
926 
927  /*! \copydoc XsDataPacket_containsPressureAge */
928  inline bool containsPressureAge(void) const
929  {
930  return 0 != XsDataPacket_containsPressureAge(this);
931  }
932 
933  /*! \brief \copybrief XsDataPacket_setPressure */
934  inline void setPressure(const XsPressure& data)
935  {
937  }
938 
939  /*! \brief \copybrief XsDataPacket_analogIn1Data */
940  inline XsAnalogInData analogIn1Data(void) const
941  {
942  XsAnalogInData returnVal;
943  return *XsDataPacket_analogIn1Data(this, &returnVal);
944  }
945 
946  /*! \copydoc XsDataPacket_containsAnalogIn1Data */
947  inline bool containsAnalogIn1Data(void) const
948  {
949  return 0 != XsDataPacket_containsAnalogIn1Data(this);
950  }
951 
952  /*! \brief \copybrief XsDataPacket_setAnalogIn1Data */
953  inline void setAnalogIn1Data(const XsAnalogInData& data)
954  {
956  }
957 
958  /*! \brief \copybrief XsDataPacket_analogIn2Data */
959  inline XsAnalogInData analogIn2Data(void) const
960  {
961  XsAnalogInData returnVal;
962  return *XsDataPacket_analogIn2Data(this, &returnVal);
963  }
964 
965  /*! \copydoc XsDataPacket_containsAnalogIn2Data */
966  inline bool containsAnalogIn2Data(void) const
967  {
968  return 0 != XsDataPacket_containsAnalogIn2Data(this);
969  }
970 
971  /*! \brief \copybrief XsDataPacket_setAnalogIn2Data */
972  inline void setAnalogIn2Data(const XsAnalogInData& data)
973  {
975  }
976 
977  /*! \brief \copybrief XsDataPacket_positionLLA */
978  inline XsVector positionLLA(void) const
979  {
980  XsVector returnVal;
981  return *XsDataPacket_positionLLA(this, &returnVal);
982  }
983 
984  /*! \copydoc XsDataPacket_containsPositionLLA */
985  inline bool containsPositionLLA(void) const
986  {
987  return 0 != XsDataPacket_containsPositionLLA(this);
988  }
989 
990  /*! \copydoc XsDataPacket_setPositionLLA */
991  inline void setPositionLLA(const XsVector& data)
992  {
994  }
995 
996  /*! \brief \copybrief XsDataPacket_latitudeLongitude */
997  inline XsVector latitudeLongitude(void) const
998  {
999  XsVector returnVal;
1000  return *XsDataPacket_latitudeLongitude(this, &returnVal);
1001  }
1002 
1003  /*! \copydoc XsDataPacket_containsLatitudeLongitude */
1004  inline bool containsLatitudeLongitude(void) const
1005  {
1006  return 0 != XsDataPacket_containsLatitudeLongitude(this);
1007  }
1008 
1009  /*! \copydoc XsDataPacket_setLatitudeLongitude */
1010  inline void setLatitudeLongitude(const XsVector& data)
1011  {
1013  }
1014 
1015  /*! \brief \copybrief XsDataPacket_altitude */
1016  inline double altitude(void) const { return XsDataPacket_altitude(this); }
1017  /*! \copydoc XsDataPacket_containsAltitude */
1018  inline bool containsAltitude(void) const
1019  {
1020  return 0 != XsDataPacket_containsAltitude(this);
1021  }
1022 
1023  /*! \copydoc XsDataPacket_setAltitude */
1024  inline void setAltitude(double data)
1025  {
1027  }
1028 
1029  /*! \brief \copybrief XsDataPacket_velocity */
1030  inline XsVector velocity(XsDataIdentifier coordinateSystem) const
1031  {
1032  XsVector returnVal;
1033  return *XsDataPacket_velocity(this, &returnVal, coordinateSystem);
1034  }
1035 
1036  /*! \brief returns the velocity with the current coordinate system*/
1037  inline XsVector velocity(void) const
1038  {
1039  XsVector returnVal;
1040  return *XsDataPacket_velocity(
1041  this, &returnVal, coordinateSystemVelocity());
1042  }
1043 
1044  /*! \copydoc XsDataPacket_containsVelocity */
1045  inline bool containsVelocity(void) const
1046  {
1047  return 0 != XsDataPacket_containsVelocity(this);
1048  }
1049 
1050  /*! \brief \copybrief XsDataPacket_setVelocity */
1051  inline void setVelocity(
1052  const XsVector& data, XsDataIdentifier coordinateSystem)
1053  {
1054  XsDataPacket_setVelocity(this, &data, coordinateSystem);
1055  }
1056 
1057  /*! \brief \copybrief XsDataPacket_velocityIdentifier */
1058  inline XsDataIdentifier velocityIdentifier() const
1059  {
1060  return XsDataPacket_velocityIdentifier(this);
1061  }
1062 
1063  /*! \copydoc XsDataPacket_coordinateSystemVelocity */
1064  inline XsDataIdentifier coordinateSystemVelocity() const
1065  {
1067  }
1068 
1069  /*! \brief \copybrief XsDataPacket_utcTime */
1070  inline XsUtcTime utcTime(void) const
1071  {
1072  XsUtcTime returnVal;
1073  return *XsDataPacket_utcTime(this, &returnVal);
1074  }
1075 
1076  /*! \copydoc XsDataPacket_containsUtcTime */
1077  inline bool containsUtcTime(void) const
1078  {
1079  return 0 != XsDataPacket_containsUtcTime(this);
1080  }
1081 
1082  /*! \brief \copybrief XsDataPacket_setUtcTime */
1083  inline void setUtcTime(const XsUtcTime& data)
1084  {
1085  XsDataPacket_setUtcTime(this, &data);
1086  }
1087 
1088  /*! \brief \copybrief XsDataPacket_frameRange */
1089  inline XsRange frameRange() const
1090  {
1091  XsRange returnVal;
1092  return *XsDataPacket_frameRange(this, &returnVal);
1093  }
1094 
1095  /*! \copydoc XsDataPacket_containsFrameRange */
1096  inline bool containsFrameRange() const
1097  {
1098  return 0 != XsDataPacket_containsFrameRange(this);
1099  }
1100 
1101  /*! \copydoc XsDataPacket_setFrameRange */
1102  inline void setFrameRange(const XsRange& r)
1103  {
1104  XsDataPacket_setFrameRange(this, &r);
1105  }
1106 
1107  /*! \brief \copybrief XsDataPacket_rssi */
1108  inline int rssi() const { return XsDataPacket_rssi(this); }
1109  /*! \copydoc XsDataPacket_containsRssi */
1110  inline bool containsRssi() const
1111  {
1112  return 0 != XsDataPacket_containsRssi(this);
1113  }
1114 
1115  /*! \copydoc XsDataPacket_setRssi */
1116  inline void setRssi(int r) { XsDataPacket_setRssi(this, r); }
1117  /*! \brief \copybrief XsDataPacket_rawGpsDop */
1118  inline XsRawGpsDop rawGpsDop(void) const
1119  {
1120  XsRawGpsDop returnVal;
1121  return *XsDataPacket_rawGpsDop(this, &returnVal);
1122  }
1123 
1124  /*! \brief \copybrief XsDataPacket_containsRawGpsDop */
1125  inline bool containsRawGpsDop(void) const
1126  {
1127  return 0 != XsDataPacket_containsRawGpsDop(this);
1128  }
1129 
1130  /*! \brief \copybrief XsDataPacket_rawGpsSol */
1131  inline XsRawGpsSol rawGpsSol(void) const
1132  {
1133  XsRawGpsSol returnVal = XsRawGpsSol();
1134  return *XsDataPacket_rawGpsSol(this, &returnVal);
1135  }
1136 
1137  /*! \brief \copybrief XsDataPacket_containsRawGpsSol */
1138  inline bool containsRawGpsSol(void) const
1139  {
1140  return 0 != XsDataPacket_containsRawGpsSol(this);
1141  }
1142 
1143  /*! \brief \copybrief XsDataPacket_rawGpsTimeUtc */
1144  inline XsRawGpsTimeUtc rawGpsTimeUtc(void) const
1145  {
1146  XsRawGpsTimeUtc returnVal;
1147  return *XsDataPacket_rawGpsTimeUtc(this, &returnVal);
1148  }
1149 
1150  /*! \brief \copybrief XsDataPacket_containsRawGpsTimeUtc */
1151  inline bool containsRawGpsTimeUtc(void) const
1152  {
1153  return 0 != XsDataPacket_containsRawGpsTimeUtc(this);
1154  }
1155 
1156  /*! \brief \copybrief XsDataPacket_rawGpsSvInfo */
1157  inline XsRawGpsSvInfo rawGpsSvInfo(void) const
1158  {
1159  XsRawGpsSvInfo returnVal;
1160  return *XsDataPacket_rawGpsSvInfo(this, &returnVal);
1161  }
1162 
1163  /*! \brief \copybrief XsDataPacket_containsRawGpsSvInfo */
1164  inline bool containsRawGpsSvInfo(void) const
1165  {
1166  return 0 != XsDataPacket_containsRawGpsSvInfo(this);
1167  }
1168 
1169  /*! \copydoc XsDataPacket_append */
1170  inline XsDataPacket& append(const XsDataPacket& other)
1171  {
1172  return *XsDataPacket_append(this, &other);
1173  }
1174 
1175  /*! \private \brief Set the time of arrival of the data packet */
1176  inline void setTimeOfArrival(XsTimeStamp t) { m_toa = t; }
1177  /*! \brief Return the time of arrival of the data packet. Only valid for
1178  * live streams. The behaviour for file streams is undefined and may change
1179  * in the future. */
1180  inline XsTimeStamp timeOfArrival() const { return m_toa; }
1181  /*! \private \brief Set the packet ID of the data packet*/
1182  inline void setPacketId(XsTimeStamp t) { m_packetId = t; }
1183  /*! \brief Return the ID of the packet.
1184  \details This ID is based on, depending on availability: (1) packet
1185  counter (2) sample time (3) arrival order
1186  \returns The ID of the packet.
1187  */
1188  inline XsTimeStamp packetId() const { return m_packetId; }
1189  /*! \copydoc XsDataPacket_setTriggerIndication */
1190  void setTriggerIndication(
1191  XsDataIdentifier triggerId,
1192  XsTriggerIndicationData const& triggerIndicationData)
1193  {
1195  this, triggerId, &triggerIndicationData);
1196  }
1197 
1198  /*! \brief Returns the trigger indication data of a packet
1199  \details
1200  If the packet does not contain the requested data, the return val struct
1201  will be set to all zeroes
1202  \param[in] triggerId The trigger data identifier to add data for (e.g.
1203  XDI_TriggerIn1 or XDI_TriggerIn2)
1204  \returns the trigger indication data of a packet
1205  */
1206  XsTriggerIndicationData triggerIndication(XsDataIdentifier triggerId)
1207  {
1208  XsTriggerIndicationData returnVal;
1209  return *XsDataPacket_triggerIndication(this, triggerId, &returnVal);
1210  }
1211 
1212  /*! \copydoc XsDataPacket_containsTriggerIndication */
1213  int containsTriggerIndication(XsDataIdentifier triggerId)
1214  {
1215  return XsDataPacket_containsTriggerIndication(this, triggerId);
1216  }
1217 
1218  protected:
1219 /*! \privatesection */
1220 #endif // __cplusplus
1221 
1222  /** The message that contains the data */
1224  /** Optional legacy MtData message as received (for logging the received
1225  * data only) */
1227  /** The device Id to which the message belongs */
1229  /** Last found data identifer, speeds up searches */
1231  /** Offset of last found data identifier, speeds up searches */
1233  /** The number of data items in the message */
1235  /** Length of the original message payload */
1237  /** Time of arrival (live packets only) */
1239  /** 64 bit packet id, based on, depending on availability: (1) packet
1240  * counter (2) sample time (3) arrival order */
1242 };
1243 
1244 #endif // file guard
XSTYPES_DLL_API int XsDataPacket_containsPressureAge(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsAnalogInData * XsDataPacket_analogIn2Data(const XsDataPacket *thisPtr, XsAnalogInData *returnVal)
GLenum GLint GLuint mask
Definition: glext.h:4050
struct XsRawGpsSol XsRawGpsSol
Definition: xsrawgpssol.h:74
XSTYPES_DLL_API void XsMessage_setMessageId(XsMessage *thisPtr, XsXbusMessageId msgId)
EIGEN_STRONG_INLINE bool empty() const
XSTYPES_DLL_API void XsDataPacket_setPositionLLA(XsDataPacket *thisPtr, const XsVector *data)
GLdouble GLdouble t
Definition: glext.h:3689
XSTYPES_DLL_API void XsDataPacket_setFrameRange(XsDataPacket *thisPtr, const XsRange *r)
XSTYPES_DLL_API void XsDataPacket_setAnalogIn2Data(XsDataPacket *thisPtr, const XsAnalogInData *data)
unsigned __int16 uint16_t
Definition: rptypes.h:44
XSTYPES_DLL_API int XsDataPacket_itemOffsetLoose(const XsDataPacket *thisPtr, XsDataIdentifier id)
XSTYPES_DLL_API XsVector * XsDataPacket_calibratedGyroscopeData(const XsDataPacket *thisPtr, XsVector *returnVal)
XSTYPES_DLL_API void XsDataPacket_construct(XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setStatusByte(XsDataPacket *thisPtr, uint8_t data)
XSTYPES_DLL_API void XsDataPacket_setOrientationMatrix(XsDataPacket *thisPtr, const XsMatrix *data, XsDataIdentifier coordinateSystem)
XSTYPES_DLL_API XsVector * XsDataPacket_calibratedAcceleration(const XsDataPacket *thisPtr, XsVector *returnVal)
XSTYPES_DLL_API uint8_t XsDataPacket_getFPValueSize(XsDataIdentifier id)
XSTYPES_DLL_API double XsDataPacket_altitude(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_coordinateSystemVelocity(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setCalibratedMagneticField(XsDataPacket *thisPtr, const XsVector *vec)
XSTYPES_DLL_API int XsDataPacket_containsSdiData(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsVector * XsDataPacket_positionLLA(const XsDataPacket *thisPtr, XsVector *returnVal)
A vector containing 3 short values.
XSTYPES_DLL_API int XsDataPacket_containsCalibratedAcceleration(const XsDataPacket *thisPtr)
struct XsDataPacket XsDataPacket
Definition: xsdatapacket.h:41
XSTYPES_DLL_API void XsDataPacket_setRawTemperature(XsDataPacket *thisPtr, uint16_t temp)
XSTYPES_DLL_API int XsDataPacket_containsAnalogIn2Data(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsDataPacket * XsDataPacket_append(XsDataPacket *thisPtr, const XsDataPacket *other)
XSTYPES_DLL_API XsPressure * XsDataPacket_pressure(const XsDataPacket *thisPtr, XsPressure *returnVal)
uint16_t m_originalMessageLength
Length of the original message payload.
Data for a trigger indication message.
XSTYPES_DLL_API int XsDataPacket_containsPositionLLA(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setPacketCounter(XsDataPacket *thisPtr, uint16_t counter)
XSTYPES_DLL_API int XsDataPacket_containsSampleTime64(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsRawGyroscopeData(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsVector * XsDataPacket_velocity(const XsDataPacket *thisPtr, XsVector *returnVal, XsDataIdentifier coordinateSystem)
XSTYPES_DLL_API void XsDataPacket_setRawGyroscopeData(XsDataPacket *thisPtr, const XsUShortVector *vec)
XSTYPES_DLL_API int XsDataPacket_containsVelocity(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setSampleTimeCoarse(XsDataPacket *thisPtr, uint32_t counter)
XSTYPES_DLL_API double XsDataPacket_temperature(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsCalibratedMagneticField(const XsDataPacket *thisPtr)
A container for NAV-TIMEUTC data.
XSTYPES_DLL_API void XsDataPacket_setRawGyroscopeTemperatureData(XsDataPacket *thisPtr, const XsUShortVector *vec)
XSTYPES_DLL_API XsAnalogInData * XsDataPacket_analogIn1Data(const XsDataPacket *thisPtr, XsAnalogInData *returnVal)
XSTYPES_DLL_API int XsDataPacket_containsLatitudeLongitude(const XsDataPacket *thisPtr)
XsDataIdentifier
Defines the data identifiers.
XSTYPES_DLL_API XsVector * XsDataPacket_latitudeLongitude(const XsDataPacket *thisPtr, XsVector *returnVal)
XSTYPES_DLL_API uint32_t XsDataPacket_sampleTimeFine(const XsDataPacket *thisPtr)
GLuint src
Definition: glext.h:7278
XSTYPES_DLL_API void XsDataPacket_setLatitudeLongitude(XsDataPacket *thisPtr, const XsVector *data)
int counter
XsTimeStamp m_toa
Time of arrival (live packets only)
XSTYPES_DLL_API void XsDataPacket_setPacketCounter8(XsDataPacket *thisPtr, uint8_t counter)
XSTYPES_DLL_API void XsDataPacket_setSampleTimeFine(XsDataPacket *thisPtr, uint32_t counter)
XSTYPES_DLL_API XsTriggerIndicationData * XsDataPacket_triggerIndication(XsDataPacket const *thisPtr, XsDataIdentifier triggerId, XsTriggerIndicationData *returnVal)
XSTYPES_DLL_API int XsDataPacket_containsRawGpsSol(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setAltitude(XsDataPacket *thisPtr, double data)
XSTYPES_DLL_API void XsDataPacket_setSdiData(XsDataPacket *thisPtr, const XsSdiData *data)
XSTYPES_DLL_API XsUShortVector * XsDataPacket_rawGyroscopeTemperatureData(const XsDataPacket *thisPtr, XsUShortVector *returnVal)
unsigned char uint8_t
Definition: rptypes.h:41
XSTYPES_DLL_API int XsDataPacket_containsDetailedStatus(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsRawGyroscopeTemperatureData(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsScrData * XsDataPacket_rawData(const XsDataPacket *thisPtr, XsScrData *returnVal)
XSTYPES_DLL_API int XsDataPacket_containsRawGpsTimeUtc(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_itemOffsetMasked(const XsDataPacket *thisPtr, XsDataIdentifier id, XsDataIdentifier mask)
XSTYPES_DLL_API int XsDataPacket_containsFrameRange(const XsDataPacket *thisPtr)
Structure for storing a single message.
Definition: xsmessage.h:198
uint16_t m_itemCount
The number of data items in the message.
XSTYPES_DLL_API int XsDataPacket_containsRssi(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setStatus(XsDataPacket *thisPtr, uint32_t data)
XSTYPES_DLL_API int XsDataPacket_containsTemperature(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsOrientation(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsRawGpsDop * XsDataPacket_rawGpsDop(const XsDataPacket *thisPtr, XsRawGpsDop *returnVal)
XSTYPES_DLL_API XsUShortVector * XsDataPacket_rawMagneticField(const XsDataPacket *thisPtr, XsUShortVector *returnVal)
XsDataIdentifier m_lastFoundId
Last found data identifer, speeds up searches.
GLubyte g
Definition: glext.h:6279
XSTYPES_DLL_API void XsDataPacket_setRawAcceleration(XsDataPacket *thisPtr, const XsUShortVector *vec)
GLubyte GLubyte b
Definition: glext.h:6279
XSTYPES_DLL_API void XsDataPacket_setFreeAcceleration(XsDataPacket *thisPtr, const XsVector *g)
XSTYPES_DLL_API XsRange * XsDataPacket_frameRange(const XsDataPacket *thisPtr, XsRange *returnVal)
Class for managing timestamps in a unified way.
Definition: xstimestamp.h:53
XSTYPES_DLL_API void XsDataPacket_setRawData(XsDataPacket *thisPtr, const XsScrData *data)
XSTYPES_DLL_API uint16_t XsDataPacket_packetCounter(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsSdiData * XsDataPacket_sdiData(const XsDataPacket *thisPtr, XsSdiData *returnVal)
int m_lastFoundOffset
Offset of last found data identifier, speeds up searches.
XSTYPES_DLL_API void XsDataPacket_setMessage(XsDataPacket *thisPtr, const XsMessage *msg)
XsDeviceId m_deviceId
The device Id to which the message belongs.
XSTYPES_DLL_API uint64_t XsDataPacket_sampleTime64(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsRawGpsSvInfo(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsCalibratedData(const XsDataPacket *thisPtr)
Data from analog inputs from sensors.
#define XSTYPES_DLL_API
Definition: xstypesconfig.h:9
XSTYPES_DLL_API int XsDataPacket_containsPressure(const XsDataPacket *thisPtr)
unsigned __int64 uint64_t
Definition: rptypes.h:50
XSTYPES_DLL_API XsGpsPvtData * XsDataPacket_gpsPvtData(const XsDataPacket *thisPtr, XsGpsPvtData *returnVal)
XSTYPES_DLL_API void XsDataPacket_setPressure(XsDataPacket *thisPtr, const XsPressure *data)
XSTYPES_DLL_API XsMessage * XsDataPacket_originalMessage(const XsDataPacket *thisPtr, XsMessage *returnVal)
XSTYPES_DLL_API void XsDataPacket_setCalibratedGyroscopeData(XsDataPacket *thisPtr, const XsVector *vec)
XSTYPES_DLL_API XsRawGpsSol * XsDataPacket_rawGpsSol(const XsDataPacket *thisPtr, XsRawGpsSol *returnVal)
XSTYPES_DLL_API XsRawGpsTimeUtc * XsDataPacket_rawGpsTimeUtc(const XsDataPacket *thisPtr, XsRawGpsTimeUtc *returnVal)
XSTYPES_DLL_API XsCalibratedData * XsDataPacket_calibratedData(const XsDataPacket *thisPtr, XsCalibratedData *returnVal)
XSTYPES_DLL_API int XsDataPacket_containsStatusByte(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsPacketCounter8(const XsDataPacket *thisPtr)
GLdouble GLdouble GLdouble r
Definition: glext.h:3705
XSTYPES_DLL_API XsEuler * XsDataPacket_orientationEuler(const XsDataPacket *thisPtr, XsEuler *returnVal, XsDataIdentifier coordinateSystem)
XSTYPES_DLL_API void XsDataPacket_setOrientationQuaternion(XsDataPacket *thisPtr, const XsQuaternion *data, XsDataIdentifier coordinateSystem)
A structure for storing UTC Time values.
Definition: xsutctime.h:15
XSTYPES_DLL_API int XsDataPacket_containsUtcTime(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_dataFormat(const XsDataPacket *thisPtr, XsDataIdentifier id)
XSTYPES_DLL_API XsUtcTime * XsDataPacket_utcTime(const XsDataPacket *thisPtr, XsUtcTime *returnVal)
A container for NAV-SVINFO data.
XSTYPES_DLL_API int XsDataPacket_containsSampleTimeFine(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsTriggerIndication(XsDataPacket const *thisPtr, XsDataIdentifier triggerId)
GLuint id
Definition: glext.h:3909
XsMessage m_msg
The message that contains the data.
XSTYPES_DLL_API XsVector * XsDataPacket_freeAcceleration(const XsDataPacket *thisPtr, XsVector *returnVal)
XSTYPES_DLL_API int XsDataPacket_containsCalibratedGyroscopeData(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsRawData(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsRawAcceleration(const XsDataPacket *thisPtr)
_u8 status
Definition: rplidar_cmd.h:19
XSTYPES_DLL_API int XsDataPacket_containsPacketCounter(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setCalibratedData(XsDataPacket *thisPtr, const XsCalibratedData *data)
Contains data received from a device or read from a file.
Definition: xsdatapacket.h:302
XSTYPES_DLL_API int XsDataPacket_rssi(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsAnalogIn1Data(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsMatrix * XsDataPacket_orientationMatrix(const XsDataPacket *thisPtr, XsMatrix *returnVal, XsDataIdentifier coordinateSystem)
XsMessage m_legacyMsg
Optional legacy MtData message as received (for logging the received data only)
A container for NAV-DOP data.
Definition: xsrawgpsdop.h:31
XSTYPES_DLL_API XsQuaternion * XsDataPacket_orientationQuaternion(const XsDataPacket *thisPtr, XsQuaternion *returnVal, XsDataIdentifier coordinateSystem)
XSTYPES_DLL_API int XsDataPacket_containsRawTemperature(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setTemperature(XsDataPacket *thisPtr, double temp)
XSTYPES_DLL_API int XsDataPacket_containsStatus(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setUtcTime(XsDataPacket *thisPtr, const XsUtcTime *data)
Container for raw sensor measurement data.
Definition: xsscrdata.h:35
XSTYPES_DLL_API void XsDataPacket_setTriggerIndication(XsDataPacket *thisPtr, XsDataIdentifier triggerId, XsTriggerIndicationData const *triggerIndicationData)
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_coordinateSystemOrientation(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsFreeAcceleration(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setOrientationEuler(XsDataPacket *thisPtr, const XsEuler *data, XsDataIdentifier coordinateSystem)
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_orientationIdentifier(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setRawMagneticField(XsDataPacket *thisPtr, const XsUShortVector *vec)
XSTYPES_DLL_API void XsDataPacket_swap(XsDataPacket *a, XsDataPacket *b)
XSTYPES_DLL_API XsRawGpsSvInfo * XsDataPacket_rawGpsSvInfo(const XsDataPacket *thisPtr, XsRawGpsSvInfo *returnVal)
XSTYPES_DLL_API void XsDataPacket_setRssi(XsDataPacket *thisPtr, int r)
XSTYPES_DLL_API int XsDataPacket_containsSampleTimeCoarse(const XsDataPacket *thisPtr)
XSTYPES_DLL_API uint8_t XsDataPacket_packetCounter8(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsUShortVector * XsDataPacket_rawGyroscopeData(const XsDataPacket *thisPtr, XsUShortVector *returnVal)
XSTYPES_DLL_API void XsDataPacket_setSampleTime64(XsDataPacket *thisPtr, uint64_t counter)
XSTYPES_DLL_API void XsDataPacket_setVelocity(XsDataPacket *thisPtr, const XsVector *data, XsDataIdentifier coordinateSystem)
XSTYPES_DLL_API void XsDataPacket_setAnalogIn1Data(XsDataPacket *thisPtr, const XsAnalogInData *data)
XSTYPES_DLL_API void XsDataPacket_copy(XsDataPacket *copy, XsDataPacket const *src)
XSTYPES_DLL_API int XsDataPacket_containsAltitude(const XsDataPacket *thisPtr)
XSTYPES_DLL_API XsUShortVector * XsDataPacket_rawAcceleration(const XsDataPacket *thisPtr, XsUShortVector *returnVal)
unsigned __int32 uint32_t
Definition: rptypes.h:47
XSTYPES_DLL_API void XsDataPacket_setCalibratedAcceleration(XsDataPacket *thisPtr, const XsVector *vec)
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: glext.h:3546
#define deviceId
Definition: CIMUXSens.cpp:40
GLubyte GLubyte GLubyte a
Definition: glext.h:6279
XSTYPES_DLL_API XsVector * XsDataPacket_calibratedMagneticField(const XsDataPacket *thisPtr, XsVector *returnVal)
XsTimeStamp m_packetId
64 bit packet id, based on, depending on availability: (1) packet counter (2) sample time (3) arrival...
A container for NAV-SOL data.
Definition: xsrawgpssol.h:27
XSTYPES_DLL_API uint32_t XsDataPacket_status(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_destruct(XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_empty(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsRawGpsDop(const XsDataPacket *thisPtr)
XSTYPES_DLL_API uint32_t XsDataPacket_sampleTimeCoarse(const XsDataPacket *thisPtr)
Data from the GPS unit of a legacy MTi-G.
Definition: xsgpspvtdata.h:34
Pressure data.
Definition: xspressure.h:17
XSTYPES_DLL_API uint16_t XsDataPacket_rawTemperature(const XsDataPacket *thisPtr)
XSTYPES_DLL_API void XsDataPacket_setGpsPvtData(XsDataPacket *thisPtr, const XsGpsPvtData *data)
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_velocityIdentifier(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsRawMagneticField(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_containsGpsPvtData(const XsDataPacket *thisPtr)
XSTYPES_DLL_API int XsDataPacket_itemOffsetExact(const XsDataPacket *thisPtr, XsDataIdentifier id)



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: 7d5e6d718 Fri Aug 24 01:51:28 2018 +0200 at lun nov 2 08:35:50 CET 2020