unit_SHT20.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_ENV_UNIT_SHT20_HPP
#define M5_UNIT_ENV_UNIT_SHT20_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
 
namespace m5 {
namespace unit {
 
namespace sht20 {
 
enum class Resolution : uint8_t {
    RH12_T14 = 0x00,  
    RH8_T12  = 0x01,  
    RH10_T13 = 0x80,  
    RH11_T11 = 0x81,  
};
 
struct Data {
    std::array<uint8_t, 6> raw{};  
    inline float temperature() const
    {
        return celsius();
    }
    float celsius() const;     
    float fahrenheit() const;  
    float humidity() const;    
};
 
}  // namespace sht20
 
class UnitSHT20 : public Component, public PeriodicMeasurementAdapter<UnitSHT20, sht20::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitSHT20, 0x40);
 
public:
    struct config_t {
        bool start_periodic{true};
        sht20::Resolution resolution{sht20::Resolution::RH12_T14};
        bool start_heater{false};
        uint32_t periodic_interval{1000};
    };
 
    explicit UnitSHT20(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<sht20::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitSHT20()
    {
    }
 
    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 humidity() const
    {
        return !empty() ? oldest().humidity() : std::numeric_limits<float>::quiet_NaN();
    }
 
 
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitSHT20, sht20::Data>::startPeriodicMeasurement();
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitSHT20, sht20::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(sht20::Data& d);
 
 
    bool readResolution(sht20::Resolution& res);
    bool writeResolution(const sht20::Resolution res);
 
 
    bool startHeater();
    bool stopHeater();
 
 
    bool softReset();
 
protected:
    bool start_periodic_measurement();
    bool stop_periodic_measurement();
    bool read_measurement(sht20::Data& d);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitSHT20, sht20::Data);
 
protected:
    std::unique_ptr<m5::container::CircularBuffer<sht20::Data>> _data{};
    config_t _cfg{};
 
private:
    bool read_user_register(uint8_t& reg);
    bool write_user_register(const uint8_t reg);
    bool trigger_measurement(const uint8_t cmd, uint16_t& raw);
};
 
namespace sht20 {
namespace command {
constexpr uint8_t TRIGGER_TEMP_HOLD{0xE3};
constexpr uint8_t TRIGGER_HUMD_HOLD{0xE5};
constexpr uint8_t TRIGGER_TEMP_NOHOLD{0xF3};
constexpr uint8_t TRIGGER_HUMD_NOHOLD{0xF5};
constexpr uint8_t WRITE_USER_REG{0xE6};
constexpr uint8_t READ_USER_REG{0xE7};
constexpr uint8_t SOFT_RESET{0xFE};
 
constexpr uint8_t REG_RESOLUTION_MASK{0x81};
constexpr uint8_t REG_HEATER_BIT{0x04};
}  // namespace command
}  // namespace sht20
 
}  // namespace unit
}  // namespace m5
#endif