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 <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
#include <cmath>
#include <array>
 
namespace m5 {
namespace unit {
namespace thermal2 {
 
constexpr uint8_t button_is_pressed{0x01};
constexpr uint8_t button_was_pressed{0x02};
constexpr uint8_t button_was_released{0x04};
constexpr uint8_t button_was_clicked{0x08};
constexpr uint8_t button_was_hold{0x10};
 
constexpr uint8_t enabled_function_buzzer{0x01};
constexpr uint8_t enabled_function_led{0x02};
constexpr uint8_t enabled_function_auto_refresh{0x04};
 
constexpr uint8_t enabled_low_temperature_low{0x01};    
constexpr uint8_t enabled_med_temperature_low{0x02};    
constexpr uint8_t enabled_ave_temperature_low{0x04};    
constexpr uint8_t enabled_high_temperature_low{0x08};   
constexpr uint8_t enabled_low_temperature_high{0x10};   
constexpr uint8_t enabled_med_temperature_high{0x20};   
constexpr uint8_t enabled_ave_temperature_high{0x40};   
constexpr uint8_t enabled_high_temperature_high{0x80};  
 
enum class Refresh : uint8_t {
    Rate0_5Hz,  
    Rate1Hz,    
    Rate2Hz,    
    Rate4Hz,    
    Rate8Hz,    
    Rate16Hz,   
    Rate32Hz,   
    Rate64Hz,   
};
 
inline static uint16_t celsius_to_raw(const float f)
{
    int i = std::round((f + 64) * 128);
    return static_cast<uint16_t>(std::max(std::min(i, (int)std::numeric_limits<uint16_t>::max()), 0));
}
inline static float raw_to_celsius(const uint16_t u16)
{
    return u16 / 128.0f - 64;
}
 
#pragma pack(push)
#pragma pack(1)
struct Data {
    uint8_t subpage{};  // Subpage 0:even 1:odd
    union {
        uint16_t temp[8]{};  // Temperature information
        struct {
            uint16_t median_temperature;
            uint16_t average_temperature;
            uint16_t most_diff_temperature;
            uint8_t most_diff_x;
            uint8_t most_diff_y;
            uint16_t lowest_temperature;
            uint8_t lowest_diff_x;
            uint8_t lowest_diff_y;
            uint16_t highest_temperature;
            uint8_t highest_diff_x;
            uint8_t highest_diff_y;
        };
    };
    uint16_t raw[384]{};  // Raw pixel data (1/2)
 
    // temperture information
    inline float medianTemperature() const
    {
        return thermal2::raw_to_celsius(temp[0]);
    }
    inline float averageTemperature() const
    {
        return thermal2::raw_to_celsius(temp[1]);
    }
    inline float mostDiffTemperature() const
    {
        return thermal2::raw_to_celsius(temp[2]);
    }
    inline float lowestTemperature() const
    {
        return thermal2::raw_to_celsius(temp[4]);
    }
    inline float highestTemperature() const
    {
        return thermal2::raw_to_celsius(temp[6]);
    }
 
    // piexl temperature
    inline float temperature(const uint_fast16_t idx) const
    {
        return (idx < 384) ? thermal2::raw_to_celsius(raw[idx]) : std::numeric_limits<float>::quiet_NaN();
    }
};
#pragma pack(pop)
 
}  // namespace thermal2
 
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 readTemeratureMonitorSize(uint8_t& wid, uint8_t& hgt);
    bool writeTemeratureMonitorSize(const uint8_t wid, const uint8_t 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 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);
    }
    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()
    {
        return _button & thermal2::button_was_pressed;
    }
    inline bool wasReleased()
    {
        return _button & thermal2::button_was_released;
    }
    inline bool wasClicked()
    {
        return _button & thermal2::button_was_clicked;
    }
    inline bool wasHold()
    {
        return _button & thermal2::button_was_hold;
    }
    inline bool isHolding()
    {
        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 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_THERSHOLD_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_THERSHOLD_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_TEPERATURE_REG{0x70};     // R 2
constexpr uint8_t AVERAGE_TEPERATURE_REG{0x72};    // R 2
constexpr uint8_t MOST_DIFF_TEPERATURE_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_TEPERATURE_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_TEPERATURE_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