unit_GP8413.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_ANADIG_UNIT_GP8413_HPP
#define M5_UNIT_ANADIG_UNIT_GP8413_HPP
#include <M5UnitComponent.hpp>
 
namespace m5 {
namespace unit {
 
namespace gp8413 {
 
enum class Output : uint8_t {
    Range5V,   
    Range10V,  
};
 
enum class Channel : uint8_t {
    Zero,  
    One,   
};
 
}  // namespace gp8413
 
class UnitGP8413 : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitGP8413, 0x59);
 
public:
    static constexpr uint16_t RESOLUTION{0x7FFF};
 
    struct config_t {
        gp8413::Output range0{gp8413::Output::Range10V};
        gp8413::Output range1{gp8413::Output::Range10V};
    };
 
    explicit UnitGP8413(const uint8_t addr = DEFAULT_ADDRESS) : Component(addr)
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitGP8413()
    {
    }
 
    virtual bool begin() override;
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
 
    gp8413::Output range(const gp8413::Channel channel) const
    {
        return _range[m5::stl::to_underlying(channel)];
    }
    float maximumVoltage(const gp8413::Channel channel) const;
    bool writeOutputRange(const gp8413::Output range0, const gp8413::Output range1);
 
 
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeVoltage(const gp8413::Channel channel, const T mv)
    {
        return (mv >= 0.0f) && writeVoltage(channel, voltage_to_raw(channel, static_cast<float>(mv)));
    }
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeChannel0Voltage(const T mv)
    {
        return (mv >= 0.0f) &&
               writeVoltage(gp8413::Channel::Zero, voltage_to_raw(gp8413::Channel::Zero, static_cast<float>(mv)));
    }
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeChannel1Voltage(const T mv)
    {
        return (mv >= 0.0f) &&
               writeVoltage(gp8413::Channel::One, voltage_to_raw(gp8413::Channel::One, static_cast<float>(mv)));
    }
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeBothVoltage(const T mv0, const T mv1)
    {
        return (mv0 >= 0.0f) && (mv1 >= 0.0f) &&
               writeBothVoltage(voltage_to_raw(gp8413::Channel::Zero, static_cast<float>(mv0)),
                                voltage_to_raw(gp8413::Channel::One, static_cast<float>(mv1)));
    }
    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
    inline bool writeBothVoltage(const T mv)
    {
        return (mv >= 0.0f) && writeBothVoltage(voltage_to_raw(gp8413::Channel::Zero, static_cast<float>(mv)),
                                                voltage_to_raw(gp8413::Channel::One, static_cast<float>(mv)));
    }
 
 
    bool writeVoltage(const gp8413::Channel channel, const uint16_t raw);
    inline bool writeChannel0Voltage(const uint16_t raw)
    {
        return writeVoltage(gp8413::Channel::Zero, static_cast<uint16_t>(raw & RESOLUTION));
    }
    inline bool writeChannel1Voltage(const uint16_t raw)
    {
        return writeVoltage(gp8413::Channel::One, static_cast<uint16_t>(raw & RESOLUTION));
    }
    bool writeBothVoltage(const uint16_t raw0, const uint16_t raw1);
    inline bool writeBothVoltage(const uint16_t raw)
    {
        return writeBothVoltage(static_cast<uint16_t>(raw & RESOLUTION), static_cast<uint16_t>(raw & RESOLUTION));
    }
 
 
    bool storeBothVoltage();
 
protected:
    uint16_t voltage_to_raw(const gp8413::Channel channel, const float mv) const;
    bool write_voltage(const uint8_t reg, const uint8_t* buf, const uint32_t len);
 
private:
    gp8413::Output _range[2]{};
    config_t _cfg{};
};
 
namespace gp8413 {
namespace command {
constexpr uint8_t OUTPUT_RANGE_REG{0x01};     // W
constexpr uint8_t OUTPUT_CHANNEL0_REG{0x02};  // W
constexpr uint8_t OUTPUT_CHANNEL1_REG{0x04};  // W
}  // namespace command
}  // namespace gp8413
 
}  // namespace unit
}  // namespace m5
#endif