u-blox_structs.h

/*
	This is a library written for the u-blox ZED-F9P and NEO-M8P-2
	SparkFun sells these at its website: www.sparkfun.com
	Do you like this library? Help support SparkFun. Buy a board!
	https://www.sparkfun.com/products/16481
	https://www.sparkfun.com/products/15136
	https://www.sparkfun.com/products/15005
	https://www.sparkfun.com/products/15733
	https://www.sparkfun.com/products/15193
	https://www.sparkfun.com/products/15210

  Original version by Nathan Seidle @ SparkFun Electronics, September 6th, 2018
	v2.0 rework by Paul Clark @ SparkFun Electronics, December 31st, 2020

	This library handles configuring and handling the responses
	from a u-blox GPS module. Works with most modules from u-blox including
	the Zed-F9P, NEO-M8P-2, NEO-M9N, ZOE-M8Q, SAM-M8Q, and many others.

	https://github.com/sparkfun/SparkFun_Ublox_Arduino_Library

	Development environment specifics:
	Arduino IDE 1.8.13

	SparkFun code, firmware, and software is released under the MIT License(http://opensource.org/licenses/MIT).
	The MIT License (MIT)
	Copyright (c) 2016 SparkFun Electronics
	Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
	associated documentation files (the "Software"), to deal in the Software without restriction,
	including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
	and/or sell copies of the Software, and to permit persons to whom the Software is furnished to
	do so, subject to the following conditions:

	The above copyright notice and this permission notice shall be included in all copies or substantial
	portions of the Software.

	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
	NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef __u_blox_structs_h__
#define __u_blox_structs_h__

#include "SparkFun_u-blox_GNSS_Arduino_Library.h"

#ifndef DEF_NUM_SENS
#define DEF_NUM_SENS 7 // The maximum number of ESF sensors
#endif

//Additional flags and pointers that need to be stored with each message type
struct ubxAutomaticFlags
{
  union
  {
    uint8_t all;
    struct
    {
      uint8_t automatic : 1; // Will this message be delivered and parsed "automatically" (without polling)
      uint8_t implicitUpdate : 1; // Is the update triggered by accessing stale data (=true) or by a call to checkUblox (=false)
      uint8_t addToFileBuffer : 1; // Should the raw UBX data be added to the file buffer?
      uint8_t callbackCopyValid : 1; // Is the copy of the data struct used by the callback valid/fresh?
    } bits;
  } flags;
};

// NAV-specific structs

// UBX-NAV-POSECEF (0x01 0x01): Position solution in ECEF
const uint16_t UBX_NAV_POSECEF_LEN = 20;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t ecefX; // ECEF X coordinate: cm
  int32_t ecefY; // ECEF Y coordinate: cm
  int32_t ecefZ; // ECEF Z coordinate: cm
  uint32_t pAcc; // Position Accuracy Estimate: cm
} UBX_NAV_POSECEF_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t ecefX : 1;
      uint32_t ecefY : 1;
      uint32_t ecefZ : 1;
      uint32_t pAcc : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_POSECEF_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_POSECEF_data_t data;
  UBX_NAV_POSECEF_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_POSECEF_data_t);
  UBX_NAV_POSECEF_data_t  *callbackData;
} UBX_NAV_POSECEF_t;

// UBX-NAV-POSLLH (0x01 0x02): Geodetic position solution
const uint16_t UBX_NAV_POSLLH_LEN = 28;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t lon; // Longitude: Degrees * 1e-7
  int32_t lat; // Latitude: Degrees * 1e-7
  int32_t height; // Height above ellipsoid: mm
  int32_t hMSL; // Height above mean sea level: mm
  uint32_t hAcc; // Horizontal Accuracy Estimate: mm
  uint32_t vAcc; // Vertical Accuracy Estimate: mm
} UBX_NAV_POSLLH_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t lon : 1;
      uint32_t lat : 1;
      uint32_t height : 1;
      uint32_t hMSL : 1;
      uint32_t hAcc : 1;
      uint32_t vAcc : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_POSLLH_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_POSLLH_data_t data;
  UBX_NAV_POSLLH_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_POSLLH_data_t);
  UBX_NAV_POSLLH_data_t  *callbackData;
} UBX_NAV_POSLLH_t;

// UBX-NAV-STATUS (0x01 0x03): Receiver navigation status
const uint16_t UBX_NAV_STATUS_LEN = 16;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint8_t gpsFix; // GPSfix Type: 0x00 = no fix; 0x01 = dead reckoning only; 0x02 = 2D-fix; 0x03 = 3D-fix
                  // 0x04 = GPS + dead reckoning combined; 0x05 = Time only fix; 0x06..0xff = reserved
  union
  {
    uint8_t all;
    struct
    {
      uint8_t gpsFixOk : 1; // 1 = position and velocity valid and within DOP and ACC Masks.
      uint8_t diffSoln : 1; // 1 = differential corrections were applied
      uint8_t wknSet : 1; // 1 = Week Number valid (see Time Validity section for details)
      uint8_t towSet : 1; // 1 = Time of Week valid (see Time Validity section for details)
    } bits;
  } flags;
  union
  {
    uint8_t all;
    struct
    {
      uint8_t diffCorr : 1; // 1 = differential corrections available
      uint8_t carrSolnValid : 1; // 1 = valid carrSoln
      uint8_t reserved : 4;
      uint8_t mapMatching : 2; // map matching status: 00: none
                               // 01: valid but not used, i.e. map matching data was received, but was too old
                               // 10: valid and used, map matching data was applied
                               // 11: valid and used, map matching data was applied.
    } bits;
  } fixStat;
  union
  {
    uint8_t all;
    struct
    {
      uint8_t psmState : 2; // power save mode state
                            // 0: ACQUISITION [or when psm disabled]
                            // 1: TRACKING
                            // 2: POWER OPTIMIZED TRACKING
                            // 3: INACTIVE
      uint8_t reserved1 : 1;
      uint8_t spoofDetState : 2; // Spoofing detection state
                                 // 0: Unknown or deactivated
                                 // 1: No spoofing indicated
                                 // 2: Spoofing indicated
                                 // 3: Multiple spoofing indications
      uint8_t reserved2 : 1;
      uint8_t carrSoln : 2; // Carrier phase range solution status:
                            // 0: no carrier phase range solution
                            // 1: carrier phase range solution with floating ambiguities
                            // 2: carrier phase range solution with fixed ambiguities
    } bits;
  } flags2;
  uint32_t ttff; // Time to first fix (millisecond time tag): ms
  uint32_t msss; // Milliseconds since Startup / Reset: ms
} UBX_NAV_STATUS_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t gpsFix : 1;

      uint32_t gpsFixOk : 1;
      uint32_t diffSoln : 1;
      uint32_t wknSet : 1;
      uint32_t towSet : 1;

      uint32_t diffCorr : 1;
      uint32_t carrSolnValid : 1;
      uint32_t mapMatching : 1;

      uint32_t psmState : 1;
      uint32_t spoofDetState : 1;
      uint32_t carrSoln : 1;

      uint32_t ttff : 1;
      uint32_t msss : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_STATUS_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_STATUS_data_t data;
  UBX_NAV_STATUS_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_STATUS_data_t);
  UBX_NAV_STATUS_data_t  *callbackData;
} UBX_NAV_STATUS_t;

// UBX-NAV-DOP (0x01 0x04): Dilution of precision
const uint16_t UBX_NAV_DOP_LEN = 18;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint16_t gDOP; // Geometric DOP: * 0.01
  uint16_t pDOP; // Position DOP: * 0.01
  uint16_t tDOP; // Time DOP: * 0.01
  uint16_t vDOP; // Vertical DOP: * 0.01
  uint16_t hDOP; // Horizontal DOP: * 0.01
  uint16_t nDOP; // Northing DOP: * 0.01
  uint16_t eDOP; // Easting DOP: * 0.01
} UBX_NAV_DOP_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t gDOP : 1;
      uint32_t pDOP : 1;
      uint32_t tDOP : 1;
      uint32_t vDOP : 1;
      uint32_t hDOP : 1;
      uint32_t nDOP : 1;
      uint32_t eDOP : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_DOP_moduleQueried_t;

typedef struct
{
  ubxAutomaticFlags automaticFlags;
  UBX_NAV_DOP_data_t data;
  UBX_NAV_DOP_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_DOP_data_t);
  UBX_NAV_DOP_data_t  *callbackData;
} UBX_NAV_DOP_t;

// UBX-NAV-ATT (0x01 0x05): Attitude solution
const uint16_t UBX_NAV_ATT_LEN = 32;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint8_t version; // Message version (0x00 for this version)
  uint8_t reserved1[3];
  int32_t roll; // Vehicle roll: Degrees * 1e-5
  int32_t pitch; // Vehicle pitch: Degrees * 1e-5
  int32_t heading; // Vehicle heading: Degrees * 1e-5
  uint32_t accRoll; // Vehicle roll accuracy (if null, roll angle is not available): Degrees * 1e-5
  uint32_t accPitch; // Vehicle pitch accuracy (if null, roll angle is not available): Degrees * 1e-5
  uint32_t accHeading; // Vehicle heading accuracy (if null, roll angle is not available): Degrees * 1e-5
} UBX_NAV_ATT_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t version : 1;
      uint32_t roll : 1;
      uint32_t pitch : 1;
      uint32_t heading : 1;
      uint32_t accRoll : 1;
      uint32_t accPitch : 1;
      uint32_t accHeading : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_ATT_moduleQueried_t;

typedef struct
{
  ubxAutomaticFlags automaticFlags;
  UBX_NAV_ATT_data_t data;
  UBX_NAV_ATT_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_ATT_data_t);
  UBX_NAV_ATT_data_t  *callbackData;
} UBX_NAV_ATT_t;

// UBX-NAV-PVT (0x01 0x07): Navigation position velocity time solution
const uint16_t UBX_NAV_PVT_LEN = 92;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint16_t year; // Year (UTC)
  uint8_t month; // Month, range 1..12 (UTC)
  uint8_t day; // Day of month, range 1..31 (UTC)
  uint8_t hour; // Hour of day, range 0..23 (UTC)
  uint8_t min; // Minute of hour, range 0..59 (UTC)
  uint8_t sec; // Seconds of minute, range 0..60 (UTC)
  union
  {
    uint8_t all;
    struct
    {
      uint8_t validDate : 1; // 1 = valid UTC Date
      uint8_t validTime : 1; // 1 = valid UTC time of day
      uint8_t fullyResolved : 1; // 1 = UTC time of day has been fully resolved (no seconds uncertainty).
      uint8_t validMag : 1; // 1 = valid magnetic declination
    } bits;
  } valid;
  uint32_t tAcc; // Time accuracy estimate (UTC): ns
  int32_t nano; // Fraction of second, range -1e9 .. 1e9 (UTC): ns
  uint8_t fixType; // GNSSfix Type:
                      // 0: no fix
                      // 1: dead reckoning only
                      // 2: 2D-fix
                      // 3: 3D-fix
                      // 4: GNSS + dead reckoning combined
                      // 5: time only fix
  union
  {
    uint8_t all;
    struct
    {
      uint8_t gnssFixOK : 1; // 1 = valid fix (i.e within DOP & accuracy masks)
      uint8_t diffSoln : 1; // 1 = differential corrections were applied
      uint8_t psmState : 3;
      uint8_t headVehValid : 1; // 1 = heading of vehicle is valid, only set if the receiver is in sensor fusion mode
      uint8_t carrSoln : 2; // Carrier phase range solution status:
                              // 0: no carrier phase range solution
                              // 1: carrier phase range solution with floating ambiguities
                              // 2: carrier phase range solution with fixed ambiguities
    } bits;
  } flags;
  union
  {
    uint8_t all;
    struct
    {
      uint8_t reserved : 5;
      uint8_t confirmedAvai : 1; // 1 = information about UTC Date and Time of Day validity confirmation is available
      uint8_t confirmedDate : 1; // 1 = UTC Date validity could be confirmed
      uint8_t confirmedTime : 1; // 1 = UTC Time of Day could be confirmed
    } bits;
  } flags2;
  uint8_t numSV; // Number of satellites used in Nav Solution
  int32_t lon; // Longitude: deg * 1e-7
  int32_t lat; // Latitude: deg * 1e-7
  int32_t height; // Height above ellipsoid: mm
  int32_t hMSL; // Height above mean sea level: mm
  uint32_t hAcc; // Horizontal accuracy estimate: mm
  uint32_t vAcc; // Vertical accuracy estimate: mm
  int32_t velN; // NED north velocity: mm/s
  int32_t velE; // NED east velocity: mm/s
  int32_t velD; // NED down velocity: mm/s
  int32_t gSpeed; // Ground Speed (2-D): mm/s
  int32_t headMot; // Heading of motion (2-D): deg * 1e-5
  uint32_t sAcc; // Speed accuracy estimate: mm/s
  uint32_t headAcc; // Heading accuracy estimate (both motion and vehicle): deg * 1e-5
  uint16_t pDOP; // Position DOP * 0.01
  union
  {
    uint8_t all;
    struct
    {
      uint8_t invalidLlh : 1; // 1 = Invalid lon, lat, height and hMSL
    } bits;
  } flags3;
  uint8_t reserved1[5];
  int32_t headVeh; // Heading of vehicle (2-D): deg * 1e-5
  int16_t magDec; // Magnetic declination: deg * 1e-2
  uint16_t magAcc; // Magnetic declination accuracy: deg * 1e-2
} UBX_NAV_PVT_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t year : 1;
      uint32_t month : 1;
      uint32_t day : 1;
      uint32_t hour : 1;
      uint32_t min : 1;
      uint32_t sec : 1;

      uint32_t validDate : 1;
      uint32_t validTime : 1;
      uint32_t fullyResolved : 1;
      uint32_t validMag : 1;

      uint32_t tAcc : 1;
      uint32_t nano : 1;
      uint32_t fixType : 1;
      uint32_t gnssFixOK : 1;
      uint32_t diffSoln : 1;
      uint32_t psmState : 1;
      uint32_t headVehValid : 1;
      uint32_t carrSoln : 1;

      uint32_t confirmedAvai : 1;
      uint32_t confirmedDate : 1;
      uint32_t confirmedTime : 1;

      uint32_t numSV : 1;
      uint32_t lon : 1;
      uint32_t lat : 1;
      uint32_t height : 1;
      uint32_t hMSL : 1;
      uint32_t hAcc : 1;
      uint32_t vAcc : 1;
      uint32_t velN : 1;
      uint32_t velE : 1;
    } bits;
  }  moduleQueried1;
  union
  {
    uint32_t all;
    struct
    {
      uint32_t velD : 1;
      uint32_t gSpeed : 1;
      uint32_t headMot : 1;
      uint32_t sAcc : 1;
      uint32_t headAcc : 1;
      uint32_t pDOP : 1;

      uint32_t invalidLlh : 1;

      uint32_t headVeh : 1;
      uint32_t magDec : 1;
      uint32_t magAcc : 1;
    } bits;
  } moduleQueried2;
} UBX_NAV_PVT_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_PVT_data_t data;
  UBX_NAV_PVT_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_PVT_data_t);
  UBX_NAV_PVT_data_t  *callbackData;
} UBX_NAV_PVT_t;

// UBX-NAV-ODO (0x01 0x09): Odometer solution
const uint16_t UBX_NAV_ODO_LEN = 20;

typedef struct
{
  uint8_t version; // Message version (0x00 for this version)
  uint8_t reserved1[3];
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint32_t distance; // Ground distance since last reset: m
  uint32_t totalDistance; // Total cumulative ground distance: m
  uint32_t distanceStd; // Ground distance accuracy (1-sigma): m
} UBX_NAV_ODO_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t version : 1;
      uint32_t iTOW : 1;
      uint32_t distance : 1;
      uint32_t totalDistance : 1;
      uint32_t distanceStd : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_ODO_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_ODO_data_t data;
  UBX_NAV_ODO_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_ODO_data_t);
  UBX_NAV_ODO_data_t  *callbackData;
} UBX_NAV_ODO_t;

// UBX-NAV-VELECEF (0x01 0x11): Velocity solution in ECEF
const uint16_t UBX_NAV_VELECEF_LEN = 20;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t ecefVX; // ECEF X velocity: cm/s
  int32_t ecefVY; // ECEF Y velocity: cm/s
  int32_t ecefVZ; // ECEF Z velocity: cm/s
  uint32_t sAcc; // Speed accuracy estimate: cm/s
} UBX_NAV_VELECEF_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t ecefVX : 1;
      uint32_t ecefVY : 1;
      uint32_t ecefVZ : 1;
      uint32_t sAcc : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_VELECEF_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_VELECEF_data_t data;
  UBX_NAV_VELECEF_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_VELECEF_data_t);
  UBX_NAV_VELECEF_data_t  *callbackData;
} UBX_NAV_VELECEF_t;

// UBX-NAV-VELNED (0x01 0x12): Velocity solution in NED frame
const uint16_t UBX_NAV_VELNED_LEN = 36;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t velN; // North velocity component: cm/s
  int32_t velE; // East velocity component: cm/s
  int32_t velD; // Down velocity component: cm/s
  uint32_t speed; // Speed (3-D): cm/s
  uint32_t gSpeed; // Ground Speed (2-D): cm/s
  int32_t heading; // Heading of motion 2-D: Degrees * 1e-5
  uint32_t sAcc; // Speed accuracy estimate: cm/s
  uint32_t cAcc; // Course/Heading accuracy estimate: Degrees * 1e-5
} UBX_NAV_VELNED_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t velN : 1;
      uint32_t velE : 1;
      uint32_t velD : 1;
      uint32_t speed : 1;
      uint32_t gSpeed : 1;
      uint32_t heading : 1;
      uint32_t sAcc : 1;
      uint32_t cAcc : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_VELNED_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_VELNED_data_t data;
  UBX_NAV_VELNED_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_VELNED_data_t);
  UBX_NAV_VELNED_data_t  *callbackData;
} UBX_NAV_VELNED_t;

// UBX-NAV-HPPOSECEF (0x01 0x13): High precision position solution in ECEF
const uint16_t UBX_NAV_HPPOSECEF_LEN = 28;

typedef struct
{
  uint8_t version; // Message version (0x00 for this version)
  uint8_t reserved1[3];
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t ecefX; // ECEF X coordinate: cm
  int32_t ecefY; // ECEF Y coordinate: cm
  int32_t ecefZ; // ECEF Z coordinate: cm
  int8_t ecefXHp; // High precision component of ECEF X coordinate: mm * 0.1
  int8_t ecefYHp; // High precision component of ECEF Y coordinate: mm * 0.1
  int8_t ecefZHp; // High precision component of ECEF Z coordinate: mm * 0.1
  union
  {
    uint8_t all;
    struct
    {
      uint8_t invalidEcef : 1; // 1 = Invalid ecefX, ecefY, ecefZ, ecefXHp, ecefYHp and ecefZHp
    } bits;
  } flags;
  uint32_t pAcc; // Position Accuracy Estimate: mm * 0.1
} UBX_NAV_HPPOSECEF_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t version : 1;
      uint32_t iTOW : 1;
      uint32_t ecefX : 1;
      uint32_t ecefY : 1;
      uint32_t ecefZ : 1;
      uint32_t ecefXHp : 1;
      uint32_t ecefYHp : 1;
      uint32_t ecefZHp : 1;

      uint32_t invalidEcef : 1;

      uint32_t pAcc : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_HPPOSECEF_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_HPPOSECEF_data_t data;
  UBX_NAV_HPPOSECEF_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_HPPOSECEF_data_t);
  UBX_NAV_HPPOSECEF_data_t  *callbackData;
} UBX_NAV_HPPOSECEF_t;

// UBX-NAV-HPPOSLLH (0x01 0x14): High precision geodetic position solution
const uint16_t UBX_NAV_HPPOSLLH_LEN = 36;

typedef struct
{
  uint8_t version; // Message version (0x00 for this version)
  uint8_t reserved1[2];
  union
  {
    uint8_t all;
    struct
    {
      uint8_t invalidLlh : 1; // 1 = Invalid lon, lat, height, hMSL, lonHp, latHp, heightHp and hMSLHp
    } bits;
  } flags;
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t lon; // Longitude: deg * 1e-7
  int32_t lat; // Latitude: deg * 1e-7
  int32_t height; // Height above ellipsoid: mm
  int32_t hMSL; // Height above mean sea level: mm
  int8_t lonHp; // High precision component of longitude: deg * 1e-9
  int8_t latHp; // High precision component of latitude: deg * 1e-9
  int8_t heightHp; // High precision component of height above ellipsoid: mm * 0.1
  int8_t hMSLHp; // High precision component of height above mean sea level: mm * 0.1
  uint32_t hAcc; // Horizontal accuracy estimate: mm * 0.1
  uint32_t vAcc; // Vertical accuracy estimate: mm * 0.1
} UBX_NAV_HPPOSLLH_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t version : 1;

      uint32_t invalidLlh : 1;

      uint32_t iTOW : 1;
      uint32_t lon : 1;
      uint32_t lat : 1;
      uint32_t height : 1;
      uint32_t hMSL : 1;
      uint32_t lonHp : 1;
      uint32_t latHp : 1;
      uint32_t heightHp : 1;
      uint32_t hMSLHp : 1;
      uint32_t hAcc : 1;
      uint32_t vAcc : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_HPPOSLLH_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_HPPOSLLH_data_t data;
  UBX_NAV_HPPOSLLH_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_HPPOSLLH_data_t);
  UBX_NAV_HPPOSLLH_data_t  *callbackData;
} UBX_NAV_HPPOSLLH_t;

// UBX-NAV-TIMEUTC (0x01 0x21): UTC time solution
const uint16_t UBX_NAV_TIMEUTC_LEN = 20;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint32_t tAcc; // Time accuracy estimate (UTC): ns
  int32_t nano; // Fraction of second, range -1e9 .. 1e9 (UTC): ns
  uint16_t year; // Year (UTC)
  uint8_t month; // Month, range 1..12 (UTC)
  uint8_t day; // Day of month, range 1..31 (UTC)
  uint8_t hour; // Hour of day, range 0..23 (UTC)
  uint8_t min; // Minute of hour, range 0..59 (UTC)
  uint8_t sec; // Seconds of minute, range 0..60 (UTC)
  union
  {
    uint8_t all;
    struct
    {
      uint8_t validTOW : 1; // 1 = Valid Time of Week
      uint8_t validWKN : 1; // 1 = Valid Week Number
      uint8_t validUTC : 1; // 1 = Valid UTC Time
      uint8_t reserved : 1;
      uint8_t utcStandard : 4; // UTC standard identifier
    } bits;
  } valid;
} UBX_NAV_TIMEUTC_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t tAcc : 1;
      uint32_t nano : 1;
      uint32_t year : 1;
      uint32_t month : 1;
      uint32_t day : 1;
      uint32_t hour : 1;
      uint32_t min : 1;
      uint32_t sec : 1;

      uint32_t validTOW : 1;
      uint32_t validWKN : 1;
      uint32_t validUTC : 1;
      uint32_t utcStandard : 1;
    } bits;
  }  moduleQueried;
} UBX_NAV_TIMEUTC_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_TIMEUTC_data_t data;
  UBX_NAV_TIMEUTC_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_TIMEUTC_data_t);
  UBX_NAV_TIMEUTC_data_t  *callbackData;
} UBX_NAV_TIMEUTC_t;

// UBX-NAV-CLOCK (0x01 0x22): Clock solution
const uint16_t UBX_NAV_CLOCK_LEN = 20;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t clkB; // Clock bias: ns
  int32_t clkD; // Clock drift: ns/s
  uint32_t tAcc; // Time accuracy estimate: ns
  uint32_t fAcc; // Frequency accuracy estimate: ps/s
} UBX_NAV_CLOCK_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t clkB : 1;
      uint32_t clkD : 1;
      uint32_t tAcc : 1;
      uint32_t fAcc : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_CLOCK_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_CLOCK_data_t data;
  UBX_NAV_CLOCK_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_CLOCK_data_t);
  UBX_NAV_CLOCK_data_t  *callbackData;
} UBX_NAV_CLOCK_t;

// UBX-NAV-TIMELS (0x01 0x26): Leap second event information
const uint16_t UBX_NAV_TIMELS_LEN = 24;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint8_t version; // Message version (0x00 for this version)
  uint8_t reserved1[3];
  uint8_t srcOfCurrLs; //Information source for the current number of leap seconds
  int8_t currLs; //Current number of leap seconds since start of GPS (Jan 6, 1980), s
  uint8_t srcOfLsChange; //Information source for the future leap second event
  int8_t lsChange; //Future leap second change if one is scheduled, +1, 0, -1s
  int32_t timeToLsEvent; //Num of secs until the next or from the last leap second, s
  uint16_t dateOfLsGpsWn; //GPS week num (WN) of the next or the last leap second event
  uint16_t dateOfLsGpsDn; //GPS day of week num (DN) for the next or last leap second event
  uint8_t reserved2[3];
  union
  {
    uint8_t all;
    struct
    {
      uint8_t validCurrLs : 1; // 1 = Valid current number of leap seconds value
      uint8_t validTimeToLsEvent : 1; // 1 = Valid time to next leap second event or from the last leap second event if no future event scheduled
    } bits;
  } valid;
} UBX_NAV_TIMELS_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t version : 1;
      uint32_t srcOfCurrLs : 1;
      uint32_t currLs : 1;
      uint32_t srcOfLsChange : 1;
      uint32_t lsChange : 1;
      uint32_t timeToLsEvent : 1;
      uint32_t dateOfLsGpsWn : 1;
      uint32_t dateOfLsGpsDn : 1;
      uint32_t validCurrLs : 1;
      uint32_t validTimeToLsEvent : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_TIMELS_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_TIMELS_data_t data;
  UBX_NAV_TIMELS_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_TIMELS_data_t);
  UBX_NAV_TIMELS_data_t  *callbackData;
} UBX_NAV_TIMELS_t;

// UBX-NAV-SAT (0x01 0x35): Satellite Information
const uint16_t UBX_NAV_SAT_MAX_BLOCKS = 255; // numSvs is 8-bit
const uint16_t UBX_NAV_SAT_MAX_LEN = 8 + (12 * UBX_NAV_SAT_MAX_BLOCKS);

typedef struct
{
  uint32_t iTOW; // GPS time of week
  uint8_t version; // Message version (0x01 for this version)
  uint8_t numSvs; // Number of satellites
  uint8_t reserved1[2];
} UBX_NAV_SAT_header_t;

typedef struct
{
  uint8_t gnssId; // GNSS identifier
  uint8_t svId; // Satellite identifier
  uint8_t cno; // Carrier-to-noise density ratio: dB-Hz
  int8_t elev; // Elevation (range: +/-90): deg
  int16_t azim; // Azimuth (range 0-360): deg
  int16_t prRes; // Pseudorange residual: m * 0.1
  union
  {
    uint32_t all;
    struct
    {
      uint32_t qualityInd : 3;  // Signal quality indicator: 0: no signal
                                // 1: searching signal
                                // 2: signal acquired
                                // 3: signal detected but unusable
                                // 4: code locked and time synchronized
                                // 5, 6, 7: code and carrier locked and time synchronized
      uint32_t svUsed : 1; // 1 = Signal in the subset specified in Signal Identifiers is currently being used for navigation
      uint32_t health : 2; // Signal health flag: 0: unknown  1: healthy  2: unhealthy
      uint32_t diffCorr : 1; // 1 = differential correction data is available for this SV
      uint32_t smoothed : 1; // 1 = carrier smoothed pseudorange used
      uint32_t orbitSource : 3; // Orbit source: 0: no orbit information is available for this SV
                                // 1: ephemeris is used
                                // 2: almanac is used
                                // 3: AssistNow Offline orbit is used
                                // 4: AssistNow Autonomous orbit is used
                                // 5, 6, 7: other orbit information is used
      uint32_t ephAvail : 1; // 1 = ephemeris is available for this SV
      uint32_t almAvail : 1; // 1 = almanac is available for this SV
      uint32_t anoAvail : 1; // 1 = AssistNow Offline data is available for this SV
      uint32_t aopAvail : 1; // 1 = AssistNow Autonomous data is available for this SV
      uint32_t reserved1 : 1;
      uint32_t sbasCorrUsed : 1; // 1 = SBAS corrections have been used for a signal in the subset specified in Signal Identifiers
      uint32_t rtcmCorrUsed : 1; // 1 = RTCM corrections have been used for a signal in the subset specified in Signal Identifiers
      uint32_t slasCorrUsed : 1; // 1 = QZSS SLAS corrections have been used for a signal in the subset specified in Signal Identifiers
      uint32_t spartnCorrUsed : 1; // 1 = SPARTN corrections have been used for a signal in the subset specified in Signal Identifiers
      uint32_t prCorrUsed : 1; // 1 = Pseudorange corrections have been used for a signal in the subset specified in Signal Identifiers
      uint32_t crCorrUsed : 1; // 1 = Carrier range corrections have been used for a signal in the subset specified in Signal Identifiers
      uint32_t doCorrUsed : 1; // 1 = Range rate (Doppler) corrections have been used for a signal in the subset specified in Signal Identifiers
      uint32_t reserved2 : 9;
    } bits;
  } flags;
} UBX_NAV_SAT_block_t;

typedef struct
{
  UBX_NAV_SAT_header_t header;
  UBX_NAV_SAT_block_t blocks[UBX_NAV_SAT_MAX_BLOCKS];
} UBX_NAV_SAT_data_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_SAT_data_t data;
  bool moduleQueried;
  void (*callbackPointer)(UBX_NAV_SAT_data_t);
  UBX_NAV_SAT_data_t  *callbackData;
} UBX_NAV_SAT_t;

// UBX-NAV-SVIN (0x01 0x3B): Survey-in data
const uint16_t UBX_NAV_SVIN_LEN = 40;

typedef struct
{
  uint8_t version; // Message version (0x00 for this version)
  uint8_t reserved1[3];
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint32_t dur; // Passed survey-in observation time: s
  int32_t meanX; // Current survey-in mean position ECEF X coordinate: cm
  int32_t meanY; // Current survey-in mean position ECEF Y coordinate: cm
  int32_t meanZ; // Current survey-in mean position ECEF Z coordinate: cm
  int8_t meanXHP; // Current high-precision survey-in mean position ECEF X coordinate: mm * 0.1
  int8_t meanYHP; // Current high-precision survey-in mean position ECEF Y coordinate: mm * 0.1
  int8_t meanZHP; // Current high-precision survey-in mean position ECEF Z coordinate: mm * 0.1
  uint8_t reserved2;
  uint32_t meanAcc; // Current survey-in mean position accuracy: mm * 0.1
  uint32_t obs; // Number of position observations used during survey-in
  int8_t valid; // Survey-in position validity flag, 1 = valid, otherwise 0
  int8_t active; // Survey-in in progress flag, 1 = in-progress, otherwise 0
  uint8_t reserved3[2];
} UBX_NAV_SVIN_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t version : 1;
      uint32_t iTOW : 1;
      uint32_t dur : 1;
      uint32_t meanX : 1;
      uint32_t meanY : 1;
      uint32_t meanZ : 1;
      uint32_t meanXHP : 1;
      uint32_t meanYHP : 1;
      uint32_t meanZHP : 1;
      uint32_t meanAcc : 1;
      uint32_t obs : 1;
      uint32_t valid : 1;
      uint32_t active : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_SVIN_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_SVIN_data_t data;
  UBX_NAV_SVIN_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_SVIN_data_t);
  UBX_NAV_SVIN_data_t  *callbackData;
} UBX_NAV_SVIN_t;

// UBX-NAV-RELPOSNED (0x01 0x3C): Relative positioning information in NED frame
// Note:
//  RELPOSNED on the M8 is only 40 bytes long
//  RELPOSNED on the F9 is 64 bytes long and contains much more information
const uint16_t UBX_NAV_RELPOSNED_LEN = 40;
const uint16_t UBX_NAV_RELPOSNED_LEN_F9 = 64;

typedef struct
{
  uint8_t version; // Message version (0x00 for this version)
  uint8_t reserved0;
  uint16_t refStationId; // Reference Station ID
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  int32_t relPosN; // North component of relative position vector: cm
  int32_t relPosE; // East component of relative position vector: cm
  int32_t relPosD; // Down component of relative position vector: cm
  int32_t relPosLength; // Length of the relative position vector: cm
  int32_t relPosHeading; // Heading of the relative position vector: Degrees * 1e-5
  uint8_t reserved1[4];
  int8_t relPosHPN; // High-precision North component of relative position vector: mm * 0.1
  int8_t relPosHPE; // High-precision East component of relative position vector: mm * 0.1
  int8_t relPosHPD; // High-precision Down component of relative position vector: mm * 0.1
  int8_t relPosHPLength; // High-precision component of the length of the relative position vector: mm * 0.1
  uint32_t accN; // Accuracy of relative position North component: mm * 0.1
  uint32_t accE; // Accuracy of relative position East component: mm * 0.1
  uint32_t accD; // Accuracy of relative position Down component: mm * 0.1
  uint32_t accLength; // Accuracy of length of the relative position vector: mm * 0.1
  uint32_t accHeading; // Accuracy of heading of the relative position vector: Degrees * 1e-5
  uint8_t reserved2[4];
  union
  {
    uint32_t all;
    struct
    {
      uint32_t gnssFixOK : 1; // A valid fix (i.e within DOP & accuracy masks)
      uint32_t diffSoln : 1; // 1 if differential corrections were applied
      uint32_t relPosValid : 1; // 1 if relative position components and accuracies are valid
      uint32_t carrSoln : 2; // Carrier phase range solution status:
                              // 0 = no carrier phase range solution
                              // 1 = carrier phase range solution with floating ambiguities
                              // 2 = carrier phase range solution with fixed ambiguities
      uint32_t isMoving : 1; // 1 if the receiver is operating in moving baseline mode
      uint32_t refPosMiss : 1; // 1 if extrapolated reference position was used to compute moving baseline solution this epoch
      uint32_t refObsMiss : 1; // 1 if extrapolated reference observations were used to compute moving baseline solution this epoch
      uint32_t relPosHeadingValid : 1; // 1 if relPosHeading is valid
      uint32_t relPosNormalized : 1; // 1 if the components of the relative position vector (including the high-precision parts) are normalized
    } bits;
  } flags;
} UBX_NAV_RELPOSNED_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t version : 1;
      uint32_t refStationId : 1;
      uint32_t iTOW : 1;
      uint32_t relPosN : 1;
      uint32_t relPosE : 1;
      uint32_t relPosD : 1;
      uint32_t relPosLength : 1;
      uint32_t relPosHeading : 1;
      uint32_t relPosHPN : 1;
      uint32_t relPosHPE : 1;
      uint32_t relPosHPD : 1;
      uint32_t relPosHPLength : 1;
      uint32_t accN : 1;
      uint32_t accE : 1;
      uint32_t accD : 1;
      uint32_t accLength : 1;
      uint32_t accHeading : 1;

      uint32_t gnssFixOK : 1;
      uint32_t diffSoln : 1;
      uint32_t relPosValid : 1;
      uint32_t carrSoln : 1;
      uint32_t isMoving : 1;
      uint32_t refPosMiss : 1;
      uint32_t refObsMiss : 1;
      uint32_t relPosHeadingValid : 1;
      uint32_t relPosNormalized : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_RELPOSNED_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_NAV_RELPOSNED_data_t data;
  UBX_NAV_RELPOSNED_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_RELPOSNED_data_t);
  UBX_NAV_RELPOSNED_data_t  *callbackData;
} UBX_NAV_RELPOSNED_t;

// UBX-NAV-AOPSTATUS (0x01 0x60): AssistNow Autonomous status
const uint16_t UBX_NAV_AOPSTATUS_LEN = 16;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  union
  {
    uint8_t all;
    struct
    {
      uint8_t useAOP : 1; // AOP enabled flag
    } bits;
  } aopCfg; // AssistNow Autonomous configuration
  uint8_t status; // AssistNow Autonomous subsystem is idle (0) or running (not 0)
  uint8_t reserved1[10];
} UBX_NAV_AOPSTATUS_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;

      uint32_t useAOP : 1;

      uint32_t status : 1;
    } bits;
  } moduleQueried;
} UBX_NAV_AOPSTATUS_moduleQueried_t;

typedef struct
{
  ubxAutomaticFlags automaticFlags;
  UBX_NAV_AOPSTATUS_data_t data;
  UBX_NAV_AOPSTATUS_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_NAV_AOPSTATUS_data_t);
  UBX_NAV_AOPSTATUS_data_t  *callbackData;
} UBX_NAV_AOPSTATUS_t;

// RXM-specific structs

// UBX-RXM-SFRBX (0x02 0x13): Broadcast navigation data subframe
// Note: length is variable
// Note: on protocol version 17: numWords is (0..16)
//       on protocol version 18+: numWords is (0..10)
const uint8_t UBX_RXM_SFRBX_MAX_WORDS = 16;
const uint16_t UBX_RXM_SFRBX_MAX_LEN = 8 + (4 * UBX_RXM_SFRBX_MAX_WORDS);

typedef struct
{
  uint8_t gnssId; // GNSS identifier
  uint8_t svId; // Satellite identifier
  uint8_t reserved1;
  uint8_t freqId; // GLONASS frequency slot
  uint8_t numWords; // The number of data words contained in this message (0..16)
  uint8_t chn; // The tracking channel number the message was received on
  uint8_t version; // Message version (0x01 for this version)
  uint8_t reserved2;
  uint32_t dwrd[UBX_RXM_SFRBX_MAX_WORDS]; // The data words
} UBX_RXM_SFRBX_data_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_RXM_SFRBX_data_t data;
  bool moduleQueried;
  void (*callbackPointer)(UBX_RXM_SFRBX_data_t);
  UBX_RXM_SFRBX_data_t  *callbackData;
} UBX_RXM_SFRBX_t;

// UBX-RXM-RAWX (0x02 0x15): Multi-GNSS raw measurement data
// Note: length is variable
const uint8_t UBX_RXM_RAWX_MAX_BLOCKS = 92; // See issue #70 and PR #74 for more info
const uint16_t UBX_RXM_RAWX_MAX_LEN = 16 + (32 * UBX_RXM_RAWX_MAX_BLOCKS);

typedef struct
{
  uint8_t rcvTow[8]; // Measurement time of week in receiver local time [64-bit float]
  uint16_t week; // GPS week number
  int8_t leapS; // GPS leap seconds
  uint8_t numMeas; // Number of measurements to follow
  union
  {
    uint8_t all;
    struct
    {
      uint8_t leapSec : 1; // Leap seconds have been determined
      uint8_t clkReset : 1; // Clock reset applied
    } bits;
  } recStat;
  uint8_t version; // Message version (0x01 for this version)
  uint8_t reserved1[2];
} UBX_RXM_RAWX_header_t;

typedef struct
{
  uint8_t prMes[8]; // Pseudorange measurement: m [64-bit float]
  uint8_t cpMes[8]; // Carrier phase measurement: cycles [64-bit float]
  uint8_t doMes[4]; // Doppler measurement: Hz [32-bit float]
  uint8_t gnssId; // GNSS identifier
  uint8_t svId; // Satellite identifier
  uint8_t sigId; // New signal identifier
  uint8_t freqId; // GLONASS frequency slot
  uint16_t lockTime; // Carrier phase locktime counter: ms
  uint8_t cno; // Carrier-to-noise density ratio: dB-Hz
  uint8_t prStdev; // Estimated pseudorange measurement standard deviation: m * 0.01 * 2^n [4-bit]
  uint8_t cpStdev; // Estimated carrier phase measurement standard deviation: cycles * 0.004 [4-bit]
  uint8_t doStdev; // Estimated Doppler measurement standard deviation: Hz * 0.002 * 2^n [4-bit]
  union
  {
    uint8_t all;
    struct
    {
      uint8_t prValid : 1; // Pseudorange valid
      uint8_t cpValid : 1; // Carrier phase valid
      uint8_t halfCyc : 1; // Half cycle valid
      uint8_t subHalfCyc : 1; // Half cycle subtracted from phase
    } bits;
  } trkStat;
  uint8_t reserved2;
} UBX_RXM_RAWX_block_t;

typedef struct
{
  UBX_RXM_RAWX_header_t header;
  UBX_RXM_RAWX_block_t blocks[UBX_RXM_RAWX_MAX_BLOCKS];
} UBX_RXM_RAWX_data_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_RXM_RAWX_data_t data;
  bool moduleQueried;
  void (*callbackPointer)(UBX_RXM_RAWX_data_t);
  UBX_RXM_RAWX_data_t  *callbackData;
} UBX_RXM_RAWX_t;

// CFG-specific structs

// UBX-CFG-RATE (0x06 0x08): Navigation/measurement rate settings
const uint16_t UBX_CFG_RATE_LEN = 6;

typedef struct
{
  uint16_t measRate; // The elapsed time between GNSS measurements, which defines the rate: ms
  uint16_t navRate; // The ratio between the number of measurements and the number of navigation solutions: cycles
  uint16_t timeRef; // The time system to which measurements are aligned: 0: UTC; 1: GPS; 2: GLONASS; 3: BeiDou; 4: Galileo
} UBX_CFG_RATE_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t measRate : 1;
      uint32_t navRate : 1;
      uint32_t timeRef : 1;
    } bits;
  } moduleQueried;
} UBX_CFG_RATE_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_CFG_RATE_data_t data;
  UBX_CFG_RATE_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_CFG_RATE_data_t);
  UBX_CFG_RATE_data_t  *callbackData;
} UBX_CFG_RATE_t;

// UBX-CFG-TP5 (0x06 0x31): Time pulse parameters
const uint16_t UBX_CFG_TP5_LEN = 32;

typedef struct
{
  uint8_t tpIdx; // Time pulse selection (0 = TIMEPULSE, 1 = TIMEPULSE2)
  uint8_t version; // Message version (0x01 for this version)
  uint8_t reserved1[2];
  int16_t antCableDelay; // Antenna cable delay: ns
  int16_t rfGroupDelay; // RF group delay: ns
  uint32_t freqPeriod; // Frequency or period time, depending on setting of bit 'isFreq': Hz_or_us
  uint32_t freqPeriodLock; // Frequency or period time when locked to GNSS time, only used if 'lockedOtherSet' is set: Hz_or_us
  uint32_t pulseLenRatio; // Pulse length or duty cycle, depending on 'isLength': us_or_2^-32
  uint32_t pulseLenRatioLock; // Pulse length or duty cycle when locked to GNSS time, only used if 'lockedOtherSet' is set: us_or_2^-32
  int32_t userConfigDelay; // User-configurable time pulse delay: ns
  union
  {
    uint32_t all;
    struct
    {
      uint32_t active : 1; // If set enable time pulse; if pin assigned to another function, other function takes precedence.
      uint32_t lockGnssFreq : 1; // If set, synchronize time pulse to GNSS as soon as GNSS time is valid. If not set, or before GNSS time is valid, use local clock.
      uint32_t lockedOtherSet : 1; // If set the receiver switches between the timepulse settings given by 'freqPeriodLocked' & 'pulseLenLocked' and those given by 'freqPeriod' & 'pulseLen'.
      uint32_t isFreq : 1; // If set 'freqPeriodLock' and 'freqPeriod' are interpreted as frequency, otherwise interpreted as period.
      uint32_t isLength : 1; // If set 'pulseLenRatioLock' and 'pulseLenRatio' interpreted as pulse length, otherwise interpreted as duty cycle.
      uint32_t alignToTow : 1; // Align pulse to top of second (period time must be integer fraction of 1s). Also set 'lockGnssFreq' to use this feature.
      uint32_t polarity : 1; // Pulse polarity: 0: falling edge at top of second; 1: rising edge at top of second
      uint32_t gridUtcGnss : 4; // Timegrid to use: 0: UTC; 1: GPS; 2: GLONASS; 3: BeiDou; 4: Galileo
      uint32_t syncMode : 3; // Sync Manager lock mode to use:
                             // 0: switch to 'freqPeriodLock' and 'pulseLenRatioLock' as soon as Sync Manager has an accurate time, never switch back to 'freqPeriod' and 'pulseLenRatio'
                             // 1: switch to 'freqPeriodLock' and 'pulseLenRatioLock' as soon as Sync Manager has an accurate time, and switch back to 'freqPeriod' and 'pulseLenRatio' as soon as time gets inaccurate
    } bits;
  } flags;
} UBX_CFG_TP5_data_t;

// TIM-specific structs

// UBX-TIM-TM2 (0x0D 0x03): Time mark data
const uint16_t UBX_TIM_TM2_LEN = 28;

typedef struct
{
  uint8_t ch; // Channel (i.e. EXTINT) upon which the pulse was measured
  union
  {
    uint8_t all;
    struct
    {
      uint8_t mode : 1; // 0=single; 1=running
      uint8_t run : 1; // 0=armed; 1=stopped
      uint8_t newFallingEdge : 1; // New falling edge detected
      uint8_t timeBase : 2; // 0=Time base is Receiver time; 1=Time base is GNSS time; 2=Time base is UTC
      uint8_t utc : 1; // 0=UTC not available; 1=UTC available
      uint8_t time : 1; // 0=Time is not valid; 1=Time is valid (Valid GNSS fix)
      uint8_t newRisingEdge : 1; // New rising edge detected
    } bits;
  } flags;
  uint16_t count; // Rising edge counter
  uint16_t wnR; // Week number of last rising edge
  uint16_t wnF; // Week number of last falling edge
  uint32_t towMsR; // TOW of rising edge: ms
  uint32_t towSubMsR; // Millisecond fraction of tow of rising edge: ns
  uint32_t towMsF; // TOW of falling edge: ms
  uint32_t towSubMsF; // Millisecond fraction of tow of falling edge: ns
  uint32_t accEst; // Accuracy estimate: ns
} UBX_TIM_TM2_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t ch : 1;
      uint32_t mode : 1;
      uint32_t run : 1;
      uint32_t newFallingEdge : 1;
      uint32_t timeBase : 1;
      uint32_t utc : 1;
      uint32_t time : 1;
      uint32_t newRisingEdge : 1;

      uint32_t count : 1;
      uint32_t wnR : 1;
      uint32_t wnF : 1;
      uint32_t towMsR : 1;
      uint32_t towSubMsR : 1;
      uint32_t towMsF : 1;
      uint32_t towSubMsF : 1;
      uint32_t accEst : 1;
    } bits;
  } moduleQueried;
} UBX_TIM_TM2_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_TIM_TM2_data_t data;
  UBX_TIM_TM2_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_TIM_TM2_data_t);
  UBX_TIM_TM2_data_t  *callbackData;
} UBX_TIM_TM2_t;

// ESF-specific structs

// UBX-ESF-ALG (0x10 0x14): IMU alignment information
const uint16_t UBX_ESF_ALG_LEN = 16;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the HNR epoch: ms
  uint8_t version; // Message version (0x01 for this version)
  union
  {
    uint8_t all;
    struct
    {
      uint8_t autoMntAlgOn : 1; // Automatic IMU-mount alignment on/off bit
      uint8_t status : 3; // Status of the IMU-mount alignment
                          //   0: user-defined/fixed angles are used
                          //   1: IMU-mount roll/pitch angles alignment is ongoing
                          //   2: IMU-mount roll/pitch/yaw angles alignment is ongoing
                          //   3: coarse IMU-mount alignment are used
                          //   4: fine IMU-mount alignment are used
    } bits;
  } flags;
  union
  {
    uint8_t all;
    struct
    {
      uint8_t tiltAlgError : 1; // IMU-mount tilt (roll and/or pitch) alignment error (0: no error, 1: error)
      uint8_t yawAlgError : 1; // IMU-mount yaw alignment error (0: no error, 1: error)
      uint8_t angleError : 1; // IMU-mount misalignment Euler angle singularity error (0: no error, 1: error)
    } bits;
  } error;
  uint8_t reserved1;
  uint32_t yaw; // IMU-mount yaw angle [0, 360]: Degrees * 1e-2
  int16_t pitch; // IMU-mount pitch angle [-90, 90]: Degrees * 1e-2
  int16_t roll; // IMU-mount roll angle [-180, 180]: Degrees * 1e-2
} UBX_ESF_ALG_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t version : 1;

      uint32_t autoMntAlgOn : 1;
      uint32_t status : 1;

      uint32_t tiltAlgError : 1;
      uint32_t yawAlgError : 1;
      uint32_t angleError : 1;

      uint32_t yaw : 1;
      uint32_t pitch : 1;
      uint32_t roll : 1;
    } bits;
  } moduleQueried;
} UBX_ESF_ALG_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_ESF_ALG_data_t data;
  UBX_ESF_ALG_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_ESF_ALG_data_t);
  UBX_ESF_ALG_data_t  *callbackData;
} UBX_ESF_ALG_t;

// UBX-ESF-INS (0x10 0x15): Vehicle dynamics information
const uint16_t UBX_ESF_INS_LEN = 36;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t version : 8; // Message version (0x01 for this version)
      uint32_t xAngRateValid : 1; // Compensated x-axis angular rate data validity flag (0: not valid, 1: valid)
      uint32_t yAngRateValid : 1; // Compensated y-axis angular rate data validity flag (0: not valid, 1: valid)
      uint32_t zAngRateValid : 1; // Compensated z-axis angular rate data validity flag (0: not valid, 1: valid)
      uint32_t xAccelValid : 1; // Compensated x-axis acceleration data validity flag (0: not valid, 1: valid)
      uint32_t yAccelValid : 1; // Compensated y-axis acceleration data validity flag (0: not valid, 1: valid)
      uint32_t zAccelValid : 1; // Compensated z-axis acceleration data validity flag (0: not valid, 1: valid)
    } bits;
  } bitfield0;
  uint8_t reserved1[4];
  uint32_t iTOW; // GPS time of week of the HNR epoch: ms
  int32_t xAngRate; // Compensated x-axis angular rate: Degrees/s * 1e-3
  int32_t yAngRate; // Compensated y-axis angular rate: Degrees/s * 1e-3
  int32_t zAngRate; // Compensated z-axis angular rate: Degrees/s * 1e-3
  int32_t xAccel; // Compensated x-axis acceleration (gravity-free): m/s^2 * 1e-2
  int32_t yAccel; // Compensated y-axis acceleration (gravity-free): m/s^2 * 1e-2
  int32_t zAccel; // Compensated z-axis acceleration (gravity-free): m/s^2 * 1e-2
} UBX_ESF_INS_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t version : 1;
      uint32_t xAngRateValid : 1;
      uint32_t yAngRateValid : 1;
      uint32_t zAngRateValid : 1;
      uint32_t xAccelValid : 1;
      uint32_t yAccelValid : 1;
      uint32_t zAccelValid : 1;

      uint32_t iTOW : 1;
      uint32_t xAngRate : 1;
      uint32_t yAngRate : 1;
      uint32_t zAngRate : 1;
      uint32_t xAccel : 1;
      uint32_t yAccel : 1;
      uint32_t zAccel : 1;
    } bits;
  } moduleQueried;
} UBX_ESF_INS_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_ESF_INS_data_t data;
  UBX_ESF_INS_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_ESF_INS_data_t);
  UBX_ESF_INS_data_t  *callbackData;
} UBX_ESF_INS_t;

// UBX-ESF-MEAS (0x10 0x02): External sensor fusion measurements
// Note: length is variable
const uint16_t UBX_ESF_MEAS_MAX_LEN = 8 + (4 * DEF_NUM_SENS) + 4;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t dataField : 24; // Data
      uint32_t dataType : 6; // Type of data (0 = no data; 1..63 = data type)
    } bits;
  } data;
} UBX_ESF_MEAS_sensorData_t;

typedef struct
{
  uint32_t timeTag; // Time tag of measurement generated by external sensor
  union
  {
    uint16_t all;
    struct
    {
      uint16_t timeMarkSent : 2; // Time mark signal was supplied just prior to sending this message:
                                 //   0 = none, 1 = on Ext0, 2 = on Ext1
      uint16_t timeMarkEdge : 1; // Trigger on rising (0) or falling (1) edge of time mark signal
      uint16_t calibTtagValid : 1; // Calibration time tag available. Always set to zero.
      uint16_t reserved : 7;
      uint16_t numMeas : 5;  // Number of measurements contained in this message (optional, can be obtained from message size)
    } bits;
  } flags;
  uint16_t id; // Identification number of data provider
  UBX_ESF_MEAS_sensorData_t data[DEF_NUM_SENS];
  uint32_t calibTtag; // OPTIONAL: Receiver local time calibrated: ms
} UBX_ESF_MEAS_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t timeMarkSent : 1;
      uint32_t timeMarkEdge : 1;
      uint32_t calibTtagValid : 1;
      uint32_t numMeas : 1;

      uint32_t id : 1;

      uint32_t data : DEF_NUM_SENS;

      uint32_t calibTtag : 1;
    } bits;
  } moduleQueried;
} UBX_ESF_MEAS_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_ESF_MEAS_data_t data;
  UBX_ESF_MEAS_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_ESF_MEAS_data_t);
  UBX_ESF_MEAS_data_t  *callbackData;
} UBX_ESF_MEAS_t;

// UBX-ESF-RAW (0x10 0x03): Raw sensor measurements
// Note: length is variable
const uint16_t UBX_ESF_RAW_MAX_LEN = 4 + (8 * DEF_NUM_SENS);

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t dataField : 24; // Data
      uint32_t dataType : 8; // Type of data (0 = no data; 1..255 = data type)
    } bits;
  } data;
  uint32_t sTag; // Sensor time tag
} UBX_ESF_RAW_sensorData_t;

typedef struct
{
  uint8_t reserved1[4];
  UBX_ESF_RAW_sensorData_t data[DEF_NUM_SENS];
} UBX_ESF_RAW_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t data : DEF_NUM_SENS;
    } bits;
  } moduleQueried;
} UBX_ESF_RAW_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_ESF_RAW_data_t data;
  UBX_ESF_RAW_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_ESF_RAW_data_t);
  UBX_ESF_RAW_data_t  *callbackData;
} UBX_ESF_RAW_t;

// UBX-ESF-STATUS (0x10 0x10): External sensor fusion status
// Note: length is variable
const uint16_t UBX_ESF_STATUS_MAX_LEN = 16 + (4 * DEF_NUM_SENS);

typedef struct
{
  union
  {
    uint8_t all;
    struct
    {
      uint8_t type : 6; // Sensor data type
      uint8_t used : 1; // If set, sensor data is used for the current sensor fusion solution
      uint8_t ready : 1; // If set, sensor is set up (configuration is available or not required) but not used for computing the current sensor fusion solution.
    } bits;
  } sensStatus1;
  union
  {
    uint8_t all;
    struct
    {
      uint8_t calibStatus : 2; // 00: Sensor is not calibrated
                               // 01: Sensor is calibrating
                               // 10/11: Sensor is calibrated
      uint8_t timeStatus : 2; // 00: No data
                              // 01: Reception of the first byte used to tag the measurement
                              // 10: Event input used to tag the measurement
                              // 11: Time tag provided with the data
    } bits;
  } sensStatus2;
  uint8_t freq; // Observation frequency: Hz
  union
  {
    uint8_t all;
    struct
    {
      uint8_t badMeas : 1; // Bad measurements detected
      uint8_t badTTag : 1; // Bad measurement time-tags detected
      uint8_t missingMeas : 1; // Missing or time-misaligned measurements detected
      uint8_t noisyMeas : 1; // High measurement noise-level detected
    } bits;
  } faults;
} UBX_ESF_STATUS_sensorStatus_t;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the HNR epoch: ms
  uint8_t version; // Message version (0x02 for this version)
  uint8_t reserved1[7];
  uint8_t fusionMode; // Fusion mode:
                      //  0: Initialization mode: receiver is initializing some unknown values required for doing sensor fusion
                      //  1: Fusion mode: GNSS and sensor data are used for navigation solution computation
                      //  2: Suspended fusion mode: sensor fusion is temporarily disabled due to e.g. invalid sensor data or detected ferry
                      //  3: Disabled fusion mode: sensor fusion is permanently disabled until receiver reset due e.g. to sensor error
  uint8_t reserved2[2];
  uint8_t numSens; // Number of sensors
  UBX_ESF_STATUS_sensorStatus_t status[DEF_NUM_SENS];
} UBX_ESF_STATUS_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t version : 1;
      uint32_t fusionMode : 1;
      uint32_t numSens : 1;

      uint32_t status : DEF_NUM_SENS;
    } bits;
  } moduleQueried;
} UBX_ESF_STATUS_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_ESF_STATUS_data_t data;
  UBX_ESF_STATUS_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_ESF_STATUS_data_t);
  UBX_ESF_STATUS_data_t  *callbackData;
} UBX_ESF_STATUS_t;

// MGA-specific structs

// UBX-MGA-ACK-DATA0 (0x13 0x60): Multiple GNSS acknowledge message
const uint16_t UBX_MGA_ACK_DATA0_LEN = 8;

typedef struct
{
  uint8_t type;     // Type of acknowledgment:
                    // 0: The message was not used by the receiver (see infoCode field for an indication of why)
                    // 1: The message was accepted for use by the receiver (the infoCode field will be 0)
  uint8_t version;  // Message version
  uint8_t infoCode; // Provides greater information on what the receiver chose to do with the message contents
                    // See sfe_ublox_mga_ack_infocode_e
  uint8_t msgId;    // UBX message ID of the acknowledged message
  uint8_t msgPayloadStart[4]; // The first 4 bytes of the acknowledged message's payload
} UBX_MGA_ACK_DATA0_data_t;

#define UBX_MGA_ACK_DATA0_RINGBUFFER_LEN 16 // Provide storage for 16 MGA ACK packets
typedef struct
{
	uint8_t head;
  uint8_t tail;
  UBX_MGA_ACK_DATA0_data_t data[UBX_MGA_ACK_DATA0_RINGBUFFER_LEN]; // Create a storage array for the MGA ACK packets
} UBX_MGA_ACK_DATA0_t;

// UBX-MGA-DBD (0x13 0x80): Navigation database dump entry
const uint16_t UBX_MGA_DBD_LEN = 164; // "The maximum payload size for firmware 2.01 onwards is 164 bytes"

typedef struct
{
  uint8_t dbdEntryHeader1; // We need to save the entire message - header, payload and checksum
  uint8_t dbdEntryHeader2;
  uint8_t dbdEntryClass;
  uint8_t dbdEntryID;
  uint8_t dbdEntryLenLSB; // We need to store the length of the DBD entry. The entry itself does not contain a length...
  uint8_t dbdEntryLenMSB;
  uint8_t dbdEntry[UBX_MGA_DBD_LEN];
  uint8_t dbdEntryChecksumA;
  uint8_t dbdEntryChecksumB;
} UBX_MGA_DBD_data_t;

#if defined(ARDUINO_ARCH_AVR)
#define UBX_MGA_DBD_RINGBUFFER_LEN 190 // Fix to let the code compile on AVR platforms - including the UNO.
#else
#define UBX_MGA_DBD_RINGBUFFER_LEN 250 // Provide storage for MGA DBD packets. TO DO: confirm if 250 is large enough for all modules!
#endif

typedef struct
{
	uint8_t head;
  uint8_t tail;
  UBX_MGA_DBD_data_t data[UBX_MGA_DBD_RINGBUFFER_LEN]; // Create a storage array for the MGA DBD packets
} UBX_MGA_DBD_t;

// HNR-specific structs

// UBX-HNR-PVT (0x28 0x00): High rate output of PVT solution
const uint16_t UBX_HNR_PVT_LEN = 72;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the HNR epoch: ms
  uint16_t year; // Year (UTC)
  uint8_t month; // Month, range 1..12 (UTC)
  uint8_t day; // Day of month, range 1..31 (UTC)
  uint8_t hour; // Hour of day, range 0..23 (UTC)
  uint8_t min; // Minute of hour, range 0..59 (UTC)
  uint8_t sec; // Seconds of minute, range 0..60 (UTC)
  union
  {
    uint8_t all;
    struct
    {
      uint8_t validDate : 1; // 1 = Valid UTC Date
      uint8_t validTime : 1; // 1 = Valid UTC Time of Day
      uint8_t fullyResolved : 1; // 1 = UTC Time of Day has been fully resolved
    } bits;
  } valid;
  int32_t nano; // Fraction of second (UTC): ns
  uint8_t gpsFix; // GPSfix Type, range 0..5
                    // 0x00 = No Fix
                    // 0x01 = Dead Reckoning only
                    // 0x02 = 2D-Fix
                    // 0x03 = 3D-Fix
                    // 0x04 = GPS + dead reckoning combined
                    // 0x05 = Time only fix
                    // 0x06..0xff: reserved
  union
  {
    uint8_t all;
    struct
    {
      uint8_t gpsFixOK : 1; // >1 = Fix within limits (e.g. DOP & accuracy)
      uint8_t diffSoln : 1; // 1 = DGPS used
      uint8_t WKNSET : 1; // 1 = Valid GPS week number
      uint8_t TOWSET : 1; // 1 = Valid GPS time of week (iTOW & fTOW)
      uint8_t headVehValid : 1; // 1= Heading of vehicle is valid
    } bits;
  } flags;
  uint8_t reserved1[2];
  int32_t lon; // Longitude: Degrees * 1e-7
  int32_t lat; // Latitude: Degrees * 1e-7
  int32_t height; // Height above ellipsoid: mm
  int32_t hMSL; // Height above MSL: mm
  int32_t gSpeed; // Ground Speed (2-D): mm/s
  int32_t speed; // Speed (3-D): mm/s
  int32_t headMot; // Heading of motion (2-D): Degrees * 1e-5
  int32_t headVeh; // Heading of vehicle (2-D): Degrees * 1e-5
  uint32_t hAcc; // Horizontal accuracy: mm
  uint32_t vAcc; // Vertical accuracy: mm
  uint32_t sAcc; // Speed accuracy: mm/s
  uint32_t headAcc; // Heading accuracy: Degrees * 1e-5
  uint8_t reserved2[4];
} UBX_HNR_PVT_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t year : 1;
      uint32_t month : 1;
      uint32_t day : 1;
      uint32_t hour : 1;
      uint32_t min : 1;
      uint32_t sec : 1;

      uint32_t validDate : 1;
      uint32_t validTime : 1;
      uint32_t fullyResolved : 1;

      uint32_t nano : 1;
      uint32_t gpsFix : 1;

      uint32_t gpsFixOK : 1;
      uint32_t diffSoln : 1;
      uint32_t WKNSET : 1;
      uint32_t TOWSET : 1;
      uint32_t headVehValid : 1;

      uint32_t lon : 1;
      uint32_t lat : 1;
      uint32_t height : 1;
      uint32_t hMSL : 1;
      uint32_t gSpeed : 1;
      uint32_t speed : 1;
      uint32_t headMot : 1;
      uint32_t headVeh : 1;
      uint32_t hAcc : 1;
      uint32_t vAcc : 1;
      uint32_t sAcc : 1;
      uint32_t headAcc : 1;
    } bits;
  } moduleQueried;
} UBX_HNR_PVT_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_HNR_PVT_data_t data;
  UBX_HNR_PVT_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_HNR_PVT_data_t);
  UBX_HNR_PVT_data_t  *callbackData;
} UBX_HNR_PVT_t;

// UBX-HNR-ATT (0x28 0x01): Attitude solution
const uint16_t UBX_HNR_ATT_LEN = 32;

typedef struct
{
  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
  uint8_t version;
  uint8_t reserved1[3];
  int32_t roll; // Vehicle roll: Degrees * 1e-5
  int32_t pitch; // Vehicle pitch: Degrees * 1e-5
  int32_t heading; // Vehicle heading: Degrees * 1e-5
  uint32_t accRoll; // Vehicle roll accuracy: Degrees * 1e-5
  uint32_t accPitch; // Vehicle pitch accuracy: Degrees * 1e-5
  uint32_t accHeading; // Vehicle heading accuracy: Degrees * 1e-5
} UBX_HNR_ATT_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t iTOW : 1;
      uint32_t version : 1;
      uint32_t roll : 1;
      uint32_t pitch : 1;
      uint32_t heading : 1;
      uint32_t accRoll : 1;
      uint32_t accPitch : 1;
      uint32_t accHeading : 1;
    } bits;
  } moduleQueried;
} UBX_HNR_ATT_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_HNR_ATT_data_t data;
  UBX_HNR_ATT_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_HNR_ATT_data_t);
  UBX_HNR_ATT_data_t  *callbackData;
} UBX_HNR_ATT_t;

// UBX-HNR-INS (0x28 0x02): Vehicle dynamics information
const uint16_t UBX_HNR_INS_LEN = 36;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t version : 8; // Message version (0x00 for this version)
      uint32_t xAngRateValid : 1; // Compensated x-axis angular rate data validity flag (0: not valid, 1: valid)
      uint32_t yAngRateValid : 1; // Compensated y-axis angular rate data validity flag (0: not valid, 1: valid)
      uint32_t zAngRateValid : 1; // Compensated z-axis angular rate data validity flag (0: not valid, 1: valid)
      uint32_t xAccelValid : 1; // Compensated x-axis acceleration data validity flag (0: not valid, 1: valid)
      uint32_t yAccelValid : 1; // Compensated y-axis acceleration data validity flag (0: not valid, 1: valid)
      uint32_t zAccelValid : 1; // Compensated z-axis acceleration data validity flag (0: not valid, 1: valid)
    } bits;
  } bitfield0;
  uint8_t reserved1[4];
  uint32_t iTOW; // GPS time of week of the HNR epoch: ms
  int32_t xAngRate; // Compensated x-axis angular rate: Degrees/s * 1e-3
  int32_t yAngRate; // Compensated y-axis angular rate: Degrees/s * 1e-3
  int32_t zAngRate; // Compensated z-axis angular rate: Degrees/s * 1e-3
  int32_t xAccel; // Compensated x-axis acceleration (with gravity): m/s^2 * 1e-2
  int32_t yAccel; // Compensated y-axis acceleration (with gravity): m/s^2 * 1e-2
  int32_t zAccel; // Compensated z-axis acceleration (with gravity): m/s^2 * 1e-2
} UBX_HNR_INS_data_t;

typedef struct
{
  union
  {
    uint32_t all;
    struct
    {
      uint32_t all : 1;

      uint32_t version : 1;
      uint32_t xAngRateValid : 1;
      uint32_t yAngRateValid : 1;
      uint32_t zAngRateValid : 1;
      uint32_t xAccelValid : 1;
      uint32_t yAccelValid : 1;
      uint32_t zAccelValid : 1;

      uint32_t iTOW : 1;
      uint32_t xAngRate : 1;
      uint32_t yAngRate : 1;
      uint32_t zAngRate : 1;
      uint32_t xAccel : 1;
      uint32_t yAccel : 1;
      uint32_t zAccel : 1;
    } bits;
  } moduleQueried;
} UBX_HNR_INS_moduleQueried_t;

typedef struct
{
	ubxAutomaticFlags automaticFlags;
  UBX_HNR_INS_data_t data;
  UBX_HNR_INS_moduleQueried_t moduleQueried;
  void (*callbackPointer)(UBX_HNR_INS_data_t);
  UBX_HNR_INS_data_t  *callbackData;
} UBX_HNR_INS_t;

#endif