data_sensor.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 data_sensor {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET                      = 0x80,
    
    DATA_ACCEL_RAW                      = 0x01,
    DATA_GYRO_RAW                       = 0x02,
    DATA_MAG_RAW                        = 0x03,
    DATA_ACCEL_SCALED                   = 0x04,
    DATA_GYRO_SCALED                    = 0x05,
    DATA_MAG_SCALED                     = 0x06,
    DATA_DELTA_THETA                    = 0x07,
    DATA_DELTA_VELOCITY                 = 0x08,
    DATA_COMP_ORIENTATION_MATRIX        = 0x09,
    DATA_COMP_QUATERNION                = 0x0A,
    DATA_COMP_ORIENTATION_UPDATE_MATRIX = 0x0B,
    DATA_COMP_EULER_ANGLES              = 0x0C,
    DATA_TEMPERATURE_RAW                = 0x0D,
    DATA_TIME_STAMP_INTERNAL            = 0x0E,
    DATA_TIME_STAMP_PPS                 = 0x0F,
    DATA_STAB_MAG                       = 0x10,
    DATA_STAB_ACCEL                     = 0x11,
    DATA_TIME_STAMP_GPS                 = 0x12,
    DATA_TEMPERATURE_ABS                = 0x14,
    DATA_RAW_CLIP_DATA                  = 0x15,
    DATA_PRESSURE_RAW                   = 0x16,
    DATA_PRESSURE_SCALED                = 0x17,
    DATA_OVERRANGE_STATUS               = 0x18,
    DATA_ODOMETER                       = 0x40,
    
    MIP_DATA_DESC_ASPP                  = 0x81,
    MIP_DATA_DESC_GXSB                  = 0x82,
};
 
// Shared Type Definitions
 
 
// Mip Fields
 
 
struct RawAccel
{
    Vector3f raw_accel; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_ACCEL_RAW;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "RawAccel";
    static constexpr const char* DOC_NAME = "RawAccel";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(raw_accel[0],raw_accel[1],raw_accel[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(raw_accel[0]),std::ref(raw_accel[1]),std::ref(raw_accel[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct RawGyro
{
    Vector3f raw_gyro; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_GYRO_RAW;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "RawGyro";
    static constexpr const char* DOC_NAME = "RawGyro";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(raw_gyro[0],raw_gyro[1],raw_gyro[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(raw_gyro[0]),std::ref(raw_gyro[1]),std::ref(raw_gyro[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct RawMag
{
    Vector3f raw_mag; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_MAG_RAW;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "RawMag";
    static constexpr const char* DOC_NAME = "RawMag";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(raw_mag[0],raw_mag[1],raw_mag[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(raw_mag[0]),std::ref(raw_mag[1]),std::ref(raw_mag[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct RawPressure
{
    float raw_pressure = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_PRESSURE_RAW;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "RawPressure";
    static constexpr const char* DOC_NAME = "RawPressure";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(raw_pressure);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(raw_pressure));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ScaledAccel
{
    Vector3f scaled_accel; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_ACCEL_SCALED;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ScaledAccel";
    static constexpr const char* DOC_NAME = "ScaledAccel";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(scaled_accel[0],scaled_accel[1],scaled_accel[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(scaled_accel[0]),std::ref(scaled_accel[1]),std::ref(scaled_accel[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ScaledGyro
{
    Vector3f scaled_gyro; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_GYRO_SCALED;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ScaledGyro";
    static constexpr const char* DOC_NAME = "ScaledGyro";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(scaled_gyro[0],scaled_gyro[1],scaled_gyro[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(scaled_gyro[0]),std::ref(scaled_gyro[1]),std::ref(scaled_gyro[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ScaledMag
{
    Vector3f scaled_mag; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_MAG_SCALED;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ScaledMag";
    static constexpr const char* DOC_NAME = "ScaledMag";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(scaled_mag[0],scaled_mag[1],scaled_mag[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(scaled_mag[0]),std::ref(scaled_mag[1]),std::ref(scaled_mag[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ScaledPressure
{
    float scaled_pressure = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_PRESSURE_SCALED;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ScaledPressure";
    static constexpr const char* DOC_NAME = "ScaledPressure";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(scaled_pressure);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(scaled_pressure));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct DeltaTheta
{
    Vector3f delta_theta; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_DELTA_THETA;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "DeltaTheta";
    static constexpr const char* DOC_NAME = "DeltaTheta";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(delta_theta[0],delta_theta[1],delta_theta[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(delta_theta[0]),std::ref(delta_theta[1]),std::ref(delta_theta[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct DeltaVelocity
{
    Vector3f delta_velocity; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_DELTA_VELOCITY;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "DeltaVelocity";
    static constexpr const char* DOC_NAME = "DeltaVelocity";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(delta_velocity[0],delta_velocity[1],delta_velocity[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(delta_velocity[0]),std::ref(delta_velocity[1]),std::ref(delta_velocity[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct CompOrientationMatrix
{
    Matrix3f m; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_ORIENTATION_MATRIX;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "CompOrientationMatrix";
    static constexpr const char* DOC_NAME = "Complementary Filter Orientation Matrix";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7],m[8]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(m[0]),std::ref(m[1]),std::ref(m[2]),std::ref(m[3]),std::ref(m[4]),std::ref(m[5]),std::ref(m[6]),std::ref(m[7]),std::ref(m[8]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct CompQuaternion
{
    Quatf q; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_QUATERNION;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "CompQuaternion";
    static constexpr const char* DOC_NAME = "Complementary Filter Quaternion";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(q[0],q[1],q[2],q[3]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(q[0]),std::ref(q[1]),std::ref(q[2]),std::ref(q[3]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct CompEulerAngles
{
    float roll = 0; 
    float pitch = 0; 
    float yaw = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_EULER_ANGLES;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "CompEulerAngles";
    static constexpr const char* DOC_NAME = "Complementary Filter Euler Angles";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(roll,pitch,yaw);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(roll),std::ref(pitch),std::ref(yaw));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct CompOrientationUpdateMatrix
{
    Matrix3f m;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_ORIENTATION_UPDATE_MATRIX;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "CompOrientationUpdateMatrix";
    static constexpr const char* DOC_NAME = "Complementary Filter Orientation Update Matrix";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7],m[8]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(m[0]),std::ref(m[1]),std::ref(m[2]),std::ref(m[3]),std::ref(m[4]),std::ref(m[5]),std::ref(m[6]),std::ref(m[7]),std::ref(m[8]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct OrientationRawTemp
{
    uint16_t raw_temp[4] = {0};
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TEMPERATURE_RAW;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "OrientationRawTemp";
    static constexpr const char* DOC_NAME = "OrientationRawTemp";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(raw_temp);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(raw_temp));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct InternalTimestamp
{
    uint32_t counts = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TIME_STAMP_INTERNAL;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "InternalTimestamp";
    static constexpr const char* DOC_NAME = "InternalTimestamp";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(counts);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(counts));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct PpsTimestamp
{
    uint32_t seconds = 0;
    uint32_t useconds = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TIME_STAMP_PPS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "PpsTimestamp";
    static constexpr const char* DOC_NAME = "PPS Timestamp";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(seconds,useconds);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(seconds),std::ref(useconds));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct GpsTimestamp
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE              = 0x0000,
            PPS_VALID         = 0x0001,  
            TIME_REFRESH      = 0x0002,  
            TIME_INITIALIZED  = 0x0004,  
            TOW_VALID         = 0x0008,  
            WEEK_NUMBER_VALID = 0x0010,  
            ALL               = 0x001F,
        };
        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 ppsValid() const { return (value & PPS_VALID) > 0; }
        void ppsValid(bool val) { value &= ~PPS_VALID; if(val) value |= PPS_VALID; }
        bool timeRefresh() const { return (value & TIME_REFRESH) > 0; }
        void timeRefresh(bool val) { value &= ~TIME_REFRESH; if(val) value |= TIME_REFRESH; }
        bool timeInitialized() const { return (value & TIME_INITIALIZED) > 0; }
        void timeInitialized(bool val) { value &= ~TIME_INITIALIZED; if(val) value |= TIME_INITIALIZED; }
        bool towValid() const { return (value & TOW_VALID) > 0; }
        void towValid(bool val) { value &= ~TOW_VALID; if(val) value |= TOW_VALID; }
        bool weekNumberValid() const { return (value & WEEK_NUMBER_VALID) > 0; }
        void weekNumberValid(bool val) { value &= ~WEEK_NUMBER_VALID; if(val) value |= WEEK_NUMBER_VALID; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    double tow = 0; 
    uint16_t week_number = 0; 
    ValidFlags valid_flags;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TIME_STAMP_GPS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GpsTimestamp";
    static constexpr const char* DOC_NAME = "GpsTimestamp";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(tow,week_number,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(tow),std::ref(week_number),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct TemperatureAbs
{
    float min_temp = 0; 
    float max_temp = 0; 
    float mean_temp = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TEMPERATURE_ABS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "TemperatureAbs";
    static constexpr const char* DOC_NAME = "Temperature Statistics";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(min_temp,max_temp,mean_temp);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(min_temp),std::ref(max_temp),std::ref(mean_temp));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct UpVector
{
    Vector3f up; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_STAB_ACCEL;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "UpVector";
    static constexpr const char* DOC_NAME = "UpVector";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(up[0],up[1],up[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(up[0]),std::ref(up[1]),std::ref(up[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct NorthVector
{
    Vector3f north; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_STAB_MAG;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "NorthVector";
    static constexpr const char* DOC_NAME = "NorthVector";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(north[0],north[1],north[2]);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(north[0]),std::ref(north[1]),std::ref(north[2]));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct OverrangeStatus
{
    struct Status : Bitfield<Status>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE    = 0x0000,
            ACCEL_X = 0x0001,  
            ACCEL_Y = 0x0002,  
            ACCEL_Z = 0x0004,  
            GYRO_X  = 0x0010,  
            GYRO_Y  = 0x0020,  
            GYRO_Z  = 0x0040,  
            MAG_X   = 0x0100,  
            MAG_Y   = 0x0200,  
            MAG_Z   = 0x0400,  
            PRESS   = 0x1000,  
            ALL     = 0x1777,
        };
        uint16_t value = NONE;
        
        Status() : value(NONE) {}
        Status(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        Status& operator=(uint16_t val) { value = val; return *this; }
        Status& operator=(int val) { value = uint16_t(val); return *this; }
        Status& operator|=(uint16_t val) { return *this = value | val; }
        Status& operator&=(uint16_t val) { return *this = value & val; }
        
        bool accelX() const { return (value & ACCEL_X) > 0; }
        void accelX(bool val) { value &= ~ACCEL_X; if(val) value |= ACCEL_X; }
        bool accelY() const { return (value & ACCEL_Y) > 0; }
        void accelY(bool val) { value &= ~ACCEL_Y; if(val) value |= ACCEL_Y; }
        bool accelZ() const { return (value & ACCEL_Z) > 0; }
        void accelZ(bool val) { value &= ~ACCEL_Z; if(val) value |= ACCEL_Z; }
        bool gyroX() const { return (value & GYRO_X) > 0; }
        void gyroX(bool val) { value &= ~GYRO_X; if(val) value |= GYRO_X; }
        bool gyroY() const { return (value & GYRO_Y) > 0; }
        void gyroY(bool val) { value &= ~GYRO_Y; if(val) value |= GYRO_Y; }
        bool gyroZ() const { return (value & GYRO_Z) > 0; }
        void gyroZ(bool val) { value &= ~GYRO_Z; if(val) value |= GYRO_Z; }
        bool magX() const { return (value & MAG_X) > 0; }
        void magX(bool val) { value &= ~MAG_X; if(val) value |= MAG_X; }
        bool magY() const { return (value & MAG_Y) > 0; }
        void magY(bool val) { value &= ~MAG_Y; if(val) value |= MAG_Y; }
        bool magZ() const { return (value & MAG_Z) > 0; }
        void magZ(bool val) { value &= ~MAG_Z; if(val) value |= MAG_Z; }
        bool press() const { return (value & PRESS) > 0; }
        void press(bool val) { value &= ~PRESS; if(val) value |= PRESS; }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    Status status;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_OVERRANGE_STATUS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "OverrangeStatus";
    static constexpr const char* DOC_NAME = "OverrangeStatus";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(status);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(status));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct OdometerData
{
    float speed = 0; 
    float uncertainty = 0; 
    uint16_t valid_flags = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_ODOMETER;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "OdometerData";
    static constexpr const char* DOC_NAME = "OdometerData";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(speed,uncertainty,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(speed),std::ref(uncertainty),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
} // namespace data_sensor
} // namespace mip