commands_3dm.hpp

Go to the documentation of this file.

#pragma once
 
#include "descriptors.h"
#include "../mip_result.h"
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
namespace mip {
class Serializer;
 
namespace C {
struct mip_interface;
} // namespace C
 
namespace commands_3dm {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET                      = 0x0C,
    
    CMD_POLL_IMU_MESSAGE                = 0x01,
    CMD_POLL_GNSS_MESSAGE               = 0x02,
    CMD_POLL_FILTER_MESSAGE             = 0x03,
    CMD_POLL_NMEA_MESSAGE               = 0x04,
    CMD_GET_IMU_BASE_RATE               = 0x06,
    CMD_GET_GNSS_BASE_RATE              = 0x07,
    CMD_IMU_MESSAGE_FORMAT              = 0x08,
    CMD_GNSS_MESSAGE_FORMAT             = 0x09,
    CMD_FILTER_MESSAGE_FORMAT           = 0x0A,
    CMD_GET_FILTER_BASE_RATE            = 0x0B,
    CMD_NMEA_MESSAGE_FORMAT             = 0x0C,
    CMD_POLL_DATA                       = 0x0D,
    CMD_GET_BASE_RATE                   = 0x0E,
    CMD_MESSAGE_FORMAT                  = 0x0F,
    CMD_CONFIGURE_FACTORY_STREAMING     = 0x10,
    CMD_CONTROL_DATA_STREAM             = 0x11,
    CMD_RAW_RTCM_2_3_MESSAGE            = 0x20,
    CMD_GNSS_CONSTELLATION_SETTINGS     = 0x21,
    CMD_GNSS_SBAS_SETTINGS              = 0x22,
    CMD_GNSS_ASSISTED_FIX_SETTINGS      = 0x23,
    CMD_GNSS_TIME_ASSISTANCE            = 0x24,
    CMD_PPS_SOURCE                      = 0x28,
    CMD_EVENT_SUPPORT                   = 0x2A,
    CMD_EVENT_CONTROL                   = 0x2B,
    CMD_EVENT_TRIGGER_STATUS            = 0x2C,
    CMD_EVENT_ACTION_STATUS             = 0x2D,
    CMD_EVENT_TRIGGER_CONFIG            = 0x2E,
    CMD_EVENT_ACTION_CONFIG             = 0x2F,
    CMD_DEVICE_STARTUP_SETTINGS         = 0x30,
    CMD_SENSOR2VEHICLE_TRANSFORM_EUL    = 0x31,
    CMD_SENSOR2VEHICLE_TRANSFORM_QUAT   = 0x32,
    CMD_SENSOR2VEHICLE_TRANSFORM_DCM    = 0x33,
    CMD_SET_GNSS_DYNAMICS_MODE          = 0x34,
    CMD_SET_IMU_SIGNAL_COND             = 0x35,
    CMD_SET_IMU_TIMESTAMP               = 0x36,
    CMD_ACCEL_BIAS                      = 0x37,
    CMD_GYRO_BIAS                       = 0x38,
    CMD_CAPTURE_GYRO_BIAS               = 0x39,
    CMD_HARD_IRON_OFFSET                = 0x3A,
    CMD_SOFT_IRON_MATRIX                = 0x3B,
    CMD_REALIGN_UP                      = 0x3C,
    CMD_REALIGN_NORTH                   = 0x3D,
    CMD_CONING_AND_SCULLING_ENABLE      = 0x3E,
    CMD_UART_BAUDRATE                   = 0x40,
    CMD_GPIO_CONFIG                     = 0x41,
    CMD_GPIO_STATE                      = 0x42,
    CMD_ODOMETER_CONFIG                 = 0x43,
    CMD_ADVANCED_DATA_FILTER            = 0x50,
    CMD_LEGACY_COMP_FILTER              = 0x51,
    CMD_SENSOR_RANGE                    = 0x52,
    CMD_CALIBRATED_RANGES               = 0x53,
    CMD_DATASTREAM_FORMAT               = 0x60,
    CMD_DEVICE_POWER_STATE              = 0x61,
    CMD_SAVE_RESTORE_GPS_SETTINGS       = 0x62,
    CMD_DEVICE_SETTINGS                 = 0x63,
    CMD_RAW_CLIP_SETTINGS               = 0x70,
    
    REPLY_IMU_MESSAGE_FORMAT            = 0x80,
    REPLY_GNSS_MESSAGE_FORMAT           = 0x81,
    REPLY_FILTER_MESSAGE_FORMAT         = 0x82,
    REPLY_IMU_BASE_RATE                 = 0x83,
    REPLY_GNSS_BASE_RATE                = 0x84,
    REPLY_DATASTREAM_ENABLE             = 0x85,
    REPLY_IMU_SIGNAL_SETTINGS           = 0x86,
    REPLY_UART_BAUDRATE                 = 0x87,
    REPLY_DATASTREAM_FORMAT             = 0x88,
    REPLY_POWER_STATE                   = 0x89,
    REPLY_FILTER_BASE_RATE              = 0x8A,
    REPLY_ADVANCED_DATA_FILTER          = 0x8B,
    REPLY_POLL_DATA                     = 0x8D,
    REPLY_BASE_RATE                     = 0x8E,
    REPLY_MESSAGE_FORMAT                = 0x8F,
    REPLY_COMMUNICATIONS_MODE           = 0x91,
    REPLY_GNSS_DYNAMICS_MODE            = 0x92,
    REPLY_IMU_TIMESTAMP_VALUE           = 0x93,
    REPLY_IMU_BASIC_STATUS              = 0x94,
    REPLY_IMU_ADVANCED_STATUS           = 0x95,
    REPLY_RAW_CLIP_SETTINGS             = 0x96,
    REPLY_LEGACY_COMP_FILTER            = 0x97,
    REPLY_ACCEL_BIAS_VECTOR             = 0x9A,
    REPLY_GYRO_BIAS_VECTOR              = 0x9B,
    REPLY_HARD_IRON_OFFSET_VECTOR       = 0x9C,
    REPLY_SOFT_IRON_COMP_MATRIX         = 0x9D,
    REPLY_CONING_AND_SCULLING_ENABLE    = 0x9E,
    REPLY_GNSS_CONSTELLATION_SETTINGS   = 0xA0,
    REPLY_GNSS_SBAS_SETTINGS            = 0xA1,
    REPLY_GNSS_ASSISTED_FIX_SETTINGS    = 0xA2,
    REPLY_GNSS_TIME_ASSISTANCE          = 0xA3,
    REPLY_SENSOR2VEHICLE_TRANSFORM_EUL  = 0xB1,
    REPLY_SENSOR2VEHICLE_TRANSFORM_QUAT = 0xB2,
    REPLY_SENSOR2VEHICLE_TRANSFORM_DCM  = 0xB3,
    REPLY_EVENT_SUPPORT                 = 0xB4,
    REPLY_EVENT_CONTROL                 = 0xB5,
    REPLY_EVENT_TRIGGER_STATUS          = 0xB6,
    REPLY_EVENT_ACTION_STATUS           = 0xB7,
    REPLY_EVENT_TRIGGER_CONFIG          = 0xB8,
    REPLY_EVENT_ACTION_CONFIG           = 0xB9,
    REPLY_NMEA_MESSAGE_FORMAT           = 0x8C,
    REPLY_PPS_SOURCE                    = 0xA8,
    REPLY_GPIO_CONFIG                   = 0xC1,
    REPLY_GPIO_STATE                    = 0xC2,
    REPLY_ODOMETER_CONFIG               = 0xC3,
    REPLY_SENSOR_RANGE                  = 0xD2,
    REPLY_CALIBRATED_RANGES             = 0xD3,
};
 
// Shared Type Definitions
 
struct NmeaMessage
{
    enum class MessageID : uint8_t
    {
        GGA  = 1,  
        GLL  = 2,  
        GSV  = 3,  
        RMC  = 4,  
        VTG  = 5,  
        HDT  = 6,  
        ZDA  = 7,  
        PRKA = 100,  
        PRKR = 101,  
    };
    
    enum class TalkerID : uint8_t
    {
        GNSS    = 1,  
        GPS     = 2,  
        GALILEO = 3,  
        GLONASS = 4,  
    };
    
    MessageID message_id = static_cast<MessageID>(0); 
    TalkerID talker_id = static_cast<TalkerID>(0); 
    uint8_t source_desc_set = 0; 
    uint16_t decimation = 0; 
    
};
void insert(Serializer& serializer, const NmeaMessage& self);
void extract(Serializer& serializer, NmeaMessage& self);
 
enum class SensorRangeType : uint8_t
{
    ALL   = 0,  
    ACCEL = 1,  
    GYRO  = 2,  
    MAG   = 3,  
    PRESS = 4,  
};
 
 
// Mip Fields
 
 
struct PollImuMessage
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_POLL_IMU_MESSAGE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    bool suppress_ack = 0; 
    uint8_t num_descriptors = 0; 
    DescriptorRate* descriptors = {nullptr}; 
    
};
void insert(Serializer& serializer, const PollImuMessage& self);
void extract(Serializer& serializer, PollImuMessage& self);
 
CmdResult pollImuMessage(C::mip_interface& device, bool suppressAck, uint8_t numDescriptors, const DescriptorRate* descriptors);
 
struct PollGnssMessage
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_POLL_GNSS_MESSAGE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    bool suppress_ack = 0; 
    uint8_t num_descriptors = 0; 
    DescriptorRate* descriptors = {nullptr}; 
    
};
void insert(Serializer& serializer, const PollGnssMessage& self);
void extract(Serializer& serializer, PollGnssMessage& self);
 
CmdResult pollGnssMessage(C::mip_interface& device, bool suppressAck, uint8_t numDescriptors, const DescriptorRate* descriptors);
 
struct PollFilterMessage
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_POLL_FILTER_MESSAGE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    bool suppress_ack = 0; 
    uint8_t num_descriptors = 0; 
    DescriptorRate* descriptors = {nullptr}; 
    
};
void insert(Serializer& serializer, const PollFilterMessage& self);
void extract(Serializer& serializer, PollFilterMessage& self);
 
CmdResult pollFilterMessage(C::mip_interface& device, bool suppressAck, uint8_t numDescriptors, const DescriptorRate* descriptors);
 
struct ImuMessageFormat
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_IMU_MESSAGE_FORMAT;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t num_descriptors = 0; 
    DescriptorRate* descriptors = {nullptr}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_IMU_MESSAGE_FORMAT;
        
        uint8_t num_descriptors = 0; 
        DescriptorRate* descriptors = {nullptr}; 
        
    };
};
void insert(Serializer& serializer, const ImuMessageFormat& self);
void extract(Serializer& serializer, ImuMessageFormat& self);
 
void insert(Serializer& serializer, const ImuMessageFormat::Response& self);
void extract(Serializer& serializer, ImuMessageFormat::Response& self);
 
CmdResult writeImuMessageFormat(C::mip_interface& device, uint8_t numDescriptors, const DescriptorRate* descriptors);
CmdResult readImuMessageFormat(C::mip_interface& device, uint8_t* numDescriptorsOut, uint8_t numDescriptorsOutMax, DescriptorRate* descriptorsOut);
CmdResult saveImuMessageFormat(C::mip_interface& device);
CmdResult loadImuMessageFormat(C::mip_interface& device);
CmdResult defaultImuMessageFormat(C::mip_interface& device);
 
struct GpsMessageFormat
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GNSS_MESSAGE_FORMAT;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t num_descriptors = 0; 
    DescriptorRate* descriptors = {nullptr}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GNSS_MESSAGE_FORMAT;
        
        uint8_t num_descriptors = 0; 
        DescriptorRate* descriptors = {nullptr}; 
        
    };
};
void insert(Serializer& serializer, const GpsMessageFormat& self);
void extract(Serializer& serializer, GpsMessageFormat& self);
 
void insert(Serializer& serializer, const GpsMessageFormat::Response& self);
void extract(Serializer& serializer, GpsMessageFormat::Response& self);
 
CmdResult writeGpsMessageFormat(C::mip_interface& device, uint8_t numDescriptors, const DescriptorRate* descriptors);
CmdResult readGpsMessageFormat(C::mip_interface& device, uint8_t* numDescriptorsOut, uint8_t numDescriptorsOutMax, DescriptorRate* descriptorsOut);
CmdResult saveGpsMessageFormat(C::mip_interface& device);
CmdResult loadGpsMessageFormat(C::mip_interface& device);
CmdResult defaultGpsMessageFormat(C::mip_interface& device);
 
struct FilterMessageFormat
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_FILTER_MESSAGE_FORMAT;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t num_descriptors = 0; 
    DescriptorRate* descriptors = {nullptr};
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_FILTER_MESSAGE_FORMAT;
        
        uint8_t num_descriptors = 0; 
        DescriptorRate* descriptors = {nullptr};
        
    };
};
void insert(Serializer& serializer, const FilterMessageFormat& self);
void extract(Serializer& serializer, FilterMessageFormat& self);
 
void insert(Serializer& serializer, const FilterMessageFormat::Response& self);
void extract(Serializer& serializer, FilterMessageFormat::Response& self);
 
CmdResult writeFilterMessageFormat(C::mip_interface& device, uint8_t numDescriptors, const DescriptorRate* descriptors);
CmdResult readFilterMessageFormat(C::mip_interface& device, uint8_t* numDescriptorsOut, uint8_t numDescriptorsOutMax, DescriptorRate* descriptorsOut);
CmdResult saveFilterMessageFormat(C::mip_interface& device);
CmdResult loadFilterMessageFormat(C::mip_interface& device);
CmdResult defaultFilterMessageFormat(C::mip_interface& device);
 
struct ImuGetBaseRate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GET_IMU_BASE_RATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_IMU_BASE_RATE;
        
        uint16_t rate = 0; 
        
    };
};
void insert(Serializer& serializer, const ImuGetBaseRate& self);
void extract(Serializer& serializer, ImuGetBaseRate& self);
 
void insert(Serializer& serializer, const ImuGetBaseRate::Response& self);
void extract(Serializer& serializer, ImuGetBaseRate::Response& self);
 
CmdResult imuGetBaseRate(C::mip_interface& device, uint16_t* rateOut);
 
struct GpsGetBaseRate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GET_GNSS_BASE_RATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GNSS_BASE_RATE;
        
        uint16_t rate = 0; 
        
    };
};
void insert(Serializer& serializer, const GpsGetBaseRate& self);
void extract(Serializer& serializer, GpsGetBaseRate& self);
 
void insert(Serializer& serializer, const GpsGetBaseRate::Response& self);
void extract(Serializer& serializer, GpsGetBaseRate::Response& self);
 
CmdResult gpsGetBaseRate(C::mip_interface& device, uint16_t* rateOut);
 
struct FilterGetBaseRate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GET_FILTER_BASE_RATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_FILTER_BASE_RATE;
        
        uint16_t rate = 0; 
        
    };
};
void insert(Serializer& serializer, const FilterGetBaseRate& self);
void extract(Serializer& serializer, FilterGetBaseRate& self);
 
void insert(Serializer& serializer, const FilterGetBaseRate::Response& self);
void extract(Serializer& serializer, FilterGetBaseRate::Response& self);
 
CmdResult filterGetBaseRate(C::mip_interface& device, uint16_t* rateOut);
 
struct PollData
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_POLL_DATA;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t desc_set = 0; 
    bool suppress_ack = 0; 
    uint8_t num_descriptors = 0; 
    uint8_t* descriptors = {nullptr}; 
    
};
void insert(Serializer& serializer, const PollData& self);
void extract(Serializer& serializer, PollData& self);
 
CmdResult pollData(C::mip_interface& device, uint8_t descSet, bool suppressAck, uint8_t numDescriptors, const uint8_t* descriptors);
 
struct GetBaseRate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GET_BASE_RATE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t desc_set = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_BASE_RATE;
        
        uint8_t desc_set = 0; 
        uint16_t rate = 0; 
        
    };
};
void insert(Serializer& serializer, const GetBaseRate& self);
void extract(Serializer& serializer, GetBaseRate& self);
 
void insert(Serializer& serializer, const GetBaseRate::Response& self);
void extract(Serializer& serializer, GetBaseRate::Response& self);
 
CmdResult getBaseRate(C::mip_interface& device, uint8_t descSet, uint16_t* rateOut);
 
struct MessageFormat
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_MESSAGE_FORMAT;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t desc_set = 0; 
    uint8_t num_descriptors = 0; 
    DescriptorRate* descriptors = {nullptr}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_MESSAGE_FORMAT;
        
        uint8_t desc_set = 0; 
        uint8_t num_descriptors = 0; 
        DescriptorRate* descriptors = {nullptr}; 
        
    };
};
void insert(Serializer& serializer, const MessageFormat& self);
void extract(Serializer& serializer, MessageFormat& self);
 
void insert(Serializer& serializer, const MessageFormat::Response& self);
void extract(Serializer& serializer, MessageFormat::Response& self);
 
CmdResult writeMessageFormat(C::mip_interface& device, uint8_t descSet, uint8_t numDescriptors, const DescriptorRate* descriptors);
CmdResult readMessageFormat(C::mip_interface& device, uint8_t descSet, uint8_t* numDescriptorsOut, uint8_t numDescriptorsOutMax, DescriptorRate* descriptorsOut);
CmdResult saveMessageFormat(C::mip_interface& device, uint8_t descSet);
CmdResult loadMessageFormat(C::mip_interface& device, uint8_t descSet);
CmdResult defaultMessageFormat(C::mip_interface& device, uint8_t descSet);
 
struct NmeaPollData
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_POLL_NMEA_MESSAGE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    bool suppress_ack = 0; 
    uint8_t count = 0; 
    NmeaMessage* format_entries = {nullptr}; 
    
};
void insert(Serializer& serializer, const NmeaPollData& self);
void extract(Serializer& serializer, NmeaPollData& self);
 
CmdResult nmeaPollData(C::mip_interface& device, bool suppressAck, uint8_t count, const NmeaMessage* formatEntries);
 
struct NmeaMessageFormat
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_NMEA_MESSAGE_FORMAT;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t count = 0; 
    NmeaMessage* format_entries = {nullptr}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_NMEA_MESSAGE_FORMAT;
        
        uint8_t count = 0; 
        NmeaMessage* format_entries = {nullptr}; 
        
    };
};
void insert(Serializer& serializer, const NmeaMessageFormat& self);
void extract(Serializer& serializer, NmeaMessageFormat& self);
 
void insert(Serializer& serializer, const NmeaMessageFormat::Response& self);
void extract(Serializer& serializer, NmeaMessageFormat::Response& self);
 
CmdResult writeNmeaMessageFormat(C::mip_interface& device, uint8_t count, const NmeaMessage* formatEntries);
CmdResult readNmeaMessageFormat(C::mip_interface& device, uint8_t* countOut, uint8_t countOutMax, NmeaMessage* formatEntriesOut);
CmdResult saveNmeaMessageFormat(C::mip_interface& device);
CmdResult loadNmeaMessageFormat(C::mip_interface& device);
CmdResult defaultNmeaMessageFormat(C::mip_interface& device);
 
struct DeviceSettings
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_DEVICE_STARTUP_SETTINGS;
    
    static const bool HAS_WRITE_FUNCTION = false;
    static const bool HAS_READ_FUNCTION = false;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    
};
void insert(Serializer& serializer, const DeviceSettings& self);
void extract(Serializer& serializer, DeviceSettings& self);
 
CmdResult saveDeviceSettings(C::mip_interface& device);
CmdResult loadDeviceSettings(C::mip_interface& device);
CmdResult defaultDeviceSettings(C::mip_interface& device);
 
struct UartBaudrate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_UART_BAUDRATE;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint32_t baud = 0;
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_UART_BAUDRATE;
        
        uint32_t baud = 0;
        
    };
};
void insert(Serializer& serializer, const UartBaudrate& self);
void extract(Serializer& serializer, UartBaudrate& self);
 
void insert(Serializer& serializer, const UartBaudrate::Response& self);
void extract(Serializer& serializer, UartBaudrate::Response& self);
 
CmdResult writeUartBaudrate(C::mip_interface& device, uint32_t baud);
CmdResult readUartBaudrate(C::mip_interface& device, uint32_t* baudOut);
CmdResult saveUartBaudrate(C::mip_interface& device);
CmdResult loadUartBaudrate(C::mip_interface& device);
CmdResult defaultUartBaudrate(C::mip_interface& device);
 
struct FactoryStreaming
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_CONFIGURE_FACTORY_STREAMING;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    enum class Action : uint8_t
    {
        OVERWRITE = 0,  
        MERGE     = 1,  
        ADD       = 2,  
    };
    
    Action action = static_cast<Action>(0);
    uint8_t reserved = 0; 
    
};
void insert(Serializer& serializer, const FactoryStreaming& self);
void extract(Serializer& serializer, FactoryStreaming& self);
 
CmdResult factoryStreaming(C::mip_interface& device, FactoryStreaming::Action action, uint8_t reserved);
 
struct DatastreamControl
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_CONTROL_DATA_STREAM;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    static const uint8_t LEGACY_IMU_STREAM = 0x01;
    static const uint8_t LEGACY_GNSS_STREAM = 0x02;
    static const uint8_t LEGACY_FILTER_STREAM = 0x03;
    static const uint8_t ALL_STREAMS = 0x00;
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t desc_set = 0; 
    bool enable = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_DATASTREAM_ENABLE;
        
        uint8_t desc_set = 0;
        bool enabled = 0;
        
    };
};
void insert(Serializer& serializer, const DatastreamControl& self);
void extract(Serializer& serializer, DatastreamControl& self);
 
void insert(Serializer& serializer, const DatastreamControl::Response& self);
void extract(Serializer& serializer, DatastreamControl::Response& self);
 
CmdResult writeDatastreamControl(C::mip_interface& device, uint8_t descSet, bool enable);
CmdResult readDatastreamControl(C::mip_interface& device, uint8_t descSet, bool* enabledOut);
CmdResult saveDatastreamControl(C::mip_interface& device, uint8_t descSet);
CmdResult loadDatastreamControl(C::mip_interface& device, uint8_t descSet);
CmdResult defaultDatastreamControl(C::mip_interface& device, uint8_t descSet);
 
struct GnssSbasSettings
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GNSS_SBAS_SETTINGS;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    struct SBASOptions : Bitfield<SBASOptions>
    {
        enum _enumType : uint16_t
        {
            NONE               = 0x0000,
            ENABLE_RANGING     = 0x0001,  
            ENABLE_CORRECTIONS = 0x0002,  
            APPLY_INTEGRITY    = 0x0004,  
        };
        uint16_t value = NONE;
        
        SBASOptions() : value(NONE) {}
        SBASOptions(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        SBASOptions& operator=(uint16_t val) { value = val; return *this; }
        SBASOptions& operator=(int val) { value = val; return *this; }
        SBASOptions& operator|=(uint16_t val) { return *this = value | val; }
        SBASOptions& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t enable_sbas = 0; 
    SBASOptions sbas_options; 
    uint8_t num_included_prns = 0; 
    uint16_t* included_prns = {nullptr}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GNSS_SBAS_SETTINGS;
        
        uint8_t enable_sbas = 0; 
        SBASOptions sbas_options; 
        uint8_t num_included_prns = 0; 
        uint16_t* included_prns = {nullptr}; 
        
    };
};
void insert(Serializer& serializer, const GnssSbasSettings& self);
void extract(Serializer& serializer, GnssSbasSettings& self);
 
void insert(Serializer& serializer, const GnssSbasSettings::Response& self);
void extract(Serializer& serializer, GnssSbasSettings::Response& self);
 
CmdResult writeGnssSbasSettings(C::mip_interface& device, uint8_t enableSbas, GnssSbasSettings::SBASOptions sbasOptions, uint8_t numIncludedPrns, const uint16_t* includedPrns);
CmdResult readGnssSbasSettings(C::mip_interface& device, uint8_t* enableSbasOut, GnssSbasSettings::SBASOptions* sbasOptionsOut, uint8_t* numIncludedPrnsOut, uint8_t numIncludedPrnsOutMax, uint16_t* includedPrnsOut);
CmdResult saveGnssSbasSettings(C::mip_interface& device);
CmdResult loadGnssSbasSettings(C::mip_interface& device);
CmdResult defaultGnssSbasSettings(C::mip_interface& device);
 
struct GnssTimeAssistance
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GNSS_TIME_ASSISTANCE;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = false;
    static const bool HAS_LOAD_FUNCTION = false;
    static const bool HAS_RESET_FUNCTION = false;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    double tow = 0; 
    uint16_t week_number = 0; 
    float accuracy = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GNSS_TIME_ASSISTANCE;
        
        double tow = 0; 
        uint16_t week_number = 0; 
        float accuracy = 0; 
        
    };
};
void insert(Serializer& serializer, const GnssTimeAssistance& self);
void extract(Serializer& serializer, GnssTimeAssistance& self);
 
void insert(Serializer& serializer, const GnssTimeAssistance::Response& self);
void extract(Serializer& serializer, GnssTimeAssistance::Response& self);
 
CmdResult writeGnssTimeAssistance(C::mip_interface& device, double tow, uint16_t weekNumber, float accuracy);
CmdResult readGnssTimeAssistance(C::mip_interface& device, double* towOut, uint16_t* weekNumberOut, float* accuracyOut);
 
struct AdvLowpassFilter
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_ADVANCED_DATA_FILTER;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t target_descriptor = 0; 
    bool enable = 0; 
    bool manual = 0; 
    uint16_t frequency = 0; 
    uint8_t reserved = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_ADVANCED_DATA_FILTER;
        
        uint8_t target_descriptor = 0;
        bool enable = 0; 
        bool manual = 0; 
        uint16_t frequency = 0; 
        uint8_t reserved = 0; 
        
    };
};
void insert(Serializer& serializer, const AdvLowpassFilter& self);
void extract(Serializer& serializer, AdvLowpassFilter& self);
 
void insert(Serializer& serializer, const AdvLowpassFilter::Response& self);
void extract(Serializer& serializer, AdvLowpassFilter::Response& self);
 
CmdResult writeAdvLowpassFilter(C::mip_interface& device, uint8_t targetDescriptor, bool enable, bool manual, uint16_t frequency, uint8_t reserved);
CmdResult readAdvLowpassFilter(C::mip_interface& device, uint8_t targetDescriptor, bool* enableOut, bool* manualOut, uint16_t* frequencyOut, uint8_t* reservedOut);
CmdResult saveAdvLowpassFilter(C::mip_interface& device, uint8_t targetDescriptor);
CmdResult loadAdvLowpassFilter(C::mip_interface& device, uint8_t targetDescriptor);
CmdResult defaultAdvLowpassFilter(C::mip_interface& device, uint8_t targetDescriptor);
 
struct PpsSource
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_PPS_SOURCE;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class Source : uint8_t
    {
        DISABLED   = 0,  
        RECEIVER_1 = 1,  
        RECEIVER_2 = 2,  
        GPIO       = 3,  
        GENERATED  = 4,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    Source source = static_cast<Source>(0);
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_PPS_SOURCE;
        
        Source source = static_cast<Source>(0);
        
    };
};
void insert(Serializer& serializer, const PpsSource& self);
void extract(Serializer& serializer, PpsSource& self);
 
void insert(Serializer& serializer, const PpsSource::Response& self);
void extract(Serializer& serializer, PpsSource::Response& self);
 
CmdResult writePpsSource(C::mip_interface& device, PpsSource::Source source);
CmdResult readPpsSource(C::mip_interface& device, PpsSource::Source* sourceOut);
CmdResult savePpsSource(C::mip_interface& device);
CmdResult loadPpsSource(C::mip_interface& device);
CmdResult defaultPpsSource(C::mip_interface& device);
 
struct GpioConfig
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GPIO_CONFIG;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class Feature : uint8_t
    {
        UNUSED    = 0,  
        GPIO      = 1,  
        PPS       = 2,  
        ENCODER   = 3,  
        TIMESTAMP = 4,  
        POWER     = 5,  
    };
    
    enum class Behavior : uint8_t
    {
        UNUSED            = 0,  
        GPIO_INPUT        = 1,  
        GPIO_OUTPUT_LOW   = 2,  
        GPIO_OUTPUT_HIGH  = 3,  
        PPS_INPUT         = 1,  
        PPS_OUTPUT        = 2,  
        ENCODER_A         = 1,  
        ENCODER_B         = 2,  
        TIMESTAMP_RISING  = 1,  
        TIMESTAMP_FALLING = 2,  
        TIMESTAMP_EITHER  = 3,  
        POWER_SHUTDOWN    = 1,  
    };
    
    struct PinMode : Bitfield<PinMode>
    {
        enum _enumType : uint8_t
        {
            NONE       = 0x00,
            OPEN_DRAIN = 0x01,  
            PULLDOWN   = 0x02,  
            PULLUP     = 0x04,  
        };
        uint8_t value = NONE;
        
        PinMode() : value(NONE) {}
        PinMode(int val) : value((uint8_t)val) {}
        operator uint8_t() const { return value; }
        PinMode& operator=(uint8_t val) { value = val; return *this; }
        PinMode& operator=(int val) { value = val; return *this; }
        PinMode& operator|=(uint8_t val) { return *this = value | val; }
        PinMode& operator&=(uint8_t val) { return *this = value & val; }
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t pin = 0; 
    Feature feature = static_cast<Feature>(0); 
    Behavior behavior = static_cast<Behavior>(0); 
    PinMode pin_mode; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GPIO_CONFIG;
        
        uint8_t pin = 0; 
        Feature feature = static_cast<Feature>(0); 
        Behavior behavior = static_cast<Behavior>(0); 
        PinMode pin_mode; 
        
    };
};
void insert(Serializer& serializer, const GpioConfig& self);
void extract(Serializer& serializer, GpioConfig& self);
 
void insert(Serializer& serializer, const GpioConfig::Response& self);
void extract(Serializer& serializer, GpioConfig::Response& self);
 
CmdResult writeGpioConfig(C::mip_interface& device, uint8_t pin, GpioConfig::Feature feature, GpioConfig::Behavior behavior, GpioConfig::PinMode pinMode);
CmdResult readGpioConfig(C::mip_interface& device, uint8_t pin, GpioConfig::Feature* featureOut, GpioConfig::Behavior* behaviorOut, GpioConfig::PinMode* pinModeOut);
CmdResult saveGpioConfig(C::mip_interface& device, uint8_t pin);
CmdResult loadGpioConfig(C::mip_interface& device, uint8_t pin);
CmdResult defaultGpioConfig(C::mip_interface& device, uint8_t pin);
 
struct GpioState
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GPIO_STATE;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = false;
    static const bool HAS_LOAD_FUNCTION = false;
    static const bool HAS_RESET_FUNCTION = false;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t pin = 0; 
    bool state = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GPIO_STATE;
        
        uint8_t pin = 0; 
        bool state = 0; 
        
    };
};
void insert(Serializer& serializer, const GpioState& self);
void extract(Serializer& serializer, GpioState& self);
 
void insert(Serializer& serializer, const GpioState::Response& self);
void extract(Serializer& serializer, GpioState::Response& self);
 
CmdResult writeGpioState(C::mip_interface& device, uint8_t pin, bool state);
CmdResult readGpioState(C::mip_interface& device, uint8_t pin, bool* stateOut);
 
struct Odometer
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_ODOMETER_CONFIG;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class Mode : uint8_t
    {
        DISABLED   = 0,  
        QUADRATURE = 2,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    Mode mode = static_cast<Mode>(0); 
    float scaling = 0; 
    float uncertainty = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_ODOMETER_CONFIG;
        
        Mode mode = static_cast<Mode>(0); 
        float scaling = 0; 
        float uncertainty = 0; 
        
    };
};
void insert(Serializer& serializer, const Odometer& self);
void extract(Serializer& serializer, Odometer& self);
 
void insert(Serializer& serializer, const Odometer::Response& self);
void extract(Serializer& serializer, Odometer::Response& self);
 
CmdResult writeOdometer(C::mip_interface& device, Odometer::Mode mode, float scaling, float uncertainty);
CmdResult readOdometer(C::mip_interface& device, Odometer::Mode* modeOut, float* scalingOut, float* uncertaintyOut);
CmdResult saveOdometer(C::mip_interface& device);
CmdResult loadOdometer(C::mip_interface& device);
CmdResult defaultOdometer(C::mip_interface& device);
 
struct GetEventSupport
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_EVENT_SUPPORT;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    enum class Query : uint8_t
    {
        TRIGGER_TYPES = 1,  
        ACTION_TYPES  = 2,  
    };
    
    struct Info
    {
        uint8_t type = 0; 
        uint8_t count = 0; 
        
    };
    Query query = static_cast<Query>(0); 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_EVENT_SUPPORT;
        
        Query query = static_cast<Query>(0); 
        uint8_t max_instances = 0; 
        uint8_t num_entries = 0; 
        Info entries[126]; 
        
    };
};
void insert(Serializer& serializer, const GetEventSupport& self);
void extract(Serializer& serializer, GetEventSupport& self);
 
void insert(Serializer& serializer, const GetEventSupport::Info& self);
void extract(Serializer& serializer, GetEventSupport::Info& self);
 
void insert(Serializer& serializer, const GetEventSupport::Response& self);
void extract(Serializer& serializer, GetEventSupport::Response& self);
 
CmdResult getEventSupport(C::mip_interface& device, GetEventSupport::Query query, uint8_t* maxInstancesOut, uint8_t* numEntriesOut, uint8_t numEntriesOutMax, GetEventSupport::Info* entriesOut);
 
struct EventControl
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_EVENT_CONTROL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    enum class Mode : uint8_t
    {
        DISABLED   = 0,  
        ENABLED    = 1,  
        TEST       = 2,  
        TEST_PULSE = 3,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t instance = 0; 
    Mode mode = static_cast<Mode>(0); 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_EVENT_CONTROL;
        
        uint8_t instance = 0; 
        Mode mode = static_cast<Mode>(0); 
        
    };
};
void insert(Serializer& serializer, const EventControl& self);
void extract(Serializer& serializer, EventControl& self);
 
void insert(Serializer& serializer, const EventControl::Response& self);
void extract(Serializer& serializer, EventControl::Response& self);
 
CmdResult writeEventControl(C::mip_interface& device, uint8_t instance, EventControl::Mode mode);
CmdResult readEventControl(C::mip_interface& device, uint8_t instance, EventControl::Mode* modeOut);
CmdResult saveEventControl(C::mip_interface& device, uint8_t instance);
CmdResult loadEventControl(C::mip_interface& device, uint8_t instance);
CmdResult defaultEventControl(C::mip_interface& device, uint8_t instance);
 
struct GetEventTriggerStatus
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_EVENT_TRIGGER_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct Status : Bitfield<Status>
    {
        enum _enumType : uint8_t
        {
            NONE    = 0x00,
            ACTIVE  = 0x01,  
            ENABLED = 0x02,  
            TEST    = 0x04,  
        };
        uint8_t value = NONE;
        
        Status() : value(NONE) {}
        Status(int val) : value((uint8_t)val) {}
        operator uint8_t() const { return value; }
        Status& operator=(uint8_t val) { value = val; return *this; }
        Status& operator=(int val) { value = val; return *this; }
        Status& operator|=(uint8_t val) { return *this = value | val; }
        Status& operator&=(uint8_t val) { return *this = value & val; }
    };
    
    struct Entry
    {
        uint8_t type = 0; 
        Status status; 
        
    };
    uint8_t requested_count = 0; 
    uint8_t requested_instances[20] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_EVENT_TRIGGER_STATUS;
        
        uint8_t count = 0; 
        Entry triggers[20]; 
        
    };
};
void insert(Serializer& serializer, const GetEventTriggerStatus& self);
void extract(Serializer& serializer, GetEventTriggerStatus& self);
 
void insert(Serializer& serializer, const GetEventTriggerStatus::Entry& self);
void extract(Serializer& serializer, GetEventTriggerStatus::Entry& self);
 
void insert(Serializer& serializer, const GetEventTriggerStatus::Response& self);
void extract(Serializer& serializer, GetEventTriggerStatus::Response& self);
 
CmdResult getEventTriggerStatus(C::mip_interface& device, uint8_t requestedCount, const uint8_t* requestedInstances, uint8_t* countOut, uint8_t countOutMax, GetEventTriggerStatus::Entry* triggersOut);
 
struct GetEventActionStatus
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_EVENT_ACTION_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct Entry
    {
        uint8_t action_type = 0; 
        uint8_t trigger_id = 0; 
        
    };
    uint8_t requested_count = 0; 
    uint8_t requested_instances[20] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_EVENT_ACTION_STATUS;
        
        uint8_t count = 0; 
        Entry actions[20]; 
        
    };
};
void insert(Serializer& serializer, const GetEventActionStatus& self);
void extract(Serializer& serializer, GetEventActionStatus& self);
 
void insert(Serializer& serializer, const GetEventActionStatus::Entry& self);
void extract(Serializer& serializer, GetEventActionStatus::Entry& self);
 
void insert(Serializer& serializer, const GetEventActionStatus::Response& self);
void extract(Serializer& serializer, GetEventActionStatus::Response& self);
 
CmdResult getEventActionStatus(C::mip_interface& device, uint8_t requestedCount, const uint8_t* requestedInstances, uint8_t* countOut, uint8_t countOutMax, GetEventActionStatus::Entry* actionsOut);
 
struct EventTrigger
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_EVENT_TRIGGER_CONFIG;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    struct GpioParams
    {
        enum class Mode : uint8_t
        {
            DISABLED   = 0,  
            WHILE_HIGH = 1,  
            WHILE_LOW  = 2,  
            EDGE       = 4,  
        };
        
        uint8_t pin = 0; 
        Mode mode = static_cast<Mode>(0); 
        
    };
    struct ThresholdParams
    {
        enum class Type : uint8_t
        {
            WINDOW   = 1,  
            INTERVAL = 2,  
        };
        
        uint8_t desc_set = 0; 
        uint8_t field_desc = 0; 
        uint8_t param_id = 0; 
        Type type = static_cast<Type>(0); 
        union
        {
            double low_thres;
            double int_thres;
        };
        union
        {
            double high_thres;
            double interval;
        };
        
    };
    struct CombinationParams
    {
        static const uint16_t LOGIC_NEVER = 0x0000;
        static const uint16_t LOGIC_ALWAYS = 0xFFFF;
        static const uint16_t LOGIC_NONE = 0x0001;
        static const uint16_t LOGIC_OR = 0xFFFE;
        static const uint16_t LOGIC_NAND = 0x7FFF;
        static const uint16_t LOGIC_XOR_ONE = 0x0116;
        static const uint16_t LOGIC_ONLY_A = 0x0002;
        static const uint16_t LOGIC_ONLY_B = 0x0004;
        static const uint16_t LOGIC_ONLY_C = 0x0010;
        static const uint16_t LOGIC_ONLY_D = 0x0100;
        static const uint16_t LOGIC_AND_AB = 0x8888;
        static const uint16_t LOGIC_AB_OR_C = 0xF8F8;
        static const uint16_t LOGIC_AND = 0x8000;
        uint16_t logic_table = 0; 
        uint8_t input_triggers[4] = {0}; 
        
    };
    enum class Type : uint8_t
    {
        NONE        = 0,  
        GPIO        = 1,  
        THRESHOLD   = 2,  
        COMBINATION = 3,  
    };
    
    union Parameters
    {
        Parameters() {}
        GpioParams gpio;
        ThresholdParams threshold;
        CombinationParams combination;
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t instance = 0; 
    Type type = static_cast<Type>(0); 
    Parameters parameters;
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_EVENT_TRIGGER_CONFIG;
        
        uint8_t instance = 0; 
        Type type = static_cast<Type>(0); 
        Parameters parameters;
        
    };
};
void insert(Serializer& serializer, const EventTrigger& self);
void extract(Serializer& serializer, EventTrigger& self);
 
void insert(Serializer& serializer, const EventTrigger::GpioParams& self);
void extract(Serializer& serializer, EventTrigger::GpioParams& self);
 
void insert(Serializer& serializer, const EventTrigger::ThresholdParams& self);
void extract(Serializer& serializer, EventTrigger::ThresholdParams& self);
 
void insert(Serializer& serializer, const EventTrigger::CombinationParams& self);
void extract(Serializer& serializer, EventTrigger::CombinationParams& self);
 
void insert(Serializer& serializer, const EventTrigger::Response& self);
void extract(Serializer& serializer, EventTrigger::Response& self);
 
CmdResult writeEventTrigger(C::mip_interface& device, uint8_t instance, EventTrigger::Type type, const EventTrigger::Parameters& parameters);
CmdResult readEventTrigger(C::mip_interface& device, uint8_t instance, EventTrigger::Type* typeOut, EventTrigger::Parameters* parametersOut);
CmdResult saveEventTrigger(C::mip_interface& device, uint8_t instance);
CmdResult loadEventTrigger(C::mip_interface& device, uint8_t instance);
CmdResult defaultEventTrigger(C::mip_interface& device, uint8_t instance);
 
struct EventAction
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_EVENT_ACTION_CONFIG;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    struct GpioParams
    {
        enum class Mode : uint8_t
        {
            DISABLED     = 0,  
            ACTIVE_HIGH  = 1,  
            ACTIVE_LOW   = 2,  
            ONESHOT_HIGH = 5,  
            ONESHOT_LOW  = 6,  
            TOGGLE       = 7,  
        };
        
        uint8_t pin = 0; 
        Mode mode = static_cast<Mode>(0); 
        
    };
    struct MessageParams
    {
        uint8_t desc_set = 0; 
        uint16_t decimation = 0; 
        uint8_t num_fields = 0; 
        uint8_t descriptors[20] = {0}; 
        
    };
    enum class Type : uint8_t
    {
        NONE    = 0,  
        GPIO    = 1,  
        MESSAGE = 2,  
    };
    
    union Parameters
    {
        Parameters() {}
        GpioParams gpio;
        MessageParams message;
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t instance = 0; 
    uint8_t trigger = 0; 
    Type type = static_cast<Type>(0); 
    Parameters parameters;
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_EVENT_ACTION_CONFIG;
        
        uint8_t instance = 0; 
        uint8_t trigger = 0; 
        Type type = static_cast<Type>(0); 
        Parameters parameters;
        
    };
};
void insert(Serializer& serializer, const EventAction& self);
void extract(Serializer& serializer, EventAction& self);
 
void insert(Serializer& serializer, const EventAction::GpioParams& self);
void extract(Serializer& serializer, EventAction::GpioParams& self);
 
void insert(Serializer& serializer, const EventAction::MessageParams& self);
void extract(Serializer& serializer, EventAction::MessageParams& self);
 
void insert(Serializer& serializer, const EventAction::Response& self);
void extract(Serializer& serializer, EventAction::Response& self);
 
CmdResult writeEventAction(C::mip_interface& device, uint8_t instance, uint8_t trigger, EventAction::Type type, const EventAction::Parameters& parameters);
CmdResult readEventAction(C::mip_interface& device, uint8_t instance, uint8_t* triggerOut, EventAction::Type* typeOut, EventAction::Parameters* parametersOut);
CmdResult saveEventAction(C::mip_interface& device, uint8_t instance);
CmdResult loadEventAction(C::mip_interface& device, uint8_t instance);
CmdResult defaultEventAction(C::mip_interface& device, uint8_t instance);
 
struct AccelBias
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_ACCEL_BIAS;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float bias[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_ACCEL_BIAS_VECTOR;
        
        float bias[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const AccelBias& self);
void extract(Serializer& serializer, AccelBias& self);
 
void insert(Serializer& serializer, const AccelBias::Response& self);
void extract(Serializer& serializer, AccelBias::Response& self);
 
CmdResult writeAccelBias(C::mip_interface& device, const float* bias);
CmdResult readAccelBias(C::mip_interface& device, float* biasOut);
CmdResult saveAccelBias(C::mip_interface& device);
CmdResult loadAccelBias(C::mip_interface& device);
CmdResult defaultAccelBias(C::mip_interface& device);
 
struct GyroBias
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_GYRO_BIAS;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float bias[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GYRO_BIAS_VECTOR;
        
        float bias[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const GyroBias& self);
void extract(Serializer& serializer, GyroBias& self);
 
void insert(Serializer& serializer, const GyroBias::Response& self);
void extract(Serializer& serializer, GyroBias::Response& self);
 
CmdResult writeGyroBias(C::mip_interface& device, const float* bias);
CmdResult readGyroBias(C::mip_interface& device, float* biasOut);
CmdResult saveGyroBias(C::mip_interface& device);
CmdResult loadGyroBias(C::mip_interface& device);
CmdResult defaultGyroBias(C::mip_interface& device);
 
struct CaptureGyroBias
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_CAPTURE_GYRO_BIAS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint16_t averaging_time_ms = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_GYRO_BIAS_VECTOR;
        
        float bias[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const CaptureGyroBias& self);
void extract(Serializer& serializer, CaptureGyroBias& self);
 
void insert(Serializer& serializer, const CaptureGyroBias::Response& self);
void extract(Serializer& serializer, CaptureGyroBias::Response& self);
 
CmdResult captureGyroBias(C::mip_interface& device, uint16_t averagingTimeMs, float* biasOut);
 
struct MagHardIronOffset
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_HARD_IRON_OFFSET;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float offset[3] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_HARD_IRON_OFFSET_VECTOR;
        
        float offset[3] = {0}; 
        
    };
};
void insert(Serializer& serializer, const MagHardIronOffset& self);
void extract(Serializer& serializer, MagHardIronOffset& self);
 
void insert(Serializer& serializer, const MagHardIronOffset::Response& self);
void extract(Serializer& serializer, MagHardIronOffset::Response& self);
 
CmdResult writeMagHardIronOffset(C::mip_interface& device, const float* offset);
CmdResult readMagHardIronOffset(C::mip_interface& device, float* offsetOut);
CmdResult saveMagHardIronOffset(C::mip_interface& device);
CmdResult loadMagHardIronOffset(C::mip_interface& device);
CmdResult defaultMagHardIronOffset(C::mip_interface& device);
 
struct MagSoftIronMatrix
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_SOFT_IRON_MATRIX;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float offset[9] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_SOFT_IRON_COMP_MATRIX;
        
        float offset[9] = {0}; 
        
    };
};
void insert(Serializer& serializer, const MagSoftIronMatrix& self);
void extract(Serializer& serializer, MagSoftIronMatrix& self);
 
void insert(Serializer& serializer, const MagSoftIronMatrix::Response& self);
void extract(Serializer& serializer, MagSoftIronMatrix::Response& self);
 
CmdResult writeMagSoftIronMatrix(C::mip_interface& device, const float* offset);
CmdResult readMagSoftIronMatrix(C::mip_interface& device, float* offsetOut);
CmdResult saveMagSoftIronMatrix(C::mip_interface& device);
CmdResult loadMagSoftIronMatrix(C::mip_interface& device);
CmdResult defaultMagSoftIronMatrix(C::mip_interface& device);
 
struct Sensor2VehicleTransformEuler
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_SENSOR2VEHICLE_TRANSFORM_EUL;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float roll = 0; 
    float pitch = 0; 
    float yaw = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_SENSOR2VEHICLE_TRANSFORM_EUL;
        
        float roll = 0; 
        float pitch = 0; 
        float yaw = 0; 
        
    };
};
void insert(Serializer& serializer, const Sensor2VehicleTransformEuler& self);
void extract(Serializer& serializer, Sensor2VehicleTransformEuler& self);
 
void insert(Serializer& serializer, const Sensor2VehicleTransformEuler::Response& self);
void extract(Serializer& serializer, Sensor2VehicleTransformEuler::Response& self);
 
CmdResult writeSensor2VehicleTransformEuler(C::mip_interface& device, float roll, float pitch, float yaw);
CmdResult readSensor2VehicleTransformEuler(C::mip_interface& device, float* rollOut, float* pitchOut, float* yawOut);
CmdResult saveSensor2VehicleTransformEuler(C::mip_interface& device);
CmdResult loadSensor2VehicleTransformEuler(C::mip_interface& device);
CmdResult defaultSensor2VehicleTransformEuler(C::mip_interface& device);
 
struct Sensor2VehicleTransformQuaternion
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_SENSOR2VEHICLE_TRANSFORM_QUAT;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float q[4] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_SENSOR2VEHICLE_TRANSFORM_QUAT;
        
        float q[4] = {0}; 
        
    };
};
void insert(Serializer& serializer, const Sensor2VehicleTransformQuaternion& self);
void extract(Serializer& serializer, Sensor2VehicleTransformQuaternion& self);
 
void insert(Serializer& serializer, const Sensor2VehicleTransformQuaternion::Response& self);
void extract(Serializer& serializer, Sensor2VehicleTransformQuaternion::Response& self);
 
CmdResult writeSensor2VehicleTransformQuaternion(C::mip_interface& device, const float* q);
CmdResult readSensor2VehicleTransformQuaternion(C::mip_interface& device, float* qOut);
CmdResult saveSensor2VehicleTransformQuaternion(C::mip_interface& device);
CmdResult loadSensor2VehicleTransformQuaternion(C::mip_interface& device);
CmdResult defaultSensor2VehicleTransformQuaternion(C::mip_interface& device);
 
struct Sensor2VehicleTransformDcm
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_SENSOR2VEHICLE_TRANSFORM_DCM;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    float dcm[9] = {0}; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_SENSOR2VEHICLE_TRANSFORM_DCM;
        
        float dcm[9] = {0}; 
        
    };
};
void insert(Serializer& serializer, const Sensor2VehicleTransformDcm& self);
void extract(Serializer& serializer, Sensor2VehicleTransformDcm& self);
 
void insert(Serializer& serializer, const Sensor2VehicleTransformDcm::Response& self);
void extract(Serializer& serializer, Sensor2VehicleTransformDcm::Response& self);
 
CmdResult writeSensor2VehicleTransformDcm(C::mip_interface& device, const float* dcm);
CmdResult readSensor2VehicleTransformDcm(C::mip_interface& device, float* dcmOut);
CmdResult saveSensor2VehicleTransformDcm(C::mip_interface& device);
CmdResult loadSensor2VehicleTransformDcm(C::mip_interface& device);
CmdResult defaultSensor2VehicleTransformDcm(C::mip_interface& device);
 
struct ComplementaryFilter
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_LEGACY_COMP_FILTER;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    bool pitch_roll_enable = 0; 
    bool heading_enable = 0; 
    float pitch_roll_time_constant = 0; 
    float heading_time_constant = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_LEGACY_COMP_FILTER;
        
        bool pitch_roll_enable = 0; 
        bool heading_enable = 0; 
        float pitch_roll_time_constant = 0; 
        float heading_time_constant = 0; 
        
    };
};
void insert(Serializer& serializer, const ComplementaryFilter& self);
void extract(Serializer& serializer, ComplementaryFilter& self);
 
void insert(Serializer& serializer, const ComplementaryFilter::Response& self);
void extract(Serializer& serializer, ComplementaryFilter::Response& self);
 
CmdResult writeComplementaryFilter(C::mip_interface& device, bool pitchRollEnable, bool headingEnable, float pitchRollTimeConstant, float headingTimeConstant);
CmdResult readComplementaryFilter(C::mip_interface& device, bool* pitchRollEnableOut, bool* headingEnableOut, float* pitchRollTimeConstantOut, float* headingTimeConstantOut);
CmdResult saveComplementaryFilter(C::mip_interface& device);
CmdResult loadComplementaryFilter(C::mip_interface& device);
CmdResult defaultComplementaryFilter(C::mip_interface& device);
 
struct SensorRange
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_SENSOR_RANGE;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    SensorRangeType sensor = static_cast<SensorRangeType>(0); 
    uint8_t setting = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_SENSOR_RANGE;
        
        SensorRangeType sensor = static_cast<SensorRangeType>(0); 
        uint8_t setting = 0; 
        
    };
};
void insert(Serializer& serializer, const SensorRange& self);
void extract(Serializer& serializer, SensorRange& self);
 
void insert(Serializer& serializer, const SensorRange::Response& self);
void extract(Serializer& serializer, SensorRange::Response& self);
 
CmdResult writeSensorRange(C::mip_interface& device, SensorRangeType sensor, uint8_t setting);
CmdResult readSensorRange(C::mip_interface& device, SensorRangeType sensor, uint8_t* settingOut);
CmdResult saveSensorRange(C::mip_interface& device, SensorRangeType sensor);
CmdResult loadSensorRange(C::mip_interface& device, SensorRangeType sensor);
CmdResult defaultSensorRange(C::mip_interface& device, SensorRangeType sensor);
 
struct CalibratedSensorRanges
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::CMD_CALIBRATED_RANGES;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct Entry
    {
        uint8_t setting = 0; 
        float range = 0; 
        
    };
    SensorRangeType sensor = static_cast<SensorRangeType>(0); 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_3dm::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_3dm::REPLY_CALIBRATED_RANGES;
        
        SensorRangeType sensor = static_cast<SensorRangeType>(0); 
        uint8_t num_ranges = 0; 
        Entry ranges[50]; 
        
    };
};
void insert(Serializer& serializer, const CalibratedSensorRanges& self);
void extract(Serializer& serializer, CalibratedSensorRanges& self);
 
void insert(Serializer& serializer, const CalibratedSensorRanges::Entry& self);
void extract(Serializer& serializer, CalibratedSensorRanges::Entry& self);
 
void insert(Serializer& serializer, const CalibratedSensorRanges::Response& self);
void extract(Serializer& serializer, CalibratedSensorRanges::Response& self);
 
CmdResult calibratedSensorRanges(C::mip_interface& device, SensorRangeType sensor, uint8_t* numRangesOut, uint8_t numRangesOutMax, CalibratedSensorRanges::Entry* rangesOut);
 
} // namespace commands_3dm
} // namespace mip