PmicAXP517.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_PMIC_AXP517
 
#include "../../PmicBase.hpp"
#include "../../PmicAdcBase.hpp"
#include "../../PmicIrqBase.hpp"
#include "../../PmicPowerBase.hpp"
 
#include "AXP517Core.hpp"
#include "AXP517Adc.hpp"
#include "AXP517Irq.hpp"
#include "AXP517Charger.hpp"
#include "AXP517Bc12.hpp"
#include "AXP517Led.hpp"
#include "AXP517Power.hpp"
#include "AXP517Gpio.hpp"
#include "AXP517Tcpc.hpp"
#include "AXP517Pd.hpp"
#include "AXP517PdNegotiator.hpp"
 
static constexpr uint8_t AXP517_SLAVE_ADDRESS = 0x34;
 
class PmicAXP517 : public PmicBase
{
public:
    using Module = AXP517Core::Module;
 
    PmicAXP517() : _core(), _adc(_core)
        , _irq(_core), _charger(_core)
        , _bc12(_core), _led(_core)
        , _power(_core), _gpio(_core),
        _bc12_2(_core), _tcpc(_core), _pd(_tcpc),
        _pdNegotiator(_tcpc, _pd)
    {}
 
 
#if defined(ARDUINO)
    bool begin(TwoWire &wire, uint8_t addr, int sda = -1, int scl = -1)
    {
        return _core.begin(wire, addr, sda, scl);
    }
 
    bool begin(TwoWire &wire, uint8_t addr, int sda, int scl, int irqPin)
    {
        if (!_core.begin(wire, addr, sda, scl)) return false;
        return configurePdIrqPin(irqPin);
    }
#elif defined(ESP_PLATFORM)
#if defined(SENSORLIB_USE_I2C_LEGACY)
 
    bool begin(i2c_port_t port_num, uint8_t addr, int sda = -1, int scl = -1)
    {
        return _core.begin(port_num, addr, sda, scl);
    }
 
    bool begin(i2c_port_t port_num, uint8_t addr, int sda, int scl, int irqPin)
    {
        if (!_core.begin(port_num, addr, sda, scl)) return false;
        return configurePdIrqPin(irqPin);
    }
#else
 
    bool begin(i2c_master_bus_handle_t handle, uint8_t addr)
    {
        return _core.begin(handle, addr);
    }
 
    bool begin(i2c_master_bus_handle_t handle, uint8_t addr, int irqPin)
    {
        if (!_core.begin(handle, addr)) return false;
        return configurePdIrqPin(irqPin);
    }
#endif
#endif
    bool begin(SensorCommCustom::CustomCallback callback,
               SensorCommCustomHal::CustomHalCallback hal_cb,
               uint8_t addr)
    {
        return _core.begin(callback, hal_cb, addr);
    }
 
    bool begin(SensorCommCustom::CustomCallback callback,
               SensorCommCustomHal::CustomHalCallback hal_cb,
               uint8_t addr,
               int irqPin)
    {
        if (!_core.begin(callback, hal_cb, addr)) return false;
        return configurePdIrqPin(irqPin);
    }
 
    void end()
    {
    }
 
    PmicCapability::Capability getCapabilities() const override
    {
        return PmicCapability::Capability::PmicSupportCharger | PmicCapability::Capability::PmicSupportPower | PmicCapability::Capability::PmicSupportAdc |
               PmicCapability::Capability::PmicSupportGpio | PmicCapability::Capability::PmicSupportLed | PmicCapability::Capability::PmicSupportIrq |
               PmicCapability::Capability::PmicSupportBc12 | PmicCapability::Capability::PmicSupportTypeC;
    }
 
    const PmicConfig &getConfig() const override
    {
        static const PmicConfig config = {
            .chipName = "AXP517",
            .i2cAddress = 0x34,
            .chipIdReg = 0x00,
            .chipIdValue = 0,
            .channelCount = 0,
            .capabilities = PmicCapability::Capability::PmicSupportCharger |
            PmicCapability::Capability::PmicSupportPower |
            PmicCapability::Capability::PmicSupportAdc |
            PmicCapability::Capability::PmicSupportGpio |
            PmicCapability::Capability::PmicSupportLed |
            PmicCapability::Capability::PmicSupportIrq |
            PmicCapability::Capability::PmicSupportBc12 |
            PmicCapability::Capability::PmicSupportTypeC,
            // REG62H[6:0]: ICC = 64*N mA, N=0..80
            .chargeCurrentMin  = 0,
            .chargeCurrentMax  = 5120,
            .chargeCurrentStep = 64,
            .chargeCurrentSteps = 81,
        };
        return config;
    }
 
    AXP517Adc &adc()
    {
        return _adc;
    }
 
    AXP517Irq &irq()
    {
        return _irq;
    }
 
    PmicPowerBase &getPower() override
    {
        return _power;
    }
 
    PmicChargerBase *getCharger() override
    {
        return &_charger;
    }
 
    PmicAdcBase &getAdc() override
    {
        return _adc;
    }
 
    PmicGpioBase *getGpio() override
    {
        return &_gpio;
    }
 
    PmicIrqBase *getIrq() override
    {
        return &_irq;
    }
 
    AXP517Charger &charger()
    {
        return _charger;
    }
 
    AXP517Bc12 &bc12()
    {
        return _bc12;
    }
 
    PmicLedBase &getLed() override
    {
        return _led;
    }
 
    AXP517Led &led()
    {
        return _led;
    }
 
    AXP517Power &power()
    {
        return _power;
    }
 
    AXP517Gpio &gpio()
    {
        return _gpio;
    }
 
    AXP517Bc12 &bc12_2()
    {
        return _bc12_2;
    }
 
    AXP517Tcpc &tcpc()
    {
        return _tcpc;
    }
 
    AXP517Pd &pdProtocol()
    {
        return _pd;
    }
 
    AXP517PdNegotiator &pd()
    {
        return _pdNegotiator;
    }
 
    AXP517PdNegotiator &pdNegotiator()
    {
        return _pdNegotiator;
    }
 
    bool setPdIrqPin(int irqPin)
    {
        return _pdNegotiator.setIrqPin(irqPin);
    }
 
    bool initPdSink(int irqPin)
    {
        return _pdNegotiator.initSink(irqPin);
    }
 
    bool requestPd(uint16_t targetMv, uint32_t timeoutMs = 6000,
                   AXP517PdNegotiator::SourceCaps *outCaps = nullptr)
    {
        AXP517PdNegotiator::RequestParams req{};
        req.targetMv = targetMv;
        return _pdNegotiator.negotiate(req, outCaps, timeoutMs);
    }
 
    bool enableModule(Module module, bool enable)
    {
        return _core.enableModule(module, enable);
    }
 
    bool isModuleEnabled(Module module)
    {
        return _core.isModuleEnabled(module);
    }
 
    AXP517Core &core()
    {
        return _core;
    }
 
    const char *getChipName() const override
    {
        return "AXP517";
    }
 
private:
    const AXP517Core &core() const
    {
        return _core;
    }
 
    bool configurePdIrqPin(int irqPin)
    {
        if (irqPin < 0) return true;
        return _pdNegotiator.setIrqPin(irqPin);
    }
 
private:
    AXP517Core _core;                    
    AXP517Adc _adc;                      
    AXP517Irq _irq;                      
    AXP517Charger _charger;              
    AXP517Bc12 _bc12;                    
    AXP517Led _led;                      
    AXP517Power _power;                  
    AXP517Gpio _gpio;                    
    AXP517Bc12 _bc12_2;                  
    AXP517Tcpc _tcpc;                    
    AXP517Pd _pd;                        
    AXP517PdNegotiator _pdNegotiator;    
};
 
#endif