unit_ADS111x.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_METER_UNIT_ADS111X_HPP
#define M5_UNIT_METER_UNIT_ADS111X_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/stl/extension.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <limits>
 
namespace m5 {
namespace unit {
 
namespace ads111x {
enum class Mux : uint8_t {
    AIN_01,  
    AIN_03,  
    AIN_13,  
    AIN_23,  
    GND_0,   
    GND_1,   
    GND_2,   
    GND_3,   
};
 
enum class Gain : uint8_t {
    PGA_6144,  
    PGA_4096,  
    PGA_2048,  
    PGA_1024,  
    PGA_512,   
    PGA_256,   
    // [6,7] PGA_256 (duplicate)
};
 
enum class Sampling : uint8_t {
    Rate8,    
    Rate16,   
    Rate32,   
    Rate64,   
    Rate128,  
    Rate250,  
    Rate475,  
    Rate860,  
};
 
enum class ComparatorQueue : uint8_t {
    One,      
    Two,      
    Four,     
    Disable,  
};
 
struct Config {
 
    inline bool os() const
    {
        return value & (1U << 15);
    }
    inline Mux mux() const
    {
        return static_cast<Mux>((value >> 12) & 0x07);
    }
    inline Gain pga() const
    {
        return static_cast<Gain>((value >> 9) & 0x07);
    }
    inline bool mode() const
    {
        return value & (1U << 8);
    }
    inline Sampling dr() const
    {
        return static_cast<Sampling>((value >> 5) & 0x07);
    }
    inline bool comp_mode() const
    {
        return value & (1U << 4);
    }
    inline bool comp_pol() const
    {
        return value & (1U << 3);
    }
    inline bool comp_lat() const
    {
        return value & (1U << 2);
    }
    inline ComparatorQueue comp_que() const
    {
        return static_cast<ComparatorQueue>(value & 0x03);
    }
 
    inline void os(const bool b)
    {
        value = (value & ~(1U << 15)) | ((b ? 1U : 0) << 15);
    }
    inline void mux(const Mux m)
    {
        value = (value & ~(0x07 << 12)) | ((m5::stl::to_underlying(m) & 0x07) << 12);
    }
    inline void pga(const Gain g)
    {
        value = (value & ~(0x07 << 9)) | ((m5::stl::to_underlying(g) & 0x07) << 9);
    }
    inline void mode(const bool b)
    {
        value = (value & ~(1U << 8)) | ((b ? 1U : 0) << 8);
    }
    inline void dr(const Sampling r)
    {
        value = (value & ~(0x07 << 5)) | ((m5::stl::to_underlying(r) & 0x07) << 5);
    }
    inline void comp_mode(const bool b)
    {
        value = (value & ~(1U << 4)) | ((b ? 1U : 0) << 4);
    }
    inline void comp_pol(const bool b)
    {
        value = (value & ~(1U << 3)) | ((b ? 1U : 0) << 3);
    }
    inline void comp_lat(const bool b)
    {
        value = (value & ~(1U << 2)) | ((b ? 1U : 0) << 2);
    }
    inline void comp_que(const ComparatorQueue c)
    {
        value = (value & ~0x03U) | (m5::stl::to_underlying(c) & 0x03);
    }
 
    uint16_t value{};
};
 
struct Data {
    uint16_t raw{};
    inline int16_t adc() const
    {
        return static_cast<int16_t>(raw);
    }
};
 
}  // namespace ads111x
 
class UnitADS111x : public Component, public PeriodicMeasurementAdapter<UnitADS111x, ads111x::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitADS111x, 0x00);
 
public:
    struct config_t {
        bool start_periodic{true};
        ads111x::Sampling rate{ads111x::Sampling::Rate128};
        ads111x::Mux mux{ads111x::Mux::AIN_01};
        ads111x::Gain gain{ads111x::Gain::PGA_2048};
        ads111x::ComparatorQueue comp_que{ads111x::ComparatorQueue::Disable};
    };
 
    explicit UnitADS111x(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<ads111x::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitADS111x()
    {
    }
 
    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 coefficient() const
    {
        return _coefficient;
    }
 
    inline int16_t adc() const
    {
        return !empty() ? oldest().adc() : std::numeric_limits<int16_t>::min();
    }
 
 
    inline bool startPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitADS111x, ads111x::Data>::startPeriodicMeasurement();
    }
    inline bool startPeriodicMeasurement(const ads111x::Sampling rate, const ads111x::Mux mux, const ads111x::Gain gain,
                                         const ads111x::ComparatorQueue comp_que)
    {
        return PeriodicMeasurementAdapter<UnitADS111x, ads111x::Data>::startPeriodicMeasurement(rate, mux, gain,
                                                                                                comp_que);
    }
    inline bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitADS111x, ads111x::Data>::stopPeriodicMeasurement();
    }
 
 
    inline ads111x::Mux multiplexer() const
    {
        return _ads_cfg.mux();
    }
    ads111x::Gain gain() const;
    inline ads111x::Sampling samplingRate() const
    {
        return _ads_cfg.dr();
    }
    inline bool comparatorMode() const
    {
        return _ads_cfg.comp_mode();
    }
    inline bool comparatorPolarity() const
    {
        return _ads_cfg.comp_pol();
    }
    inline bool latchingComparator() const
    {
        return _ads_cfg.comp_lat();
    }
    inline ads111x::ComparatorQueue comparatorQueue() const
    {
        return _ads_cfg.comp_que();
    }
 
    virtual bool writeMultiplexer(const ads111x::Mux mux) = 0;
    virtual bool writeGain(const ads111x::Gain gain) = 0;
    bool writeSamplingRate(const ads111x::Sampling rate);
    virtual bool writeComparatorMode(const bool b) = 0;
    virtual bool writeComparatorPolarity(const bool b) = 0;
    virtual bool writeLatchingComparator(const bool b) = 0;
    virtual bool writeComparatorQueue(const ads111x::ComparatorQueue c) = 0;
 
 
    bool measureSingleshot(ads111x::Data& d, const uint32_t timeoutMillis = 1000U);
 
 
    bool readThreshold(int16_t& high, int16_t& low);
    bool writeThreshold(const int16_t high, const int16_t low);
 
    bool generalReset();
 
protected:
    bool start_periodic_measurement();
    virtual bool start_periodic_measurement(const ads111x::Sampling rate, const ads111x::Mux mux,
                                            const ads111x::Gain gain, const ads111x::ComparatorQueue comp_que) = 0;
    bool stop_periodic_measurement();
 
    bool read_adc_raw(ads111x::Data& d);
    bool start_single_measurement();
    bool in_conversion();
 
    bool read_config(ads111x::Config& c);
    bool write_config(const ads111x::Config& c);
    void apply_interval(const ads111x::Sampling rate);
    virtual void apply_coefficient(const ads111x::Gain gain);
 
    bool write_multiplexer(const ads111x::Mux mux);
    bool write_gain(const ads111x::Gain gain);
    bool write_comparator_mode(const bool b);
    bool write_comparator_polarity(const bool b);
    bool write_latching_comparator(const bool b);
    bool write_comparator_queue(const ads111x::ComparatorQueue c);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitADS111x, ads111x::Data);
 
protected:
    std::unique_ptr<m5::container::CircularBuffer<ads111x::Data>> _data{};
    float _coefficient{};
    ads111x::Config _ads_cfg{};
 
    config_t _cfg{};
};
 
namespace ads111x {
namespace command {
 
constexpr uint8_t CONVERSION_REG{0x00};
constexpr uint8_t CONFIG_REG{0x01};
constexpr uint8_t LOW_THRESHOLD_REG{0x02};
constexpr uint8_t HIGH_THRESHOLD_REG{0x03};
 
}  // namespace command
}  // namespace ads111x
 
}  // namespace unit
}  // namespace m5
 
#endif