commands_filter.h

Go to the documentation of this file.

#pragma once
 
#include <mip/definitions/common.h>
#include <mip/mip_descriptors.h>
#include <mip/mip_result.h>
#include <mip/mip_interface.h>
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
#ifdef __cplusplus
namespace mip {
namespace C {
extern "C" {
 
#endif // __cplusplus
 
 
// Descriptors
 
enum 
{
    MIP_FILTER_CMD_DESC_SET                                                   = 0x0D,
    
    MIP_CMD_DESC_FILTER_RESET_FILTER                                          = 0x01,
    MIP_CMD_DESC_FILTER_SET_INITIAL_ATTITUDE                                  = 0x02,
    MIP_CMD_DESC_FILTER_SET_INITIAL_HEADING                                   = 0x03,
    MIP_CMD_DESC_FILTER_SET_INITIAL_HEADING_FROM_MAG                          = 0x04,
    MIP_CMD_DESC_FILTER_RUN                                                   = 0x05,
    MIP_CMD_DESC_FILTER_SELECT_FILTER                                         = 0x0F,
    MIP_CMD_DESC_FILTER_VEHICLE_DYNAMICS_MODE                                 = 0x10,
    MIP_CMD_DESC_FILTER_SENSOR2VEHICLE_ROTATION_EULER                         = 0x11,
    MIP_CMD_DESC_FILTER_SENSOR2VEHICLE_OFFSET                                 = 0x12,
    MIP_CMD_DESC_FILTER_ANTENNA_OFFSET                                        = 0x13,
    MIP_CMD_DESC_FILTER_ESTIMATION_CONTROL_FLAGS                              = 0x14,
    MIP_CMD_DESC_FILTER_GNSS_SOURCE_CONTROL                                   = 0x15,
    MIP_CMD_DESC_FILTER_EXTERNAL_GNSS_UPDATE                                  = 0x16,
    MIP_CMD_DESC_FILTER_EXTERNAL_HEADING_UPDATE                               = 0x17,
    MIP_CMD_DESC_FILTER_HEADING_UPDATE_CONTROL                                = 0x18,
    MIP_CMD_DESC_FILTER_AUTOINIT_CONTROL                                      = 0x19,
    MIP_CMD_DESC_FILTER_ACCEL_NOISE                                           = 0x1A,
    MIP_CMD_DESC_FILTER_GYRO_NOISE                                            = 0x1B,
    MIP_CMD_DESC_FILTER_ACCEL_BIAS_MODEL                                      = 0x1C,
    MIP_CMD_DESC_FILTER_GYRO_BIAS_MODEL                                       = 0x1D,
    MIP_CMD_DESC_FILTER_ZUPT_CONTROL                                          = 0x1E,
    MIP_CMD_DESC_FILTER_EXTERNAL_HEADING_UPDATE_WITH_TIME                     = 0x1F,
    MIP_CMD_DESC_FILTER_ANGULAR_ZUPT_CONTROL                                  = 0x20,
    MIP_CMD_DESC_FILTER_TARE_ORIENTATION                                      = 0x21,
    MIP_CMD_DESC_FILTER_COMMANDED_ZUPT                                        = 0x22,
    MIP_CMD_DESC_FILTER_COMMANDED_ANGULAR_ZUPT                                = 0x23,
    MIP_CMD_DESC_FILTER_AUTO_HEADING_UPDATE_CONTROL                           = 0x24,
    MIP_CMD_DESC_FILTER_MAG_AUTO_CALIBRATION_CONTROL                          = 0x25,
    MIP_CMD_DESC_FILTER_MAG_CAPTURE_AUTO_CALIBRATION                          = 0x27,
    MIP_CMD_DESC_FILTER_GRAVITY_NOISE                                         = 0x28,
    MIP_CMD_DESC_FILTER_PRESSURE_NOISE                                        = 0x29,
    MIP_CMD_DESC_FILTER_GRAVITY_NOISE_MINIMUM                                 = 0x2A,
    MIP_CMD_DESC_FILTER_HARD_IRON_OFFSET_NOISE                                = 0x2B,
    MIP_CMD_DESC_FILTER_SOFT_IRON_MATRIX_NOISE                                = 0x2C,
    MIP_CMD_DESC_FILTER_LOW_PASS_SENSOR_FILTER                                = 0x30,
    MIP_CMD_DESC_FILTER_MAG_NOISE                                             = 0x42,
    MIP_CMD_DESC_FILTER_DECLINATION_SOURCE                                    = 0x43,
    MIP_CMD_DESC_FILTER_HOT_START_CONTROL                                     = 0x48,
    MIP_CMD_DESC_FILTER_SECONDARY_VELOCITY_AIDING_CONTROL                     = 0x4A,
    MIP_CMD_DESC_FILTER_INCLINATION_SOURCE                                    = 0x4C,
    MIP_CMD_DESC_FILTER_MAGNETIC_MAGNITUDE_SOURCE                             = 0x4D,
    MIP_CMD_DESC_FILTER_SENSOR2VEHICLE_ROTATION_DCM                           = 0x4E,
    MIP_CMD_DESC_FILTER_SENSOR2VEHICLE_ROTATION_QUATERNION                    = 0x4F,
    MIP_CMD_DESC_FILTER_REFERENCE_POSITION                                    = 0x26,
    MIP_CMD_DESC_FILTER_ENABLE_MEASUREMENT                                    = 0x41,
    MIP_CMD_DESC_FILTER_ACCEL_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL    = 0x44,
    MIP_CMD_DESC_FILTER_MAG_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL      = 0x45,
    MIP_CMD_DESC_FILTER_MAG_DIP_ANGLE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL      = 0x46,
    MIP_CMD_DESC_FILTER_ALTITUDE_AIDING_CONTROL                               = 0x47,
    MIP_CMD_DESC_FILTER_SECONDARY_PITCH_ROLL_AIDING_CONTROL                   = 0x4B,
    MIP_CMD_DESC_FILTER_AIDING_MEASUREMENT_ENABLE                             = 0x50,
    MIP_CMD_DESC_FILTER_KINEMATIC_CONSTRAINT                                  = 0x51,
    MIP_CMD_DESC_FILTER_INITIALIZATION_CONFIGURATION                          = 0x52,
    MIP_CMD_DESC_FILTER_ADAPTIVE_FILTER_OPTIONS                               = 0x53,
    MIP_CMD_DESC_FILTER_MULTI_ANTENNA_OFFSET                                  = 0x54,
    MIP_CMD_DESC_FILTER_REL_POS_CONFIGURATION                                 = 0x55,
    MIP_CMD_DESC_FILTER_REF_POINT_LEVER_ARM                                   = 0x56,
    MIP_CMD_DESC_FILTER_SPEED_MEASUREMENT                                     = 0x60,
    MIP_CMD_DESC_FILTER_SPEED_LEVER_ARM                                       = 0x61,
    MIP_CMD_DESC_VERTICAL_GYRO_CONSTRAINT_CONTROL                             = 0x62,
    MIP_CMD_DESC_WHEELED_VEHICLE_CONSTRAINT_CONTROL                           = 0x63,
    MIP_CMD_DESC_GNSS_ANTENNA_CALIBRATION_CONTROL                             = 0x64,
    MIP_CMD_DESC_SENSOR_TO_VEHICLE_CALIBRATION_CONTROL                        = 0x65,
    
    MIP_REPLY_DESC_FILTER_VEHICLE_DYNAMICS_MODE                               = 0x80,
    MIP_REPLY_DESC_FILTER_SENSOR2VEHICLE_ROTATION_EULER                       = 0x81,
    MIP_REPLY_DESC_FILTER_SENSOR2VEHICLE_OFFSET                               = 0x82,
    MIP_REPLY_DESC_FILTER_ANTENNA_OFFSET                                      = 0x83,
    MIP_REPLY_DESC_FILTER_ESTIMATION_CONTROL_FLAGS                            = 0x84,
    MIP_REPLY_DESC_FILTER_GNSS_SOURCE_CONTROL                                 = 0x86,
    MIP_REPLY_DESC_FILTER_HEADING_UPDATE_CONTROL                              = 0x87,
    MIP_REPLY_DESC_FILTER_AUTOINIT_CONTROL                                    = 0x88,
    MIP_REPLY_DESC_FILTER_ACCEL_NOISE                                         = 0x89,
    MIP_REPLY_DESC_FILTER_GYRO_NOISE                                          = 0x8A,
    MIP_REPLY_DESC_FILTER_MAG_NOISE                                           = 0xB1,
    MIP_REPLY_DESC_FILTER_ACCEL_BIAS_MODEL                                    = 0x8B,
    MIP_REPLY_DESC_FILTER_GYRO_BIAS_MODEL                                     = 0x8C,
    MIP_REPLY_DESC_FILTER_ZUPT_CONTROL                                        = 0x8D,
    MIP_REPLY_DESC_FILTER_ANGULAR_ZUPT_CONTROL                                = 0x8E,
    MIP_REPLY_DESC_FILTER_SELECT_FILTER                                       = 0x8F,
    MIP_REPLY_DESC_FILTER_GRAVITY_NOISE                                       = 0x93,
    MIP_REPLY_DESC_FILTER_PRESSURE_NOISE                                      = 0x94,
    MIP_REPLY_DESC_FILTER_GRAVITY_NOISE_MINIMUM                               = 0x95,
    MIP_REPLY_DESC_FILTER_HARD_IRON_OFFSET_NOISE                              = 0x96,
    MIP_REPLY_DESC_FILTER_SOFT_IRON_MATRIX_NOISE                              = 0x97,
    MIP_REPLY_DESC_FILTER_LOW_PASS_SENSOR_FILTER                              = 0xA0,
    MIP_REPLY_DESC_FILTER_SET_INITIAL_HEADING                                 = 0x98,
    MIP_REPLY_DESC_FILTER_REFERENCE_POSITION                                  = 0x90,
    MIP_REPLY_DESC_FILTER_AUTO_HEADING_UPDATE_CONTROL                         = 0x91,
    MIP_REPLY_DESC_FILTER_MAG_AUTO_CALIBRATION_CONTROL                        = 0x92,
    MIP_REPLY_DESC_FILTER_ENABLE_MEASUREMENT                                  = 0xB0,
    MIP_REPLY_DESC_FILTER_DECLINATION_SOURCE                                  = 0xB2,
    MIP_REPLY_DESC_FILTER_ACCEL_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL  = 0xB3,
    MIP_REPLY_DESC_FILTER_MAG_MAGNITUDE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL    = 0xB4,
    MIP_REPLY_DESC_FILTER_MAG_DIP_ANGLE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL    = 0xB5,
    MIP_REPLY_DESC_FILTER_MAG_ANGULAR_RATE_ERROR_ADAPTIVE_MEASUREMENT_CONTROL = 0xB6,
    MIP_REPLY_DESC_FILTER_ALTITUDE_AIDING_CONTROL                             = 0xB7,
    MIP_REPLY_DESC_FILTER_HOT_START_CONTROL                                   = 0xB8,
    MIP_REPLY_DESC_FILTER_SECONDARY_VELOCITY_AIDING_CONTROL                   = 0xBA,
    MIP_REPLY_DESC_FILTER_SECONDARY_PITCH_ROLL_AIDING_CONTROL                 = 0xBB,
    MIP_REPLY_DESC_FILTER_INCLINATION_SOURCE                                  = 0xBC,
    MIP_REPLY_DESC_FILTER_MAGNETIC_MAGNITUDE_SOURCE                           = 0xBD,
    MIP_REPLY_DESC_FILTER_SENSOR2VEHICLE_ROTATION_DCM                         = 0xBE,
    MIP_REPLY_DESC_FILTER_SENSOR2VEHICLE_ROTATION_QUATERNION                  = 0xBF,
    MIP_REPLY_DESC_FILTER_AIDING_MEASUREMENT_ENABLE                           = 0xD0,
    MIP_REPLY_DESC_FILTER_KINEMATIC_CONSTRAINT                                = 0xD1,
    MIP_REPLY_DESC_FILTER_INITIALIZATION_CONFIGURATION                        = 0xD2,
    MIP_REPLY_DESC_FILTER_ADAPTIVE_FILTER_OPTIONS                             = 0xD3,
    MIP_REPLY_DESC_FILTER_MULTI_ANTENNA_OFFSET                                = 0xD4,
    MIP_REPLY_DESC_FILTER_REL_POS_CONFIGURATION                               = 0xD5,
    MIP_REPLY_DESC_FILTER_SPEED_MEASUREMENT                                   = 0xE0,
    MIP_REPLY_DESC_VERTICAL_GYRO_CONSTRAINT_CONTROL                           = 0xE2,
    MIP_REPLY_DESC_WHEELED_VEHICLE_CONSTRAINT_CONTROL                         = 0xE3,
    MIP_REPLY_DESC_GNSS_ANTENNA_CALIBRATION_CONTROL                           = 0xE4,
    MIP_REPLY_DESC_FILTER_TARE_ORIENTATION                                    = 0xA1,
    MIP_REPLY_DESC_FILTER_REF_POINT_LEVER_ARM                                 = 0xD6,
    MIP_REPLY_DESC_FILTER_SPEED_LEVER_ARM                                     = 0xE1,
};
 
// Shared Type Definitions
 
enum mip_filter_reference_frame
{
    MIP_FILTER_REFERENCE_FRAME_ECEF = 1,  
    MIP_FILTER_REFERENCE_FRAME_LLH  = 2,  
};
typedef enum mip_filter_reference_frame mip_filter_reference_frame;
 
static inline void insert_mip_filter_reference_frame(microstrain_serializer* serializer, const mip_filter_reference_frame self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_reference_frame(microstrain_serializer* serializer, mip_filter_reference_frame* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
enum mip_filter_mag_param_source
{
    MIP_FILTER_MAG_PARAM_SOURCE_NONE   = 1,  
    MIP_FILTER_MAG_PARAM_SOURCE_WMM    = 2,  
    MIP_FILTER_MAG_PARAM_SOURCE_MANUAL = 3,  
};
typedef enum mip_filter_mag_param_source mip_filter_mag_param_source;
 
static inline void insert_mip_filter_mag_param_source(microstrain_serializer* serializer, const mip_filter_mag_param_source self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_mag_param_source(microstrain_serializer* serializer, mip_filter_mag_param_source* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
enum mip_filter_adaptive_measurement
{
    MIP_FILTER_ADAPTIVE_MEASUREMENT_DISABLED = 0,  
    MIP_FILTER_ADAPTIVE_MEASUREMENT_FIXED    = 1,  
    MIP_FILTER_ADAPTIVE_MEASUREMENT_AUTO     = 2,  
};
typedef enum mip_filter_adaptive_measurement mip_filter_adaptive_measurement;
 
static inline void insert_mip_filter_adaptive_measurement(microstrain_serializer* serializer, const mip_filter_adaptive_measurement self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_adaptive_measurement(microstrain_serializer* serializer, mip_filter_adaptive_measurement* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
// Mip Fields
 
 
typedef struct mip_filter_reset_command mip_filter_reset_command; 
 
mip_cmd_result mip_filter_reset(mip_interface* device);
 
 
struct mip_filter_set_initial_attitude_command
{
    float roll; 
    float pitch; 
    float heading; 
};
typedef struct mip_filter_set_initial_attitude_command mip_filter_set_initial_attitude_command;
 
void insert_mip_filter_set_initial_attitude_command(microstrain_serializer* serializer, const mip_filter_set_initial_attitude_command* self);
void extract_mip_filter_set_initial_attitude_command(microstrain_serializer* serializer, mip_filter_set_initial_attitude_command* self);
 
mip_cmd_result mip_filter_set_initial_attitude(mip_interface* device, float roll, float pitch, float heading);
 
 
typedef uint16_t mip_filter_estimation_control_command_enable_flags;
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_NONE               = 0x0000;
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_GYRO_BIAS          = 0x0001; 
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_ACCEL_BIAS         = 0x0002; 
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_GYRO_SCALE_FACTOR  = 0x0004; 
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_ACCEL_SCALE_FACTOR = 0x0008; 
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_ANTENNA_OFFSET     = 0x0010; 
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_AUTO_MAG_HARD_IRON = 0x0020; 
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_AUTO_MAG_SOFT_IRON = 0x0040; 
static const mip_filter_estimation_control_command_enable_flags MIP_FILTER_ESTIMATION_CONTROL_COMMAND_ENABLE_FLAGS_ALL                = 0x007F;
static inline void insert_mip_filter_estimation_control_command_enable_flags(microstrain_serializer* serializer, const mip_filter_estimation_control_command_enable_flags self)
{
    microstrain_insert_u16(serializer, (uint16_t)(self));
}
static inline void extract_mip_filter_estimation_control_command_enable_flags(microstrain_serializer* serializer, mip_filter_estimation_control_command_enable_flags* self)
{
    uint16_t tmp = 0;
    microstrain_extract_u16(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_estimation_control_command
{
    mip_function_selector function;
    mip_filter_estimation_control_command_enable_flags enable; 
};
typedef struct mip_filter_estimation_control_command mip_filter_estimation_control_command;
 
void insert_mip_filter_estimation_control_command(microstrain_serializer* serializer, const mip_filter_estimation_control_command* self);
void extract_mip_filter_estimation_control_command(microstrain_serializer* serializer, mip_filter_estimation_control_command* self);
 
struct mip_filter_estimation_control_response
{
    mip_filter_estimation_control_command_enable_flags enable; 
};
typedef struct mip_filter_estimation_control_response mip_filter_estimation_control_response;
 
void insert_mip_filter_estimation_control_response(microstrain_serializer* serializer, const mip_filter_estimation_control_response* self);
void extract_mip_filter_estimation_control_response(microstrain_serializer* serializer, mip_filter_estimation_control_response* self);
 
mip_cmd_result mip_filter_write_estimation_control(mip_interface* device, mip_filter_estimation_control_command_enable_flags enable);
mip_cmd_result mip_filter_read_estimation_control(mip_interface* device, mip_filter_estimation_control_command_enable_flags* enable_out);
mip_cmd_result mip_filter_save_estimation_control(mip_interface* device);
mip_cmd_result mip_filter_load_estimation_control(mip_interface* device);
mip_cmd_result mip_filter_default_estimation_control(mip_interface* device);
 
 
struct mip_filter_external_gnss_update_command
{
    double gps_time; 
    uint16_t gps_week; 
    double latitude; 
    double longitude; 
    double height; 
    mip_vector3f velocity; 
    mip_vector3f pos_uncertainty; 
    mip_vector3f vel_uncertainty; 
};
typedef struct mip_filter_external_gnss_update_command mip_filter_external_gnss_update_command;
 
void insert_mip_filter_external_gnss_update_command(microstrain_serializer* serializer, const mip_filter_external_gnss_update_command* self);
void extract_mip_filter_external_gnss_update_command(microstrain_serializer* serializer, mip_filter_external_gnss_update_command* self);
 
mip_cmd_result mip_filter_external_gnss_update(mip_interface* device, double gps_time, uint16_t gps_week, double latitude, double longitude, double height, const float* velocity, const float* pos_uncertainty, const float* vel_uncertainty);
 
 
struct mip_filter_external_heading_update_command
{
    float heading; 
    float heading_uncertainty; 
    uint8_t type; 
};
typedef struct mip_filter_external_heading_update_command mip_filter_external_heading_update_command;
 
void insert_mip_filter_external_heading_update_command(microstrain_serializer* serializer, const mip_filter_external_heading_update_command* self);
void extract_mip_filter_external_heading_update_command(microstrain_serializer* serializer, mip_filter_external_heading_update_command* self);
 
mip_cmd_result mip_filter_external_heading_update(mip_interface* device, float heading, float heading_uncertainty, uint8_t type);
 
 
struct mip_filter_external_heading_update_with_time_command
{
    double gps_time; 
    uint16_t gps_week; 
    float heading; 
    float heading_uncertainty; 
    uint8_t type; 
};
typedef struct mip_filter_external_heading_update_with_time_command mip_filter_external_heading_update_with_time_command;
 
void insert_mip_filter_external_heading_update_with_time_command(microstrain_serializer* serializer, const mip_filter_external_heading_update_with_time_command* self);
void extract_mip_filter_external_heading_update_with_time_command(microstrain_serializer* serializer, mip_filter_external_heading_update_with_time_command* self);
 
mip_cmd_result mip_filter_external_heading_update_with_time(mip_interface* device, double gps_time, uint16_t gps_week, float heading, float heading_uncertainty, uint8_t type);
 
 
typedef uint8_t mip_filter_tare_orientation_command_mip_tare_axes;
static const mip_filter_tare_orientation_command_mip_tare_axes MIP_FILTER_TARE_ORIENTATION_COMMAND_MIP_TARE_AXES_NONE  = 0x0;
static const mip_filter_tare_orientation_command_mip_tare_axes MIP_FILTER_TARE_ORIENTATION_COMMAND_MIP_TARE_AXES_ROLL  = 0x1; 
static const mip_filter_tare_orientation_command_mip_tare_axes MIP_FILTER_TARE_ORIENTATION_COMMAND_MIP_TARE_AXES_PITCH = 0x2; 
static const mip_filter_tare_orientation_command_mip_tare_axes MIP_FILTER_TARE_ORIENTATION_COMMAND_MIP_TARE_AXES_YAW   = 0x4; 
static const mip_filter_tare_orientation_command_mip_tare_axes MIP_FILTER_TARE_ORIENTATION_COMMAND_MIP_TARE_AXES_ALL   = 0x7;
static inline void insert_mip_filter_tare_orientation_command_mip_tare_axes(microstrain_serializer* serializer, const mip_filter_tare_orientation_command_mip_tare_axes self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_tare_orientation_command_mip_tare_axes(microstrain_serializer* serializer, mip_filter_tare_orientation_command_mip_tare_axes* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_tare_orientation_command
{
    mip_function_selector function;
    mip_filter_tare_orientation_command_mip_tare_axes axes; 
};
typedef struct mip_filter_tare_orientation_command mip_filter_tare_orientation_command;
 
void insert_mip_filter_tare_orientation_command(microstrain_serializer* serializer, const mip_filter_tare_orientation_command* self);
void extract_mip_filter_tare_orientation_command(microstrain_serializer* serializer, mip_filter_tare_orientation_command* self);
 
struct mip_filter_tare_orientation_response
{
    mip_filter_tare_orientation_command_mip_tare_axes axes; 
};
typedef struct mip_filter_tare_orientation_response mip_filter_tare_orientation_response;
 
void insert_mip_filter_tare_orientation_response(microstrain_serializer* serializer, const mip_filter_tare_orientation_response* self);
void extract_mip_filter_tare_orientation_response(microstrain_serializer* serializer, mip_filter_tare_orientation_response* self);
 
mip_cmd_result mip_filter_write_tare_orientation(mip_interface* device, mip_filter_tare_orientation_command_mip_tare_axes axes);
mip_cmd_result mip_filter_read_tare_orientation(mip_interface* device, mip_filter_tare_orientation_command_mip_tare_axes* axes_out);
mip_cmd_result mip_filter_save_tare_orientation(mip_interface* device);
mip_cmd_result mip_filter_load_tare_orientation(mip_interface* device);
mip_cmd_result mip_filter_default_tare_orientation(mip_interface* device);
 
 
enum mip_filter_vehicle_dynamics_mode_command_dynamics_mode
{
    MIP_FILTER_VEHICLE_DYNAMICS_MODE_COMMAND_DYNAMICS_MODE_PORTABLE        = 1,  
    MIP_FILTER_VEHICLE_DYNAMICS_MODE_COMMAND_DYNAMICS_MODE_AUTOMOTIVE      = 2,  
    MIP_FILTER_VEHICLE_DYNAMICS_MODE_COMMAND_DYNAMICS_MODE_AIRBORNE        = 3,  
    MIP_FILTER_VEHICLE_DYNAMICS_MODE_COMMAND_DYNAMICS_MODE_AIRBORNE_HIGH_G = 4,  
};
typedef enum mip_filter_vehicle_dynamics_mode_command_dynamics_mode mip_filter_vehicle_dynamics_mode_command_dynamics_mode;
 
static inline void insert_mip_filter_vehicle_dynamics_mode_command_dynamics_mode(microstrain_serializer* serializer, const mip_filter_vehicle_dynamics_mode_command_dynamics_mode self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_vehicle_dynamics_mode_command_dynamics_mode(microstrain_serializer* serializer, mip_filter_vehicle_dynamics_mode_command_dynamics_mode* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_vehicle_dynamics_mode_command
{
    mip_function_selector function;
    mip_filter_vehicle_dynamics_mode_command_dynamics_mode mode;
};
typedef struct mip_filter_vehicle_dynamics_mode_command mip_filter_vehicle_dynamics_mode_command;
 
void insert_mip_filter_vehicle_dynamics_mode_command(microstrain_serializer* serializer, const mip_filter_vehicle_dynamics_mode_command* self);
void extract_mip_filter_vehicle_dynamics_mode_command(microstrain_serializer* serializer, mip_filter_vehicle_dynamics_mode_command* self);
 
struct mip_filter_vehicle_dynamics_mode_response
{
    mip_filter_vehicle_dynamics_mode_command_dynamics_mode mode;
};
typedef struct mip_filter_vehicle_dynamics_mode_response mip_filter_vehicle_dynamics_mode_response;
 
void insert_mip_filter_vehicle_dynamics_mode_response(microstrain_serializer* serializer, const mip_filter_vehicle_dynamics_mode_response* self);
void extract_mip_filter_vehicle_dynamics_mode_response(microstrain_serializer* serializer, mip_filter_vehicle_dynamics_mode_response* self);
 
mip_cmd_result mip_filter_write_vehicle_dynamics_mode(mip_interface* device, mip_filter_vehicle_dynamics_mode_command_dynamics_mode mode);
mip_cmd_result mip_filter_read_vehicle_dynamics_mode(mip_interface* device, mip_filter_vehicle_dynamics_mode_command_dynamics_mode* mode_out);
mip_cmd_result mip_filter_save_vehicle_dynamics_mode(mip_interface* device);
mip_cmd_result mip_filter_load_vehicle_dynamics_mode(mip_interface* device);
mip_cmd_result mip_filter_default_vehicle_dynamics_mode(mip_interface* device);
 
 
struct mip_filter_sensor_to_vehicle_rotation_euler_command
{
    mip_function_selector function;
    float roll; 
    float pitch; 
    float yaw; 
};
typedef struct mip_filter_sensor_to_vehicle_rotation_euler_command mip_filter_sensor_to_vehicle_rotation_euler_command;
 
void insert_mip_filter_sensor_to_vehicle_rotation_euler_command(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_rotation_euler_command* self);
void extract_mip_filter_sensor_to_vehicle_rotation_euler_command(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_rotation_euler_command* self);
 
struct mip_filter_sensor_to_vehicle_rotation_euler_response
{
    float roll; 
    float pitch; 
    float yaw; 
};
typedef struct mip_filter_sensor_to_vehicle_rotation_euler_response mip_filter_sensor_to_vehicle_rotation_euler_response;
 
void insert_mip_filter_sensor_to_vehicle_rotation_euler_response(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_rotation_euler_response* self);
void extract_mip_filter_sensor_to_vehicle_rotation_euler_response(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_rotation_euler_response* self);
 
mip_cmd_result mip_filter_write_sensor_to_vehicle_rotation_euler(mip_interface* device, float roll, float pitch, float yaw);
mip_cmd_result mip_filter_read_sensor_to_vehicle_rotation_euler(mip_interface* device, float* roll_out, float* pitch_out, float* yaw_out);
mip_cmd_result mip_filter_save_sensor_to_vehicle_rotation_euler(mip_interface* device);
mip_cmd_result mip_filter_load_sensor_to_vehicle_rotation_euler(mip_interface* device);
mip_cmd_result mip_filter_default_sensor_to_vehicle_rotation_euler(mip_interface* device);
 
 
struct mip_filter_sensor_to_vehicle_rotation_dcm_command
{
    mip_function_selector function;
    mip_matrix3f dcm;
};
typedef struct mip_filter_sensor_to_vehicle_rotation_dcm_command mip_filter_sensor_to_vehicle_rotation_dcm_command;
 
void insert_mip_filter_sensor_to_vehicle_rotation_dcm_command(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_rotation_dcm_command* self);
void extract_mip_filter_sensor_to_vehicle_rotation_dcm_command(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_rotation_dcm_command* self);
 
struct mip_filter_sensor_to_vehicle_rotation_dcm_response
{
    mip_matrix3f dcm;
};
typedef struct mip_filter_sensor_to_vehicle_rotation_dcm_response mip_filter_sensor_to_vehicle_rotation_dcm_response;
 
void insert_mip_filter_sensor_to_vehicle_rotation_dcm_response(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_rotation_dcm_response* self);
void extract_mip_filter_sensor_to_vehicle_rotation_dcm_response(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_rotation_dcm_response* self);
 
mip_cmd_result mip_filter_write_sensor_to_vehicle_rotation_dcm(mip_interface* device, const float* dcm);
mip_cmd_result mip_filter_read_sensor_to_vehicle_rotation_dcm(mip_interface* device, float* dcm_out);
mip_cmd_result mip_filter_save_sensor_to_vehicle_rotation_dcm(mip_interface* device);
mip_cmd_result mip_filter_load_sensor_to_vehicle_rotation_dcm(mip_interface* device);
mip_cmd_result mip_filter_default_sensor_to_vehicle_rotation_dcm(mip_interface* device);
 
 
struct mip_filter_sensor_to_vehicle_rotation_quaternion_command
{
    mip_function_selector function;
    mip_quatf quat;
};
typedef struct mip_filter_sensor_to_vehicle_rotation_quaternion_command mip_filter_sensor_to_vehicle_rotation_quaternion_command;
 
void insert_mip_filter_sensor_to_vehicle_rotation_quaternion_command(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_rotation_quaternion_command* self);
void extract_mip_filter_sensor_to_vehicle_rotation_quaternion_command(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_rotation_quaternion_command* self);
 
struct mip_filter_sensor_to_vehicle_rotation_quaternion_response
{
    mip_quatf quat;
};
typedef struct mip_filter_sensor_to_vehicle_rotation_quaternion_response mip_filter_sensor_to_vehicle_rotation_quaternion_response;
 
void insert_mip_filter_sensor_to_vehicle_rotation_quaternion_response(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_rotation_quaternion_response* self);
void extract_mip_filter_sensor_to_vehicle_rotation_quaternion_response(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_rotation_quaternion_response* self);
 
mip_cmd_result mip_filter_write_sensor_to_vehicle_rotation_quaternion(mip_interface* device, const float* quat);
mip_cmd_result mip_filter_read_sensor_to_vehicle_rotation_quaternion(mip_interface* device, float* quat_out);
mip_cmd_result mip_filter_save_sensor_to_vehicle_rotation_quaternion(mip_interface* device);
mip_cmd_result mip_filter_load_sensor_to_vehicle_rotation_quaternion(mip_interface* device);
mip_cmd_result mip_filter_default_sensor_to_vehicle_rotation_quaternion(mip_interface* device);
 
 
struct mip_filter_sensor_to_vehicle_offset_command
{
    mip_function_selector function;
    mip_vector3f offset; 
};
typedef struct mip_filter_sensor_to_vehicle_offset_command mip_filter_sensor_to_vehicle_offset_command;
 
void insert_mip_filter_sensor_to_vehicle_offset_command(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_offset_command* self);
void extract_mip_filter_sensor_to_vehicle_offset_command(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_offset_command* self);
 
struct mip_filter_sensor_to_vehicle_offset_response
{
    mip_vector3f offset; 
};
typedef struct mip_filter_sensor_to_vehicle_offset_response mip_filter_sensor_to_vehicle_offset_response;
 
void insert_mip_filter_sensor_to_vehicle_offset_response(microstrain_serializer* serializer, const mip_filter_sensor_to_vehicle_offset_response* self);
void extract_mip_filter_sensor_to_vehicle_offset_response(microstrain_serializer* serializer, mip_filter_sensor_to_vehicle_offset_response* self);
 
mip_cmd_result mip_filter_write_sensor_to_vehicle_offset(mip_interface* device, const float* offset);
mip_cmd_result mip_filter_read_sensor_to_vehicle_offset(mip_interface* device, float* offset_out);
mip_cmd_result mip_filter_save_sensor_to_vehicle_offset(mip_interface* device);
mip_cmd_result mip_filter_load_sensor_to_vehicle_offset(mip_interface* device);
mip_cmd_result mip_filter_default_sensor_to_vehicle_offset(mip_interface* device);
 
 
struct mip_filter_antenna_offset_command
{
    mip_function_selector function;
    mip_vector3f offset; 
};
typedef struct mip_filter_antenna_offset_command mip_filter_antenna_offset_command;
 
void insert_mip_filter_antenna_offset_command(microstrain_serializer* serializer, const mip_filter_antenna_offset_command* self);
void extract_mip_filter_antenna_offset_command(microstrain_serializer* serializer, mip_filter_antenna_offset_command* self);
 
struct mip_filter_antenna_offset_response
{
    mip_vector3f offset; 
};
typedef struct mip_filter_antenna_offset_response mip_filter_antenna_offset_response;
 
void insert_mip_filter_antenna_offset_response(microstrain_serializer* serializer, const mip_filter_antenna_offset_response* self);
void extract_mip_filter_antenna_offset_response(microstrain_serializer* serializer, mip_filter_antenna_offset_response* self);
 
mip_cmd_result mip_filter_write_antenna_offset(mip_interface* device, const float* offset);
mip_cmd_result mip_filter_read_antenna_offset(mip_interface* device, float* offset_out);
mip_cmd_result mip_filter_save_antenna_offset(mip_interface* device);
mip_cmd_result mip_filter_load_antenna_offset(mip_interface* device);
mip_cmd_result mip_filter_default_antenna_offset(mip_interface* device);
 
 
enum mip_filter_gnss_source_command_source
{
    MIP_FILTER_GNSS_SOURCE_COMMAND_SOURCE_ALL_INT = 1,  
    MIP_FILTER_GNSS_SOURCE_COMMAND_SOURCE_EXT     = 2,  
    MIP_FILTER_GNSS_SOURCE_COMMAND_SOURCE_INT_1   = 3,  
    MIP_FILTER_GNSS_SOURCE_COMMAND_SOURCE_INT_2   = 4,  
};
typedef enum mip_filter_gnss_source_command_source mip_filter_gnss_source_command_source;
 
static inline void insert_mip_filter_gnss_source_command_source(microstrain_serializer* serializer, const mip_filter_gnss_source_command_source self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_gnss_source_command_source(microstrain_serializer* serializer, mip_filter_gnss_source_command_source* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_gnss_source_command
{
    mip_function_selector function;
    mip_filter_gnss_source_command_source source;
};
typedef struct mip_filter_gnss_source_command mip_filter_gnss_source_command;
 
void insert_mip_filter_gnss_source_command(microstrain_serializer* serializer, const mip_filter_gnss_source_command* self);
void extract_mip_filter_gnss_source_command(microstrain_serializer* serializer, mip_filter_gnss_source_command* self);
 
struct mip_filter_gnss_source_response
{
    mip_filter_gnss_source_command_source source;
};
typedef struct mip_filter_gnss_source_response mip_filter_gnss_source_response;
 
void insert_mip_filter_gnss_source_response(microstrain_serializer* serializer, const mip_filter_gnss_source_response* self);
void extract_mip_filter_gnss_source_response(microstrain_serializer* serializer, mip_filter_gnss_source_response* self);
 
mip_cmd_result mip_filter_write_gnss_source(mip_interface* device, mip_filter_gnss_source_command_source source);
mip_cmd_result mip_filter_read_gnss_source(mip_interface* device, mip_filter_gnss_source_command_source* source_out);
mip_cmd_result mip_filter_save_gnss_source(mip_interface* device);
mip_cmd_result mip_filter_load_gnss_source(mip_interface* device);
mip_cmd_result mip_filter_default_gnss_source(mip_interface* device);
 
 
enum mip_filter_heading_source_command_source
{
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_NONE                          = 0,  
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_MAG                           = 1,  
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_GNSS_VEL                      = 2,  
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_EXTERNAL                      = 3,  
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_GNSS_VEL_AND_MAG              = 4,  
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_GNSS_VEL_AND_EXTERNAL         = 5,  
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_MAG_AND_EXTERNAL              = 6,  
    MIP_FILTER_HEADING_SOURCE_COMMAND_SOURCE_GNSS_VEL_AND_MAG_AND_EXTERNAL = 7,  
};
typedef enum mip_filter_heading_source_command_source mip_filter_heading_source_command_source;
 
static inline void insert_mip_filter_heading_source_command_source(microstrain_serializer* serializer, const mip_filter_heading_source_command_source self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_heading_source_command_source(microstrain_serializer* serializer, mip_filter_heading_source_command_source* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_heading_source_command
{
    mip_function_selector function;
    mip_filter_heading_source_command_source source;
};
typedef struct mip_filter_heading_source_command mip_filter_heading_source_command;
 
void insert_mip_filter_heading_source_command(microstrain_serializer* serializer, const mip_filter_heading_source_command* self);
void extract_mip_filter_heading_source_command(microstrain_serializer* serializer, mip_filter_heading_source_command* self);
 
struct mip_filter_heading_source_response
{
    mip_filter_heading_source_command_source source;
};
typedef struct mip_filter_heading_source_response mip_filter_heading_source_response;
 
void insert_mip_filter_heading_source_response(microstrain_serializer* serializer, const mip_filter_heading_source_response* self);
void extract_mip_filter_heading_source_response(microstrain_serializer* serializer, mip_filter_heading_source_response* self);
 
mip_cmd_result mip_filter_write_heading_source(mip_interface* device, mip_filter_heading_source_command_source source);
mip_cmd_result mip_filter_read_heading_source(mip_interface* device, mip_filter_heading_source_command_source* source_out);
mip_cmd_result mip_filter_save_heading_source(mip_interface* device);
mip_cmd_result mip_filter_load_heading_source(mip_interface* device);
mip_cmd_result mip_filter_default_heading_source(mip_interface* device);
 
 
struct mip_filter_auto_init_control_command
{
    mip_function_selector function;
    uint8_t enable; 
};
typedef struct mip_filter_auto_init_control_command mip_filter_auto_init_control_command;
 
void insert_mip_filter_auto_init_control_command(microstrain_serializer* serializer, const mip_filter_auto_init_control_command* self);
void extract_mip_filter_auto_init_control_command(microstrain_serializer* serializer, mip_filter_auto_init_control_command* self);
 
struct mip_filter_auto_init_control_response
{
    uint8_t enable; 
};
typedef struct mip_filter_auto_init_control_response mip_filter_auto_init_control_response;
 
void insert_mip_filter_auto_init_control_response(microstrain_serializer* serializer, const mip_filter_auto_init_control_response* self);
void extract_mip_filter_auto_init_control_response(microstrain_serializer* serializer, mip_filter_auto_init_control_response* self);
 
mip_cmd_result mip_filter_write_auto_init_control(mip_interface* device, uint8_t enable);
mip_cmd_result mip_filter_read_auto_init_control(mip_interface* device, uint8_t* enable_out);
mip_cmd_result mip_filter_save_auto_init_control(mip_interface* device);
mip_cmd_result mip_filter_load_auto_init_control(mip_interface* device);
mip_cmd_result mip_filter_default_auto_init_control(mip_interface* device);
 
 
struct mip_filter_accel_noise_command
{
    mip_function_selector function;
    mip_vector3f noise; 
};
typedef struct mip_filter_accel_noise_command mip_filter_accel_noise_command;
 
void insert_mip_filter_accel_noise_command(microstrain_serializer* serializer, const mip_filter_accel_noise_command* self);
void extract_mip_filter_accel_noise_command(microstrain_serializer* serializer, mip_filter_accel_noise_command* self);
 
struct mip_filter_accel_noise_response
{
    mip_vector3f noise; 
};
typedef struct mip_filter_accel_noise_response mip_filter_accel_noise_response;
 
void insert_mip_filter_accel_noise_response(microstrain_serializer* serializer, const mip_filter_accel_noise_response* self);
void extract_mip_filter_accel_noise_response(microstrain_serializer* serializer, mip_filter_accel_noise_response* self);
 
mip_cmd_result mip_filter_write_accel_noise(mip_interface* device, const float* noise);
mip_cmd_result mip_filter_read_accel_noise(mip_interface* device, float* noise_out);
mip_cmd_result mip_filter_save_accel_noise(mip_interface* device);
mip_cmd_result mip_filter_load_accel_noise(mip_interface* device);
mip_cmd_result mip_filter_default_accel_noise(mip_interface* device);
 
 
struct mip_filter_gyro_noise_command
{
    mip_function_selector function;
    mip_vector3f noise; 
};
typedef struct mip_filter_gyro_noise_command mip_filter_gyro_noise_command;
 
void insert_mip_filter_gyro_noise_command(microstrain_serializer* serializer, const mip_filter_gyro_noise_command* self);
void extract_mip_filter_gyro_noise_command(microstrain_serializer* serializer, mip_filter_gyro_noise_command* self);
 
struct mip_filter_gyro_noise_response
{
    mip_vector3f noise; 
};
typedef struct mip_filter_gyro_noise_response mip_filter_gyro_noise_response;
 
void insert_mip_filter_gyro_noise_response(microstrain_serializer* serializer, const mip_filter_gyro_noise_response* self);
void extract_mip_filter_gyro_noise_response(microstrain_serializer* serializer, mip_filter_gyro_noise_response* self);
 
mip_cmd_result mip_filter_write_gyro_noise(mip_interface* device, const float* noise);
mip_cmd_result mip_filter_read_gyro_noise(mip_interface* device, float* noise_out);
mip_cmd_result mip_filter_save_gyro_noise(mip_interface* device);
mip_cmd_result mip_filter_load_gyro_noise(mip_interface* device);
mip_cmd_result mip_filter_default_gyro_noise(mip_interface* device);
 
 
struct mip_filter_accel_bias_model_command
{
    mip_function_selector function;
    mip_vector3f beta; 
    mip_vector3f noise; 
};
typedef struct mip_filter_accel_bias_model_command mip_filter_accel_bias_model_command;
 
void insert_mip_filter_accel_bias_model_command(microstrain_serializer* serializer, const mip_filter_accel_bias_model_command* self);
void extract_mip_filter_accel_bias_model_command(microstrain_serializer* serializer, mip_filter_accel_bias_model_command* self);
 
struct mip_filter_accel_bias_model_response
{
    mip_vector3f beta; 
    mip_vector3f noise; 
};
typedef struct mip_filter_accel_bias_model_response mip_filter_accel_bias_model_response;
 
void insert_mip_filter_accel_bias_model_response(microstrain_serializer* serializer, const mip_filter_accel_bias_model_response* self);
void extract_mip_filter_accel_bias_model_response(microstrain_serializer* serializer, mip_filter_accel_bias_model_response* self);
 
mip_cmd_result mip_filter_write_accel_bias_model(mip_interface* device, const float* beta, const float* noise);
mip_cmd_result mip_filter_read_accel_bias_model(mip_interface* device, float* beta_out, float* noise_out);
mip_cmd_result mip_filter_save_accel_bias_model(mip_interface* device);
mip_cmd_result mip_filter_load_accel_bias_model(mip_interface* device);
mip_cmd_result mip_filter_default_accel_bias_model(mip_interface* device);
 
 
struct mip_filter_gyro_bias_model_command
{
    mip_function_selector function;
    mip_vector3f beta; 
    mip_vector3f noise; 
};
typedef struct mip_filter_gyro_bias_model_command mip_filter_gyro_bias_model_command;
 
void insert_mip_filter_gyro_bias_model_command(microstrain_serializer* serializer, const mip_filter_gyro_bias_model_command* self);
void extract_mip_filter_gyro_bias_model_command(microstrain_serializer* serializer, mip_filter_gyro_bias_model_command* self);
 
struct mip_filter_gyro_bias_model_response
{
    mip_vector3f beta; 
    mip_vector3f noise; 
};
typedef struct mip_filter_gyro_bias_model_response mip_filter_gyro_bias_model_response;
 
void insert_mip_filter_gyro_bias_model_response(microstrain_serializer* serializer, const mip_filter_gyro_bias_model_response* self);
void extract_mip_filter_gyro_bias_model_response(microstrain_serializer* serializer, mip_filter_gyro_bias_model_response* self);
 
mip_cmd_result mip_filter_write_gyro_bias_model(mip_interface* device, const float* beta, const float* noise);
mip_cmd_result mip_filter_read_gyro_bias_model(mip_interface* device, float* beta_out, float* noise_out);
mip_cmd_result mip_filter_save_gyro_bias_model(mip_interface* device);
mip_cmd_result mip_filter_load_gyro_bias_model(mip_interface* device);
mip_cmd_result mip_filter_default_gyro_bias_model(mip_interface* device);
 
 
enum mip_filter_altitude_aiding_command_aiding_selector
{
    MIP_FILTER_ALTITUDE_AIDING_COMMAND_AIDING_SELECTOR_NONE    = 0,  
    MIP_FILTER_ALTITUDE_AIDING_COMMAND_AIDING_SELECTOR_PRESURE = 1,  
};
typedef enum mip_filter_altitude_aiding_command_aiding_selector mip_filter_altitude_aiding_command_aiding_selector;
 
static inline void insert_mip_filter_altitude_aiding_command_aiding_selector(microstrain_serializer* serializer, const mip_filter_altitude_aiding_command_aiding_selector self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_altitude_aiding_command_aiding_selector(microstrain_serializer* serializer, mip_filter_altitude_aiding_command_aiding_selector* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_altitude_aiding_command
{
    mip_function_selector function;
    mip_filter_altitude_aiding_command_aiding_selector selector; 
};
typedef struct mip_filter_altitude_aiding_command mip_filter_altitude_aiding_command;
 
void insert_mip_filter_altitude_aiding_command(microstrain_serializer* serializer, const mip_filter_altitude_aiding_command* self);
void extract_mip_filter_altitude_aiding_command(microstrain_serializer* serializer, mip_filter_altitude_aiding_command* self);
 
struct mip_filter_altitude_aiding_response
{
    mip_filter_altitude_aiding_command_aiding_selector selector; 
};
typedef struct mip_filter_altitude_aiding_response mip_filter_altitude_aiding_response;
 
void insert_mip_filter_altitude_aiding_response(microstrain_serializer* serializer, const mip_filter_altitude_aiding_response* self);
void extract_mip_filter_altitude_aiding_response(microstrain_serializer* serializer, mip_filter_altitude_aiding_response* self);
 
mip_cmd_result mip_filter_write_altitude_aiding(mip_interface* device, mip_filter_altitude_aiding_command_aiding_selector selector);
mip_cmd_result mip_filter_read_altitude_aiding(mip_interface* device, mip_filter_altitude_aiding_command_aiding_selector* selector_out);
mip_cmd_result mip_filter_save_altitude_aiding(mip_interface* device);
mip_cmd_result mip_filter_load_altitude_aiding(mip_interface* device);
mip_cmd_result mip_filter_default_altitude_aiding(mip_interface* device);
 
 
enum mip_filter_pitch_roll_aiding_command_aiding_source
{
    MIP_FILTER_PITCH_ROLL_AIDING_COMMAND_AIDING_SOURCE_NONE        = 0,  
    MIP_FILTER_PITCH_ROLL_AIDING_COMMAND_AIDING_SOURCE_GRAVITY_VEC = 1,  
};
typedef enum mip_filter_pitch_roll_aiding_command_aiding_source mip_filter_pitch_roll_aiding_command_aiding_source;
 
static inline void insert_mip_filter_pitch_roll_aiding_command_aiding_source(microstrain_serializer* serializer, const mip_filter_pitch_roll_aiding_command_aiding_source self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_pitch_roll_aiding_command_aiding_source(microstrain_serializer* serializer, mip_filter_pitch_roll_aiding_command_aiding_source* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_pitch_roll_aiding_command
{
    mip_function_selector function;
    mip_filter_pitch_roll_aiding_command_aiding_source source; 
};
typedef struct mip_filter_pitch_roll_aiding_command mip_filter_pitch_roll_aiding_command;
 
void insert_mip_filter_pitch_roll_aiding_command(microstrain_serializer* serializer, const mip_filter_pitch_roll_aiding_command* self);
void extract_mip_filter_pitch_roll_aiding_command(microstrain_serializer* serializer, mip_filter_pitch_roll_aiding_command* self);
 
struct mip_filter_pitch_roll_aiding_response
{
    mip_filter_pitch_roll_aiding_command_aiding_source source; 
};
typedef struct mip_filter_pitch_roll_aiding_response mip_filter_pitch_roll_aiding_response;
 
void insert_mip_filter_pitch_roll_aiding_response(microstrain_serializer* serializer, const mip_filter_pitch_roll_aiding_response* self);
void extract_mip_filter_pitch_roll_aiding_response(microstrain_serializer* serializer, mip_filter_pitch_roll_aiding_response* self);
 
mip_cmd_result mip_filter_write_pitch_roll_aiding(mip_interface* device, mip_filter_pitch_roll_aiding_command_aiding_source source);
mip_cmd_result mip_filter_read_pitch_roll_aiding(mip_interface* device, mip_filter_pitch_roll_aiding_command_aiding_source* source_out);
mip_cmd_result mip_filter_save_pitch_roll_aiding(mip_interface* device);
mip_cmd_result mip_filter_load_pitch_roll_aiding(mip_interface* device);
mip_cmd_result mip_filter_default_pitch_roll_aiding(mip_interface* device);
 
 
struct mip_filter_auto_zupt_command
{
    mip_function_selector function;
    uint8_t enable; 
    float threshold; 
};
typedef struct mip_filter_auto_zupt_command mip_filter_auto_zupt_command;
 
void insert_mip_filter_auto_zupt_command(microstrain_serializer* serializer, const mip_filter_auto_zupt_command* self);
void extract_mip_filter_auto_zupt_command(microstrain_serializer* serializer, mip_filter_auto_zupt_command* self);
 
struct mip_filter_auto_zupt_response
{
    uint8_t enable; 
    float threshold; 
};
typedef struct mip_filter_auto_zupt_response mip_filter_auto_zupt_response;
 
void insert_mip_filter_auto_zupt_response(microstrain_serializer* serializer, const mip_filter_auto_zupt_response* self);
void extract_mip_filter_auto_zupt_response(microstrain_serializer* serializer, mip_filter_auto_zupt_response* self);
 
mip_cmd_result mip_filter_write_auto_zupt(mip_interface* device, uint8_t enable, float threshold);
mip_cmd_result mip_filter_read_auto_zupt(mip_interface* device, uint8_t* enable_out, float* threshold_out);
mip_cmd_result mip_filter_save_auto_zupt(mip_interface* device);
mip_cmd_result mip_filter_load_auto_zupt(mip_interface* device);
mip_cmd_result mip_filter_default_auto_zupt(mip_interface* device);
 
 
struct mip_filter_auto_angular_zupt_command
{
    mip_function_selector function;
    uint8_t enable; 
    float threshold; 
};
typedef struct mip_filter_auto_angular_zupt_command mip_filter_auto_angular_zupt_command;
 
void insert_mip_filter_auto_angular_zupt_command(microstrain_serializer* serializer, const mip_filter_auto_angular_zupt_command* self);
void extract_mip_filter_auto_angular_zupt_command(microstrain_serializer* serializer, mip_filter_auto_angular_zupt_command* self);
 
struct mip_filter_auto_angular_zupt_response
{
    uint8_t enable; 
    float threshold; 
};
typedef struct mip_filter_auto_angular_zupt_response mip_filter_auto_angular_zupt_response;
 
void insert_mip_filter_auto_angular_zupt_response(microstrain_serializer* serializer, const mip_filter_auto_angular_zupt_response* self);
void extract_mip_filter_auto_angular_zupt_response(microstrain_serializer* serializer, mip_filter_auto_angular_zupt_response* self);
 
mip_cmd_result mip_filter_write_auto_angular_zupt(mip_interface* device, uint8_t enable, float threshold);
mip_cmd_result mip_filter_read_auto_angular_zupt(mip_interface* device, uint8_t* enable_out, float* threshold_out);
mip_cmd_result mip_filter_save_auto_angular_zupt(mip_interface* device);
mip_cmd_result mip_filter_load_auto_angular_zupt(mip_interface* device);
mip_cmd_result mip_filter_default_auto_angular_zupt(mip_interface* device);
 
 
typedef struct mip_filter_commanded_zupt_command mip_filter_commanded_zupt_command; 
 
mip_cmd_result mip_filter_commanded_zupt(mip_interface* device);
 
 
typedef struct mip_filter_commanded_angular_zupt_command mip_filter_commanded_angular_zupt_command; 
 
mip_cmd_result mip_filter_commanded_angular_zupt(mip_interface* device);
 
 
struct mip_filter_mag_capture_auto_cal_command
{
    mip_function_selector function;
};
typedef struct mip_filter_mag_capture_auto_cal_command mip_filter_mag_capture_auto_cal_command;
 
void insert_mip_filter_mag_capture_auto_cal_command(microstrain_serializer* serializer, const mip_filter_mag_capture_auto_cal_command* self);
void extract_mip_filter_mag_capture_auto_cal_command(microstrain_serializer* serializer, mip_filter_mag_capture_auto_cal_command* self);
 
mip_cmd_result mip_filter_write_mag_capture_auto_cal(mip_interface* device);
mip_cmd_result mip_filter_save_mag_capture_auto_cal(mip_interface* device);
 
 
struct mip_filter_gravity_noise_command
{
    mip_function_selector function;
    mip_vector3f noise; 
};
typedef struct mip_filter_gravity_noise_command mip_filter_gravity_noise_command;
 
void insert_mip_filter_gravity_noise_command(microstrain_serializer* serializer, const mip_filter_gravity_noise_command* self);
void extract_mip_filter_gravity_noise_command(microstrain_serializer* serializer, mip_filter_gravity_noise_command* self);
 
struct mip_filter_gravity_noise_response
{
    mip_vector3f noise; 
};
typedef struct mip_filter_gravity_noise_response mip_filter_gravity_noise_response;
 
void insert_mip_filter_gravity_noise_response(microstrain_serializer* serializer, const mip_filter_gravity_noise_response* self);
void extract_mip_filter_gravity_noise_response(microstrain_serializer* serializer, mip_filter_gravity_noise_response* self);
 
mip_cmd_result mip_filter_write_gravity_noise(mip_interface* device, const float* noise);
mip_cmd_result mip_filter_read_gravity_noise(mip_interface* device, float* noise_out);
mip_cmd_result mip_filter_save_gravity_noise(mip_interface* device);
mip_cmd_result mip_filter_load_gravity_noise(mip_interface* device);
mip_cmd_result mip_filter_default_gravity_noise(mip_interface* device);
 
 
struct mip_filter_pressure_altitude_noise_command
{
    mip_function_selector function;
    float noise; 
};
typedef struct mip_filter_pressure_altitude_noise_command mip_filter_pressure_altitude_noise_command;
 
void insert_mip_filter_pressure_altitude_noise_command(microstrain_serializer* serializer, const mip_filter_pressure_altitude_noise_command* self);
void extract_mip_filter_pressure_altitude_noise_command(microstrain_serializer* serializer, mip_filter_pressure_altitude_noise_command* self);
 
struct mip_filter_pressure_altitude_noise_response
{
    float noise; 
};
typedef struct mip_filter_pressure_altitude_noise_response mip_filter_pressure_altitude_noise_response;
 
void insert_mip_filter_pressure_altitude_noise_response(microstrain_serializer* serializer, const mip_filter_pressure_altitude_noise_response* self);
void extract_mip_filter_pressure_altitude_noise_response(microstrain_serializer* serializer, mip_filter_pressure_altitude_noise_response* self);
 
mip_cmd_result mip_filter_write_pressure_altitude_noise(mip_interface* device, float noise);
mip_cmd_result mip_filter_read_pressure_altitude_noise(mip_interface* device, float* noise_out);
mip_cmd_result mip_filter_save_pressure_altitude_noise(mip_interface* device);
mip_cmd_result mip_filter_load_pressure_altitude_noise(mip_interface* device);
mip_cmd_result mip_filter_default_pressure_altitude_noise(mip_interface* device);
 
 
struct mip_filter_hard_iron_offset_noise_command
{
    mip_function_selector function;
    mip_vector3f noise; 
};
typedef struct mip_filter_hard_iron_offset_noise_command mip_filter_hard_iron_offset_noise_command;
 
void insert_mip_filter_hard_iron_offset_noise_command(microstrain_serializer* serializer, const mip_filter_hard_iron_offset_noise_command* self);
void extract_mip_filter_hard_iron_offset_noise_command(microstrain_serializer* serializer, mip_filter_hard_iron_offset_noise_command* self);
 
struct mip_filter_hard_iron_offset_noise_response
{
    mip_vector3f noise; 
};
typedef struct mip_filter_hard_iron_offset_noise_response mip_filter_hard_iron_offset_noise_response;
 
void insert_mip_filter_hard_iron_offset_noise_response(microstrain_serializer* serializer, const mip_filter_hard_iron_offset_noise_response* self);
void extract_mip_filter_hard_iron_offset_noise_response(microstrain_serializer* serializer, mip_filter_hard_iron_offset_noise_response* self);
 
mip_cmd_result mip_filter_write_hard_iron_offset_noise(mip_interface* device, const float* noise);
mip_cmd_result mip_filter_read_hard_iron_offset_noise(mip_interface* device, float* noise_out);
mip_cmd_result mip_filter_save_hard_iron_offset_noise(mip_interface* device);
mip_cmd_result mip_filter_load_hard_iron_offset_noise(mip_interface* device);
mip_cmd_result mip_filter_default_hard_iron_offset_noise(mip_interface* device);
 
 
struct mip_filter_soft_iron_matrix_noise_command
{
    mip_function_selector function;
    mip_matrix3f noise; 
};
typedef struct mip_filter_soft_iron_matrix_noise_command mip_filter_soft_iron_matrix_noise_command;
 
void insert_mip_filter_soft_iron_matrix_noise_command(microstrain_serializer* serializer, const mip_filter_soft_iron_matrix_noise_command* self);
void extract_mip_filter_soft_iron_matrix_noise_command(microstrain_serializer* serializer, mip_filter_soft_iron_matrix_noise_command* self);
 
struct mip_filter_soft_iron_matrix_noise_response
{
    mip_matrix3f noise; 
};
typedef struct mip_filter_soft_iron_matrix_noise_response mip_filter_soft_iron_matrix_noise_response;
 
void insert_mip_filter_soft_iron_matrix_noise_response(microstrain_serializer* serializer, const mip_filter_soft_iron_matrix_noise_response* self);
void extract_mip_filter_soft_iron_matrix_noise_response(microstrain_serializer* serializer, mip_filter_soft_iron_matrix_noise_response* self);
 
mip_cmd_result mip_filter_write_soft_iron_matrix_noise(mip_interface* device, const float* noise);
mip_cmd_result mip_filter_read_soft_iron_matrix_noise(mip_interface* device, float* noise_out);
mip_cmd_result mip_filter_save_soft_iron_matrix_noise(mip_interface* device);
mip_cmd_result mip_filter_load_soft_iron_matrix_noise(mip_interface* device);
mip_cmd_result mip_filter_default_soft_iron_matrix_noise(mip_interface* device);
 
 
struct mip_filter_mag_noise_command
{
    mip_function_selector function;
    mip_vector3f noise; 
};
typedef struct mip_filter_mag_noise_command mip_filter_mag_noise_command;
 
void insert_mip_filter_mag_noise_command(microstrain_serializer* serializer, const mip_filter_mag_noise_command* self);
void extract_mip_filter_mag_noise_command(microstrain_serializer* serializer, mip_filter_mag_noise_command* self);
 
struct mip_filter_mag_noise_response
{
    mip_vector3f noise; 
};
typedef struct mip_filter_mag_noise_response mip_filter_mag_noise_response;
 
void insert_mip_filter_mag_noise_response(microstrain_serializer* serializer, const mip_filter_mag_noise_response* self);
void extract_mip_filter_mag_noise_response(microstrain_serializer* serializer, mip_filter_mag_noise_response* self);
 
mip_cmd_result mip_filter_write_mag_noise(mip_interface* device, const float* noise);
mip_cmd_result mip_filter_read_mag_noise(mip_interface* device, float* noise_out);
mip_cmd_result mip_filter_save_mag_noise(mip_interface* device);
mip_cmd_result mip_filter_load_mag_noise(mip_interface* device);
mip_cmd_result mip_filter_default_mag_noise(mip_interface* device);
 
 
struct mip_filter_inclination_source_command
{
    mip_function_selector function;
    mip_filter_mag_param_source source; 
    float inclination; 
};
typedef struct mip_filter_inclination_source_command mip_filter_inclination_source_command;
 
void insert_mip_filter_inclination_source_command(microstrain_serializer* serializer, const mip_filter_inclination_source_command* self);
void extract_mip_filter_inclination_source_command(microstrain_serializer* serializer, mip_filter_inclination_source_command* self);
 
struct mip_filter_inclination_source_response
{
    mip_filter_mag_param_source source; 
    float inclination; 
};
typedef struct mip_filter_inclination_source_response mip_filter_inclination_source_response;
 
void insert_mip_filter_inclination_source_response(microstrain_serializer* serializer, const mip_filter_inclination_source_response* self);
void extract_mip_filter_inclination_source_response(microstrain_serializer* serializer, mip_filter_inclination_source_response* self);
 
mip_cmd_result mip_filter_write_inclination_source(mip_interface* device, mip_filter_mag_param_source source, float inclination);
mip_cmd_result mip_filter_read_inclination_source(mip_interface* device, mip_filter_mag_param_source* source_out, float* inclination_out);
mip_cmd_result mip_filter_save_inclination_source(mip_interface* device);
mip_cmd_result mip_filter_load_inclination_source(mip_interface* device);
mip_cmd_result mip_filter_default_inclination_source(mip_interface* device);
 
 
struct mip_filter_magnetic_declination_source_command
{
    mip_function_selector function;
    mip_filter_mag_param_source source; 
    float declination; 
};
typedef struct mip_filter_magnetic_declination_source_command mip_filter_magnetic_declination_source_command;
 
void insert_mip_filter_magnetic_declination_source_command(microstrain_serializer* serializer, const mip_filter_magnetic_declination_source_command* self);
void extract_mip_filter_magnetic_declination_source_command(microstrain_serializer* serializer, mip_filter_magnetic_declination_source_command* self);
 
struct mip_filter_magnetic_declination_source_response
{
    mip_filter_mag_param_source source; 
    float declination; 
};
typedef struct mip_filter_magnetic_declination_source_response mip_filter_magnetic_declination_source_response;
 
void insert_mip_filter_magnetic_declination_source_response(microstrain_serializer* serializer, const mip_filter_magnetic_declination_source_response* self);
void extract_mip_filter_magnetic_declination_source_response(microstrain_serializer* serializer, mip_filter_magnetic_declination_source_response* self);
 
mip_cmd_result mip_filter_write_magnetic_declination_source(mip_interface* device, mip_filter_mag_param_source source, float declination);
mip_cmd_result mip_filter_read_magnetic_declination_source(mip_interface* device, mip_filter_mag_param_source* source_out, float* declination_out);
mip_cmd_result mip_filter_save_magnetic_declination_source(mip_interface* device);
mip_cmd_result mip_filter_load_magnetic_declination_source(mip_interface* device);
mip_cmd_result mip_filter_default_magnetic_declination_source(mip_interface* device);
 
 
struct mip_filter_mag_field_magnitude_source_command
{
    mip_function_selector function;
    mip_filter_mag_param_source source; 
    float magnitude; 
};
typedef struct mip_filter_mag_field_magnitude_source_command mip_filter_mag_field_magnitude_source_command;
 
void insert_mip_filter_mag_field_magnitude_source_command(microstrain_serializer* serializer, const mip_filter_mag_field_magnitude_source_command* self);
void extract_mip_filter_mag_field_magnitude_source_command(microstrain_serializer* serializer, mip_filter_mag_field_magnitude_source_command* self);
 
struct mip_filter_mag_field_magnitude_source_response
{
    mip_filter_mag_param_source source; 
    float magnitude; 
};
typedef struct mip_filter_mag_field_magnitude_source_response mip_filter_mag_field_magnitude_source_response;
 
void insert_mip_filter_mag_field_magnitude_source_response(microstrain_serializer* serializer, const mip_filter_mag_field_magnitude_source_response* self);
void extract_mip_filter_mag_field_magnitude_source_response(microstrain_serializer* serializer, mip_filter_mag_field_magnitude_source_response* self);
 
mip_cmd_result mip_filter_write_mag_field_magnitude_source(mip_interface* device, mip_filter_mag_param_source source, float magnitude);
mip_cmd_result mip_filter_read_mag_field_magnitude_source(mip_interface* device, mip_filter_mag_param_source* source_out, float* magnitude_out);
mip_cmd_result mip_filter_save_mag_field_magnitude_source(mip_interface* device);
mip_cmd_result mip_filter_load_mag_field_magnitude_source(mip_interface* device);
mip_cmd_result mip_filter_default_mag_field_magnitude_source(mip_interface* device);
 
 
struct mip_filter_reference_position_command
{
    mip_function_selector function;
    bool enable; 
    double latitude; 
    double longitude; 
    double altitude; 
};
typedef struct mip_filter_reference_position_command mip_filter_reference_position_command;
 
void insert_mip_filter_reference_position_command(microstrain_serializer* serializer, const mip_filter_reference_position_command* self);
void extract_mip_filter_reference_position_command(microstrain_serializer* serializer, mip_filter_reference_position_command* self);
 
struct mip_filter_reference_position_response
{
    bool enable; 
    double latitude; 
    double longitude; 
    double altitude; 
};
typedef struct mip_filter_reference_position_response mip_filter_reference_position_response;
 
void insert_mip_filter_reference_position_response(microstrain_serializer* serializer, const mip_filter_reference_position_response* self);
void extract_mip_filter_reference_position_response(microstrain_serializer* serializer, mip_filter_reference_position_response* self);
 
mip_cmd_result mip_filter_write_reference_position(mip_interface* device, bool enable, double latitude, double longitude, double altitude);
mip_cmd_result mip_filter_read_reference_position(mip_interface* device, bool* enable_out, double* latitude_out, double* longitude_out, double* altitude_out);
mip_cmd_result mip_filter_save_reference_position(mip_interface* device);
mip_cmd_result mip_filter_load_reference_position(mip_interface* device);
mip_cmd_result mip_filter_default_reference_position(mip_interface* device);
 
 
struct mip_filter_accel_magnitude_error_adaptive_measurement_command
{
    mip_function_selector function;
    mip_filter_adaptive_measurement adaptive_measurement; 
    float frequency; 
    float low_limit; 
    float high_limit; 
    float low_limit_uncertainty; 
    float high_limit_uncertainty; 
    float minimum_uncertainty; 
};
typedef struct mip_filter_accel_magnitude_error_adaptive_measurement_command mip_filter_accel_magnitude_error_adaptive_measurement_command;
 
void insert_mip_filter_accel_magnitude_error_adaptive_measurement_command(microstrain_serializer* serializer, const mip_filter_accel_magnitude_error_adaptive_measurement_command* self);
void extract_mip_filter_accel_magnitude_error_adaptive_measurement_command(microstrain_serializer* serializer, mip_filter_accel_magnitude_error_adaptive_measurement_command* self);
 
struct mip_filter_accel_magnitude_error_adaptive_measurement_response
{
    mip_filter_adaptive_measurement adaptive_measurement; 
    float frequency; 
    float low_limit; 
    float high_limit; 
    float low_limit_uncertainty; 
    float high_limit_uncertainty; 
    float minimum_uncertainty; 
};
typedef struct mip_filter_accel_magnitude_error_adaptive_measurement_response mip_filter_accel_magnitude_error_adaptive_measurement_response;
 
void insert_mip_filter_accel_magnitude_error_adaptive_measurement_response(microstrain_serializer* serializer, const mip_filter_accel_magnitude_error_adaptive_measurement_response* self);
void extract_mip_filter_accel_magnitude_error_adaptive_measurement_response(microstrain_serializer* serializer, mip_filter_accel_magnitude_error_adaptive_measurement_response* self);
 
mip_cmd_result mip_filter_write_accel_magnitude_error_adaptive_measurement(mip_interface* device, mip_filter_adaptive_measurement adaptive_measurement, float frequency, float low_limit, float high_limit, float low_limit_uncertainty, float high_limit_uncertainty, float minimum_uncertainty);
mip_cmd_result mip_filter_read_accel_magnitude_error_adaptive_measurement(mip_interface* device, mip_filter_adaptive_measurement* adaptive_measurement_out, float* frequency_out, float* low_limit_out, float* high_limit_out, float* low_limit_uncertainty_out, float* high_limit_uncertainty_out, float* minimum_uncertainty_out);
mip_cmd_result mip_filter_save_accel_magnitude_error_adaptive_measurement(mip_interface* device);
mip_cmd_result mip_filter_load_accel_magnitude_error_adaptive_measurement(mip_interface* device);
mip_cmd_result mip_filter_default_accel_magnitude_error_adaptive_measurement(mip_interface* device);
 
 
struct mip_filter_mag_magnitude_error_adaptive_measurement_command
{
    mip_function_selector function;
    mip_filter_adaptive_measurement adaptive_measurement; 
    float frequency; 
    float low_limit; 
    float high_limit; 
    float low_limit_uncertainty; 
    float high_limit_uncertainty; 
    float minimum_uncertainty; 
};
typedef struct mip_filter_mag_magnitude_error_adaptive_measurement_command mip_filter_mag_magnitude_error_adaptive_measurement_command;
 
void insert_mip_filter_mag_magnitude_error_adaptive_measurement_command(microstrain_serializer* serializer, const mip_filter_mag_magnitude_error_adaptive_measurement_command* self);
void extract_mip_filter_mag_magnitude_error_adaptive_measurement_command(microstrain_serializer* serializer, mip_filter_mag_magnitude_error_adaptive_measurement_command* self);
 
struct mip_filter_mag_magnitude_error_adaptive_measurement_response
{
    mip_filter_adaptive_measurement adaptive_measurement; 
    float frequency; 
    float low_limit; 
    float high_limit; 
    float low_limit_uncertainty; 
    float high_limit_uncertainty; 
    float minimum_uncertainty; 
};
typedef struct mip_filter_mag_magnitude_error_adaptive_measurement_response mip_filter_mag_magnitude_error_adaptive_measurement_response;
 
void insert_mip_filter_mag_magnitude_error_adaptive_measurement_response(microstrain_serializer* serializer, const mip_filter_mag_magnitude_error_adaptive_measurement_response* self);
void extract_mip_filter_mag_magnitude_error_adaptive_measurement_response(microstrain_serializer* serializer, mip_filter_mag_magnitude_error_adaptive_measurement_response* self);
 
mip_cmd_result mip_filter_write_mag_magnitude_error_adaptive_measurement(mip_interface* device, mip_filter_adaptive_measurement adaptive_measurement, float frequency, float low_limit, float high_limit, float low_limit_uncertainty, float high_limit_uncertainty, float minimum_uncertainty);
mip_cmd_result mip_filter_read_mag_magnitude_error_adaptive_measurement(mip_interface* device, mip_filter_adaptive_measurement* adaptive_measurement_out, float* frequency_out, float* low_limit_out, float* high_limit_out, float* low_limit_uncertainty_out, float* high_limit_uncertainty_out, float* minimum_uncertainty_out);
mip_cmd_result mip_filter_save_mag_magnitude_error_adaptive_measurement(mip_interface* device);
mip_cmd_result mip_filter_load_mag_magnitude_error_adaptive_measurement(mip_interface* device);
mip_cmd_result mip_filter_default_mag_magnitude_error_adaptive_measurement(mip_interface* device);
 
 
struct mip_filter_mag_dip_angle_error_adaptive_measurement_command
{
    mip_function_selector function;
    bool enable; 
    float frequency; 
    float high_limit; 
    float high_limit_uncertainty; 
    float minimum_uncertainty; 
};
typedef struct mip_filter_mag_dip_angle_error_adaptive_measurement_command mip_filter_mag_dip_angle_error_adaptive_measurement_command;
 
void insert_mip_filter_mag_dip_angle_error_adaptive_measurement_command(microstrain_serializer* serializer, const mip_filter_mag_dip_angle_error_adaptive_measurement_command* self);
void extract_mip_filter_mag_dip_angle_error_adaptive_measurement_command(microstrain_serializer* serializer, mip_filter_mag_dip_angle_error_adaptive_measurement_command* self);
 
struct mip_filter_mag_dip_angle_error_adaptive_measurement_response
{
    bool enable; 
    float frequency; 
    float high_limit; 
    float high_limit_uncertainty; 
    float minimum_uncertainty; 
};
typedef struct mip_filter_mag_dip_angle_error_adaptive_measurement_response mip_filter_mag_dip_angle_error_adaptive_measurement_response;
 
void insert_mip_filter_mag_dip_angle_error_adaptive_measurement_response(microstrain_serializer* serializer, const mip_filter_mag_dip_angle_error_adaptive_measurement_response* self);
void extract_mip_filter_mag_dip_angle_error_adaptive_measurement_response(microstrain_serializer* serializer, mip_filter_mag_dip_angle_error_adaptive_measurement_response* self);
 
mip_cmd_result mip_filter_write_mag_dip_angle_error_adaptive_measurement(mip_interface* device, bool enable, float frequency, float high_limit, float high_limit_uncertainty, float minimum_uncertainty);
mip_cmd_result mip_filter_read_mag_dip_angle_error_adaptive_measurement(mip_interface* device, bool* enable_out, float* frequency_out, float* high_limit_out, float* high_limit_uncertainty_out, float* minimum_uncertainty_out);
mip_cmd_result mip_filter_save_mag_dip_angle_error_adaptive_measurement(mip_interface* device);
mip_cmd_result mip_filter_load_mag_dip_angle_error_adaptive_measurement(mip_interface* device);
mip_cmd_result mip_filter_default_mag_dip_angle_error_adaptive_measurement(mip_interface* device);
 
 
enum mip_filter_aiding_measurement_enable_command_aiding_source
{
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_GNSS_POS_VEL          = 0,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_GNSS_HEADING          = 1,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_ALTIMETER             = 2,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_SPEED                 = 3,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_MAGNETOMETER          = 4,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_EXTERNAL_HEADING      = 5,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_EXTERNAL_ALTIMETER    = 6,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_EXTERNAL_MAGNETOMETER = 7,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_BODY_FRAME_VEL        = 8,  
    MIP_FILTER_AIDING_MEASUREMENT_ENABLE_COMMAND_AIDING_SOURCE_ALL                   = 65535,  
};
typedef enum mip_filter_aiding_measurement_enable_command_aiding_source mip_filter_aiding_measurement_enable_command_aiding_source;
 
static inline void insert_mip_filter_aiding_measurement_enable_command_aiding_source(microstrain_serializer* serializer, const mip_filter_aiding_measurement_enable_command_aiding_source self)
{
    microstrain_insert_u16(serializer, (uint16_t)(self));
}
static inline void extract_mip_filter_aiding_measurement_enable_command_aiding_source(microstrain_serializer* serializer, mip_filter_aiding_measurement_enable_command_aiding_source* self)
{
    uint16_t tmp = 0;
    microstrain_extract_u16(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_aiding_measurement_enable_command
{
    mip_function_selector function;
    mip_filter_aiding_measurement_enable_command_aiding_source aiding_source; 
    bool enable; 
};
typedef struct mip_filter_aiding_measurement_enable_command mip_filter_aiding_measurement_enable_command;
 
void insert_mip_filter_aiding_measurement_enable_command(microstrain_serializer* serializer, const mip_filter_aiding_measurement_enable_command* self);
void extract_mip_filter_aiding_measurement_enable_command(microstrain_serializer* serializer, mip_filter_aiding_measurement_enable_command* self);
 
struct mip_filter_aiding_measurement_enable_response
{
    mip_filter_aiding_measurement_enable_command_aiding_source aiding_source; 
    bool enable; 
};
typedef struct mip_filter_aiding_measurement_enable_response mip_filter_aiding_measurement_enable_response;
 
void insert_mip_filter_aiding_measurement_enable_response(microstrain_serializer* serializer, const mip_filter_aiding_measurement_enable_response* self);
void extract_mip_filter_aiding_measurement_enable_response(microstrain_serializer* serializer, mip_filter_aiding_measurement_enable_response* self);
 
mip_cmd_result mip_filter_write_aiding_measurement_enable(mip_interface* device, mip_filter_aiding_measurement_enable_command_aiding_source aiding_source, bool enable);
mip_cmd_result mip_filter_read_aiding_measurement_enable(mip_interface* device, mip_filter_aiding_measurement_enable_command_aiding_source aiding_source, bool* enable_out);
mip_cmd_result mip_filter_save_aiding_measurement_enable(mip_interface* device, mip_filter_aiding_measurement_enable_command_aiding_source aiding_source);
mip_cmd_result mip_filter_load_aiding_measurement_enable(mip_interface* device, mip_filter_aiding_measurement_enable_command_aiding_source aiding_source);
mip_cmd_result mip_filter_default_aiding_measurement_enable(mip_interface* device, mip_filter_aiding_measurement_enable_command_aiding_source aiding_source);
 
 
typedef struct mip_filter_run_command mip_filter_run_command; 
 
mip_cmd_result mip_filter_run(mip_interface* device);
 
 
struct mip_filter_kinematic_constraint_command
{
    mip_function_selector function;
    uint8_t acceleration_constraint_selection; 
    uint8_t velocity_constraint_selection; 
    uint8_t angular_constraint_selection; 
};
typedef struct mip_filter_kinematic_constraint_command mip_filter_kinematic_constraint_command;
 
void insert_mip_filter_kinematic_constraint_command(microstrain_serializer* serializer, const mip_filter_kinematic_constraint_command* self);
void extract_mip_filter_kinematic_constraint_command(microstrain_serializer* serializer, mip_filter_kinematic_constraint_command* self);
 
struct mip_filter_kinematic_constraint_response
{
    uint8_t acceleration_constraint_selection; 
    uint8_t velocity_constraint_selection; 
    uint8_t angular_constraint_selection; 
};
typedef struct mip_filter_kinematic_constraint_response mip_filter_kinematic_constraint_response;
 
void insert_mip_filter_kinematic_constraint_response(microstrain_serializer* serializer, const mip_filter_kinematic_constraint_response* self);
void extract_mip_filter_kinematic_constraint_response(microstrain_serializer* serializer, mip_filter_kinematic_constraint_response* self);
 
mip_cmd_result mip_filter_write_kinematic_constraint(mip_interface* device, uint8_t acceleration_constraint_selection, uint8_t velocity_constraint_selection, uint8_t angular_constraint_selection);
mip_cmd_result mip_filter_read_kinematic_constraint(mip_interface* device, uint8_t* acceleration_constraint_selection_out, uint8_t* velocity_constraint_selection_out, uint8_t* angular_constraint_selection_out);
mip_cmd_result mip_filter_save_kinematic_constraint(mip_interface* device);
mip_cmd_result mip_filter_load_kinematic_constraint(mip_interface* device);
mip_cmd_result mip_filter_default_kinematic_constraint(mip_interface* device);
 
 
typedef uint8_t mip_filter_initialization_configuration_command_alignment_selector;
static const mip_filter_initialization_configuration_command_alignment_selector MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_ALIGNMENT_SELECTOR_NONE         = 0x00;
static const mip_filter_initialization_configuration_command_alignment_selector MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_ALIGNMENT_SELECTOR_DUAL_ANTENNA = 0x01; 
static const mip_filter_initialization_configuration_command_alignment_selector MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_ALIGNMENT_SELECTOR_KINEMATIC    = 0x02; 
static const mip_filter_initialization_configuration_command_alignment_selector MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_ALIGNMENT_SELECTOR_MAGNETOMETER = 0x04; 
static const mip_filter_initialization_configuration_command_alignment_selector MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_ALIGNMENT_SELECTOR_EXTERNAL     = 0x08; 
static const mip_filter_initialization_configuration_command_alignment_selector MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_ALIGNMENT_SELECTOR_ALL          = 0x0F;
static inline void insert_mip_filter_initialization_configuration_command_alignment_selector(microstrain_serializer* serializer, const mip_filter_initialization_configuration_command_alignment_selector self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_initialization_configuration_command_alignment_selector(microstrain_serializer* serializer, mip_filter_initialization_configuration_command_alignment_selector* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
enum mip_filter_initialization_configuration_command_initial_condition_source
{
    MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_INITIAL_CONDITION_SOURCE_AUTO_POS_VEL_ATT        = 0,  
    MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_INITIAL_CONDITION_SOURCE_AUTO_POS_VEL_PITCH_ROLL = 1,  
    MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_INITIAL_CONDITION_SOURCE_AUTO_POS_VEL            = 2,  
    MIP_FILTER_INITIALIZATION_CONFIGURATION_COMMAND_INITIAL_CONDITION_SOURCE_MANUAL                  = 3,  
};
typedef enum mip_filter_initialization_configuration_command_initial_condition_source mip_filter_initialization_configuration_command_initial_condition_source;
 
static inline void insert_mip_filter_initialization_configuration_command_initial_condition_source(microstrain_serializer* serializer, const mip_filter_initialization_configuration_command_initial_condition_source self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_initialization_configuration_command_initial_condition_source(microstrain_serializer* serializer, mip_filter_initialization_configuration_command_initial_condition_source* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_initialization_configuration_command
{
    mip_function_selector function;
    uint8_t wait_for_run_command; 
    mip_filter_initialization_configuration_command_initial_condition_source initial_cond_src; 
    mip_filter_initialization_configuration_command_alignment_selector auto_heading_alignment_selector; 
    float initial_heading; 
    float initial_pitch; 
    float initial_roll; 
    mip_vector3f initial_position; 
    mip_vector3f initial_velocity; 
    mip_filter_reference_frame reference_frame_selector; 
};
typedef struct mip_filter_initialization_configuration_command mip_filter_initialization_configuration_command;
 
void insert_mip_filter_initialization_configuration_command(microstrain_serializer* serializer, const mip_filter_initialization_configuration_command* self);
void extract_mip_filter_initialization_configuration_command(microstrain_serializer* serializer, mip_filter_initialization_configuration_command* self);
 
struct mip_filter_initialization_configuration_response
{
    uint8_t wait_for_run_command; 
    mip_filter_initialization_configuration_command_initial_condition_source initial_cond_src; 
    mip_filter_initialization_configuration_command_alignment_selector auto_heading_alignment_selector; 
    float initial_heading; 
    float initial_pitch; 
    float initial_roll; 
    mip_vector3f initial_position; 
    mip_vector3f initial_velocity; 
    mip_filter_reference_frame reference_frame_selector; 
};
typedef struct mip_filter_initialization_configuration_response mip_filter_initialization_configuration_response;
 
void insert_mip_filter_initialization_configuration_response(microstrain_serializer* serializer, const mip_filter_initialization_configuration_response* self);
void extract_mip_filter_initialization_configuration_response(microstrain_serializer* serializer, mip_filter_initialization_configuration_response* self);
 
mip_cmd_result mip_filter_write_initialization_configuration(mip_interface* device, uint8_t wait_for_run_command, mip_filter_initialization_configuration_command_initial_condition_source initial_cond_src, mip_filter_initialization_configuration_command_alignment_selector auto_heading_alignment_selector, float initial_heading, float initial_pitch, float initial_roll, const float* initial_position, const float* initial_velocity, mip_filter_reference_frame reference_frame_selector);
mip_cmd_result mip_filter_read_initialization_configuration(mip_interface* device, uint8_t* wait_for_run_command_out, mip_filter_initialization_configuration_command_initial_condition_source* initial_cond_src_out, mip_filter_initialization_configuration_command_alignment_selector* auto_heading_alignment_selector_out, float* initial_heading_out, float* initial_pitch_out, float* initial_roll_out, float* initial_position_out, float* initial_velocity_out, mip_filter_reference_frame* reference_frame_selector_out);
mip_cmd_result mip_filter_save_initialization_configuration(mip_interface* device);
mip_cmd_result mip_filter_load_initialization_configuration(mip_interface* device);
mip_cmd_result mip_filter_default_initialization_configuration(mip_interface* device);
 
 
struct mip_filter_adaptive_filter_options_command
{
    mip_function_selector function;
    uint8_t level; 
    uint16_t time_limit; 
};
typedef struct mip_filter_adaptive_filter_options_command mip_filter_adaptive_filter_options_command;
 
void insert_mip_filter_adaptive_filter_options_command(microstrain_serializer* serializer, const mip_filter_adaptive_filter_options_command* self);
void extract_mip_filter_adaptive_filter_options_command(microstrain_serializer* serializer, mip_filter_adaptive_filter_options_command* self);
 
struct mip_filter_adaptive_filter_options_response
{
    uint8_t level; 
    uint16_t time_limit; 
};
typedef struct mip_filter_adaptive_filter_options_response mip_filter_adaptive_filter_options_response;
 
void insert_mip_filter_adaptive_filter_options_response(microstrain_serializer* serializer, const mip_filter_adaptive_filter_options_response* self);
void extract_mip_filter_adaptive_filter_options_response(microstrain_serializer* serializer, mip_filter_adaptive_filter_options_response* self);
 
mip_cmd_result mip_filter_write_adaptive_filter_options(mip_interface* device, uint8_t level, uint16_t time_limit);
mip_cmd_result mip_filter_read_adaptive_filter_options(mip_interface* device, uint8_t* level_out, uint16_t* time_limit_out);
mip_cmd_result mip_filter_save_adaptive_filter_options(mip_interface* device);
mip_cmd_result mip_filter_load_adaptive_filter_options(mip_interface* device);
mip_cmd_result mip_filter_default_adaptive_filter_options(mip_interface* device);
 
 
struct mip_filter_multi_antenna_offset_command
{
    mip_function_selector function;
    uint8_t receiver_id; 
    mip_vector3f antenna_offset; 
};
typedef struct mip_filter_multi_antenna_offset_command mip_filter_multi_antenna_offset_command;
 
void insert_mip_filter_multi_antenna_offset_command(microstrain_serializer* serializer, const mip_filter_multi_antenna_offset_command* self);
void extract_mip_filter_multi_antenna_offset_command(microstrain_serializer* serializer, mip_filter_multi_antenna_offset_command* self);
 
struct mip_filter_multi_antenna_offset_response
{
    uint8_t receiver_id;
    mip_vector3f antenna_offset;
};
typedef struct mip_filter_multi_antenna_offset_response mip_filter_multi_antenna_offset_response;
 
void insert_mip_filter_multi_antenna_offset_response(microstrain_serializer* serializer, const mip_filter_multi_antenna_offset_response* self);
void extract_mip_filter_multi_antenna_offset_response(microstrain_serializer* serializer, mip_filter_multi_antenna_offset_response* self);
 
mip_cmd_result mip_filter_write_multi_antenna_offset(mip_interface* device, uint8_t receiver_id, const float* antenna_offset);
mip_cmd_result mip_filter_read_multi_antenna_offset(mip_interface* device, uint8_t receiver_id, float* antenna_offset_out);
mip_cmd_result mip_filter_save_multi_antenna_offset(mip_interface* device, uint8_t receiver_id);
mip_cmd_result mip_filter_load_multi_antenna_offset(mip_interface* device, uint8_t receiver_id);
mip_cmd_result mip_filter_default_multi_antenna_offset(mip_interface* device, uint8_t receiver_id);
 
 
struct mip_filter_rel_pos_configuration_command
{
    mip_function_selector function;
    uint8_t source; 
    mip_filter_reference_frame reference_frame_selector; 
    mip_vector3d reference_coordinates; 
};
typedef struct mip_filter_rel_pos_configuration_command mip_filter_rel_pos_configuration_command;
 
void insert_mip_filter_rel_pos_configuration_command(microstrain_serializer* serializer, const mip_filter_rel_pos_configuration_command* self);
void extract_mip_filter_rel_pos_configuration_command(microstrain_serializer* serializer, mip_filter_rel_pos_configuration_command* self);
 
struct mip_filter_rel_pos_configuration_response
{
    uint8_t source; 
    mip_filter_reference_frame reference_frame_selector; 
    mip_vector3d reference_coordinates; 
};
typedef struct mip_filter_rel_pos_configuration_response mip_filter_rel_pos_configuration_response;
 
void insert_mip_filter_rel_pos_configuration_response(microstrain_serializer* serializer, const mip_filter_rel_pos_configuration_response* self);
void extract_mip_filter_rel_pos_configuration_response(microstrain_serializer* serializer, mip_filter_rel_pos_configuration_response* self);
 
mip_cmd_result mip_filter_write_rel_pos_configuration(mip_interface* device, uint8_t source, mip_filter_reference_frame reference_frame_selector, const double* reference_coordinates);
mip_cmd_result mip_filter_read_rel_pos_configuration(mip_interface* device, uint8_t* source_out, mip_filter_reference_frame* reference_frame_selector_out, double* reference_coordinates_out);
mip_cmd_result mip_filter_save_rel_pos_configuration(mip_interface* device);
mip_cmd_result mip_filter_load_rel_pos_configuration(mip_interface* device);
mip_cmd_result mip_filter_default_rel_pos_configuration(mip_interface* device);
 
 
enum mip_filter_ref_point_lever_arm_command_reference_point_selector
{
    MIP_FILTER_REF_POINT_LEVER_ARM_COMMAND_REFERENCE_POINT_SELECTOR_VEH = 1,  
};
typedef enum mip_filter_ref_point_lever_arm_command_reference_point_selector mip_filter_ref_point_lever_arm_command_reference_point_selector;
 
static inline void insert_mip_filter_ref_point_lever_arm_command_reference_point_selector(microstrain_serializer* serializer, const mip_filter_ref_point_lever_arm_command_reference_point_selector self)
{
    microstrain_insert_u8(serializer, (uint8_t)(self));
}
static inline void extract_mip_filter_ref_point_lever_arm_command_reference_point_selector(microstrain_serializer* serializer, mip_filter_ref_point_lever_arm_command_reference_point_selector* self)
{
    uint8_t tmp = 0;
    microstrain_extract_u8(serializer, &tmp);
    *self = tmp;
}
 
 
struct mip_filter_ref_point_lever_arm_command
{
    mip_function_selector function;
    mip_filter_ref_point_lever_arm_command_reference_point_selector ref_point_sel; 
    mip_vector3f lever_arm_offset; 
};
typedef struct mip_filter_ref_point_lever_arm_command mip_filter_ref_point_lever_arm_command;
 
void insert_mip_filter_ref_point_lever_arm_command(microstrain_serializer* serializer, const mip_filter_ref_point_lever_arm_command* self);
void extract_mip_filter_ref_point_lever_arm_command(microstrain_serializer* serializer, mip_filter_ref_point_lever_arm_command* self);
 
struct mip_filter_ref_point_lever_arm_response
{
    mip_filter_ref_point_lever_arm_command_reference_point_selector ref_point_sel; 
    mip_vector3f lever_arm_offset; 
};
typedef struct mip_filter_ref_point_lever_arm_response mip_filter_ref_point_lever_arm_response;
 
void insert_mip_filter_ref_point_lever_arm_response(microstrain_serializer* serializer, const mip_filter_ref_point_lever_arm_response* self);
void extract_mip_filter_ref_point_lever_arm_response(microstrain_serializer* serializer, mip_filter_ref_point_lever_arm_response* self);
 
mip_cmd_result mip_filter_write_ref_point_lever_arm(mip_interface* device, mip_filter_ref_point_lever_arm_command_reference_point_selector ref_point_sel, const float* lever_arm_offset);
mip_cmd_result mip_filter_read_ref_point_lever_arm(mip_interface* device, mip_filter_ref_point_lever_arm_command_reference_point_selector* ref_point_sel_out, float* lever_arm_offset_out);
mip_cmd_result mip_filter_save_ref_point_lever_arm(mip_interface* device);
mip_cmd_result mip_filter_load_ref_point_lever_arm(mip_interface* device);
mip_cmd_result mip_filter_default_ref_point_lever_arm(mip_interface* device);
 
 
struct mip_filter_speed_measurement_command
{
    uint8_t source; 
    float time_of_week; 
    float speed; 
    float speed_uncertainty; 
};
typedef struct mip_filter_speed_measurement_command mip_filter_speed_measurement_command;
 
void insert_mip_filter_speed_measurement_command(microstrain_serializer* serializer, const mip_filter_speed_measurement_command* self);
void extract_mip_filter_speed_measurement_command(microstrain_serializer* serializer, mip_filter_speed_measurement_command* self);
 
mip_cmd_result mip_filter_speed_measurement(mip_interface* device, uint8_t source, float time_of_week, float speed, float speed_uncertainty);
 
 
struct mip_filter_speed_lever_arm_command
{
    mip_function_selector function;
    uint8_t source; 
    mip_vector3f lever_arm_offset; 
};
typedef struct mip_filter_speed_lever_arm_command mip_filter_speed_lever_arm_command;
 
void insert_mip_filter_speed_lever_arm_command(microstrain_serializer* serializer, const mip_filter_speed_lever_arm_command* self);
void extract_mip_filter_speed_lever_arm_command(microstrain_serializer* serializer, mip_filter_speed_lever_arm_command* self);
 
struct mip_filter_speed_lever_arm_response
{
    uint8_t source; 
    mip_vector3f lever_arm_offset; 
};
typedef struct mip_filter_speed_lever_arm_response mip_filter_speed_lever_arm_response;
 
void insert_mip_filter_speed_lever_arm_response(microstrain_serializer* serializer, const mip_filter_speed_lever_arm_response* self);
void extract_mip_filter_speed_lever_arm_response(microstrain_serializer* serializer, mip_filter_speed_lever_arm_response* self);
 
mip_cmd_result mip_filter_write_speed_lever_arm(mip_interface* device, uint8_t source, const float* lever_arm_offset);
mip_cmd_result mip_filter_read_speed_lever_arm(mip_interface* device, uint8_t source, float* lever_arm_offset_out);
mip_cmd_result mip_filter_save_speed_lever_arm(mip_interface* device, uint8_t source);
mip_cmd_result mip_filter_load_speed_lever_arm(mip_interface* device, uint8_t source);
mip_cmd_result mip_filter_default_speed_lever_arm(mip_interface* device, uint8_t source);
 
 
struct mip_filter_wheeled_vehicle_constraint_control_command
{
    mip_function_selector function;
    uint8_t enable; 
};
typedef struct mip_filter_wheeled_vehicle_constraint_control_command mip_filter_wheeled_vehicle_constraint_control_command;
 
void insert_mip_filter_wheeled_vehicle_constraint_control_command(microstrain_serializer* serializer, const mip_filter_wheeled_vehicle_constraint_control_command* self);
void extract_mip_filter_wheeled_vehicle_constraint_control_command(microstrain_serializer* serializer, mip_filter_wheeled_vehicle_constraint_control_command* self);
 
struct mip_filter_wheeled_vehicle_constraint_control_response
{
    uint8_t enable; 
};
typedef struct mip_filter_wheeled_vehicle_constraint_control_response mip_filter_wheeled_vehicle_constraint_control_response;
 
void insert_mip_filter_wheeled_vehicle_constraint_control_response(microstrain_serializer* serializer, const mip_filter_wheeled_vehicle_constraint_control_response* self);
void extract_mip_filter_wheeled_vehicle_constraint_control_response(microstrain_serializer* serializer, mip_filter_wheeled_vehicle_constraint_control_response* self);
 
mip_cmd_result mip_filter_write_wheeled_vehicle_constraint_control(mip_interface* device, uint8_t enable);
mip_cmd_result mip_filter_read_wheeled_vehicle_constraint_control(mip_interface* device, uint8_t* enable_out);
mip_cmd_result mip_filter_save_wheeled_vehicle_constraint_control(mip_interface* device);
mip_cmd_result mip_filter_load_wheeled_vehicle_constraint_control(mip_interface* device);
mip_cmd_result mip_filter_default_wheeled_vehicle_constraint_control(mip_interface* device);
 
 
struct mip_filter_vertical_gyro_constraint_control_command
{
    mip_function_selector function;
    uint8_t enable; 
};
typedef struct mip_filter_vertical_gyro_constraint_control_command mip_filter_vertical_gyro_constraint_control_command;
 
void insert_mip_filter_vertical_gyro_constraint_control_command(microstrain_serializer* serializer, const mip_filter_vertical_gyro_constraint_control_command* self);
void extract_mip_filter_vertical_gyro_constraint_control_command(microstrain_serializer* serializer, mip_filter_vertical_gyro_constraint_control_command* self);
 
struct mip_filter_vertical_gyro_constraint_control_response
{
    uint8_t enable; 
};
typedef struct mip_filter_vertical_gyro_constraint_control_response mip_filter_vertical_gyro_constraint_control_response;
 
void insert_mip_filter_vertical_gyro_constraint_control_response(microstrain_serializer* serializer, const mip_filter_vertical_gyro_constraint_control_response* self);
void extract_mip_filter_vertical_gyro_constraint_control_response(microstrain_serializer* serializer, mip_filter_vertical_gyro_constraint_control_response* self);
 
mip_cmd_result mip_filter_write_vertical_gyro_constraint_control(mip_interface* device, uint8_t enable);
mip_cmd_result mip_filter_read_vertical_gyro_constraint_control(mip_interface* device, uint8_t* enable_out);
mip_cmd_result mip_filter_save_vertical_gyro_constraint_control(mip_interface* device);
mip_cmd_result mip_filter_load_vertical_gyro_constraint_control(mip_interface* device);
mip_cmd_result mip_filter_default_vertical_gyro_constraint_control(mip_interface* device);
 
 
struct mip_filter_gnss_antenna_cal_control_command
{
    mip_function_selector function;
    uint8_t enable; 
    float max_offset; 
};
typedef struct mip_filter_gnss_antenna_cal_control_command mip_filter_gnss_antenna_cal_control_command;
 
void insert_mip_filter_gnss_antenna_cal_control_command(microstrain_serializer* serializer, const mip_filter_gnss_antenna_cal_control_command* self);
void extract_mip_filter_gnss_antenna_cal_control_command(microstrain_serializer* serializer, mip_filter_gnss_antenna_cal_control_command* self);
 
struct mip_filter_gnss_antenna_cal_control_response
{
    uint8_t enable; 
    float max_offset; 
};
typedef struct mip_filter_gnss_antenna_cal_control_response mip_filter_gnss_antenna_cal_control_response;
 
void insert_mip_filter_gnss_antenna_cal_control_response(microstrain_serializer* serializer, const mip_filter_gnss_antenna_cal_control_response* self);
void extract_mip_filter_gnss_antenna_cal_control_response(microstrain_serializer* serializer, mip_filter_gnss_antenna_cal_control_response* self);
 
mip_cmd_result mip_filter_write_gnss_antenna_cal_control(mip_interface* device, uint8_t enable, float max_offset);
mip_cmd_result mip_filter_read_gnss_antenna_cal_control(mip_interface* device, uint8_t* enable_out, float* max_offset_out);
mip_cmd_result mip_filter_save_gnss_antenna_cal_control(mip_interface* device);
mip_cmd_result mip_filter_load_gnss_antenna_cal_control(mip_interface* device);
mip_cmd_result mip_filter_default_gnss_antenna_cal_control(mip_interface* device);
 
 
struct mip_filter_set_initial_heading_command
{
    float heading; 
};
typedef struct mip_filter_set_initial_heading_command mip_filter_set_initial_heading_command;
 
void insert_mip_filter_set_initial_heading_command(microstrain_serializer* serializer, const mip_filter_set_initial_heading_command* self);
void extract_mip_filter_set_initial_heading_command(microstrain_serializer* serializer, mip_filter_set_initial_heading_command* self);
 
mip_cmd_result mip_filter_set_initial_heading(mip_interface* device, float heading);
 
 
#ifdef __cplusplus
} // extern "C"
} // namespace C
} // namespace mip
#endif // __cplusplus