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};  // 15bits
 
    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, (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, (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, (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 writeBothVoltage(voltage_to_raw(gp8413::Channel::Zero, (float)mv0),
                                voltage_to_raw(gp8413::Channel::One, (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, (float)mv),
                                                voltage_to_raw(gp8413::Channel::One, (float)mv));
    }
 
 
    bool writeVoltage(const gp8413::Channel channel, const uint16_t 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 gp8413::Channel channel, const T raw)
    {
        return writeVoltage(channel, static_cast<uint16_t>(raw & RESOLUTION));
    }
    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 writeChannel0Voltage(const T raw)
    {
        return writeVoltage(gp8413::Channel::Zero, static_cast<uint16_t>(raw & RESOLUTION));
    }
    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 writeChannel1Voltage(const T raw)
    {
        return writeVoltage(gp8413::Channel::One, static_cast<uint16_t>(raw & RESOLUTION));
    }
    bool writeBothVoltage(const uint16_t raw0, const uint16_t raw1);
    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 writeBothVoltage(const T raw0, const T raw1)
    {
        return writeBothVoltage(static_cast<uint16_t>(raw0 & RESOLUTION), static_cast<uint16_t>(raw1 & RESOLUTION));
    }
    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 writeBothVoltage(const T raw)
    {
        return writeBothVoltage(static_cast<uint16_t>(raw & RESOLUTION), static_cast<uint16_t>(raw & RESOLUTION));
    }
 
protected:
    uint16_t voltage_to_raw(const gp8413::Channel channel, const float mv);
    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{0x01};
constexpr uint8_t OUTPUT_CHANNEL_0{0x02};
constexpr uint8_t OUTPUT_CHANNEL_1{0x04};
 
}  // namespace command
}  // namespace gp8413
 
}  // namespace unit
}  // namespace m5
 
#endif