data_filter.hpp

Go to the documentation of this file.

#pragma once
 
#include "descriptors.h"
#include "../mip_result.h"
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
namespace mip {
class Serializer;
 
namespace C {
struct mip_interface;
} // namespace C
 
namespace data_filter {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET                                   = 0x82,
    
    DATA_POS_LLH                                     = 0x01,
    DATA_VEL_NED                                     = 0x02,
    DATA_ATT_QUATERNION                              = 0x03,
    DATA_ATT_MATRIX                                  = 0x04,
    DATA_ATT_EULER_ANGLES                            = 0x05,
    DATA_GYRO_BIAS                                   = 0x06,
    DATA_ACCEL_BIAS                                  = 0x07,
    DATA_POS_UNCERTAINTY                             = 0x08,
    DATA_VEL_UNCERTAINTY                             = 0x09,
    DATA_ATT_UNCERTAINTY_EULER                       = 0x0A,
    DATA_GYRO_BIAS_UNCERTAINTY                       = 0x0B,
    DATA_ACCEL_BIAS_UNCERTAINTY                      = 0x0C,
    DATA_LINEAR_ACCELERATION                         = 0x0D,
    DATA_COMPENSATED_ANGULAR_RATE                    = 0x0E,
    DATA_WGS84_GRAVITY                               = 0x0F,
    DATA_FILTER_STATUS                               = 0x10,
    DATA_FILTER_TIMESTAMP                            = 0x11,
    DATA_ATT_UNCERTAINTY_QUATERNION                  = 0x12,
    DATA_GRAVITY_VECTOR                              = 0x13,
    DATA_HEADING_UPDATE_STATE                        = 0x14,
    DATA_MAGNETIC_MODEL                              = 0x15,
    DATA_GYRO_SCALE_FACTOR                           = 0x16,
    DATA_ACCEL_SCALE_FACTOR                          = 0x17,
    DATA_GYRO_SCALE_FACTOR_UNCERTAINTY               = 0x18,
    DATA_ACCEL_SCALE_FACTOR_UNCERTAINTY              = 0x19,
    DATA_MAG_BIAS                                    = 0x1A,
    DATA_MAG_BIAS_UNCERTAINTY                        = 0x1B,
    DATA_COMPENSATED_ACCELERATION                    = 0x1C,
    DATA_STANDARD_ATMOSPHERE_DATA                    = 0x20,
    DATA_PRESSURE_ALTITUDE_DATA                      = 0x21,
    DATA_DENSITY_ALTITUDE_DATA                       = 0x22,
    DATA_MAG_SCALE_FACTOR                            = 0x23,
    DATA_MAG_SCALE_FACTOR_UNCERTAINTY                = 0x24,
    DATA_MAG_COMPENSATION_OFFSET                     = 0x25,
    DATA_MAG_COMPENSATION_MATRIX                     = 0x26,
    DATA_COMPENSATED_MAGNETOMETER                    = 0x27,
    DATA_MAG_COMPENSATION_OFFSET_UNCERTAINTY         = 0x28,
    DATA_MAG_COMPENSATION_MATRIX_UNCERTAINTY         = 0x29,
    DATA_MAG_COVARIANCE                              = 0x2A,
    DATA_GRAVITY_COVARIANCE                          = 0x2B,
    DATA_MAG_RESIDUAL                                = 0x2C,
    DATA_MAG_FILTERED_RESIDUAL                       = 0x2D,
    DATA_ANTENNA_OFFSET_CORRECTION                   = 0x30,
    DATA_ANTENNA_OFFSET_CORRECTION_UNCERTAINTY       = 0x31,
    DATA_CLOCK_CORRECTION                            = 0x32,
    DATA_CLOCK_CORRECTION_UNCERTAINTY                = 0x33,
    DATA_MULTI_ANTENNA_OFFSET_CORRECTION             = 0x34,
    DATA_MULTI_ANTENNA_OFFSET_CORRECTION_UNCERTAINTY = 0x35,
    DATA_ECEF_POS_UNCERTAINTY                        = 0x36,
    DATA_ECEF_VEL_UNCERTAINTY                        = 0x37,
    DATA_ECEF_POS                                    = 0x40,
    DATA_ECEF_VEL                                    = 0x41,
    DATA_REL_POS_NED                                 = 0x42,
    DATA_GNSS_POS_AID_STATUS                         = 0x43,
    DATA_GNSS_ATT_AID_STATUS                         = 0x44,
    DATA_HEAD_AID_STATUS                             = 0x45,
    DATA_AID_MEAS_SUMMARY                            = 0x46,
    DATA_ODOMETER_SCALE_FACTOR_ERROR                 = 0x47,
    DATA_ODOMETER_SCALE_FACTOR_ERROR_UNCERTAINTY     = 0x48,
    DATA_GNSS_DUAL_ANTENNA_STATUS                    = 0x49,
    
};
 
// Shared Type Definitions
 
enum class FilterMode : uint16_t
{
    GX5_STARTUP            = 0,  
    GX5_INIT               = 1,  
    GX5_RUN_SOLUTION_VALID = 2,  
    GX5_RUN_SOLUTION_ERROR = 3,  
    INIT                   = 1,  
    VERT_GYRO              = 2,  
    AHRS                   = 3,  
    FULL_NAV               = 4,  
};
 
enum class FilterDynamicsMode : uint16_t
{
    GX5_PORTABLE   = 1,  
    GX5_AUTOMOTIVE = 2,  
    GX5_AIRBORNE   = 3,  
    GQ7_DEFAULT    = 1,  
};
 
struct FilterStatusFlags : Bitfield<FilterStatusFlags>
{
    enum _enumType : uint16_t
    {
        NONE                                           = 0x0000,
        GX5_INIT_NO_ATTITUDE                           = 0x1000,  
        GX5_INIT_NO_POSITION_VELOCITY                  = 0x2000,  
        GX5_RUN_IMU_UNAVAILABLE                        = 0x0001,  
        GX5_RUN_GPS_UNAVAILABLE                        = 0x0002,  
        GX5_RUN_MATRIX_SINGULARITY                     = 0x0008,  
        GX5_RUN_POSITION_COVARIANCE_WARNING            = 0x0010,  
        GX5_RUN_VELOCITY_COVARIANCE_WARNING            = 0x0020,  
        GX5_RUN_ATTITUDE_COVARIANCE_WARNING            = 0x0040,  
        GX5_RUN_NAN_IN_SOLUTION_WARNING                = 0x0080,  
        GX5_RUN_GYRO_BIAS_EST_HIGH_WARNING             = 0x0100,  
        GX5_RUN_ACCEL_BIAS_EST_HIGH_WARNING            = 0x0200,  
        GX5_RUN_GYRO_SCALE_FACTOR_EST_HIGH_WARNING     = 0x0400,  
        GX5_RUN_ACCEL_SCALE_FACTOR_EST_HIGH_WARNING    = 0x0800,  
        GX5_RUN_MAG_BIAS_EST_HIGH_WARNING              = 0x1000,  
        GX5_RUN_ANT_OFFSET_CORRECTION_EST_HIGH_WARNING = 0x2000,  
        GX5_RUN_MAG_HARD_IRON_EST_HIGH_WARNING         = 0x4000,  
        GX5_RUN_MAG_SOFT_IRON_EST_HIGH_WARNING         = 0x8000,  
        GQ7_FILTER_CONDITION                           = 0x0003,  
        GQ7_ROLL_PITCH_WARNING                         = 0x0004,  
        GQ7_HEADING_WARNING                            = 0x0008,  
        GQ7_POSITION_WARNING                           = 0x0010,  
        GQ7_VELOCITY_WARNING                           = 0x0020,  
        GQ7_IMU_BIAS_WARNING                           = 0x0040,  
        GQ7_GNSS_CLK_WARNING                           = 0x0080,  
        GQ7_ANTENNA_LEVER_ARM_WARNING                  = 0x0100,  
        GQ7_MOUNTING_TRANSFORM_WARNING                 = 0x0200,  
        GQ7_TIME_SYNC_WARNING                          = 0x0400,  
        GQ7_SOLUTION_ERROR                             = 0xF000,  
    };
    uint16_t value = NONE;
    
    FilterStatusFlags() : value(NONE) {}
    FilterStatusFlags(int val) : value((uint16_t)val) {}
    operator uint16_t() const { return value; }
    FilterStatusFlags& operator=(uint16_t val) { value = val; return *this; }
    FilterStatusFlags& operator=(int val) { value = val; return *this; }
    FilterStatusFlags& operator|=(uint16_t val) { return *this = value | val; }
    FilterStatusFlags& operator&=(uint16_t val) { return *this = value & val; }
};
 
enum class FilterAidingMeasurementType : uint8_t
{
    GNSS         = 1,  
    DUAL_ANTENNA = 2,  
    HEADING      = 3,  
    PRESSURE     = 4,  
    MAGNETOMETER = 5,  
    SPEED        = 6,  
};
 
struct FilterMeasurementIndicator : Bitfield<FilterMeasurementIndicator>
{
    enum _enumType : uint8_t
    {
        NONE                  = 0x00,
        ENABLED               = 0x01,  
        USED                  = 0x02,  
        RESIDUAL_HIGH_WARNING = 0x04,  
        SAMPLE_TIME_WARNING   = 0x08,  
        CONFIGURATION_ERROR   = 0x10,  
        MAX_NUM_MEAS_EXCEEDED = 0x20,  
    };
    uint8_t value = NONE;
    
    FilterMeasurementIndicator() : value(NONE) {}
    FilterMeasurementIndicator(int val) : value((uint8_t)val) {}
    operator uint8_t() const { return value; }
    FilterMeasurementIndicator& operator=(uint8_t val) { value = val; return *this; }
    FilterMeasurementIndicator& operator=(int val) { value = val; return *this; }
    FilterMeasurementIndicator& operator|=(uint8_t val) { return *this = value | val; }
    FilterMeasurementIndicator& operator&=(uint8_t val) { return *this = value & val; }
};
 
struct GnssAidStatusFlags : Bitfield<GnssAidStatusFlags>
{
    enum _enumType : uint16_t
    {
        NONE           = 0x0000,
        TIGHT_COUPLING = 0x0001,  
        DIFFERENTIAL   = 0x0002,  
        INTEGER_FIX    = 0x0004,  
        GPS_L1         = 0x0008,  
        GPS_L2         = 0x0010,  
        GPS_L5         = 0x0020,  
        GLO_L1         = 0x0040,  
        GLO_L2         = 0x0080,  
        GAL_E1         = 0x0100,  
        GAL_E5         = 0x0200,  
        GAL_E6         = 0x0400,  
        BEI_B1         = 0x0800,  
        BEI_B2         = 0x1000,  
        BEI_B3         = 0x2000,  
        NO_FIX         = 0x4000,  
        CONFIG_ERROR   = 0x8000,  
    };
    uint16_t value = NONE;
    
    GnssAidStatusFlags() : value(NONE) {}
    GnssAidStatusFlags(int val) : value((uint16_t)val) {}
    operator uint16_t() const { return value; }
    GnssAidStatusFlags& operator=(uint16_t val) { value = val; return *this; }
    GnssAidStatusFlags& operator=(int val) { value = val; return *this; }
    GnssAidStatusFlags& operator|=(uint16_t val) { return *this = value | val; }
    GnssAidStatusFlags& operator&=(uint16_t val) { return *this = value & val; }
};
 
 
// Mip Fields
 
 
struct PositionLlh
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_POS_LLH;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    double latitude = 0; 
    double longitude = 0; 
    double ellipsoid_height = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const PositionLlh& self);
void extract(Serializer& serializer, PositionLlh& self);
 
 
struct VelocityNed
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_VEL_NED;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float north = 0; 
    float east = 0; 
    float down = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const VelocityNed& self);
void extract(Serializer& serializer, VelocityNed& self);
 
 
struct AttitudeQuaternion
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ATT_QUATERNION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float q[4] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AttitudeQuaternion& self);
void extract(Serializer& serializer, AttitudeQuaternion& self);
 
 
struct AttitudeDcm
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ATT_MATRIX;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float dcm[9] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AttitudeDcm& self);
void extract(Serializer& serializer, AttitudeDcm& self);
 
 
struct EulerAngles
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ATT_EULER_ANGLES;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float roll = 0; 
    float pitch = 0; 
    float yaw = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const EulerAngles& self);
void extract(Serializer& serializer, EulerAngles& self);
 
 
struct GyroBias
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GYRO_BIAS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float bias[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const GyroBias& self);
void extract(Serializer& serializer, GyroBias& self);
 
 
struct AccelBias
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ACCEL_BIAS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float bias[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AccelBias& self);
void extract(Serializer& serializer, AccelBias& self);
 
 
struct PositionLlhUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_POS_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float north = 0; 
    float east = 0; 
    float down = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const PositionLlhUncertainty& self);
void extract(Serializer& serializer, PositionLlhUncertainty& self);
 
 
struct VelocityNedUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_VEL_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float north = 0; 
    float east = 0; 
    float down = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const VelocityNedUncertainty& self);
void extract(Serializer& serializer, VelocityNedUncertainty& self);
 
 
struct EulerAnglesUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ATT_UNCERTAINTY_EULER;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float roll = 0; 
    float pitch = 0; 
    float yaw = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const EulerAnglesUncertainty& self);
void extract(Serializer& serializer, EulerAnglesUncertainty& self);
 
 
struct GyroBiasUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GYRO_BIAS_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float bias_uncert[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const GyroBiasUncertainty& self);
void extract(Serializer& serializer, GyroBiasUncertainty& self);
 
 
struct AccelBiasUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ACCEL_BIAS_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float bias_uncert[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AccelBiasUncertainty& self);
void extract(Serializer& serializer, AccelBiasUncertainty& self);
 
 
struct Timestamp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_FILTER_TIMESTAMP;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    double tow = 0; 
    uint16_t week_number = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const Timestamp& self);
void extract(Serializer& serializer, Timestamp& self);
 
 
struct Status
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_FILTER_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    FilterMode filter_state = static_cast<FilterMode>(0); 
    FilterDynamicsMode dynamics_mode = static_cast<FilterDynamicsMode>(0); 
    FilterStatusFlags status_flags; 
    
};
void insert(Serializer& serializer, const Status& self);
void extract(Serializer& serializer, Status& self);
 
 
struct LinearAccel
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_LINEAR_ACCELERATION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float accel[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const LinearAccel& self);
void extract(Serializer& serializer, LinearAccel& self);
 
 
struct GravityVector
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GRAVITY_VECTOR;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float gravity[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const GravityVector& self);
void extract(Serializer& serializer, GravityVector& self);
 
 
struct CompAccel
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_COMPENSATED_ACCELERATION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float accel[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const CompAccel& self);
void extract(Serializer& serializer, CompAccel& self);
 
 
struct CompAngularRate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_COMPENSATED_ANGULAR_RATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float gyro[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const CompAngularRate& self);
void extract(Serializer& serializer, CompAngularRate& self);
 
 
struct QuaternionAttitudeUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ATT_UNCERTAINTY_QUATERNION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float q[4] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const QuaternionAttitudeUncertainty& self);
void extract(Serializer& serializer, QuaternionAttitudeUncertainty& self);
 
 
struct Wgs84GravityMag
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_WGS84_GRAVITY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float magnitude = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const Wgs84GravityMag& self);
void extract(Serializer& serializer, Wgs84GravityMag& self);
 
 
struct HeadingUpdateState
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_HEADING_UPDATE_STATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    enum class HeadingSource : uint16_t
    {
        NONE                 = 0,  
        MAGNETOMETER         = 1,  
        GNSS_VELOCITY_VECTOR = 2,  
        EXTERNAL             = 4,  
        DUAL_ANTENNA         = 8,  
    };
    
    float heading = 0; 
    float heading_1sigma = 0; 
    HeadingSource source = static_cast<HeadingSource>(0);
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const HeadingUpdateState& self);
void extract(Serializer& serializer, HeadingUpdateState& self);
 
 
struct MagneticModel
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAGNETIC_MODEL;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float intensity_north = 0; 
    float intensity_east = 0; 
    float intensity_down = 0; 
    float inclination = 0; 
    float declination = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagneticModel& self);
void extract(Serializer& serializer, MagneticModel& self);
 
 
struct AccelScaleFactor
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ACCEL_SCALE_FACTOR;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scale_factor[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AccelScaleFactor& self);
void extract(Serializer& serializer, AccelScaleFactor& self);
 
 
struct AccelScaleFactorUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ACCEL_SCALE_FACTOR_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scale_factor_uncert[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AccelScaleFactorUncertainty& self);
void extract(Serializer& serializer, AccelScaleFactorUncertainty& self);
 
 
struct GyroScaleFactor
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GYRO_SCALE_FACTOR;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scale_factor[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const GyroScaleFactor& self);
void extract(Serializer& serializer, GyroScaleFactor& self);
 
 
struct GyroScaleFactorUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GYRO_SCALE_FACTOR_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scale_factor_uncert[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const GyroScaleFactorUncertainty& self);
void extract(Serializer& serializer, GyroScaleFactorUncertainty& self);
 
 
struct MagBias
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_BIAS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float bias[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagBias& self);
void extract(Serializer& serializer, MagBias& self);
 
 
struct MagBiasUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_BIAS_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float bias_uncert[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagBiasUncertainty& self);
void extract(Serializer& serializer, MagBiasUncertainty& self);
 
 
struct StandardAtmosphere
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_STANDARD_ATMOSPHERE_DATA;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float geometric_altitude = 0; 
    float geopotential_altitude = 0; 
    float standard_temperature = 0; 
    float standard_pressure = 0; 
    float standard_density = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const StandardAtmosphere& self);
void extract(Serializer& serializer, StandardAtmosphere& self);
 
 
struct PressureAltitude
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_PRESSURE_ALTITUDE_DATA;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float pressure_altitude = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const PressureAltitude& self);
void extract(Serializer& serializer, PressureAltitude& self);
 
 
struct DensityAltitude
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_DENSITY_ALTITUDE_DATA;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float density_altitude = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const DensityAltitude& self);
void extract(Serializer& serializer, DensityAltitude& self);
 
 
struct AntennaOffsetCorrection
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ANTENNA_OFFSET_CORRECTION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float offset[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AntennaOffsetCorrection& self);
void extract(Serializer& serializer, AntennaOffsetCorrection& self);
 
 
struct AntennaOffsetCorrectionUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ANTENNA_OFFSET_CORRECTION_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float offset_uncert[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const AntennaOffsetCorrectionUncertainty& self);
void extract(Serializer& serializer, AntennaOffsetCorrectionUncertainty& self);
 
 
struct MultiAntennaOffsetCorrection
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MULTI_ANTENNA_OFFSET_CORRECTION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t receiver_id = 0; 
    float offset[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MultiAntennaOffsetCorrection& self);
void extract(Serializer& serializer, MultiAntennaOffsetCorrection& self);
 
 
struct MultiAntennaOffsetCorrectionUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MULTI_ANTENNA_OFFSET_CORRECTION_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t receiver_id = 0; 
    float offset_uncert[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MultiAntennaOffsetCorrectionUncertainty& self);
void extract(Serializer& serializer, MultiAntennaOffsetCorrectionUncertainty& self);
 
 
struct MagnetometerOffset
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_COMPENSATION_OFFSET;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float hard_iron[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagnetometerOffset& self);
void extract(Serializer& serializer, MagnetometerOffset& self);
 
 
struct MagnetometerMatrix
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_COMPENSATION_MATRIX;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float soft_iron[9] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagnetometerMatrix& self);
void extract(Serializer& serializer, MagnetometerMatrix& self);
 
 
struct MagnetometerOffsetUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_COMPENSATION_OFFSET_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float hard_iron_uncertainty[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagnetometerOffsetUncertainty& self);
void extract(Serializer& serializer, MagnetometerOffsetUncertainty& self);
 
 
struct MagnetometerMatrixUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_COMPENSATION_MATRIX_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float soft_iron_uncertainty[9] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagnetometerMatrixUncertainty& self);
void extract(Serializer& serializer, MagnetometerMatrixUncertainty& self);
 
 
struct MagnetometerCovarianceMatrix
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_COVARIANCE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float covariance[9] = {0};
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagnetometerCovarianceMatrix& self);
void extract(Serializer& serializer, MagnetometerCovarianceMatrix& self);
 
 
struct MagnetometerResidualVector
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_MAG_RESIDUAL;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float residual[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const MagnetometerResidualVector& self);
void extract(Serializer& serializer, MagnetometerResidualVector& self);
 
 
struct ClockCorrection
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_CLOCK_CORRECTION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t receiver_id = 0; 
    float bias = 0; 
    float bias_drift = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const ClockCorrection& self);
void extract(Serializer& serializer, ClockCorrection& self);
 
 
struct ClockCorrectionUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_CLOCK_CORRECTION_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t receiver_id = 0; 
    float bias_uncertainty = 0; 
    float bias_drift_uncertainty = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const ClockCorrectionUncertainty& self);
void extract(Serializer& serializer, ClockCorrectionUncertainty& self);
 
 
struct GnssPosAidStatus
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GNSS_POS_AID_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t receiver_id = 0;
    float time_of_week = 0; 
    GnssAidStatusFlags status; 
    uint8_t reserved[8] = {0};
    
};
void insert(Serializer& serializer, const GnssPosAidStatus& self);
void extract(Serializer& serializer, GnssPosAidStatus& self);
 
 
struct GnssAttAidStatus
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GNSS_ATT_AID_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float time_of_week = 0; 
    GnssAidStatusFlags status; 
    uint8_t reserved[8] = {0};
    
};
void insert(Serializer& serializer, const GnssAttAidStatus& self);
void extract(Serializer& serializer, GnssAttAidStatus& self);
 
 
struct HeadAidStatus
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_HEAD_AID_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    enum class HeadingAidType : uint8_t
    {
        DUAL_ANTENNA     = 1,  
        EXTERNAL_MESSAGE = 2,  
    };
    
    float time_of_week = 0; 
    HeadingAidType type = static_cast<HeadingAidType>(0); 
    float reserved[2] = {0};
    
};
void insert(Serializer& serializer, const HeadAidStatus& self);
void extract(Serializer& serializer, HeadAidStatus& self);
 
 
struct RelPosNed
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_REL_POS_NED;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    double relative_position[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const RelPosNed& self);
void extract(Serializer& serializer, RelPosNed& self);
 
 
struct EcefPos
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ECEF_POS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    double position_ecef[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const EcefPos& self);
void extract(Serializer& serializer, EcefPos& self);
 
 
struct EcefVel
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ECEF_VEL;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float velocity_ecef[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const EcefVel& self);
void extract(Serializer& serializer, EcefVel& self);
 
 
struct EcefPosUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ECEF_POS_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float pos_uncertainty[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const EcefPosUncertainty& self);
void extract(Serializer& serializer, EcefPosUncertainty& self);
 
 
struct EcefVelUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ECEF_VEL_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float vel_uncertainty[3] = {0}; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const EcefVelUncertainty& self);
void extract(Serializer& serializer, EcefVelUncertainty& self);
 
 
struct AidingMeasurementSummary
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_AID_MEAS_SUMMARY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float time_of_week = 0; 
    uint8_t source = 0;
    FilterAidingMeasurementType type = static_cast<FilterAidingMeasurementType>(0); 
    FilterMeasurementIndicator indicator;
    
};
void insert(Serializer& serializer, const AidingMeasurementSummary& self);
void extract(Serializer& serializer, AidingMeasurementSummary& self);
 
 
struct OdometerScaleFactorError
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ODOMETER_SCALE_FACTOR_ERROR;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scale_factor_error = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const OdometerScaleFactorError& self);
void extract(Serializer& serializer, OdometerScaleFactorError& self);
 
 
struct OdometerScaleFactorErrorUncertainty
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_ODOMETER_SCALE_FACTOR_ERROR_UNCERTAINTY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scale_factor_error_uncertainty = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const OdometerScaleFactorErrorUncertainty& self);
void extract(Serializer& serializer, OdometerScaleFactorErrorUncertainty& self);
 
 
struct GnssDualAntennaStatus
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_filter::DATA_GNSS_DUAL_ANTENNA_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    enum class FixType : uint8_t
    {
        FIX_NONE     = 0,  
        FIX_DA_FLOAT = 1,  
        FIX_DA_FIXED = 2,  
    };
    
    struct DualAntennaStatusFlags : Bitfield<DualAntennaStatusFlags>
    {
        enum _enumType : uint16_t
        {
            NONE                  = 0x0000,
            RCV_1_DATA_VALID      = 0x0001,  
            RCV_2_DATA_VALID      = 0x0002,  
            ANTENNA_OFFSETS_VALID = 0x0004,  
        };
        uint16_t value = NONE;
        
        DualAntennaStatusFlags() : value(NONE) {}
        DualAntennaStatusFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        DualAntennaStatusFlags& operator=(uint16_t val) { value = val; return *this; }
        DualAntennaStatusFlags& operator=(int val) { value = val; return *this; }
        DualAntennaStatusFlags& operator|=(uint16_t val) { return *this = value | val; }
        DualAntennaStatusFlags& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    float time_of_week = 0; 
    float heading = 0; 
    float heading_unc = 0; 
    FixType fix_type = static_cast<FixType>(0); 
    DualAntennaStatusFlags status_flags;
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const GnssDualAntennaStatus& self);
void extract(Serializer& serializer, GnssDualAntennaStatus& self);
 
 
} // namespace data_filter
} // namespace mip