unit_WeightI2C.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_WEIGHT_I2C_UNIT_WEIGHT_I2C_HPP
#define M5_UNIT_WEIGHT_I2C_UNIT_WEIGHT_I2C_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <m5_utility/types.hpp>
#include <array>
#include <cstring>  // std::memcpy
#include <limits>   // NaN
 
namespace m5 {
namespace unit {
 
namespace weighti2c {
 
enum class Mode : uint8_t { Float, Int };
 
struct Data {
    static_assert(sizeof(float) == 4, "Invalid float size");  // I2C protocol assumes IEEE 754 float (4 bytes)
    std::array<uint8_t, 4> raw{};                             
    bool is_float{};
 
    inline float weight() const
    {
        if (!is_float) {
            return std::numeric_limits<float>::quiet_NaN();
        }
        float val{};
        std::memcpy(&val, raw.data(), raw.size());
        return val;
    }
    inline int32_t iweight() const
    {
        return !is_float
                   ? static_cast<int32_t>(static_cast<uint32_t>(raw[0]) | (static_cast<uint32_t>(raw[1]) << 8) |
                                          (static_cast<uint32_t>(raw[2]) << 16) | (static_cast<uint32_t>(raw[3]) << 24))
                   : std::numeric_limits<int32_t>::min();
    }
};
}  // namespace weighti2c
 
class UnitWeightI2C : public Component, public PeriodicMeasurementAdapter<UnitWeightI2C, weighti2c::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitWeightI2C, 0x26);
 
public:
    struct config_t {
        bool lp_enable{true};
        uint8_t avg_filter_level{10};
        uint8_t ema_filter_alpha{10};
        bool start_periodic{true};
        weighti2c::Mode mode{weighti2c::Mode::Float};
        uint32_t interval{80};
    };
 
    explicit UnitWeightI2C(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<weighti2c::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 100 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitWeightI2C()
    {
    }
 
    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 weight() const
    {
        return !empty() ? oldest().weight() : std::numeric_limits<float>::quiet_NaN();
    }
    inline int32_t iweight() const
    {
        return !empty() ? oldest().iweight() : std::numeric_limits<int32_t>::min();
    }
 
 
    inline bool startPeriodicMeasurement(const weighti2c::Mode mode, const uint32_t interval = 80)
    {
        return PeriodicMeasurementAdapter<UnitWeightI2C, weighti2c::Data>::startPeriodicMeasurement(mode, interval);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitWeightI2C, weighti2c::Data>::stopPeriodicMeasurement();
    }
 
 
    bool measureSingleshot(weighti2c::Data& data, const weighti2c::Mode mode);
    bool measureSingleshot(char* buf);
 
 
    bool readGap(float& gap);
    bool writeGap(const float gap, const uint32_t duration = 100);
 
    bool resetOffset();
 
 
    bool isEnabledLPFilter(bool& enabled);
    bool enableLPFilter(const bool enable);
    bool readAvgFilterLevel(uint8_t& level);
    bool writeAvgFilterLevel(const uint8_t level);
    bool readEmaFilterAlpha(uint8_t& alpha);
    bool writeEmaFilterAlpha(const uint8_t alpha);
 
    bool readRawADC(int32_t& value);
 
 
    bool readI2CAddress(uint8_t& i2c_address);
    bool changeI2CAddress(const uint8_t i2c_address);
 
protected:
    bool read_register(const uint8_t reg, uint8_t* buf, const size_t len);
    inline bool read_register8(const uint8_t reg, uint8_t& val)
    {
        return read_register(reg, &val, 1);
    }
 
    bool start_periodic_measurement(const weighti2c::Mode mode, const uint32_t interval);
    bool stop_periodic_measurement();
    bool read_measurement(weighti2c::Data& d, const weighti2c::Mode m);
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitWeightI2C, weighti2c::Data);
 
protected:
    weighti2c::Mode _mode{};
    std::unique_ptr<m5::container::CircularBuffer<weighti2c::Data>> _data{};
    config_t _cfg{};
};
 
namespace weighti2c {
namespace command {
// clang-format off
constexpr uint8_t RAW_ADC_REG           {0x00}; // R
constexpr uint8_t WEIGHT_REG            {0x10}; // R
constexpr uint8_t GAP_REG               {0x40}; // R/W
constexpr uint8_t OFFSET_REG            {0x50}; // W
constexpr uint8_t WEIGHTX100_INT_REG    {0x60}; // R
constexpr uint8_t WEIGHTX100_STRING_REG {0x70}; // R
constexpr uint8_t FILTER_REG            {0x80}; // R/W
constexpr uint8_t FILTER_LP_REG         {0x80}; // R/W
constexpr uint8_t FILTER_AVG_REG        {0x81}; // R/W
constexpr uint8_t FILTER_EMA_REG        {0x82}; // R/W
constexpr uint8_t FIRMWARE_VERSION_REG  {0xFE}; // R
constexpr uint8_t I2C_ADDRESS_REG       {0xFF}; // R/W
// clang-format on
}  // namespace command
}  // namespace weighti2c
 
}  // namespace unit
}  // namespace m5
#endif