unit_SHT30.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_ENV_UNIT_SHT30_HPP
#define M5_UNIT_ENV_UNIT_SHT30_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
 
namespace m5 {
namespace unit {
 
namespace sht30 {
enum class Repeatability : uint8_t {
    High,    
    Medium,  
    Low      
};
 
enum class MPS : uint8_t {
    Half,  
    One,   
    Two,   
    Four,  
    Ten,   
};
 
struct Status {
    inline bool alertPending() const
    {
        return value & (1U << 15);
    }
    inline bool heater() const
    {
        return value & (1U << 13);
    }
    inline bool trackingAlertRH() const
    {
        return value & (1U << 11);
    }
    inline bool trackingAlert() const
    {
        return value & (1U << 10);
    }
    inline bool reset() const
    {
        return value & (1U << 4);
    }
    inline bool command() const
    {
        return value & (1U << 1);
    }
    inline bool checksum() const
    {
        return value & (1U << 0);
    }
    uint16_t value{};
};
 
struct Data {
    std::array<uint8_t, 6> raw{};  
    inline float temperature() const
    {
        return celsius();
    }
    float celsius() const;     
    float fahrenheit() const;  
    float humidity() const;    
};
 
}  // namespace sht30
 
class UnitSHT30 : public Component, public PeriodicMeasurementAdapter<UnitSHT30, sht30::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitSHT30, 0x44);
 
public:
    struct config_t {
        bool start_periodic{true};
        sht30::MPS mps{sht30::MPS::One};
        sht30::Repeatability repeatability{sht30::Repeatability::High};
        bool start_heater{false};
    };
 
    explicit UnitSHT30(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<sht30::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitSHT30()
    {
    }
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
 
    inline config_t config()
    {
        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 humidity() const
    {
        return !empty() ? oldest().humidity() : std::numeric_limits<float>::quiet_NaN();
    }
 
 
    inline bool startPeriodicMeasurement(const sht30::MPS mps, const sht30::Repeatability rep)
    {
        return PeriodicMeasurementAdapter<UnitSHT30, sht30::Data>::startPeriodicMeasurement(mps, rep);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitSHT30, sht30::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(sht30::Data& d, const sht30::Repeatability rep = sht30::Repeatability::High,
                           const bool stretch = true);
 
    bool writeModeAccelerateResponseTime();
 
 
    bool softReset();
    bool generalReset();
 
 
    bool startHeater();
    bool stopHeater();
 
 
    bool readStatus(sht30::Status& s);
    bool clearStatus();
 
 
    bool readSerialNumber(uint32_t& serialNumber);
    bool readSerialNumber(char* serialNumber);
 
protected:
    bool start_periodic_measurement(const sht30::MPS mps, const sht30::Repeatability rep);
    bool stop_periodic_measurement();
    bool read_measurement(sht30::Data& d);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitSHT30, sht30::Data);
 
protected:
    std::unique_ptr<m5::container::CircularBuffer<sht30::Data>> _data{};
    config_t _cfg{};
};
 
namespace sht30 {
namespace command {
// Measurement Commands for Single Shot Data Acquisition Mode
constexpr uint16_t SINGLE_SHOT_ENABLE_STRETCH_HIGH{0x2C06};
constexpr uint16_t SINGLE_SHOT_ENABLE_STRETCH_MEDIUM{0x2C0D};
constexpr uint16_t SINGLE_SHOT_ENABLE_STRETCH_LOW{0x2C10};
constexpr uint16_t SINGLE_SHOT_DISABLE_STRETCH_HIGH{0x2400};
constexpr uint16_t SINGLE_SHOT_DISABLE_STRETCH_MEDIUM{0x240B};
constexpr uint16_t SINGLE_SHOT_DISABLE_STRETCH_LOW{0x2416};
// Measurement Commands for Periodic Data Acquisition Mode
constexpr uint16_t START_PERIODIC_MPS_HALF_HIGH{0x2032};
constexpr uint16_t START_PERIODIC_MPS_HALF_MEDIUM{0x2024};
constexpr uint16_t START_PERIODIC_MPS_HALF_LOW{0x202f};
 
constexpr uint16_t START_PERIODIC_MPS_1_HIGH{0x2130};
constexpr uint16_t START_PERIODIC_MPS_1_MEDIUM{0x2126};
constexpr uint16_t START_PERIODIC_MPS_1_LOW{0x212D};
 
constexpr uint16_t START_PERIODIC_MPS_2_HIGH{0x2236};
constexpr uint16_t START_PERIODIC_MPS_2_MEDIUM{0x2220};
constexpr uint16_t START_PERIODIC_MPS_2_LOW{0x222B};
 
constexpr uint16_t START_PERIODIC_MPS_4_HIGH{0x2334};
constexpr uint16_t START_PERIODIC_MPS_4_MEDIUM{0x2322};
constexpr uint16_t START_PERIODIC_MPS_4_LOW{0x2329};
 
constexpr uint16_t START_PERIODIC_MPS_10_HIGH{0x2737};
constexpr uint16_t START_PERIODIC_MPS_10_MEDIUM{0x2721};
constexpr uint16_t START_PERIODIC_MPS_10_LOW{0x272A};
 
constexpr uint16_t STOP_PERIODIC_MEASUREMENT{0x3093};
constexpr uint16_t ACCELERATED_RESPONSE_TIME{0x2B32};
constexpr uint16_t READ_MEASUREMENT{0xE000};
// Reset
constexpr uint16_t SOFT_RESET{0x30A2};
// Heater
constexpr uint16_t START_HEATER{0x306D};
constexpr uint16_t STOP_HEATER{0x3066};
// Status
constexpr uint16_t READ_STATUS{0xF32D};
constexpr uint16_t CLEAR_STATUS{0x3041};
// Serial
constexpr uint16_t GET_SERIAL_NUMBER_ENABLE_STRETCH{0x3780};
constexpr uint16_t GET_SERIAL_NUMBER_DISABLE_STRETCH{0x3682};
}  // namespace command
}  // namespace sht30
 
}  // namespace unit
}  // namespace m5
#endif