unit_BMP280.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_ENV_UNIT_BMP280_HPP
#define M5_UNIT_ENV_UNIT_BMP280_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
 
namespace m5 {
namespace unit {
 
namespace bmp280 {
 
enum class PowerMode : uint8_t {
    Sleep,          
    Forced,         
    Normal = 0x03,  
};
 
enum class Oversampling : uint8_t {
    Skipped,  
    X1,       
    X2,       
    X4,       
    X8,       
    X16,      
};
 
enum class OversamplingSetting : uint8_t {
    UltraLowPower,        
    LowPower,             
    StandardResolution,   
    HighResolution,       
    UltraHighResolution,  
};
 
enum class Filter : uint8_t {
    Off,      
    Coeff2,   
    Coeff4,   
    Coeff8,   
    Coeff16,  
};
 
enum class Standby : uint8_t {
    Time0_5ms,   
    Time62_5ms,  
    Time125ms,   
    Time250ms,   
    Time500ms,   
    Time1sec,    
    Time2sec,    
    Time4sec,    
};
 
enum class UseCase : uint8_t {
    LowPower,  
    Dynamic,   
    Weather,   
    Elevator,  
    Drop,      
    Indoor,    
};
 
union Trimming {
    uint8_t value[12 * 2]{};
    struct {
        //
        uint16_t dig_T1;
        int16_t dig_T2;
        int16_t dig_T3;
        //
        uint16_t dig_P1;
        int16_t dig_P2;
        int16_t dig_P3;
        int16_t dig_P4;
        int16_t dig_P5;
        int16_t dig_P6;
        int16_t dig_P7;
        int16_t dig_P8;
        int16_t dig_P9;
        // uint16_t reserved;
    } __attribute__((packed));
};
 
struct Data {
    std::array<uint8_t, 6> raw{};  
    const Trimming* trimming{};    
 
    inline float temperature() const
    {
        return celsius();
    }
    float celsius() const;     
    float fahrenheit() const;  
    float pressure() const;    
};
 
}  // namespace bmp280
 
class UnitBMP280 : public Component, public PeriodicMeasurementAdapter<UnitBMP280, bmp280::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitBMP280, 0x76);
 
public:
    struct config_t {
        bool start_periodic{true};
        bmp280::Oversampling osrs_pressure{bmp280::Oversampling::X16};
        bmp280::Oversampling osrs_temperature{bmp280::Oversampling::X2};
        bmp280::Filter filter{bmp280::Filter::Coeff16};
        bmp280::Standby standby{bmp280::Standby::Time1sec};
    };
 
    explicit UnitBMP280(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<bmp280::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitBMP280()
    {
    }
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
 
    inline config_t config() const
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    inline float temperature() const
    {
        return !empty() ? oldest().temperature() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float celsius() const
    {
        return !empty() ? oldest().celsius() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float fahrenheit() const
    {
        return !empty() ? oldest().fahrenheit() : std::numeric_limits<float>::quiet_NaN();
    }
    inline float pressure() const
    {
        return !empty() ? oldest().pressure() : std::numeric_limits<float>::quiet_NaN();
    }
 
 
    inline bool startPeriodicMeasurement(const bmp280::Oversampling osrsPressure,
                                         const bmp280::Oversampling osrsTemperature, const bmp280::Filter filter,
                                         const bmp280::Standby st)
    {
        return PeriodicMeasurementAdapter<UnitBMP280, bmp280::Data>::startPeriodicMeasurement(
            osrsPressure, osrsTemperature, filter, st);
    }
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitBMP280, bmp280::Data>::startPeriodicMeasurement();
    }
 
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitBMP280, bmp280::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(bmp280::Data& d, const bmp280::Oversampling osrsPressure,
                           const bmp280::Oversampling osrsTemperature, const bmp280::Filter filter);
    inline bool measureSingleshot(bmp280::Data& d)
    {
        return measure_singleshot(d);
    }
 
 
    bool readOversampling(bmp280::Oversampling& osrsPressure, bmp280::Oversampling& osrsTemperature);
    bool writeOversampling(const bmp280::Oversampling osrsPressure, const bmp280::Oversampling osrsTemperature);
    bool writeOversamplingPressure(const bmp280::Oversampling osrsPressure);
    bool writeOversamplingTemperature(const bmp280::Oversampling osrsTemperature);
    bool writeOversampling(const bmp280::OversamplingSetting osrss);
    bool readFilter(bmp280::Filter& f);
    bool writeFilter(const bmp280::Filter& f);
    bool readStandbyTime(bmp280::Standby& s);
    bool writeStandbyTime(const bmp280::Standby s);
    bool readPowerMode(bmp280::PowerMode& m);
    bool writePowerMode(const bmp280::PowerMode m);
    bool writeUseCaseSetting(const bmp280::UseCase uc);
 
    bool softReset();
 
protected:
    bool start_periodic_measurement(const bmp280::Oversampling osrsPressure, const bmp280::Oversampling osrsTemperature,
                                    const bmp280::Filter filter, const bmp280::Standby st);
    bool start_periodic_measurement();
    bool stop_periodic_measurement();
    bool read_measurement(bmp280::Data& d);
    bool measure_singleshot(bmp280::Data& d);
 
    bool read_trimming(bmp280::Trimming& t);
    bool is_data_ready();
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitBMP280, bmp280::Data);
 
protected:
    std::unique_ptr<m5::container::CircularBuffer<bmp280::Data>> _data{};
    config_t _cfg{};
    bmp280::Trimming _trimming{};
};
 
namespace bmp280 {
namespace command {
 
constexpr uint8_t CHIP_ID{0xD0};
// constexpr uint8_t CHIP_VERSION{0xD1};
constexpr uint8_t SOFT_RESET{0xE0};
constexpr uint8_t GET_STATUS{0xF3};
constexpr uint8_t CONTROL_MEASUREMENT{0xF4};
constexpr uint8_t CONFIG{0xF5};
 
constexpr uint8_t GET_MEASUREMENT{0xF7};       // 6bytes
constexpr uint8_t GET_PRESSURE{0xF7};          // 3bytes
constexpr uint8_t GET_PRESSURE_MSB{0xF7};      // 7:0
constexpr uint8_t GET_PRESSURE_LSB{0xF8};      // 7:0
constexpr uint8_t GET_PRESSURE_XLSB{0xF9};     // 7:4
constexpr uint8_t GET_TEMPERATURE{0xFA};       // 3 bytes
constexpr uint8_t GET_TEMPERATURE_MSB{0xFA};   // 7:0
constexpr uint8_t GET_TEMPERATURE_LSB{0xFB};   // 7:0
constexpr uint8_t GET_TEMPERATURE_XLSB{0xFC};  // 7:4
 
constexpr uint8_t TRIMMING_DIG{0x88};  // 12 bytes
constexpr uint8_t TRIMMING_DIG_T1{0x88};
constexpr uint8_t TRIMMING_DIG_T2{0x8A};
constexpr uint8_t TRIMMING_DIG_T3{0x8C};
constexpr uint8_t TRIMMING_DIG_P1{0x8E};
constexpr uint8_t TRIMMING_DIG_P2{0x90};
constexpr uint8_t TRIMMING_DIG_P3{0x92};
constexpr uint8_t TRIMMING_DIG_P4{0x94};
constexpr uint8_t TRIMMING_DIG_P5{0x96};
constexpr uint8_t TRIMMING_DIG_P6{0x98};
constexpr uint8_t TRIMMING_DIG_P7{0x9A};
constexpr uint8_t TRIMMING_DIG_P8{0x9C};
constexpr uint8_t TRIMMING_DIG_P9{0x9E};
constexpr uint8_t TRIMMING_DIG_RESERVED{0xA0};
 
}  // namespace command
}  // namespace bmp280
 
}  // namespace unit
}  // namespace m5
 
#endif