unit_QMP6988.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_ENV_UNIT_QMP6988_HPP
#define M5_UNIT_ENV_UNIT_QMP6988_HPP
#include <M5UnitComponent.hpp>
#include <m5_utility/stl/extension.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
 
namespace m5 {
namespace unit {
 
namespace qmp6988 {
 
enum class PowerMode : uint8_t {
    Sleep,          
    Forced,         
    Normal = 0x03,  
};
 
enum class Oversampling : uint8_t {
    Skipped,  
    X1,       
    X2,       
    X4,       
    X8,       
    X16,      
    X32,      
    X64,      
};
 
enum class OversamplingSetting : uint8_t {
    HighSpeed,          
    LowPower,           
    Standard,           
    HighAccuracy,       
    UltraHighAccuracy,  
    UltraHightAccuracy [[deprecated("Use UltraHighAccuracy")]] = UltraHighAccuracy,
};
 
enum class Filter : uint8_t {
    Off,      
    Coeff2,   
    Coeff4,   
    Coeff8,   
    Coeff16,  
    Coeff32,  
};
 
enum class Standby : uint8_t {
    Time1ms,    
    Time5ms,    
    Time50ms,   
    Time250ms,  
    Time500ms,  
    Time1sec,   
    Time2sec,   
    Time4sec,   
};
 
enum class UseCase : uint8_t {
    Weather,   
    Drop,      
    Elevator,  
    Stair,     
    Indoor,    
};
 
struct Calibration {
    int32_t b00{}, bt1{}, bp1{};
    int64_t bt2{};
    int32_t b11{}, bp2{}, b12{}, b21{}, bp3{}, a0{}, a1{}, a2{};
};
 
struct Data {
    std::array<uint8_t, 6> raw{};  
    inline float temperature() const
    {
        return celsius();
    }
    float celsius() const;     
    float fahrenheit() const;  
    float pressure() const;    
    const Calibration* calib{};
};
 
}  // namespace qmp6988
 
class UnitQMP6988 : public Component, public PeriodicMeasurementAdapter<UnitQMP6988, qmp6988::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitQMP6988, 0x70);
 
public:
    struct config_t {
        bool start_periodic{true};
        qmp6988::Oversampling osrs_pressure{qmp6988::Oversampling::X8};
        qmp6988::Oversampling osrs_temperature{qmp6988::Oversampling::X1};
        qmp6988::Filter filter{qmp6988::Filter::Coeff4};
        qmp6988::Standby standby{qmp6988::Standby::Time1sec};
    };
 
    explicit UnitQMP6988(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<qmp6988::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 100 * 1000U;
        // QMP6988 datasheet: if bus >400 kbit/s and shared, wait >=1 ms before access
        component_config(ccfg);
    }
    virtual ~UnitQMP6988()
    {
    }
 
    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 qmp6988::Oversampling osrsPressure,
                                         const qmp6988::Oversampling osrsTemperature, const qmp6988::Filter f,
                                         const qmp6988::Standby st)
    {
        return PeriodicMeasurementAdapter<UnitQMP6988, qmp6988::Data>::startPeriodicMeasurement(osrsPressure,
                                                                                                osrsTemperature, f, st);
    }
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitQMP6988, qmp6988::Data>::startPeriodicMeasurement();
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitQMP6988, qmp6988::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(qmp6988::Data& d, const qmp6988::Oversampling osrsPressure,
                           const qmp6988::Oversampling osrsTemperature, const qmp6988::Filter f);
    bool measureSingleshot(qmp6988::Data& d);
 
 
    bool readOversampling(qmp6988::Oversampling& osrsPressure, qmp6988::Oversampling& osrsTemperature);
    bool writeOversampling(const qmp6988::Oversampling osrsPressure, const qmp6988::Oversampling osrsTemperature);
    bool writeOversamplingPressure(const qmp6988::Oversampling osrsPressure);
    bool writeOversamplingTemperature(const qmp6988::Oversampling osrsTemperature);
    bool writeOversampling(const qmp6988::OversamplingSetting osrss);
    bool readFilter(qmp6988::Filter& f);
    bool writeFilter(const qmp6988::Filter f);
    bool readStandbyTime(qmp6988::Standby& st);
    bool writeStandbyTime(const qmp6988::Standby st);
    bool readPowerMode(qmp6988::PowerMode& mode);
    bool writePowerMode(const qmp6988::PowerMode mode);
    bool writeUseCaseSetting(const qmp6988::UseCase uc);
 
    bool softReset();
 
protected:
    bool start_periodic_measurement();
    bool start_periodic_measurement(const qmp6988::Oversampling ost, const qmp6988::Oversampling osp,
                                    const qmp6988::Filter f, const qmp6988::Standby st);
    bool stop_periodic_measurement();
 
    bool read_calibration(qmp6988::Calibration& c);
 
    bool read_measurement(qmp6988::Data& d, const bool only_temperature = false);
    bool is_data_ready();
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitQMP6988, qmp6988::Data);
 
protected:
    std::unique_ptr<m5::container::CircularBuffer<qmp6988::Data>> _data{};
    qmp6988::Calibration _calibration{};
    config_t _cfg{};
    bool _only_temperature{};
};
 
namespace qmp6988 {
namespace command {
 
constexpr uint8_t CHIP_ID{0xD1};
 
constexpr uint8_t READ_PRESSURE{0xF7};     // ~ F9 3bytes
constexpr uint8_t READ_TEMPERATURE{0xFA};  // ~ FC 3bytes
 
constexpr uint8_t IO_SETUP{0xF5};
constexpr uint8_t CONTROL_MEASUREMENT{0xF4};
constexpr uint8_t GET_STATUS{0xF3};
constexpr uint8_t IIR_FILTER{0xF1};
 
constexpr uint8_t SOFT_RESET{0xE0};
 
constexpr uint8_t READ_COMPENSATION_COEFFICIENT{0xA0};  // ~ 0xB8 25 bytes
 
}  // namespace command
}  // namespace qmp6988
 
}  // namespace unit
}  // namespace m5
#endif