unit_DualKmeter.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_METER_UNIT_DUAL_KMETER_HPP
#define M5_UNIT_METER_UNIT_DUAL_KMETER_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>  // NaN
#include <array>
 
namespace m5 {
namespace unit {
 
namespace dual_kmeter {
 
enum class Channel : uint8_t {
    One,  
    Two,  
};
 
enum class MeasurementUnit : uint8_t {
    Celsius,     
    Fahrenheit,  
};
 
struct Data {
    std::array<uint8_t, 4> raw{};  
    Channel channel{};             
 
    //@note Unit depends on setting
    inline float temperature() const
    {
        return static_cast<int32_t>(((uint32_t)raw[3] << 24) | ((uint32_t)raw[2] << 16) | ((uint32_t)raw[1] << 8) |
                                    ((uint32_t)raw[0] << 0)) *
               0.01f;
    }
};
 
}  // namespace dual_kmeter
 
class UnitDualKmeter : public Component, public PeriodicMeasurementAdapter<UnitDualKmeter, dual_kmeter::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitDualKmeter, 0x11);
 
public:
    struct config_t {
        bool start_periodic{true};
        uint32_t interval{100};
        dual_kmeter::Channel measurement_channel{dual_kmeter::Channel::One};
        dual_kmeter::MeasurementUnit measurement_unit{dual_kmeter::MeasurementUnit::Celsius};
    };
 
    explicit UnitDualKmeter(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<dual_kmeter::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 100 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitDualKmeter()
    {
    }
 
    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;
    }
 
 
    dual_kmeter::MeasurementUnit measurementUnit() const
    {
        return _munit;
    }
    dual_kmeter::Channel measurementChannel() const
    {
        return _channel;
    }
    void setMeasurementUnit(const dual_kmeter::MeasurementUnit munit)
    {
        _munit = munit;
    }
 
    inline float temperature() const
    {
        return !empty() ? oldest().temperature() : std::numeric_limits<float>::quiet_NaN();
    }
 
 
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitDualKmeter, dual_kmeter::Data>::startPeriodicMeasurement();
    }
    inline bool startPeriodicMeasurement(
        const uint32_t interval, const dual_kmeter::Channel channel = dual_kmeter::Channel::One,
        const dual_kmeter::MeasurementUnit munit = dual_kmeter::MeasurementUnit::Celsius)
    {
        return PeriodicMeasurementAdapter<UnitDualKmeter, dual_kmeter::Data>::startPeriodicMeasurement(interval,
                                                                                                       channel, munit);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitDualKmeter, dual_kmeter::Data>::stopPeriodicMeasurement();
    }
 
    bool readStatus(uint8_t& status);
 
    bool readFirmwareVersion(uint8_t& ver);
 
 
    bool measureSingleshot(dual_kmeter::Data& d, const dual_kmeter::Channel channel,
                           dual_kmeter::MeasurementUnit munit = dual_kmeter::MeasurementUnit::Celsius,
                           const uint32_t timeoutMs           = 100);
    bool measureInternalSingleshot(dual_kmeter::Data& d, const dual_kmeter::Channel channel,
                                   const dual_kmeter::MeasurementUnit munit = dual_kmeter::MeasurementUnit::Celsius,
                                   const uint32_t timeoutMs                 = 100);
 
 
    bool readCurrentChannel(dual_kmeter::Channel& channel);
    bool writeCurrentChannel(const dual_kmeter::Channel channel);
 
protected:
    inline bool read_register(const uint8_t reg, uint8_t* rbuf, const uint32_t len)
    {
        return readRegister(reg, rbuf, len, 0, false);
    }
    inline bool read_register8(const uint8_t reg, uint8_t& v)
    {
        return readRegister8(reg, v, 0, false);
    }
 
    bool start_periodic_measurement();
    bool start_periodic_measurement(const uint32_t interval, const dual_kmeter::Channel channel,
                                    const dual_kmeter::MeasurementUnit munit);
    bool stop_periodic_measurement();
 
    bool read_measurement(dual_kmeter::Data& d, const dual_kmeter::MeasurementUnit munit);
    bool read_internal_measurement(dual_kmeter::Data& d, const dual_kmeter::MeasurementUnit munit);
 
    bool is_data_ready()
    {
        uint8_t s{};
        return readStatus(s) && (s == 0U);
    }
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitDualKmeter, dual_kmeter::Data);
 
protected:
    std::unique_ptr<m5::container::CircularBuffer<dual_kmeter::Data>> _data{};
    dual_kmeter::MeasurementUnit _munit{dual_kmeter::MeasurementUnit::Celsius};
    dual_kmeter::Channel _channel{}, _current_channel{};
    config_t _cfg{};
};
 
namespace dual_kmeter {
namespace command {
constexpr uint8_t TEMPERATURE_CELSIUS_REG{0x00};                    // R
constexpr uint8_t TEMPERATURE_FAHRENHEIT_REG{0x04};                 // R
constexpr uint8_t INTERNAL_TEMPERATURE_CELSIUS_REG{0x10};           // R
constexpr uint8_t INTERNAL_TEMPERATURE_FAHRENHEIT_REG{0x14};        // R
constexpr uint8_t CHANNEL_REG{0x20};                                // R/W
constexpr uint8_t STATUS_REG{0x30};                                 // R
constexpr uint8_t TEMPERATURE_CELSIUS_STRING_REG{0x40};             // R
constexpr uint8_t TEMPERATURE_FAHRENHEITSTRING_REG{0x50};           // R
constexpr uint8_t INTERNAL_TEMPERATURE_CELSIUS_STRING_REG{0x60};    // R
constexpr uint8_t INTERNAL_TEMPERATURE_FAHRENHEITSTRING_REG{0x70};  // R
constexpr uint8_t FIRMWARE_VERSION_REG{0xFE};                       // R
}  // namespace command
}  // namespace dual_kmeter
 
}  // namespace unit
}  // namespace m5
 
#endif