unit_NCIR2.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_THERMO_UNIT_NCIR2_HPP
#define M5_UNIT_THERMO_UNIT_NCIR2_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
#include <array>
 
namespace m5 {
namespace unit {
 
namespace ncir2 {
struct Data {
    std::array<uint8_t, 2> raw{0x00, 0x80};  // Raw [0]:low byte [1]:high byte
    inline int16_t value() const
    {
        return (raw[1] << 8 | raw[0]);
    }
    inline float temperature() const
    {
        return value() * 0.01f;
    }
    inline float celsius() const
    {
        return temperature();
    }
    inline float fahrenheit() const
    {
        return celsius() * 9.0f / 5.0f + 32.f;
    }
};
}  // namespace ncir2
 
class UnitNCIR2 : public Component, public PeriodicMeasurementAdapter<UnitNCIR2, ncir2::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitNCIR2, 0x5A);
 
public:
    struct config_t {
        bool start_periodic{true};
        uint32_t interval{250};
        uint32_t button_interval{20};
    };
 
    explicit UnitNCIR2(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<ncir2::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 100 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitNCIR2()
    {
    }
 
    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 bool startPeriodicMeasurement(const uint32_t interval)
    {
        return PeriodicMeasurementAdapter<UnitNCIR2, ncir2::Data>::startPeriodicMeasurement(interval);
    }
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitNCIR2, ncir2::Data>::startPeriodicMeasurement();
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitNCIR2, ncir2::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(ncir2::Data& d);
 
 
    bool readEmissivity(uint16_t& raw);
    bool readEmissivity(float& e);
    bool writeEmissivity(const uint16_t raw);
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeEmissivity(const T e)
    {
        return write_emissivity(static_cast<float>(e));
    }
 
 
    bool readAlarmTemperature(const bool highlow, int16_t& raw);
    bool readAlarmTemperature(const bool highlow, float& celsius);
    bool writeAlarmTemperature(const bool highlow, const int16_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 write_alarm_temperature(highlow, 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, uint16_t& interval, uint8_t& rawDuty);
    bool readAlarmBuzzer(const bool highlow, uint16_t& freq, uint16_t& interval, float& duty);
    bool writeAlarmBuzzer(const bool highlow, const uint16_t freq, const uint16_t interval, const uint8_t rawDuty);
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeAlarmBuzzer(const bool highlow, const uint16_t freq, const uint16_t interval, const T duty)
    {
        return write_alarm_buzzer(highlow, freq, interval, static_cast<float>(duty));
    }
 
 
    bool readBuzzer(uint16_t& freq, uint8_t& rawDuty);
    bool readBuzzer(uint16_t& freq, float& duty);
 
    bool writeBuzzer(const uint16_t freq, const uint8_t rawDuty);
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeBuzzer(const uint16_t freq, const T duty)
    {
        return write_buzzer(freq, static_cast<float>(duty));
    }
 
    bool readBuzzerControl(bool& enabled);
    bool writeBuzzerControl(const bool enabled);
 
 
    bool readLED(uint32_t& rgb);
    inline bool writeLED(const uint32_t rgb)
    {
        return writeLED(rgb >> 16, rgb >> 8, rgb & 0xFF);
    }
    bool writeLED(const uint8_t r, const uint8_t g, const uint8_t b);
 
 
    bool readChipTemperature(ncir2::Data& d);
 
 
    bool writeConfig();
 
 
    bool readButtonStatus(bool& press);
    inline bool isPressed() const
    {
        return _button;
    }
    inline bool wasPressed() const
    {
        return _button && (_button != _prev_button);
    }
    inline bool wasReleased()
    {
        return !_button && (_button != _prev_button);
    }
 
    bool readFirmwareVersion(uint8_t& ver);
 
 
    bool changeI2CAddress(const uint8_t i2c_address);
    bool readI2CAddress(uint8_t& i2c_address);
 
protected:
    bool start_periodic_measurement(const uint32_t interval);
    bool start_periodic_measurement();
    bool stop_periodic_measurement();
 
    bool read_temperature(const uint8_t reg, uint8_t v[2]);
 
    bool write_emissivity(const float e);
    bool write_alarm_temperature(const bool highlow, const float celsius);
    bool write_alarm_buzzer(const bool highlow, const uint16_t freq, const uint16_t interval, const float duty);
    bool write_buzzer(const uint16_t freq, const float duty);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitNCIR2, ncir2::Data);
 
private:
    std::unique_ptr<m5::container::CircularBuffer<ncir2::Data>> _data{};
    bool _button{}, _prev_button{};
    uint32_t _button_interval{20};
    types::elapsed_time_t _latest_button{};
    config_t _cfg{};
};
 
namespace ncir2 {
namespace command {
constexpr uint8_t TEMPERATURE_REG{0x00};                 // R
constexpr uint8_t EMISSIVITY_REG{0x10};                  // R/W
constexpr uint8_t ALARM_TEMPERATURE_REG{0x20};           // R/W
constexpr uint8_t ALARM_LED_REG{0x30};                   // R/W
constexpr uint8_t ALARM_BUZZER_REG{0x40};                // W
constexpr uint8_t ALARM_BUZZER_LOW_FREQ_REG{0x40};       // R
constexpr uint8_t ALARM_BUZZER_LOW_INTERVAL_REG{0x42};   // R
constexpr uint8_t ALARM_BUZZER_LOW_DUTY_REG{0x44};       // R
constexpr uint8_t ALARM_BUZZER_HIGH_FREQ_REG{0x45};      // R
constexpr uint8_t ALARM_BUZZER_HIGH_INTERVAL_REG{0x47};  // R
constexpr uint8_t ALARM_BUZZER_HIGH_DUTY_REG{0x48};      // R
constexpr uint8_t BUZZER_REG{0x50};                      // W
constexpr uint8_t BUZZER_FREQ_REG{0x50};                 // R
constexpr uint8_t BUZZER_DUTY_REG{0x52};                 // R
constexpr uint8_t BUZZER_CONTROL_REG{0x53};              // R/W
constexpr uint8_t LED_REG{0x60};                         // R/W
constexpr uint8_t BUTTON_REG{0x70};                      // R
constexpr uint8_t SAVE_CONFIG_REG{0x80};                 // W
constexpr uint8_t CHIP_TEMPERATURE_REG{0x90};            // R
constexpr uint8_t FIRMWARE_VERSION_REG{0xFE};            // R
constexpr uint8_t I2C_ADDRESS_REG{0xFF};                 // R/W
}  // namespace command
}  // namespace ncir2
 
}  // namespace unit
}  // namespace m5
 
#endif