SensorDefs.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
#include <math.h>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846f
#endif
enum class SensorRemap {
    // Chip top view, upper left corner
    //  -------------
    // | *             |
    // |               |
    // |               |
    // |               |
    // |               |
    //  -------------
    TOP_LAYER_LEFT_CORNER,
    // Chip top view, upper right corner
    //  -------------
    // |             * |
    // |               |
    // |               |
    // |               |
    // |               |
    //  -------------
    TOP_LAYER_RIGHT_CORNER,
    // Chip top view, bottom right corner of the top
    //  -------------
    // |               |
    // |               |
    // |               |
    // |               |
    // |             * |
    //  -------------
    TOP_LAYER_BOTTOM_RIGHT_CORNER,
    // The top view of the chip, the lower left corner of the front bottom
    //  -------------
    // |               |
    // |               |
    // |               |
    // |               |
    // | *             |
    //  -------------
    TOP_LAYER_BOTTOM_LEFT_CORNER,
    // The bottom view of the chip, the upper left corner of the top
    //  -------------
    // | *             |
    // |               |
    // |               |
    // |               |
    // |               |
    //  -------------
    BOTTOM_LAYER_TOP_LEFT_CORNER,
    // The bottom view of the chip, the upper right corner of the top
    //  -------------
    // |             * |
    // |               |
    // |               |
    // |               |
    // |               |
    //  -------------
    BOTTOM_LAYER_TOP_RIGHT_CORNER,
    // The bottom view of the chip, the lower right corner of the bottom
    //  -------------
    // |               |
    // |               |
    // |               |
    // |               |
    // |             * |
    //  -------------
    BOTTOM_LAYER_BOTTOM_RIGHT_CORNER,
    // Chip bottom view, bottom left corner
    //  -------------
    // |               |
    // |               |
    // |               |
    // |               |
    // | *             |
    //  -------------
    BOTTOM_LAYER_BOTTOM_LEFT_CORNER,
};
 
 
enum SensorDirection {
    //  ________________
    // |                |
    // |             *  |
    // |                |
    // |                |
    // |                |
    // |                |
    // |________________|
    DIRECTION_TOP_RIGHT,
 
    //  ________________
    // |                |
    // |  *             |
    // |                |
    // |                |
    // |                |
    // |                |
    // |________________|
    DIRECTION_TOP_LEFT,
 
    //  ________________
    // |                |
    // |                |
    // |                |
    // |                |
    // |                |
    // |  *             |
    // |________________|
    DIRECTION_BOTTOM_LEFT,
 
    //  ________________
    // |                |
    // |                |
    // |                |
    // |                |
    // |                |
    // |             *  |
    // |________________|
    DIRECTION_BOTTOM_RIGHT,
 
    //  ________________
    // |________________|
    //    *
    DIRECTION_BOTTOM,
 
    //  __*_____________
    // |________________|
    DIRECTION_TOP,
 
    // Unknown direction
    DIRECTION_UNKNOWN
};
 
enum class SensorType {
    UNKNOWN = 0,     
    ACCELEROMETER,   
    GYROSCOPE,       
    MAGNETOMETER,    
    PRESSURE,        
    TEMPERATURE,     
    HUMIDITY,        
    MULTI_AXIS       
};
 
struct SensorVector {
    float x;  
    float y;  
    float z;  
};
 
struct RawVector {
    int16_t x;  
    int16_t y;  
    int16_t z;  
};
 
enum class OperationMode {
    SUSPEND = 0,
    NORMAL,
    SINGLE_MEASUREMENT,
    CONTINUOUS_MEASUREMENT,
};
 
enum class AccelFullScaleRange {
    FS_2G = 0,   
    FS_4G,       
    FS_8G,       
    FS_16G,      
    FS_32G,      
    FS_64G,      
    FS_128G      
};
 
enum class InterruptPinMap {
    DISABLE = 0,  
    PIN1 = 1,     
    PIN2          
};
 
enum class TapEvent : uint8_t {
    INVALID = 0,
    SINGLE  = 1,
    DOUBLE  = 2,
};
 
 
enum class MagFullScaleRange {
    FS_2G = 0,      // ±2 Gauss
    FS_4G,          // ±4 Gauss
    FS_8G,          // ±8 Gauss
    FS_12G,         // ±12 Gauss
    FS_16G,         // ±16 Gauss
    FS_20G,         // ±20 Gauss
    FS_25G,         // ±25 Gauss
    FS_30G,         // ±30 Gauss
    FS_32G          // ±32 Gauss
};
 
enum class MagOverSampleRatio {
    OSR_8,   
    OSR_4,   
    OSR_2,   
    OSR_1    
};
 
enum class MagDownSampleRatio {
    DSR_1,   
    DSR_2,   
    DSR_4,   
    DSR_8,   
};
 
enum class MagLowPassFilter {
    LPF_1,  
    LPF_2,  
    LPF_4,  
    LPF_8,  
    LPF_16  
};
 
enum class GyroFullScaleRange {
    FS_125_DPS = 0,  
    FS_250_DPS,   
    FS_500_DPS,        
    FS_1000_DPS,       
    FS_2000_DPS,       
    FS_4000_DPS        
};
 
struct AccelerometerData {
    SensorVector mps2;       
    RawVector raw;           
    float temperature;       
 
    AccelerometerData() : mps2{0, 0, 0}, raw{0, 0, 0}, temperature{0} {}
};
 
struct MagnetometerData {
    SensorVector magnetic_field;  
    RawVector raw;                
    float temperature;            
    float heading;                
    float heading_degrees;        
    bool overflow;                
    bool skip_data;               
 
    MagnetometerData() : magnetic_field{0, 0, 0}, raw{0, 0, 0}, temperature{0}, heading{0}, heading_degrees{0}, overflow{false}, skip_data{false} {}
};
 
struct GyroscopeData {
    SensorVector dps;           
    RawVector    raw;           
    float        temperature;   
 
    GyroscopeData() : dps{0, 0, 0}, raw{0, 0, 0}, temperature{0} {}
};
 
struct SensorConfig {
 
    SensorType type;            
    float range;                
    float sample_rate;          
    uint32_t latency;           
    OperationMode mode;         
    SensorConfig() : type(SensorType::UNKNOWN), range(0), sample_rate(0), latency(0), mode(OperationMode::SUSPEND) {}
 
    SensorConfig(SensorType type, float range, float sample_rate, uint32_t latency, OperationMode mode)
        : type(type), range(range), sample_rate(sample_rate), latency(latency), mode(mode) {}
};
 
struct SensorInfo {
    const char *manufacturer;       
    const char *model;              
    uint8_t i2c_address;            
    uint8_t version;                
    uint32_t uid;                   
    SensorType type;                
 
    SensorInfo() : manufacturer("Unknown"), model("Unknown"), i2c_address(0), version(0), uid(0), type(SensorType::UNKNOWN) {}
};