data_sensor.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 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
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_ACCEL_RAW;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float raw_accel[3] = {0}; 
    
};
void insert(Serializer& serializer, const RawAccel& self);
void extract(Serializer& serializer, RawAccel& self);
 
 
struct RawGyro
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_GYRO_RAW;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float raw_gyro[3] = {0}; 
    
};
void insert(Serializer& serializer, const RawGyro& self);
void extract(Serializer& serializer, RawGyro& self);
 
 
struct RawMag
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_MAG_RAW;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float raw_mag[3] = {0}; 
    
};
void insert(Serializer& serializer, const RawMag& self);
void extract(Serializer& serializer, RawMag& self);
 
 
struct RawPressure
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_PRESSURE_RAW;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float raw_pressure = 0; 
    
};
void insert(Serializer& serializer, const RawPressure& self);
void extract(Serializer& serializer, RawPressure& self);
 
 
struct ScaledAccel
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_ACCEL_SCALED;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scaled_accel[3] = {0}; 
    
};
void insert(Serializer& serializer, const ScaledAccel& self);
void extract(Serializer& serializer, ScaledAccel& self);
 
 
struct ScaledGyro
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_GYRO_SCALED;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scaled_gyro[3] = {0}; 
    
};
void insert(Serializer& serializer, const ScaledGyro& self);
void extract(Serializer& serializer, ScaledGyro& self);
 
 
struct ScaledMag
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_MAG_SCALED;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scaled_mag[3] = {0}; 
    
};
void insert(Serializer& serializer, const ScaledMag& self);
void extract(Serializer& serializer, ScaledMag& self);
 
 
struct ScaledPressure
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_PRESSURE_SCALED;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float scaled_pressure = 0; 
    
};
void insert(Serializer& serializer, const ScaledPressure& self);
void extract(Serializer& serializer, ScaledPressure& self);
 
 
struct DeltaTheta
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_DELTA_THETA;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float delta_theta[3] = {0}; 
    
};
void insert(Serializer& serializer, const DeltaTheta& self);
void extract(Serializer& serializer, DeltaTheta& self);
 
 
struct DeltaVelocity
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_DELTA_VELOCITY;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float delta_velocity[3] = {0}; 
    
};
void insert(Serializer& serializer, const DeltaVelocity& self);
void extract(Serializer& serializer, DeltaVelocity& self);
 
 
struct CompOrientationMatrix
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_ORIENTATION_MATRIX;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float m[9] = {0}; 
    
};
void insert(Serializer& serializer, const CompOrientationMatrix& self);
void extract(Serializer& serializer, CompOrientationMatrix& self);
 
 
struct CompQuaternion
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_QUATERNION;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float q[4] = {0}; 
    
};
void insert(Serializer& serializer, const CompQuaternion& self);
void extract(Serializer& serializer, CompQuaternion& self);
 
 
struct CompEulerAngles
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_EULER_ANGLES;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float roll = 0; 
    float pitch = 0; 
    float yaw = 0; 
    
};
void insert(Serializer& serializer, const CompEulerAngles& self);
void extract(Serializer& serializer, CompEulerAngles& self);
 
 
struct CompOrientationUpdateMatrix
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_COMP_ORIENTATION_UPDATE_MATRIX;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float m[9] = {0};
    
};
void insert(Serializer& serializer, const CompOrientationUpdateMatrix& self);
void extract(Serializer& serializer, CompOrientationUpdateMatrix& self);
 
 
struct OrientationRawTemp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TEMPERATURE_RAW;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint16_t raw_temp[4] = {0};
    
};
void insert(Serializer& serializer, const OrientationRawTemp& self);
void extract(Serializer& serializer, OrientationRawTemp& self);
 
 
struct InternalTimestamp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TIME_STAMP_INTERNAL;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint32_t counts = 0;
    
};
void insert(Serializer& serializer, const InternalTimestamp& self);
void extract(Serializer& serializer, InternalTimestamp& self);
 
 
struct PpsTimestamp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TIME_STAMP_PPS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint32_t seconds = 0;
    uint32_t useconds = 0;
    
};
void insert(Serializer& serializer, const PpsTimestamp& self);
void extract(Serializer& serializer, PpsTimestamp& self);
 
 
struct GpsTimestamp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TIME_STAMP_GPS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct ValidFlags : Bitfield<ValidFlags>
    {
        enum _enumType : uint16_t
        {
            NONE              = 0x0000,
            PPS_VALID         = 0x0001,  
            TIME_REFRESH      = 0x0002,  
            TIME_INITIALIZED  = 0x0004,  
            TOW_VALID         = 0x0008,  
            WEEK_NUMBER_VALID = 0x0010,  
        };
        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 = val; return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    double tow = 0; 
    uint16_t week_number = 0; 
    ValidFlags valid_flags;
    
};
void insert(Serializer& serializer, const GpsTimestamp& self);
void extract(Serializer& serializer, GpsTimestamp& self);
 
 
struct TemperatureAbs
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_TEMPERATURE_ABS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float min_temp = 0; 
    float max_temp = 0; 
    float mean_temp = 0; 
    
};
void insert(Serializer& serializer, const TemperatureAbs& self);
void extract(Serializer& serializer, TemperatureAbs& self);
 
 
struct UpVector
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_STAB_ACCEL;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float up[3] = {0}; 
    
};
void insert(Serializer& serializer, const UpVector& self);
void extract(Serializer& serializer, UpVector& self);
 
 
struct NorthVector
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_STAB_MAG;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float north[3] = {0}; 
    
};
void insert(Serializer& serializer, const NorthVector& self);
void extract(Serializer& serializer, NorthVector& self);
 
 
struct OverrangeStatus
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_OVERRANGE_STATUS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct Status : Bitfield<Status>
    {
        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,  
        };
        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 = val; return *this; }
        Status& operator|=(uint16_t val) { return *this = value | val; }
        Status& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    Status status;
    
};
void insert(Serializer& serializer, const OverrangeStatus& self);
void extract(Serializer& serializer, OverrangeStatus& self);
 
 
struct OdometerData
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_sensor::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_sensor::DATA_ODOMETER;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    float speed = 0; 
    float uncertainty = 0; 
    uint16_t valid_flags = 0; 
    
};
void insert(Serializer& serializer, const OdometerData& self);
void extract(Serializer& serializer, OdometerData& self);
 
 
} // namespace data_sensor
} // namespace mip