commands_aiding.hpp

Go to the documentation of this file.

#pragma once
 
#include <mip/definitions/common.hpp>
#include <mip/mip_descriptors.hpp>
#include <mip/mip_result.hpp>
#include <mip/mip_interface.hpp>
 
#include <stdint.h>
#include <stddef.h>
 
namespace mip {
namespace C {
struct mip_interface;
} // namespace C
 
namespace commands_aiding {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET             = 0x13,
    
    CMD_FRAME_CONFIG           = 0x01,
    CMD_LOCAL_FRAME            = 0x03,
    CMD_ECHO_CONTROL           = 0x1F,
    CMD_POS_LOCAL              = 0x20,
    CMD_POS_ECEF               = 0x21,
    CMD_POS_LLH                = 0x22,
    CMD_HEIGHT_ABOVE_ELLIPSOID = 0x23,
    CMD_HEIGHT_REL             = 0x24,
    CMD_VEL_ECEF               = 0x28,
    CMD_VEL_NED                = 0x29,
    CMD_VEL_BODY_FRAME         = 0x2A,
    CMD_WHEELSPEED             = 0x2B,
    CMD_HEADING_TRUE           = 0x31,
    CMD_MAGNETIC_FIELD         = 0x32,
    CMD_PRESSURE               = 0x33,
    CMD_DELTA_POSITION         = 0x38,
    CMD_DELTA_ATTITUDE         = 0x39,
    CMD_ANGULAR_RATE_LOCAL     = 0x3A,
    
    REPLY_FRAME_CONFIG         = 0x81,
    REPLY_ECHO_CONTROL         = 0x9F,
};
 
// Shared Type Definitions
 
struct Time
{
    enum class Timebase : uint8_t
    {
        INTERNAL_REFERENCE = 1,  
        EXTERNAL_TIME      = 2,  
        TIME_OF_ARRIVAL    = 3,  
    };
    
    Timebase timebase = static_cast<Timebase>(0); 
    uint8_t reserved = 0; 
    uint64_t nanoseconds = 0; 
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
// Mip Fields
 
 
struct FrameConfig
{
    enum class Format : uint8_t
    {
        EULER      = 1,  
        QUATERNION = 2,  
    };
    
    union Rotation
    {
        Vector3f euler;
        Quatf quaternion;
        
        Rotation() {}
    };
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t frame_id = 0; 
    Format format = static_cast<Format>(0); 
    bool tracking_enabled = 0; 
    Vector3f translation; 
    Rotation rotation; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_FRAME_CONFIG;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "FrameConfig";
    static constexpr const char* DOC_NAME = "Frame Configuration";
    static constexpr const bool HAS_FUNCTION_SELECTOR = true;
    
    auto asTuple() const
    {
        return std::make_tuple(frame_id,format,tracking_enabled,translation,rotation);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(frame_id),std::ref(format),std::ref(tracking_enabled),std::ref(translation),std::ref(rotation));
    }
    
    static FrameConfig create_sld_all(::mip::FunctionSelector function)
    {
        FrameConfig cmd;
        cmd.function = function;
        cmd.frame_id = 0;
        return cmd;
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        uint8_t frame_id = 0; 
        Format format = static_cast<Format>(0); 
        bool tracking_enabled = 0; 
        Vector3f translation; 
        Rotation rotation; 
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::REPLY_FRAME_CONFIG;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "FrameConfig::Response";
        static constexpr const char* DOC_NAME = "Frame Configuration Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(frame_id,format,tracking_enabled,translation,rotation);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(frame_id),std::ref(format),std::ref(tracking_enabled),std::ref(translation),std::ref(rotation));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<FrameConfig> writeFrameConfig(C::mip_interface& device, uint8_t frameId, FrameConfig::Format format, bool trackingEnabled, const float* translation, const FrameConfig::Rotation& rotation);
TypedResult<FrameConfig> readFrameConfig(C::mip_interface& device, uint8_t frameId, FrameConfig::Format format, bool* trackingEnabledOut, float* translationOut, FrameConfig::Rotation* rotationOut);
TypedResult<FrameConfig> saveFrameConfig(C::mip_interface& device, uint8_t frameId);
TypedResult<FrameConfig> loadFrameConfig(C::mip_interface& device, uint8_t frameId);
TypedResult<FrameConfig> defaultFrameConfig(C::mip_interface& device, uint8_t frameId);
 
 
struct EchoControl
{
    enum class Mode : uint8_t
    {
        SUPPRESS_ACK = 0,  
        STANDARD     = 1,  
        RESPONSE     = 2,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    Mode mode = static_cast<Mode>(0); 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_ECHO_CONTROL;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "EchoControl";
    static constexpr const char* DOC_NAME = "Aiding Command Echo Control";
    static constexpr const bool HAS_FUNCTION_SELECTOR = true;
    
    auto asTuple() const
    {
        return std::make_tuple(mode);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(mode));
    }
    
    static EchoControl create_sld_all(::mip::FunctionSelector function)
    {
        EchoControl cmd;
        cmd.function = function;
        return cmd;
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        Mode mode = static_cast<Mode>(0); 
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::REPLY_ECHO_CONTROL;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "EchoControl::Response";
        static constexpr const char* DOC_NAME = "Aiding Command Echo Control Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(mode);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(mode));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<EchoControl> writeEchoControl(C::mip_interface& device, EchoControl::Mode mode);
TypedResult<EchoControl> readEchoControl(C::mip_interface& device, EchoControl::Mode* modeOut);
TypedResult<EchoControl> saveEchoControl(C::mip_interface& device);
TypedResult<EchoControl> loadEchoControl(C::mip_interface& device);
TypedResult<EchoControl> defaultEchoControl(C::mip_interface& device);
 
 
struct PosEcef
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE = 0x0000,
            X    = 0x0001,  
            Y    = 0x0002,  
            Z    = 0x0004,  
            ALL  = 0x0007,
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        bool x() const { return (value & X) > 0; }
        void x(bool val) { value &= ~X; if(val) value |= X; }
        bool y() const { return (value & Y) > 0; }
        void y(bool val) { value &= ~Y; if(val) value |= Y; }
        bool z() const { return (value & Z) > 0; }
        void z(bool val) { value &= ~Z; if(val) value |= Z; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    Time time; 
    uint8_t frame_id = 0; 
    Vector3d position; 
    Vector3f uncertainty; 
    ValidFlags valid_flags; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_POS_ECEF;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "PosEcef";
    static constexpr const char* DOC_NAME = "ECEF Position";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,position,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(position),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<PosEcef> posEcef(C::mip_interface& device, const Time& time, uint8_t frameId, const double* position, const float* uncertainty, PosEcef::ValidFlags validFlags);
 
 
struct PosLlh
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE      = 0x0000,
            LATITUDE  = 0x0001,  
            LONGITUDE = 0x0002,  
            HEIGHT    = 0x0004,  
            ALL       = 0x0007,
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        bool latitude() const { return (value & LATITUDE) > 0; }
        void latitude(bool val) { value &= ~LATITUDE; if(val) value |= LATITUDE; }
        bool longitude() const { return (value & LONGITUDE) > 0; }
        void longitude(bool val) { value &= ~LONGITUDE; if(val) value |= LONGITUDE; }
        bool height() const { return (value & HEIGHT) > 0; }
        void height(bool val) { value &= ~HEIGHT; if(val) value |= HEIGHT; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    Time time; 
    uint8_t frame_id = 0; 
    double latitude = 0; 
    double longitude = 0; 
    double height = 0; 
    Vector3f uncertainty; 
    ValidFlags valid_flags; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_POS_LLH;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "PosLlh";
    static constexpr const char* DOC_NAME = "LLH Position";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,latitude,longitude,height,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(latitude),std::ref(longitude),std::ref(height),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<PosLlh> posLlh(C::mip_interface& device, const Time& time, uint8_t frameId, double latitude, double longitude, double height, const float* uncertainty, PosLlh::ValidFlags validFlags);
 
 
struct HeightAboveEllipsoid
{
    Time time; 
    uint8_t frame_id = 0; 
    float height = 0; 
    float uncertainty = 0; 
    uint16_t valid_flags = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_HEIGHT_ABOVE_ELLIPSOID;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "HeightAboveEllipsoid";
    static constexpr const char* DOC_NAME = "Height Above Ellipsoid";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,height,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(height),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<HeightAboveEllipsoid> heightAboveEllipsoid(C::mip_interface& device, const Time& time, uint8_t frameId, float height, float uncertainty, uint16_t validFlags);
 
 
struct VelEcef
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE = 0x0000,
            X    = 0x0001,  
            Y    = 0x0002,  
            Z    = 0x0004,  
            ALL  = 0x0007,
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        bool x() const { return (value & X) > 0; }
        void x(bool val) { value &= ~X; if(val) value |= X; }
        bool y() const { return (value & Y) > 0; }
        void y(bool val) { value &= ~Y; if(val) value |= Y; }
        bool z() const { return (value & Z) > 0; }
        void z(bool val) { value &= ~Z; if(val) value |= Z; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    Time time; 
    uint8_t frame_id = 0; 
    Vector3f velocity; 
    Vector3f uncertainty; 
    ValidFlags valid_flags; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_VEL_ECEF;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "VelEcef";
    static constexpr const char* DOC_NAME = "ECEF Velocity";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,velocity,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(velocity),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<VelEcef> velEcef(C::mip_interface& device, const Time& time, uint8_t frameId, const float* velocity, const float* uncertainty, VelEcef::ValidFlags validFlags);
 
 
struct VelNed
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE = 0x0000,
            X    = 0x0001,  
            Y    = 0x0002,  
            Z    = 0x0004,  
            ALL  = 0x0007,
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        bool x() const { return (value & X) > 0; }
        void x(bool val) { value &= ~X; if(val) value |= X; }
        bool y() const { return (value & Y) > 0; }
        void y(bool val) { value &= ~Y; if(val) value |= Y; }
        bool z() const { return (value & Z) > 0; }
        void z(bool val) { value &= ~Z; if(val) value |= Z; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    Time time; 
    uint8_t frame_id = 0; 
    Vector3f velocity; 
    Vector3f uncertainty; 
    ValidFlags valid_flags; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_VEL_NED;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "VelNed";
    static constexpr const char* DOC_NAME = "NED Velocity";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,velocity,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(velocity),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<VelNed> velNed(C::mip_interface& device, const Time& time, uint8_t frameId, const float* velocity, const float* uncertainty, VelNed::ValidFlags validFlags);
 
 
struct VelBodyFrame
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE = 0x0000,
            X    = 0x0001,  
            Y    = 0x0002,  
            Z    = 0x0004,  
            ALL  = 0x0007,
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        bool x() const { return (value & X) > 0; }
        void x(bool val) { value &= ~X; if(val) value |= X; }
        bool y() const { return (value & Y) > 0; }
        void y(bool val) { value &= ~Y; if(val) value |= Y; }
        bool z() const { return (value & Z) > 0; }
        void z(bool val) { value &= ~Z; if(val) value |= Z; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    Time time; 
    uint8_t frame_id = 0; 
    Vector3f velocity; 
    Vector3f uncertainty; 
    ValidFlags valid_flags; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_VEL_BODY_FRAME;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "VelBodyFrame";
    static constexpr const char* DOC_NAME = "Body Frame Velocity";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,velocity,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(velocity),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<VelBodyFrame> velBodyFrame(C::mip_interface& device, const Time& time, uint8_t frameId, const float* velocity, const float* uncertainty, VelBodyFrame::ValidFlags validFlags);
 
 
struct HeadingTrue
{
    Time time; 
    uint8_t frame_id = 0; 
    float heading = 0; 
    float uncertainty = 0; 
    uint16_t valid_flags = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_HEADING_TRUE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "HeadingTrue";
    static constexpr const char* DOC_NAME = "True Heading";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,heading,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(heading),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<HeadingTrue> headingTrue(C::mip_interface& device, const Time& time, uint8_t frameId, float heading, float uncertainty, uint16_t validFlags);
 
 
struct MagneticField
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE = 0x0000,
            X    = 0x0001,  
            Y    = 0x0002,  
            Z    = 0x0004,  
            ALL  = 0x0007,
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        bool x() const { return (value & X) > 0; }
        void x(bool val) { value &= ~X; if(val) value |= X; }
        bool y() const { return (value & Y) > 0; }
        void y(bool val) { value &= ~Y; if(val) value |= Y; }
        bool z() const { return (value & Z) > 0; }
        void z(bool val) { value &= ~Z; if(val) value |= Z; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    Time time; 
    uint8_t frame_id = 0; 
    Vector3f magnetic_field; 
    Vector3f uncertainty; 
    ValidFlags valid_flags; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_MAGNETIC_FIELD;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "MagneticField";
    static constexpr const char* DOC_NAME = "Magnetic Field";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,magnetic_field,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(magnetic_field),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<MagneticField> magneticField(C::mip_interface& device, const Time& time, uint8_t frameId, const float* magneticField, const float* uncertainty, MagneticField::ValidFlags validFlags);
 
 
struct Pressure
{
    Time time; 
    uint8_t frame_id = 0; 
    float pressure = 0; 
    float uncertainty = 0; 
    uint16_t valid_flags = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_aiding::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_aiding::CMD_PRESSURE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "Pressure";
    static constexpr const char* DOC_NAME = "Pressure";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(time,frame_id,pressure,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(time),std::ref(frame_id),std::ref(pressure),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<Pressure> pressure(C::mip_interface& device, const Time& time, uint8_t frameId, float pressure, float uncertainty, uint16_t validFlags);
 
 
} // namespace commands_aiding
} // namespace mip