unit_Thermal2.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_THERMO_UNIT_THERMAL2_HPP
#define M5_UNIT_THERMO_UNIT_THERMAL2_HPP
#include "unit_Thermal2_data.hpp"
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
 
namespace m5 {
namespace unit {
 
class UnitThermal2 : public Component, public PeriodicMeasurementAdapter<UnitThermal2, thermal2::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitThermal2, 0x32);
 
public:
    struct config_t {
        bool start_periodic{true};
        thermal2::Refresh rate{thermal2::Refresh::Rate16Hz};
        uint8_t monitor_width{15};
        uint8_t monitor_height{11};
        uint8_t function_control{thermal2::enabled_function_led};
        uint32_t button_interval{20};
    };
 
    explicit UnitThermal2(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<thermal2::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitThermal2()
    {
    }
 
    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 bool startPeriodicMeasurement(const thermal2::Refresh rate)
    {
        return PeriodicMeasurementAdapter<UnitThermal2, thermal2::Data>::startPeriodicMeasurement(rate);
    }
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitThermal2, thermal2::Data>::startPeriodicMeasurement();
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitThermal2, thermal2::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(thermal2::Data& page0, thermal2::Data& page1);
 
 
    bool readFunctionControl(uint8_t& value);
    inline bool readBuzzerEnabled(bool& enabled)
    {
        return read_function_control_bit(thermal2::enabled_function_buzzer, enabled);
    }
    inline bool readLEDEnabled(bool& enabled)
    {
        return read_function_control_bit(thermal2::enabled_function_led, enabled);
    }
    bool writeFunctionControl(const uint8_t value, const bool verify = true);
    inline bool writeBuzzerEnabled(const bool enabled)
    {
        return write_function_control_bit(thermal2::enabled_function_buzzer, enabled);
    }
    inline bool writeLEDEnabled(const bool enabled)
    {
        return write_function_control_bit(thermal2::enabled_function_led, enabled);
    }
 
    bool readRefreshRate(thermal2::Refresh& rate);
    bool writeRefreshRate(const thermal2::Refresh rate);
 
    bool readNoiseFilterLevel(uint8_t& level);
    bool writeNoiseFilterLevel(const uint8_t level);
 
    bool readTemperatureMonitorSize(uint8_t& wid, uint8_t& hgt);
    bool writeTemperatureMonitorSize(const uint8_t wid, const uint8_t hgt);
 
    [[deprecated("Use readTemperatureMonitorSize")]] inline bool readTemeratureMonitorSize(uint8_t& wid, uint8_t& hgt)
    {
        return readTemperatureMonitorSize(wid, hgt);
    }
    [[deprecated("Use writeTemperatureMonitorSize")]] inline bool writeTemeratureMonitorSize(const uint8_t wid,
                                                                                             const uint8_t hgt)
    {
        return writeTemperatureMonitorSize(wid, hgt);
    }
 
 
    bool readAlarmEnabled(uint8_t& enabled_bits);
    bool writeAlarmEnabled(const uint8_t enabled_bits);
 
    bool readAlarmTemperature(const bool highlow, uint16_t& raw);
    bool readAlarmTemperature(const bool highlow, float& celsius);
    bool writeAlarmTemperature(const bool highlow, const uint16_t raw);
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeAlarmTemperature(const bool highlow, const T celsius)
    {
        return std::isfinite(celsius) &&
               writeAlarmTemperature(highlow, thermal2::celsius_to_raw(static_cast<float>(celsius)));
    }
 
    bool readAlarmLED(const bool highlow, uint32_t& rgb);
    inline bool writeAlarmLED(const bool highlow, const uint32_t rgb)
    {
        return writeAlarmLED(highlow, rgb >> 16, rgb >> 8, rgb & 0xFF);
    }
    bool writeAlarmLED(const bool highlow, const uint8_t r, const uint8_t g, const uint8_t b);
 
    bool readAlarmBuzzer(const bool highlow, uint16_t& freq, uint8_t& interval);
    bool writeAlarmBuzzer(const bool highlow, const uint16_t freq, const uint8_t interval);
 
 
    bool readBuzzer(uint16_t& freq, uint8_t& duty);
    bool writeBuzzer(const uint16_t freq, const uint8_t duty, const bool verify = true);
    bool writeBuzzerDuty(const uint8_t duty);
 
    inline bool readBuzzerControl(bool& enabled)
    {
        return readBuzzerEnabled(enabled);
    }
    inline bool writeBuzzerControl(const bool enabled)
    {
        return writeBuzzerEnabled(enabled);
    }
 
 
    bool readLED(uint32_t& rgb);
    inline bool writeLED(const uint32_t rgb, const bool verify = true)
    {
        return writeLED(rgb >> 16, rgb >> 8, rgb & 0xFF, verify);
    }
    bool writeLED(const uint8_t r, const uint8_t g, const uint8_t b, const bool verify = true);
 
 
    bool readButtonStatus(uint8_t& bs);
 
    inline bool isPressed() const
    {
        return _button & thermal2::button_is_pressed;
    }
    inline bool wasPressed() const
    {
        return _button & thermal2::button_was_pressed;
    }
    inline bool wasReleased() const
    {
        return _button & thermal2::button_was_released;
    }
    inline bool wasClicked() const
    {
        return _button & thermal2::button_was_clicked;
    }
    inline bool wasHold() const
    {
        return _button & thermal2::button_was_hold;
    }
    inline bool isHolding() const
    {
        return isPressed() && _holding;
    }
 
    bool readFirmwareVersion(uint16_t& ver);
 
 
    bool changeI2CAddress(const uint8_t i2c_address);
    bool readI2CAddress(uint8_t& i2c_address);
 
protected:
    bool read_function_control_bit(const uint8_t bit, bool& enabled);
    bool write_function_control_bit(const uint8_t bit, const bool enabled);
    bool write_function_control(const uint8_t value, const bool verify);
 
    bool request_data();
    bool read_data_status(uint8_t s[2]);  // [0]:data refresh ctrl, [1]subpage information
    bool read_data(thermal2::Data& data);
 
    bool start_periodic_measurement(const thermal2::Refresh rate);
    bool start_periodic_measurement();
    bool stop_periodic_measurement();
 
    inline bool read_register(const uint8_t reg, uint8_t* v, const uint32_t len)
    {
        return readRegister(reg, v, len, 0, false /* stopbit false */);
    }
 
    inline bool read_register8(const uint8_t reg, uint8_t& v)
    {
        return readRegister8(reg, v, 0, false /* stopbit false */);
    }
 
    inline bool read_register16LE(const uint8_t reg, uint16_t& v)
    {
        return readRegister16LE(reg, v, 0, false /* stopbit false */);
    }
 
    inline bool read_register16BE(const uint8_t reg, uint16_t& v)
    {
        return readRegister16BE(reg, v, 0, false /* stopbit false */);
    }
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitThermal2, thermal2::Data);
 
private:
    std::unique_ptr<m5::container::CircularBuffer<thermal2::Data>> _data{};
    uint8_t _button{}, _holding{};
    uint32_t _button_interval{20};
    types::elapsed_time_t _latest_button{};
    config_t _cfg{};
};
 
namespace thermal2 {
namespace command {
constexpr uint8_t BUTTON_STATUS_REG{0x00};             // R/W
constexpr uint8_t TEMPERATURE_ALARM_STATUS_REG{0x01};  // R
// constexpr uint8_t DEVICE_STATUS_REG{0x02};             // R 2
constexpr uint8_t DEVICE_ID_REG{0x04};            // R 2
constexpr uint8_t FIRMWARE_VERSION_REG{0x06};     // R 2
constexpr uint8_t I2C_ADDRESS_REG{0x08};          // R/W 2 (0x09:bit inverted) I
constexpr uint8_t FUNCTION_CONTROL_REG{0x0A};     // R/W
constexpr uint8_t REFRESH_RATE_CONFIG_REG{0x0B};  // R/W I
constexpr uint8_t NOISE_FILTER_CONFIG_REG{0x0C};  // R/W I
 
constexpr uint8_t TEMPERATURE_MONITOR_SIZE_REG{0x10};  // R/W I
constexpr uint8_t ENABLE_TEMPERATURE_ALARM_REG{0x11};  // R/W I
constexpr uint8_t BUZZER_FREQ_REG{0x12};               // R/W 2
constexpr uint8_t BUZZER_DUTY_REG{0x14};               // R/W
constexpr uint8_t LED_REG{0x15};                       // R/W 3(R,G,B)
 
constexpr uint8_t LOW_ALARM_THRESHOLD_REG{0x20};    // R/W 2 I
constexpr uint8_t LOW_ALARM_BUZZER_FREQ_REG{0x22};  // R/W 2 I
constexpr uint8_t LOW_ALARM_INTERVAL_REG{0x24};     // R/W I
constexpr uint8_t LOW_ALARM_LED_REG{0x25};          // R/W 3 I
 
constexpr uint8_t HIGH_ALARM_THRESHOLD_REG{0x30};    // R/W 2 I
constexpr uint8_t HIGH_ALARM_BUZZER_FREQ_REG{0x32};  // R/W 2 I
constexpr uint8_t HIGH_ALARM_INTERVAL_REG{0x34};     // R/W I
constexpr uint8_t HIGH_ALARM_LED_REG{0x35};          // R/W 3 I
 
constexpr uint8_t DATA_REFRESH_CONTROL_REG{0x6E};  // R/W I
constexpr uint8_t SUB_PAGE_INFORMATION_REG{0x6F};  // R
 
constexpr uint8_t MEDIAN_TEMPERATURE_REG{0x70};     // R 2
constexpr uint8_t AVERAGE_TEMPERATURE_REG{0x72};    // R 2
constexpr uint8_t MOST_DIFF_TEMPERATURE_REG{0x74};  // R 2
constexpr uint8_t MOST_DIFF_X_POS_REG{0x76};        // R
constexpr uint8_t MOST_DIFF_Y_POS_REG{0x77};        // R
constexpr uint8_t LOWEST_TEMPERATURE_REG{0x78};     // R 2
constexpr uint8_t LOWEST_DIFF_X_POS_REG{0x7A};      // R
constexpr uint8_t LOWEST_DIFF_Y_POS_REG{0x7B};      // R
constexpr uint8_t HIGHEST_TEMPERATURE_REG{0x7C};    // R 2
constexpr uint8_t HIGHEST_DIFF_X_POS_REG{0x7E};     // R
constexpr uint8_t HIGHEST_DIFF_Y_POS_REG{0x7F};     // R
 
constexpr uint8_t TEMPERATURE_DATA_REG{0x80};  // R 768
}  // namespace command
}  // namespace thermal2
 
}  // namespace unit
}  // namespace m5
#endif