commands_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 commands_filter {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET                                            = 0x0D,
    
    CMD_RESET_FILTER                                          = 0x01,
    CMD_SET_INITIAL_ATTITUDE                                  = 0x02,
    CMD_SET_INITIAL_HEADING                                   = 0x03,
    CMD_SET_INITIAL_HEADING_FROM_MAG                          = 0x04,
    CMD_RUN                                                   = 0x05,
    CMD_SELECT_FILTER                                         = 0x0F,
    CMD_VEHICLE_DYNAMICS_MODE                                 = 0x10,
    CMD_SENSOR2VEHICLE_ROTATION_EULER                         = 0x11,
    CMD_SENSOR2VEHICLE_OFFSET                                 = 0x12,
    CMD_ANTENNA_OFFSET                                        = 0x13,
    CMD_ESTIMATION_CONTROL_FLAGS                              = 0x14,
    CMD_GNSS_SOURCE_CONTROL                                   = 0x15,
    CMD_EXTERNAL_GNSS_UPDATE                                  = 0x16,
    CMD_EXTERNAL_HEADING_UPDATE                               = 0x17,
    CMD_HEADING_UPDATE_CONTROL                                = 0x18,
    CMD_AUTOINIT_CONTROL                                      = 0x19,
    CMD_ACCEL_NOISE                                           = 0x1A,
    CMD_GYRO_NOISE                                            = 0x1B,
    CMD_ACCEL_BIAS_MODEL                                      = 0x1C,
    CMD_GYRO_BIAS_MODEL                                       = 0x1D,
    CMD_ZUPT_CONTROL                                          = 0x1E,
    CMD_EXTERNAL_HEADING_UPDATE_WITH_TIME                     = 0x1F,
    CMD_ANGULAR_ZUPT_CONTROL                                  = 0x20,
    CMD_TARE_ORIENTATION                                      = 0x21,
    CMD_COMMANDED_ZUPT                                        = 0x22,
    CMD_COMMANDED_ANGULAR_ZUPT                                = 0x23,
    CMD_AUTO_HEADING_UPDATE_CONTROL                           = 0x24,
    CMD_MAG_AUTO_CALIBRATION_CONTROL                          = 0x25,
    CMD_MAG_CAPTURE_AUTO_CALIBRATION                          = 0x27,
    CMD_GRAVITY_NOISE                                         = 0x28,
    CMD_PRESSURE_NOISE                                        = 0x29,
    CMD_GRAVITY_NOISE_MINIMUM                                 = 0x2A,
    CMD_HARD_IRON_OFFSET_NOISE                                = 0x2B,
    CMD_SOFT_IRON_MATRIX_NOISE                                = 0x2C,
    CMD_LOW_PASS_SENSOR_FILTER                                = 0x30,
    CMD_MAG_NOISE                                             = 0x42,
    CMD_DECLINATION_SOURCE                                    = 0x43,
    CMD_HOT_START_CONTROL                                     = 0x48,
    CMD_SECONDARY_VELOCITY_AIDING_CONTROL                     = 0x4A,
    CMD_INCLINATION_SOURCE                                    = 0x4C,
    CMD_MAGNETIC_MAGNITUDE_SOURCE                             = 0x4D,
    CMD_SENSOR2VEHICLE_ROTATION_DCM                           = 0x4E,
    CMD_SENSOR2VEHICLE_ROTATION_QUATERNION                    = 0x4F,
    CMD_REFERENCE_POSITION                                    = 0x26,
    CMD_ENABLE_MEASUREMENT                                    = 0x41,
    CMD_ACCEL_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL    = 0x44,
    CMD_MAG_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL      = 0x45,
    CMD_MAG_DIP_ANGLE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL      = 0x46,
    CMD_ALTITUDE_AIDING_CONTROL                               = 0x47,
    CMD_SECONDARY_PITCH_ROLL_AIDING_CONTROL                   = 0x4B,
    CMD_AIDING_MEASUREMENT_ENABLE                             = 0x50,
    CMD_KINEMATIC_CONSTRAINT                                  = 0x51,
    CMD_INITIALIZATION_CONFIGURATION                          = 0x52,
    CMD_ADAPTIVE_FILTER_OPTIONS                               = 0x53,
    CMD_MULTI_ANTENNA_OFFSET                                  = 0x54,
    CMD_REL_POS_CONFIGURATION                                 = 0x55,
    CMD_REF_POINT_LEVER_ARM                                   = 0x56,
    CMD_SPEED_MEASUREMENT                                     = 0x60,
    CMD_SPEED_LEVER_ARM                                       = 0x61,
    CMD_GYRO_CONSTRAINT_CONTROL                               = 0x62,
    CMD_VEHICLE_CONSTRAINT_CONTROL                            = 0x63,
    CMD_ANTENNA_CALIBRATION_CONTROL                           = 0x64,
    CMD_TO_VEHICLE_CALIBRATION_CONTROL                        = 0x65,
    
    REPLY_VEHICLE_DYNAMICS_MODE                               = 0x80,
    REPLY_SENSOR2VEHICLE_ROTATION_EULER                       = 0x81,
    REPLY_SENSOR2VEHICLE_OFFSET                               = 0x82,
    REPLY_ANTENNA_OFFSET                                      = 0x83,
    REPLY_ESTIMATION_CONTROL_FLAGS                            = 0x84,
    REPLY_GNSS_SOURCE_CONTROL                                 = 0x86,
    REPLY_HEADING_UPDATE_CONTROL                              = 0x87,
    REPLY_AUTOINIT_CONTROL                                    = 0x88,
    REPLY_ACCEL_NOISE                                         = 0x89,
    REPLY_GYRO_NOISE                                          = 0x8A,
    REPLY_MAG_NOISE                                           = 0xB1,
    REPLY_ACCEL_BIAS_MODEL                                    = 0x8B,
    REPLY_GYRO_BIAS_MODEL                                     = 0x8C,
    REPLY_ZUPT_CONTROL                                        = 0x8D,
    REPLY_ANGULAR_ZUPT_CONTROL                                = 0x8E,
    REPLY_SELECT_FILTER                                       = 0x8F,
    REPLY_GRAVITY_NOISE                                       = 0x93,
    REPLY_PRESSURE_NOISE                                      = 0x94,
    REPLY_GRAVITY_NOISE_MINIMUM                               = 0x95,
    REPLY_HARD_IRON_OFFSET_NOISE                              = 0x96,
    REPLY_SOFT_IRON_MATRIX_NOISE                              = 0x97,
    REPLY_LOW_PASS_SENSOR_FILTER                              = 0xA0,
    REPLY_SET_INITIAL_HEADING                                 = 0x98,
    REPLY_REFERENCE_POSITION                                  = 0x90,
    REPLY_AUTO_HEADING_UPDATE_CONTROL                         = 0x91,
    REPLY_MAG_AUTO_CALIBRATION_CONTROL                        = 0x92,
    REPLY_ENABLE_MEASUREMENT                                  = 0xB0,
    REPLY_DECLINATION_SOURCE                                  = 0xB2,
    REPLY_ACCEL_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL  = 0xB3,
    REPLY_MAG_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL    = 0xB4,
    REPLY_MAG_DIP_ANGLE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL    = 0xB5,
    REPLY_MAG_ANGULAR_RATE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL = 0xB6,
    REPLY_ALTITUDE_AIDING_CONTROL                             = 0xB7,
    REPLY_HOT_START_CONTROL                                   = 0xB8,
    REPLY_SECONDARY_VELOCITY_AIDING_CONTROL                   = 0xBA,
    REPLY_SECONDARY_PITCH_ROLL_AIDING_CONTROL                 = 0xBB,
    REPLY_INCLINATION_SOURCE                                  = 0xBC,
    REPLY_MAGNETIC_MAGNITUDE_SOURCE                           = 0xBD,
    REPLY_SENSOR2VEHICLE_ROTATION_DCM                         = 0xBE,
    REPLY_SENSOR2VEHICLE_ROTATION_QUATERNION                  = 0xBF,
    REPLY_AIDING_MEASUREMENT_ENABLE                           = 0xD0,
    REPLY_KINEMATIC_CONSTRAINT                                = 0xD1,
    REPLY_INITIALIZATION_CONFIGURATION                        = 0xD2,
    REPLY_ADAPTIVE_FILTER_OPTIONS                             = 0xD3,
    REPLY_MULTI_ANTENNA_OFFSET                                = 0xD4,
    REPLY_REL_POS_CONFIGURATION                               = 0xD5,
    REPLY_SPEED_MEASUREMENT                                   = 0xE0,
    REPLY_GYRO_CONSTRAINT_CONTROL                             = 0xE2,
    REPLY_VEHICLE_CONSTRAINT_CONTROL                          = 0xE3,
    REPLY_ANTENNA_CALIBRATION_CONTROL                         = 0xE4,
    REPLY_TARE_ORIENTATION                                    = 0xA1,
    REPLY_REF_POINT_LEVER_ARM                                 = 0xD6,
    REPLY_SPEED_LEVER_ARM                                     = 0xE1,
};
 
// Shared Type Definitions
 
enum class FilterReferenceFrame : uint8_t
{
    ECEF = 1,  
    LLH  = 2,  
};
 
enum class FilterMagDeclinationSource : uint8_t
{
    NONE   = 1,  
    WMM    = 2,  
    MANUAL = 3,  
};
 
 
// Mip Fields
 
 
struct Reset
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_RESET_FILTER;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const Reset& self);
void extract(Serializer& serializer, Reset& self);
 
CmdResult reset(C::mip_interface& device);
 
struct SetInitialAttitude
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SET_INITIAL_ATTITUDE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float roll = 0; 
    float pitch = 0; 
    float heading = 0; 
    
};
void insert(Serializer& serializer, const SetInitialAttitude& self);
void extract(Serializer& serializer, SetInitialAttitude& self);
 
CmdResult setInitialAttitude(C::mip_interface& device, float roll, float pitch, float heading);
 
struct EstimationControl
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_ESTIMATION_CONTROL_FLAGS;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    struct EnableFlags : Bitfield<EnableFlags>
    {
        enum _enumType : uint16_t
        {
            NONE               = 0x0000,
            GYRO_BIAS          = 0x0001,  
            ACCEL_BIAS         = 0x0002,  
            GYRO_SCALE_FACTOR  = 0x0004,  
            ACCEL_SCALE_FACTOR = 0x0008,  
            ANTENNA_OFFSET     = 0x0010,  
            AUTO_MAG_HARD_IRON = 0x0020,  
            AUTO_MAG_SOFT_IRON = 0x0040,  
        };
        uint16_t value = NONE;
        
        EnableFlags() : value(NONE) {}
        EnableFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        EnableFlags& operator=(uint16_t val) { value = val; return *this; }
        EnableFlags& operator=(int val) { value = val; return *this; }
        EnableFlags& operator|=(uint16_t val) { return *this = value | val; }
        EnableFlags& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    EnableFlags enable; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_ESTIMATION_CONTROL_FLAGS;
        
        EnableFlags enable; 
        
    };
};
void insert(Serializer& serializer, const EstimationControl& self);
void extract(Serializer& serializer, EstimationControl& self);
 
void insert(Serializer& serializer, const EstimationControl::Response& self);
void extract(Serializer& serializer, EstimationControl::Response& self);
 
CmdResult writeEstimationControl(C::mip_interface& device, EstimationControl::EnableFlags enable);
CmdResult readEstimationControl(C::mip_interface& device, EstimationControl::EnableFlags* enableOut);
CmdResult saveEstimationControl(C::mip_interface& device);
CmdResult loadEstimationControl(C::mip_interface& device);
CmdResult defaultEstimationControl(C::mip_interface& device);
 
struct ExternalGnssUpdate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_EXTERNAL_GNSS_UPDATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    double gps_time = 0; 
    uint16_t gps_week = 0; 
    double latitude = 0; 
    double longitude = 0; 
    double height = 0; 
    float velocity[3] = {0}; 
    float pos_uncertainty[3] = {0}; 
    float vel_uncertainty[3] = {0}; 
    
};
void insert(Serializer& serializer, const ExternalGnssUpdate& self);
void extract(Serializer& serializer, ExternalGnssUpdate& self);
 
CmdResult externalGnssUpdate(C::mip_interface& device, double gpsTime, uint16_t gpsWeek, double latitude, double longitude, double height, const float* velocity, const float* posUncertainty, const float* velUncertainty);
 
struct ExternalHeadingUpdate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_EXTERNAL_HEADING_UPDATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float heading = 0; 
    float heading_uncertainty = 0; 
    uint8_t type = 0; 
    
};
void insert(Serializer& serializer, const ExternalHeadingUpdate& self);
void extract(Serializer& serializer, ExternalHeadingUpdate& self);
 
CmdResult externalHeadingUpdate(C::mip_interface& device, float heading, float headingUncertainty, uint8_t type);
 
struct ExternalHeadingUpdateWithTime
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_EXTERNAL_HEADING_UPDATE_WITH_TIME;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    double gps_time = 0; 
    uint16_t gps_week = 0; 
    float heading = 0; 
    float heading_uncertainty = 0; 
    uint8_t type = 0; 
    
};
void insert(Serializer& serializer, const ExternalHeadingUpdateWithTime& self);
void extract(Serializer& serializer, ExternalHeadingUpdateWithTime& self);
 
CmdResult externalHeadingUpdateWithTime(C::mip_interface& device, double gpsTime, uint16_t gpsWeek, float heading, float headingUncertainty, uint8_t type);
 
struct TareOrientation
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_TARE_ORIENTATION;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    struct MipTareAxes : Bitfield<MipTareAxes>
    {
        enum _enumType : uint8_t
        {
            NONE  = 0x0,
            ROLL  = 0x1,  
            PITCH = 0x2,  
            YAW   = 0x4,  
        };
        uint8_t value = NONE;
        
        MipTareAxes() : value(NONE) {}
        MipTareAxes(int val) : value((uint8_t)val) {}
        operator uint8_t() const { return value; }
        MipTareAxes& operator=(uint8_t val) { value = val; return *this; }
        MipTareAxes& operator=(int val) { value = val; return *this; }
        MipTareAxes& operator|=(uint8_t val) { return *this = value | val; }
        MipTareAxes& operator&=(uint8_t val) { return *this = value & val; }
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    MipTareAxes axes; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_TARE_ORIENTATION;
        
        MipTareAxes axes; 
        
    };
};
void insert(Serializer& serializer, const TareOrientation& self);
void extract(Serializer& serializer, TareOrientation& self);
 
void insert(Serializer& serializer, const TareOrientation::Response& self);
void extract(Serializer& serializer, TareOrientation::Response& self);
 
CmdResult writeTareOrientation(C::mip_interface& device, TareOrientation::MipTareAxes axes);
CmdResult readTareOrientation(C::mip_interface& device, TareOrientation::MipTareAxes* axesOut);
CmdResult saveTareOrientation(C::mip_interface& device);
CmdResult loadTareOrientation(C::mip_interface& device);
CmdResult defaultTareOrientation(C::mip_interface& device);
 
struct SensorToVehicleRotationEuler
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SENSOR2VEHICLE_ROTATION_EULER;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float roll = 0; 
    float pitch = 0; 
    float yaw = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_SENSOR2VEHICLE_ROTATION_EULER;
        
        float roll = 0; 
        float pitch = 0; 
        float yaw = 0; 
        
    };
};
void insert(Serializer& serializer, const SensorToVehicleRotationEuler& self);
void extract(Serializer& serializer, SensorToVehicleRotationEuler& self);
 
void insert(Serializer& serializer, const SensorToVehicleRotationEuler::Response& self);
void extract(Serializer& serializer, SensorToVehicleRotationEuler::Response& self);
 
CmdResult writeSensorToVehicleRotationEuler(C::mip_interface& device, float roll, float pitch, float yaw);
CmdResult readSensorToVehicleRotationEuler(C::mip_interface& device, float* rollOut, float* pitchOut, float* yawOut);
CmdResult saveSensorToVehicleRotationEuler(C::mip_interface& device);
CmdResult loadSensorToVehicleRotationEuler(C::mip_interface& device);
CmdResult defaultSensorToVehicleRotationEuler(C::mip_interface& device);
 
struct SensorToVehicleRotationDcm
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SENSOR2VEHICLE_ROTATION_DCM;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float dcm[9] = {0};
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_SENSOR2VEHICLE_ROTATION_DCM;
        
        float dcm[9] = {0};
        
    };
};
void insert(Serializer& serializer, const SensorToVehicleRotationDcm& self);
void extract(Serializer& serializer, SensorToVehicleRotationDcm& self);
 
void insert(Serializer& serializer, const SensorToVehicleRotationDcm::Response& self);
void extract(Serializer& serializer, SensorToVehicleRotationDcm::Response& self);
 
CmdResult writeSensorToVehicleRotationDcm(C::mip_interface& device, const float* dcm);
CmdResult readSensorToVehicleRotationDcm(C::mip_interface& device, float* dcmOut);
CmdResult saveSensorToVehicleRotationDcm(C::mip_interface& device);
CmdResult loadSensorToVehicleRotationDcm(C::mip_interface& device);
CmdResult defaultSensorToVehicleRotationDcm(C::mip_interface& device);
 
struct SensorToVehicleRotationQuaternion
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SENSOR2VEHICLE_ROTATION_QUATERNION;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float quat[4] = {0};
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_SENSOR2VEHICLE_ROTATION_QUATERNION;
        
        float quat[4] = {0};
        
    };
};
void insert(Serializer& serializer, const SensorToVehicleRotationQuaternion& self);
void extract(Serializer& serializer, SensorToVehicleRotationQuaternion& self);
 
void insert(Serializer& serializer, const SensorToVehicleRotationQuaternion::Response& self);
void extract(Serializer& serializer, SensorToVehicleRotationQuaternion::Response& self);
 
CmdResult writeSensorToVehicleRotationQuaternion(C::mip_interface& device, const float* quat);
CmdResult readSensorToVehicleRotationQuaternion(C::mip_interface& device, float* quatOut);
CmdResult saveSensorToVehicleRotationQuaternion(C::mip_interface& device);
CmdResult loadSensorToVehicleRotationQuaternion(C::mip_interface& device);
CmdResult defaultSensorToVehicleRotationQuaternion(C::mip_interface& device);
 
struct SensorToVehicleOffset
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SENSOR2VEHICLE_OFFSET;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float offset[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_SENSOR2VEHICLE_OFFSET;
        
        float offset[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const SensorToVehicleOffset& self);
void extract(Serializer& serializer, SensorToVehicleOffset& self);
 
void insert(Serializer& serializer, const SensorToVehicleOffset::Response& self);
void extract(Serializer& serializer, SensorToVehicleOffset::Response& self);
 
CmdResult writeSensorToVehicleOffset(C::mip_interface& device, const float* offset);
CmdResult readSensorToVehicleOffset(C::mip_interface& device, float* offsetOut);
CmdResult saveSensorToVehicleOffset(C::mip_interface& device);
CmdResult loadSensorToVehicleOffset(C::mip_interface& device);
CmdResult defaultSensorToVehicleOffset(C::mip_interface& device);
 
struct AntennaOffset
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_ANTENNA_OFFSET;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float offset[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_ANTENNA_OFFSET;
        
        float offset[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const AntennaOffset& self);
void extract(Serializer& serializer, AntennaOffset& self);
 
void insert(Serializer& serializer, const AntennaOffset::Response& self);
void extract(Serializer& serializer, AntennaOffset::Response& self);
 
CmdResult writeAntennaOffset(C::mip_interface& device, const float* offset);
CmdResult readAntennaOffset(C::mip_interface& device, float* offsetOut);
CmdResult saveAntennaOffset(C::mip_interface& device);
CmdResult loadAntennaOffset(C::mip_interface& device);
CmdResult defaultAntennaOffset(C::mip_interface& device);
 
struct GnssSource
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_GNSS_SOURCE_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class Source : uint8_t
    {
        ALL_INT = 1,  
        EXT     = 2,  
        INT_1   = 3,  
        INT_2   = 4,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    Source source = static_cast<Source>(0);
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_GNSS_SOURCE_CONTROL;
        
        Source source = static_cast<Source>(0);
        
    };
};
void insert(Serializer& serializer, const GnssSource& self);
void extract(Serializer& serializer, GnssSource& self);
 
void insert(Serializer& serializer, const GnssSource::Response& self);
void extract(Serializer& serializer, GnssSource::Response& self);
 
CmdResult writeGnssSource(C::mip_interface& device, GnssSource::Source source);
CmdResult readGnssSource(C::mip_interface& device, GnssSource::Source* sourceOut);
CmdResult saveGnssSource(C::mip_interface& device);
CmdResult loadGnssSource(C::mip_interface& device);
CmdResult defaultGnssSource(C::mip_interface& device);
 
struct HeadingSource
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_HEADING_UPDATE_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class Source : uint8_t
    {
        NONE                          = 0,  
        MAG                           = 1,  
        GNSS_VEL                      = 2,  
        EXTERNAL                      = 3,  
        GNSS_VEL_AND_MAG              = 4,  
        GNSS_VEL_AND_EXTERNAL         = 5,  
        MAG_AND_EXTERNAL              = 6,  
        GNSS_VEL_AND_MAG_AND_EXTERNAL = 7,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    Source source = static_cast<Source>(0);
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_HEADING_UPDATE_CONTROL;
        
        Source source = static_cast<Source>(0);
        
    };
};
void insert(Serializer& serializer, const HeadingSource& self);
void extract(Serializer& serializer, HeadingSource& self);
 
void insert(Serializer& serializer, const HeadingSource::Response& self);
void extract(Serializer& serializer, HeadingSource::Response& self);
 
CmdResult writeHeadingSource(C::mip_interface& device, HeadingSource::Source source);
CmdResult readHeadingSource(C::mip_interface& device, HeadingSource::Source* sourceOut);
CmdResult saveHeadingSource(C::mip_interface& device);
CmdResult loadHeadingSource(C::mip_interface& device);
CmdResult defaultHeadingSource(C::mip_interface& device);
 
struct AutoInitControl
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_AUTOINIT_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t enable = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_AUTOINIT_CONTROL;
        
        uint8_t enable = 0; 
        
    };
};
void insert(Serializer& serializer, const AutoInitControl& self);
void extract(Serializer& serializer, AutoInitControl& self);
 
void insert(Serializer& serializer, const AutoInitControl::Response& self);
void extract(Serializer& serializer, AutoInitControl::Response& self);
 
CmdResult writeAutoInitControl(C::mip_interface& device, uint8_t enable);
CmdResult readAutoInitControl(C::mip_interface& device, uint8_t* enableOut);
CmdResult saveAutoInitControl(C::mip_interface& device);
CmdResult loadAutoInitControl(C::mip_interface& device);
CmdResult defaultAutoInitControl(C::mip_interface& device);
 
struct AltitudeAiding
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_ALTITUDE_AIDING_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t aiding_selector = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_ALTITUDE_AIDING_CONTROL;
        
        uint8_t aiding_selector = 0; 
        
    };
};
void insert(Serializer& serializer, const AltitudeAiding& self);
void extract(Serializer& serializer, AltitudeAiding& self);
 
void insert(Serializer& serializer, const AltitudeAiding::Response& self);
void extract(Serializer& serializer, AltitudeAiding::Response& self);
 
CmdResult writeAltitudeAiding(C::mip_interface& device, uint8_t aidingSelector);
CmdResult readAltitudeAiding(C::mip_interface& device, uint8_t* aidingSelectorOut);
CmdResult saveAltitudeAiding(C::mip_interface& device);
CmdResult loadAltitudeAiding(C::mip_interface& device);
CmdResult defaultAltitudeAiding(C::mip_interface& device);
 
struct AutoZupt
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_ZUPT_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t enable = 0; 
    float threshold = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_ZUPT_CONTROL;
        
        uint8_t enable = 0; 
        float threshold = 0; 
        
    };
};
void insert(Serializer& serializer, const AutoZupt& self);
void extract(Serializer& serializer, AutoZupt& self);
 
void insert(Serializer& serializer, const AutoZupt::Response& self);
void extract(Serializer& serializer, AutoZupt::Response& self);
 
CmdResult writeAutoZupt(C::mip_interface& device, uint8_t enable, float threshold);
CmdResult readAutoZupt(C::mip_interface& device, uint8_t* enableOut, float* thresholdOut);
CmdResult saveAutoZupt(C::mip_interface& device);
CmdResult loadAutoZupt(C::mip_interface& device);
CmdResult defaultAutoZupt(C::mip_interface& device);
 
struct AutoAngularZupt
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_ANGULAR_ZUPT_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t enable = 0; 
    float threshold = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_ANGULAR_ZUPT_CONTROL;
        
        uint8_t enable = 0; 
        float threshold = 0; 
        
    };
};
void insert(Serializer& serializer, const AutoAngularZupt& self);
void extract(Serializer& serializer, AutoAngularZupt& self);
 
void insert(Serializer& serializer, const AutoAngularZupt::Response& self);
void extract(Serializer& serializer, AutoAngularZupt::Response& self);
 
CmdResult writeAutoAngularZupt(C::mip_interface& device, uint8_t enable, float threshold);
CmdResult readAutoAngularZupt(C::mip_interface& device, uint8_t* enableOut, float* thresholdOut);
CmdResult saveAutoAngularZupt(C::mip_interface& device);
CmdResult loadAutoAngularZupt(C::mip_interface& device);
CmdResult defaultAutoAngularZupt(C::mip_interface& device);
 
struct CommandedZupt
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_COMMANDED_ZUPT;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const CommandedZupt& self);
void extract(Serializer& serializer, CommandedZupt& self);
 
CmdResult commandedZupt(C::mip_interface& device);
 
struct CommandedAngularZupt
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_COMMANDED_ANGULAR_ZUPT;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const CommandedAngularZupt& self);
void extract(Serializer& serializer, CommandedAngularZupt& self);
 
CmdResult commandedAngularZupt(C::mip_interface& device);
 
struct AidingMeasurementEnable
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_AIDING_MEASUREMENT_ENABLE;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class AidingSource : uint16_t
    {
        GNSS_POS_VEL     = 0,  
        GNSS_HEADING     = 1,  
        ALTIMETER        = 2,  
        SPEED            = 3,  
        MAGNETOMETER     = 4,  
        EXTERNAL_HEADING = 5,  
        ALL              = 65535,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    AidingSource aiding_source = static_cast<AidingSource>(0); 
    bool enable = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_AIDING_MEASUREMENT_ENABLE;
        
        AidingSource aiding_source = static_cast<AidingSource>(0); 
        bool enable = 0; 
        
    };
};
void insert(Serializer& serializer, const AidingMeasurementEnable& self);
void extract(Serializer& serializer, AidingMeasurementEnable& self);
 
void insert(Serializer& serializer, const AidingMeasurementEnable::Response& self);
void extract(Serializer& serializer, AidingMeasurementEnable::Response& self);
 
CmdResult writeAidingMeasurementEnable(C::mip_interface& device, AidingMeasurementEnable::AidingSource aidingSource, bool enable);
CmdResult readAidingMeasurementEnable(C::mip_interface& device, AidingMeasurementEnable::AidingSource aidingSource, bool* enableOut);
CmdResult saveAidingMeasurementEnable(C::mip_interface& device, AidingMeasurementEnable::AidingSource aidingSource);
CmdResult loadAidingMeasurementEnable(C::mip_interface& device, AidingMeasurementEnable::AidingSource aidingSource);
CmdResult defaultAidingMeasurementEnable(C::mip_interface& device, AidingMeasurementEnable::AidingSource aidingSource);
 
struct Run
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_RUN;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const Run& self);
void extract(Serializer& serializer, Run& self);
 
CmdResult run(C::mip_interface& device);
 
struct KinematicConstraint
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_KINEMATIC_CONSTRAINT;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t acceleration_constraint_selection = 0; 
    uint8_t velocity_constraint_selection = 0; 
    uint8_t angular_constraint_selection = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_KINEMATIC_CONSTRAINT;
        
        uint8_t acceleration_constraint_selection = 0; 
        uint8_t velocity_constraint_selection = 0; 
        uint8_t angular_constraint_selection = 0; 
        
    };
};
void insert(Serializer& serializer, const KinematicConstraint& self);
void extract(Serializer& serializer, KinematicConstraint& self);
 
void insert(Serializer& serializer, const KinematicConstraint::Response& self);
void extract(Serializer& serializer, KinematicConstraint::Response& self);
 
CmdResult writeKinematicConstraint(C::mip_interface& device, uint8_t accelerationConstraintSelection, uint8_t velocityConstraintSelection, uint8_t angularConstraintSelection);
CmdResult readKinematicConstraint(C::mip_interface& device, uint8_t* accelerationConstraintSelectionOut, uint8_t* velocityConstraintSelectionOut, uint8_t* angularConstraintSelectionOut);
CmdResult saveKinematicConstraint(C::mip_interface& device);
CmdResult loadKinematicConstraint(C::mip_interface& device);
CmdResult defaultKinematicConstraint(C::mip_interface& device);
 
struct InitializationConfiguration
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_INITIALIZATION_CONFIGURATION;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    struct AlignmentSelector : Bitfield<AlignmentSelector>
    {
        enum _enumType : uint8_t
        {
            NONE         = 0x00,
            DUAL_ANTENNA = 0x01,  
            KINEMATIC    = 0x02,  
            MAGNETOMETER = 0x04,  
        };
        uint8_t value = NONE;
        
        AlignmentSelector() : value(NONE) {}
        AlignmentSelector(int val) : value((uint8_t)val) {}
        operator uint8_t() const { return value; }
        AlignmentSelector& operator=(uint8_t val) { value = val; return *this; }
        AlignmentSelector& operator=(int val) { value = val; return *this; }
        AlignmentSelector& operator|=(uint8_t val) { return *this = value | val; }
        AlignmentSelector& operator&=(uint8_t val) { return *this = value & val; }
    };
    
    enum class InitialConditionSource : uint8_t
    {
        AUTO_POS_VEL_ATT        = 0,  
        AUTO_POS_VEL_PITCH_ROLL = 1,  
        AUTO_POS_VEL            = 2,  
        MANUAL                  = 3,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t wait_for_run_command = 0; 
    InitialConditionSource initial_cond_src = static_cast<InitialConditionSource>(0); 
    AlignmentSelector auto_heading_alignment_selector; 
    float initial_heading = 0; 
    float initial_pitch = 0; 
    float initial_roll = 0; 
    float initial_position[3] = {0}; 
    float initial_velocity[3] = {0}; 
    FilterReferenceFrame reference_frame_selector = static_cast<FilterReferenceFrame>(0); 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_INITIALIZATION_CONFIGURATION;
        
        uint8_t wait_for_run_command = 0; 
        InitialConditionSource initial_cond_src = static_cast<InitialConditionSource>(0); 
        AlignmentSelector auto_heading_alignment_selector; 
        float initial_heading = 0; 
        float initial_pitch = 0; 
        float initial_roll = 0; 
        float initial_position[3] = {0}; 
        float initial_velocity[3] = {0}; 
        FilterReferenceFrame reference_frame_selector = static_cast<FilterReferenceFrame>(0); 
        
    };
};
void insert(Serializer& serializer, const InitializationConfiguration& self);
void extract(Serializer& serializer, InitializationConfiguration& self);
 
void insert(Serializer& serializer, const InitializationConfiguration::Response& self);
void extract(Serializer& serializer, InitializationConfiguration::Response& self);
 
CmdResult writeInitializationConfiguration(C::mip_interface& device, uint8_t waitForRunCommand, InitializationConfiguration::InitialConditionSource initialCondSrc, InitializationConfiguration::AlignmentSelector autoHeadingAlignmentSelector, float initialHeading, float initialPitch, float initialRoll, const float* initialPosition, const float* initialVelocity, FilterReferenceFrame referenceFrameSelector);
CmdResult readInitializationConfiguration(C::mip_interface& device, uint8_t* waitForRunCommandOut, InitializationConfiguration::InitialConditionSource* initialCondSrcOut, InitializationConfiguration::AlignmentSelector* autoHeadingAlignmentSelectorOut, float* initialHeadingOut, float* initialPitchOut, float* initialRollOut, float* initialPositionOut, float* initialVelocityOut, FilterReferenceFrame* referenceFrameSelectorOut);
CmdResult saveInitializationConfiguration(C::mip_interface& device);
CmdResult loadInitializationConfiguration(C::mip_interface& device);
CmdResult defaultInitializationConfiguration(C::mip_interface& device);
 
struct AdaptiveFilterOptions
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_ADAPTIVE_FILTER_OPTIONS;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t level = 0; 
    uint16_t time_limit = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_ADAPTIVE_FILTER_OPTIONS;
        
        uint8_t level = 0; 
        uint16_t time_limit = 0; 
        
    };
};
void insert(Serializer& serializer, const AdaptiveFilterOptions& self);
void extract(Serializer& serializer, AdaptiveFilterOptions& self);
 
void insert(Serializer& serializer, const AdaptiveFilterOptions::Response& self);
void extract(Serializer& serializer, AdaptiveFilterOptions::Response& self);
 
CmdResult writeAdaptiveFilterOptions(C::mip_interface& device, uint8_t level, uint16_t timeLimit);
CmdResult readAdaptiveFilterOptions(C::mip_interface& device, uint8_t* levelOut, uint16_t* timeLimitOut);
CmdResult saveAdaptiveFilterOptions(C::mip_interface& device);
CmdResult loadAdaptiveFilterOptions(C::mip_interface& device);
CmdResult defaultAdaptiveFilterOptions(C::mip_interface& device);
 
struct MultiAntennaOffset
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_MULTI_ANTENNA_OFFSET;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t receiver_id = 0; 
    float antenna_offset[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_MULTI_ANTENNA_OFFSET;
        
        uint8_t receiver_id = 0;
        float antenna_offset[3] = {0};
        
    };
};
void insert(Serializer& serializer, const MultiAntennaOffset& self);
void extract(Serializer& serializer, MultiAntennaOffset& self);
 
void insert(Serializer& serializer, const MultiAntennaOffset::Response& self);
void extract(Serializer& serializer, MultiAntennaOffset::Response& self);
 
CmdResult writeMultiAntennaOffset(C::mip_interface& device, uint8_t receiverId, const float* antennaOffset);
CmdResult readMultiAntennaOffset(C::mip_interface& device, uint8_t receiverId, float* antennaOffsetOut);
CmdResult saveMultiAntennaOffset(C::mip_interface& device, uint8_t receiverId);
CmdResult loadMultiAntennaOffset(C::mip_interface& device, uint8_t receiverId);
CmdResult defaultMultiAntennaOffset(C::mip_interface& device, uint8_t receiverId);
 
struct RelPosConfiguration
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_REL_POS_CONFIGURATION;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t source = 0; 
    FilterReferenceFrame reference_frame_selector = static_cast<FilterReferenceFrame>(0); 
    double reference_coordinates[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_REL_POS_CONFIGURATION;
        
        uint8_t source = 0; 
        FilterReferenceFrame reference_frame_selector = static_cast<FilterReferenceFrame>(0); 
        double reference_coordinates[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const RelPosConfiguration& self);
void extract(Serializer& serializer, RelPosConfiguration& self);
 
void insert(Serializer& serializer, const RelPosConfiguration::Response& self);
void extract(Serializer& serializer, RelPosConfiguration::Response& self);
 
CmdResult writeRelPosConfiguration(C::mip_interface& device, uint8_t source, FilterReferenceFrame referenceFrameSelector, const double* referenceCoordinates);
CmdResult readRelPosConfiguration(C::mip_interface& device, uint8_t* sourceOut, FilterReferenceFrame* referenceFrameSelectorOut, double* referenceCoordinatesOut);
CmdResult saveRelPosConfiguration(C::mip_interface& device);
CmdResult loadRelPosConfiguration(C::mip_interface& device);
CmdResult defaultRelPosConfiguration(C::mip_interface& device);
 
struct RefPointLeverArm
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_REF_POINT_LEVER_ARM;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class ReferencePointSelector : uint8_t
    {
        VEH = 1,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    ReferencePointSelector ref_point_sel = static_cast<ReferencePointSelector>(0); 
    float lever_arm_offset[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_REF_POINT_LEVER_ARM;
        
        ReferencePointSelector ref_point_sel = static_cast<ReferencePointSelector>(0); 
        float lever_arm_offset[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const RefPointLeverArm& self);
void extract(Serializer& serializer, RefPointLeverArm& self);
 
void insert(Serializer& serializer, const RefPointLeverArm::Response& self);
void extract(Serializer& serializer, RefPointLeverArm::Response& self);
 
CmdResult writeRefPointLeverArm(C::mip_interface& device, RefPointLeverArm::ReferencePointSelector refPointSel, const float* leverArmOffset);
CmdResult readRefPointLeverArm(C::mip_interface& device, RefPointLeverArm::ReferencePointSelector* refPointSelOut, float* leverArmOffsetOut);
CmdResult saveRefPointLeverArm(C::mip_interface& device);
CmdResult loadRefPointLeverArm(C::mip_interface& device);
CmdResult defaultRefPointLeverArm(C::mip_interface& device);
 
struct SpeedMeasurement
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SPEED_MEASUREMENT;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t source = 0; 
    float time_of_week = 0; 
    float speed = 0; 
    float speed_uncertainty = 0; 
    
};
void insert(Serializer& serializer, const SpeedMeasurement& self);
void extract(Serializer& serializer, SpeedMeasurement& self);
 
CmdResult speedMeasurement(C::mip_interface& device, uint8_t source, float timeOfWeek, float speed, float speedUncertainty);
 
struct SpeedLeverArm
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SPEED_LEVER_ARM;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t source = 0; 
    float lever_arm_offset[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_SPEED_LEVER_ARM;
        
        uint8_t source = 0; 
        float lever_arm_offset[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const SpeedLeverArm& self);
void extract(Serializer& serializer, SpeedLeverArm& self);
 
void insert(Serializer& serializer, const SpeedLeverArm::Response& self);
void extract(Serializer& serializer, SpeedLeverArm::Response& self);
 
CmdResult writeSpeedLeverArm(C::mip_interface& device, uint8_t source, const float* leverArmOffset);
CmdResult readSpeedLeverArm(C::mip_interface& device, uint8_t source, float* leverArmOffsetOut);
CmdResult saveSpeedLeverArm(C::mip_interface& device, uint8_t source);
CmdResult loadSpeedLeverArm(C::mip_interface& device, uint8_t source);
CmdResult defaultSpeedLeverArm(C::mip_interface& device, uint8_t source);
 
struct WheeledVehicleConstraintControl
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_VEHICLE_CONSTRAINT_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t enable = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_VEHICLE_CONSTRAINT_CONTROL;
        
        uint8_t enable = 0; 
        
    };
};
void insert(Serializer& serializer, const WheeledVehicleConstraintControl& self);
void extract(Serializer& serializer, WheeledVehicleConstraintControl& self);
 
void insert(Serializer& serializer, const WheeledVehicleConstraintControl::Response& self);
void extract(Serializer& serializer, WheeledVehicleConstraintControl::Response& self);
 
CmdResult writeWheeledVehicleConstraintControl(C::mip_interface& device, uint8_t enable);
CmdResult readWheeledVehicleConstraintControl(C::mip_interface& device, uint8_t* enableOut);
CmdResult saveWheeledVehicleConstraintControl(C::mip_interface& device);
CmdResult loadWheeledVehicleConstraintControl(C::mip_interface& device);
CmdResult defaultWheeledVehicleConstraintControl(C::mip_interface& device);
 
struct VerticalGyroConstraintControl
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_GYRO_CONSTRAINT_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t enable = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_GYRO_CONSTRAINT_CONTROL;
        
        uint8_t enable = 0; 
        
    };
};
void insert(Serializer& serializer, const VerticalGyroConstraintControl& self);
void extract(Serializer& serializer, VerticalGyroConstraintControl& self);
 
void insert(Serializer& serializer, const VerticalGyroConstraintControl::Response& self);
void extract(Serializer& serializer, VerticalGyroConstraintControl::Response& self);
 
CmdResult writeVerticalGyroConstraintControl(C::mip_interface& device, uint8_t enable);
CmdResult readVerticalGyroConstraintControl(C::mip_interface& device, uint8_t* enableOut);
CmdResult saveVerticalGyroConstraintControl(C::mip_interface& device);
CmdResult loadVerticalGyroConstraintControl(C::mip_interface& device);
CmdResult defaultVerticalGyroConstraintControl(C::mip_interface& device);
 
struct GnssAntennaCalControl
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_ANTENNA_CALIBRATION_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t enable = 0; 
    float max_offset = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_ANTENNA_CALIBRATION_CONTROL;
        
        uint8_t enable = 0; 
        float max_offset = 0; 
        
    };
};
void insert(Serializer& serializer, const GnssAntennaCalControl& self);
void extract(Serializer& serializer, GnssAntennaCalControl& self);
 
void insert(Serializer& serializer, const GnssAntennaCalControl::Response& self);
void extract(Serializer& serializer, GnssAntennaCalControl::Response& self);
 
CmdResult writeGnssAntennaCalControl(C::mip_interface& device, uint8_t enable, float maxOffset);
CmdResult readGnssAntennaCalControl(C::mip_interface& device, uint8_t* enableOut, float* maxOffsetOut);
CmdResult saveGnssAntennaCalControl(C::mip_interface& device);
CmdResult loadGnssAntennaCalControl(C::mip_interface& device);
CmdResult defaultGnssAntennaCalControl(C::mip_interface& device);
 
struct MagneticDeclinationSource
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_DECLINATION_SOURCE;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    FilterMagDeclinationSource source = static_cast<FilterMagDeclinationSource>(0); 
    float declination = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::REPLY_DECLINATION_SOURCE;
        
        FilterMagDeclinationSource source = static_cast<FilterMagDeclinationSource>(0); 
        float declination = 0; 
        
    };
};
void insert(Serializer& serializer, const MagneticDeclinationSource& self);
void extract(Serializer& serializer, MagneticDeclinationSource& self);
 
void insert(Serializer& serializer, const MagneticDeclinationSource::Response& self);
void extract(Serializer& serializer, MagneticDeclinationSource::Response& self);
 
CmdResult writeMagneticDeclinationSource(C::mip_interface& device, FilterMagDeclinationSource source, float declination);
CmdResult readMagneticDeclinationSource(C::mip_interface& device, FilterMagDeclinationSource* sourceOut, float* declinationOut);
CmdResult saveMagneticDeclinationSource(C::mip_interface& device);
CmdResult loadMagneticDeclinationSource(C::mip_interface& device);
CmdResult defaultMagneticDeclinationSource(C::mip_interface& device);
 
struct SetInitialHeading
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_filter::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_filter::CMD_SET_INITIAL_HEADING;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float heading = 0; 
    
};
void insert(Serializer& serializer, const SetInitialHeading& self);
void extract(Serializer& serializer, SetInitialHeading& self);
 
CmdResult setInitialHeading(C::mip_interface& device, float heading);
 
} // namespace commands_filter
} // namespace mip