unit_MCP4725.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_ANADIG_UNIT_MCP4725_HPP
#define M5_UNIT_ANADIG_UNIT_MCP4725_HPP
#include <M5UnitComponent.hpp>
 
namespace m5 {
namespace unit {
 
namespace mcp4725 {
 
enum class PowerDown : uint8_t {
    Normal,    
    OHM_1K,    
    OHM_100K,  
    OHM_500K   
};
 
}  // namespace mcp4725
 
class UnitMCP4725 : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitMCP4725, 0x60);
 
public:
    static constexpr uint16_t RESOLUTION{0x0FFF};  // 12bits max code
 
    static inline float raw_to_voltage(const uint16_t raw, const float supply_voltage)
    {
        return static_cast<float>(raw) * supply_voltage / 4096.0f;
    }
    static inline uint16_t voltage_to_raw(const float mv, const float supply_voltage)
    {
        float val    = m5::stl::clamp(mv, 0.0f, supply_voltage);
        uint32_t raw = static_cast<uint32_t>((val / supply_voltage) * 4096.0f);
        return static_cast<uint16_t>(raw > RESOLUTION ? RESOLUTION : raw);
    }
 
    struct config_t {
        bool using_eeprom_settings{false};
        float supply_voltage{5000.f};
        float saturation_voltage{3300.f};
    };
 
    explicit UnitMCP4725(const uint8_t addr = DEFAULT_ADDRESS) : Component(addr)
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitMCP4725()
    {
    }
 
    virtual bool begin() override;
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    inline mcp4725::PowerDown powerDown() const
    {
        return _powerDown;
    }
    inline uint16_t lastValue() const
    {
        return _lastValue;
    }
 
 
    bool writePowerDown(const mcp4725::PowerDown pd);
 
 
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeVoltage(const T mv)
    {
        float limit = (_cfg.saturation_voltage > 0.f) ? _cfg.saturation_voltage : _cfg.supply_voltage;
        return (mv >= 0.0f) &&
               writeVoltage(voltage_to_raw(std::min(static_cast<float>(mv), limit), _cfg.supply_voltage));
    }
    inline bool writeVoltage(const uint16_t raw)
    {
        return write_voltage(Command::FastMode, raw);
    }
    template <typename T, typename std::enable_if<!std::is_same<uint16_t, T>::value && std::is_unsigned<T>::value,
                                                  std::nullptr_t>::type = nullptr>
    inline bool writeVoltage(const T raw)
    {
        return writeVoltage(static_cast<uint16_t>(raw & RESOLUTION));
    }
 
 
 
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeVoltageAndEEPROM(const T mv, const bool blocking = true)
    {
        float limit = (_cfg.saturation_voltage > 0.f) ? _cfg.saturation_voltage : _cfg.supply_voltage;
        return (mv >= 0.0f) &&
               writeVoltageAndEEPROM(voltage_to_raw(std::min(static_cast<float>(mv), limit), _cfg.supply_voltage),
                                     blocking);
    }
 
    bool writeVoltageAndEEPROM(const uint16_t raw, const bool blocking = true);
 
    template <typename T, typename std::enable_if<!std::is_same<uint16_t, T>::value && std::is_unsigned<T>::value,
                                                  std::nullptr_t>::type = nullptr>
    bool writeVoltageAndEEPROM(const T raw, const bool blocking = true)
    {
        return writeVoltageAndEEPROM(static_cast<uint16_t>(raw & RESOLUTION), blocking);
    }
 
    bool generalReset();
 
    bool readDACRegister(mcp4725::PowerDown& pd, uint16_t& raw);
    bool readEEPROM(mcp4725::PowerDown& pd, uint16_t& raw);
 
protected:
    enum class Command : uint8_t {
        FastMode,           // 2bytes [0:0:PD1:PD0:D11:D10:D9:D8] [D7... D0]
        WriteDAC,           // 3bytes [0:1:0:X:X:PD1:PD0:X]       [D11...D4] [D3:D2:D1:D0:X:X:X:X]
        WriteDACAndEEPROM,  // 3bytes [0:1:1:X:X:PD1:PD0:X]       [D11...D4] [D3:D2:D1:D0:X:X:X:X]
    };
 
    bool write_voltage(const Command cmd, const uint16_t raw);
    bool is_eeprom_ready();
    uint32_t make_buffer(uint8_t buf[3], const uint16_t raw, const Command cmd);
    bool read_status(uint8_t rbuf[5]);
 
private:
    mcp4725::PowerDown _powerDown{};
    uint16_t _lastValue{};
    config_t _cfg{};
};
 
}  // namespace unit
}  // namespace m5
 
#endif