PmicAXP202.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_PMIC_AXP202
 
#include "../../PmicBase.hpp"
#include "../../PmicAdcBase.hpp"
#include "../../PmicIrqBase.hpp"
 
#include "AXP202Regs.hpp"
#include "AXP202Core.hpp"
#include "AXP202Adc.hpp"
#include "AXP202PowerEx.hpp"
#include "AXP202ChargerEx.hpp"
#include "AXP202Coulomb.hpp"
#include "../axp1xx/AXP1xxIrq.hpp"
#include "../axp1xx/AXP1xxCharger.hpp"
#include "AXP202Gpio.hpp"
#include "AXP202Channel.hpp"
 
#include "../axp1xx/AXP1xxPower.hpp"
#include "../axp1xx/AXP1xxPwron.hpp"
#include "../axp1xx/AXP1xxTimer.hpp"
#include "../axp1xx/AXP1xxLed.hpp"
 
static constexpr uint8_t AXP202_SLAVE_ADDRESS = 0x35;
 
class PmicAXP202 : public PmicBase
{
public:
    PmicAXP202() : _core(), _adc(_core)
        , _irq(_core), _charger(_core)
        , _power(_core)
        , _pwron(_core)
        , _timer(_core)
        , _led(_core)
        , _gpio(_core), _channel(_core)
        , _powerEx(_core), _chargerEx(_core), _coulomb(_core)
    {}
 
#if defined(ARDUINO)
    bool begin(TwoWire &wire, uint8_t addr, int sda = -1, int scl = -1)
    {
        return _core.begin(wire, addr, sda, scl);
    }
#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);
    }
#else
    bool begin(i2c_master_bus_handle_t handle, uint8_t addr)
    {
        return _core.begin(handle, addr);
    }
#endif
#endif
 
    bool begin(SensorCommCustom::CustomCallback callback,
               SensorCommCustomHal::CustomHalCallback hal_cb,
               uint8_t addr)
    {
        return _core.begin(callback, hal_cb, addr);
    }
 
    void end()
    {
    }
 
    PmicCapability::Capability getCapabilities() const override
    {
        return PmicCapability::Capability::PmicSupportCharger |
               PmicCapability::Capability::PmicSupportPower |
               PmicCapability::Capability::PmicSupportAdc |
               PmicCapability::Capability::PmicSupportIrq |
               PmicCapability::Capability::PmicSupportGpio |
               PmicCapability::Capability::PmicSupportLed |
               PmicCapability::Capability::PmicSupportPowerBtn |
               PmicCapability::Capability::PmicSupportChannel;
    }
 
    const PmicConfig &getConfig() const override
    {
        static const PmicConfig config = {
            .chipName = "AXP202",
            .i2cAddress = 0x35,
            .chipIdReg = 0x03,
            .chipIdValue = 0x41,
            .channelCount = 7,
            .capabilities = PmicCapability::Capability::PmicSupportCharger |
            PmicCapability::Capability::PmicSupportPower |
            PmicCapability::Capability::PmicSupportAdc |
            PmicCapability::Capability::PmicSupportIrq |
            PmicCapability::Capability::PmicSupportGpio |
            PmicCapability::Capability::PmicSupportLed |
            PmicCapability::Capability::PmicSupportPowerBtn |
            PmicCapability::Capability::PmicSupportChannel,
            // REG33H[3:0]: Icharge = [300 + N*100] mA, N=0..15
            .chargeCurrentMin  = 300,
            .chargeCurrentMax  = 1800,
            .chargeCurrentStep = 100,
            .chargeCurrentSteps = 16,
        };
        return config;
    }
 
    // ---- Interface accessors (PmicBase contract) ----
 
    PmicPowerBase &getPower() override
    {
        return _power;
    }
 
    PmicChargerBase *getCharger() override
    {
        return &_charger;
    }
 
    PmicAdcBase &getAdc() override
    {
        return _adc;
    }
 
    PmicGpioBase *getGpio() override
    {
        return &_gpio;
    }
 
    PmicLedBase &getLed() override
    {
        return _led;
    }
 
    PmicChannelBase *getChannel() override
    {
        return &_channel;
    }
 
    PmicIrqBase *getIrq() override
    {
        return &_irq;
    }
 
    const char *getChipName() const override
    {
        return "AXP202";
    }
 
    // ---- Chip-specific module accessors ----
 
    AXP1xxIrq<axp202_regs> &irq()
    {
        return _irq;
    }
 
    AXP1xxTimer<axp202_regs> &timer()
    {
        return _timer;
    }
 
    AXP1xxCharger<axp202_regs> &charger()
    {
        return _charger;
    }
 
    AXP202Gpio &gpio()
    {
        return _gpio;
    }
 
    AXP202Adc &adc()
    {
        return _adc;
    }
 
    AXP202Core &core()
    {
        return _core;
    }
 
    AXP202PowerEx &power()
    {
        return _powerEx;
    }
 
    AXP202ChargerEx &chargerEx()
    {
        return _chargerEx;
    }
 
    AXP202Coulomb &coulomb()
    {
        return _coulomb;
    }
 
    AXP1xxLed<axp202_regs> &led()
    {
        return _led;
    }
 
    AXP1xxPwron<axp202_regs> &pwron()
    {
        return _pwron;
    }
 
    // ---- Status & basic info ----
 
    uint16_t getStatus()
    {
        int s0 = _core.readReg(axp202_regs::bmu::STATUS);
        int s1 = _core.readReg(axp202_regs::bmu::MODE_CHGSTATUS);
        if (s0 < 0 || s1 < 0) return 0;
        return (static_cast<uint16_t>(s0) << 8) | static_cast<uint16_t>(s1);
    }
 
    bool isVbusGood()
    {
        return _core.getRegBit(axp202_regs::bmu::STATUS, 5);
    }
 
    bool isBatteryConnect()
    {
        return _core.getRegBit(axp202_regs::bmu::MODE_CHGSTATUS, 5);
    }
 
    bool isCharging()
    {
        return _charger.isCharging();
    }
 
    uint8_t getChipID()
    {
        int id = _core.readReg(axp202_regs::bmu::IC_TYPE);
        if (id < 0) return 0;
        return static_cast<uint8_t>(id);
    }
 
    // ---- System control ----
 
    void shutdown()
    {
        _core.setRegBit(axp202_regs::pmu::OFF_CTL, 7);
    }
 
    bool enableSleep(bool en)
    {
        return en ? _core.setRegBit(axp202_regs::pmu::VOFF_SET, 3)
               : _core.clrRegBit(axp202_regs::pmu::VOFF_SET, 3);
    }
 
private:
    const AXP202Core &core() const
    {
        return _core;
    }
 
    AXP202Core _core;
    AXP202Adc _adc;
    AXP1xxIrq<axp202_regs> _irq;
    AXP1xxCharger<axp202_regs> _charger;
    AXP1xxPower<axp202_regs> _power;
    AXP1xxPwron<axp202_regs> _pwron;
    AXP1xxTimer<axp202_regs> _timer;
    AXP1xxLed<axp202_regs> _led;
    AXP202Gpio _gpio;
    AXP202Channel _channel;
    AXP202PowerEx _powerEx;
    AXP202ChargerEx _chargerEx;
    AXP202Coulomb _coulomb;
};
 
using AXP202Irq = AXP1xxIrq<axp202_regs>;
 
using AXP202Timer = AXP1xxTimer<axp202_regs>;
 
#endif