unit_STHS34PF80.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_INFRARED_UNIT_STHS34PF80_HPP
#define M5_UNIT_INFRARED_UNIT_STHS34PF80_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
#include <array>
 
namespace m5 {
namespace unit {
 
namespace sths34pf80 {
 
enum class LowPassFilter : uint8_t {
    ODR9,    
    ODR20,   
    ODR50,   
    ODR100,  
    ODR200,  
    ODR400,  
    ODR800,  
};
 
enum class AmbientTemperatureAverage : uint8_t {
    Samples8,  
    Samples4,  
    Samples2,  
    Samples1,  
};
 
enum class ObjectTemperatureAverage : uint8_t {
    Samples2,     
    Samples8,     
    Samples32,    
    Samples128,   
    Samples256,   
    Samples512,   
    Samples1024,  
    Samples2048,  
};
 
enum class Gain : uint8_t {
    Wide,            
    Default = 0x07,  
};
 
enum class ODR : uint8_t {
    PowerDown,  
    Rate0_25,   
    Rate0_5,    
    Rate1,      
    Rate2,      
    Rate4,      
    Rate8,      
    Rate15,     
    Rate30,     
};
 
struct Data {
    static constexpr uint8_t PRES_FLAG{0x04};        
    static constexpr uint8_t MOT_FLAG{0x02};         
    static constexpr uint8_t TAMB_SHOCK_FLAG{0x01};  
 
    std::array<uint8_t, 13> raw{};
    uint16_t sensitivity{};  
 
    inline int16_t object() const
    {
        return static_cast<int16_t>((raw[1] << 8) | raw[0]);
    }
    inline float objectTemperature() const
    {
        return sensitivity ? object() / static_cast<float>(sensitivity) : std::numeric_limits<float>::quiet_NaN();
    }
    inline int16_t ambient() const
    {
        return static_cast<int16_t>((raw[3] << 8) | raw[2]);
    }
    inline float ambientTemperature() const
    {
        // It is possible without sensitivity, but the absence of sensitivity is an error
        return sensitivity ? ambient() / 100.f /* Fixed value */ : std::numeric_limits<float>::quiet_NaN();
    }
    inline int16_t compensated_object() const
    {
        return static_cast<int16_t>((raw[5] << 8) | raw[4]);
    }
    inline float compensatedObjectTemperature() const
    {
        return sensitivity ? compensated_object() / static_cast<float>(sensitivity)
                           : std::numeric_limits<float>::quiet_NaN();
    }
    inline int16_t presence() const
    {
        return static_cast<int16_t>((raw[7] << 8) | raw[6]);
    }
    inline int16_t motion() const
    {
        return static_cast<int16_t>((raw[9] << 8) | raw[8]);
    }
    inline int16_t ambient_shock() const
    {
        return static_cast<int16_t>((raw[11] << 8) | raw[10]);
    }
    inline bool isPresence() const
    {
        return raw[12] & PRES_FLAG;
    }
    inline bool isMotion() const
    {
        return raw[12] & MOT_FLAG;
    }
    inline bool isAmbientShock() const
    {
        return raw[12] & TAMB_SHOCK_FLAG;
    }
};
}  // namespace sths34pf80
 
class UnitSTHS34PF80 : public Component, public PeriodicMeasurementAdapter<UnitSTHS34PF80, sths34pf80::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitSTHS34PF80, 0x5A);
 
public:
    static sths34pf80::ODR maximum_odr(const sths34pf80::ObjectTemperatureAverage avg_tmos);
 
    struct config_t {
        bool start_periodic{true};
        sths34pf80::Gain mode{sths34pf80::Gain::Default};
        sths34pf80::ODR odr{sths34pf80::ODR::Rate30};
        bool comp_type{true};
        bool abs{false};
        sths34pf80::AmbientTemperatureAverage avg_t{sths34pf80::AmbientTemperatureAverage::Samples8};
        sths34pf80::ObjectTemperatureAverage avg_tmos{sths34pf80::ObjectTemperatureAverage::Samples32};
    };
 
    explicit UnitSTHS34PF80(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<sths34pf80::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitSTHS34PF80()
    {
    }
 
    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;
    }
 
 
    uint16_t sensitivity() const
    {
        return _sensitivity;
    }
 
    inline int16_t object() const
    {
        return !empty() ? oldest().object() : 0;
    }
    inline float objectTemperature() const
    {
        return !empty() ? oldest().objectTemperature() : std::numeric_limits<float>::quiet_NaN();
    }
    inline int16_t ambient() const
    {
        return !empty() ? oldest().ambient() : 0;
    }
    inline float ambientTemperature() const
    {
        return !empty() ? oldest().ambientTemperature() : std::numeric_limits<float>::quiet_NaN();
    }
    inline int16_t compensated_object() const
    {
        return !empty() ? oldest().compensated_object() : 0;
    }
    inline float compensatedObjectTemperature() const
    {
        return !empty() ? oldest().compensatedObjectTemperature() : std::numeric_limits<float>::quiet_NaN();
    }
    inline int16_t presence() const
    {
        return !empty() ? oldest().presence() : 0;
    }
    inline int16_t motion() const
    {
        return !empty() ? oldest().motion() : 0;
    }
    inline int16_t ambient_shock() const
    {
        return !empty() ? oldest().ambient_shock() : 0;
    }
    inline bool isPresence() const
    {
        return !empty() ? oldest().isPresence() : false;
    }
    inline bool isMotion() const
    {
        return !empty() ? oldest().isMotion() : false;
    }
    inline bool isAmbientShock() const
    {
        return !empty() ? oldest().isAmbientShock() : false;
    }
 
 
    inline bool startPeriodicMeasurement(const sths34pf80::Gain mode, const sths34pf80::ODR odr,
                                         const bool comp_type = true, const bool abs = false)
    {
        return PeriodicMeasurementAdapter<UnitSTHS34PF80, sths34pf80::Data>::startPeriodicMeasurement(mode, odr,
                                                                                                      comp_type, abs);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitSTHS34PF80, sths34pf80::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(sths34pf80::Data& data, const sths34pf80::AmbientTemperatureAverage avg_t,
                           const sths34pf80::ObjectTemperatureAverage avg_tmos);
 
 
    bool readAverageTrim(sths34pf80::AmbientTemperatureAverage& avg_t, sths34pf80::ObjectTemperatureAverage& avg_tmos);
    bool writeAverageTrim(const sths34pf80::AmbientTemperatureAverage avg_t,
                          const sths34pf80::ObjectTemperatureAverage avg_tmos);
 
    bool readGainMode(sths34pf80::Gain& mode);
    bool writeGainMode(const sths34pf80::Gain mode);
 
    bool readSensitivityRaw(int8_t& raw);
    bool readSensitivity(uint16_t& value);
    bool writeSensitivityRaw(const int8_t raw);
    bool writeSensitivity(const uint16_t value);
 
    bool readObjectDataRate(sths34pf80::ODR& odr);
 
 
    bool resetAlgorithm();
 
    bool readLowPassFilter(sths34pf80::LowPassFilter& lpf_p_m, sths34pf80::LowPassFilter& lpf_m,
                           sths34pf80::LowPassFilter& lpf_p, sths34pf80::LowPassFilter& lpf_a_t);
    bool writeLowPassFilter(const sths34pf80::LowPassFilter lpf_p_m, const sths34pf80::LowPassFilter lpf_m,
                            const sths34pf80::LowPassFilter lpf_p, const sths34pf80::LowPassFilter lpf_a_t);
 
    bool readPresenceThreshold(uint16_t& thres);
    bool writePresenceThreshold(const uint16_t thres);
    bool readMotionThreshold(uint16_t& thres);
    bool writeMotionThreshold(const uint16_t thres);
    bool readAmbientShockThreshold(uint16_t& thres);
    bool writeAmbientShockThreshold(const uint16_t thres);
 
    bool readPresenceHysteresis(uint8_t& hyst);
    bool writePresenceHysteresis(const uint8_t hyst);
    bool readMotionHysteresis(uint8_t& hyst);
    bool writeMotionHysteresis(const uint8_t hyst);
    bool readAmbientShockHysteresis(uint8_t& hyst);
    bool writeAmbientShockHysteresis(const uint8_t hyst);
 
    bool readAlgorithmConfig(uint8_t& v);
 
    bool softReset();
 
protected:
    bool read_embedded_register(const uint8_t ereg, uint8_t* rbuf, const uint32_t len);
    bool write_embedded_register(const uint8_t ereg, const uint8_t* buf, const uint32_t len);
    inline bool read_embedded_register8(const uint8_t ereg, uint8_t& v)
    {
        return read_embedded_register(ereg, &v, 1);
    }
    inline bool write_embedded_register8(const uint8_t ereg, const uint8_t v)
    {
        return write_embedded_register(ereg, &v, 1);
    }
    bool read_embedded_register16LE(const uint8_t ereg, uint16_t& v)
    {
        uint8_t rbuf[2]{};
        if (read_embedded_register(ereg, rbuf, 2)) {
            v = rbuf[0] | (rbuf[1] << 8);
            return true;
        }
        return false;
    }
    bool write_embedded_register16LE(const uint8_t ereg, const uint16_t v)
    {
        uint8_t buf[2]{};
        buf[0] = v & 0xFF;
        buf[1] = (v >> 8) & 0xFF;
        return write_embedded_register(ereg, buf, 2);
    }
 
    bool start_periodic_measurement();
    bool start_periodic_measurement(const sths34pf80::Gain mode, const sths34pf80::ODR odr, const bool comp_type,
                                    const bool abs);
    bool stop_periodic_measurement();
 
    bool write_odr(const sths34pf80::ODR odr);
    bool write_algorithm_config(const uint8_t v);
 
    bool is_data_ready();
    bool read_measurement(sths34pf80::Data& d, const bool full = true);
 
    bool guard_in_periodic(const char* fname);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitSTHS34PF80, sths34pf80::Data);
 
private:
    std::unique_ptr<m5::container::CircularBuffer<sths34pf80::Data>> _data{};
    uint16_t _sensitivity{};
    config_t _cfg{};
};
 
namespace sths34pf80 {
namespace command {
constexpr uint8_t LPF1_REG{0x0C};         // R/W
constexpr uint8_t LPF2_REG{0x0D};         // R/W
constexpr uint8_t WHO_AM_I_REG{0x0F};     // R
constexpr uint8_t AVG_TRIM_REG{0x10};     // R/W
constexpr uint8_t CTRL0_REG{0x17};        // R/W
constexpr uint8_t SENS_DATA_REG{0x1D};    // R/W
constexpr uint8_t CTRL1_REG{0x20};        // R/W
constexpr uint8_t CTRL2_REG{0x21};        // R/W
constexpr uint8_t CTRL3_REG{0x22};        // R/W
constexpr uint8_t STATUS_REG{0x23};       // R
constexpr uint8_t FUNC_STATUS_REG{0x25};  // R
 
constexpr uint8_t TOBJECT_L_REG{0x26};     // R
constexpr uint8_t TOBJECT_H_REG{0x27};     // R
constexpr uint8_t TAMBIENT_L_REG{0x28};    // R
constexpr uint8_t TAMBIENT_H_REG{0x29};    // R
constexpr uint8_t TOBJ_COMP_L_REG{0x38};   // R
constexpr uint8_t TOBJ_COMP_H_REG{0x39};   // R
constexpr uint8_t TPRESENCE_L_REG{0x3A};   // R
constexpr uint8_t TPRESENCE_H_REG{0x3B};   // R
constexpr uint8_t TMOTION_L_REG{0x3C};     // R
constexpr uint8_t TMOTION_H_REG{0x3D};     // R
constexpr uint8_t TAMB_SHOCK_L_REG{0x3E};  // R
constexpr uint8_t TAMB_SHOCK_H_REG{0x3F};  // R
 
// Embedded functions
constexpr uint8_t FUNC_CFG_ADDR_REG{0x08};
constexpr uint8_t FUNC_CFG_DATA_REG{0x09};
constexpr uint8_t PAGE_RW_REG{0x11};
 
constexpr uint8_t PRESENCE_THS_REG{0x20};
constexpr uint8_t MOTION_THS_REG{0x22};
constexpr uint8_t TAMB_SHOCK_THS_REG{0x24};
constexpr uint8_t HYST_MOTION_REG{0x26};
constexpr uint8_t HYST_PRESENCE_REG{0x27};
constexpr uint8_t ALGO_CONFIG_REG{0x28};
constexpr uint8_t HYST_TAMB_SHOCK_REG{0x29};
constexpr uint8_t RESET_ALGO_REG{0x2A};
 
}  // namespace command
}  // namespace sths34pf80
 
}  // namespace unit
}  // namespace m5
#endif