AXP1xxCharger.hpp

Go to the documentation of this file.

 
#pragma once
#include "../../PmicChargerBase.hpp"
#include "../../../platform/SensorCommWrapper.hpp"
 
template<typename Regs>
class AXP1xxCharger : public PmicChargerBase
{
public:
    explicit AXP1xxCharger(SensorCommWrapper &core) : _core(core) {}
 
    bool enableCharging(bool enable) override
    {
        return enable ? _core.setRegBit(Regs::chg::CHARGE1, 7)
               : _core.clrRegBit(Regs::chg::CHARGE1, 7);
    }
 
    bool isCharging() override
    {
        return getStatus().charging;
    }
 
    bool setPreChargeCurrent(uint16_t mA) override
    {
        (void)mA;
        return false;
    }
 
    uint16_t getPreChargeCurrent() override
    {
        return 0;
    }
 
    bool setFastChargeCurrent(uint16_t mA) override
    {
        if (mA < Regs::chg::CHG_CUR_MIN) mA = Regs::chg::CHG_CUR_MIN;
        if (mA > Regs::chg::CHG_CUR_MAX) mA = Regs::chg::CHG_CUR_MAX;
        uint8_t code = (mA - Regs::chg::CHG_CUR_MIN) / Regs::chg::CHG_CUR_STEP;
        int regVal = _core.readReg(Regs::chg::CHARGE1);
        if (regVal < 0) return false;
        regVal = (regVal & 0xF0) | code;
        return _core.writeReg(Regs::chg::CHARGE1, static_cast<uint8_t>(regVal)) >= 0;
    }
 
    uint16_t getFastChargeCurrent() override
    {
        int val = _core.readReg(Regs::chg::CHARGE1);
        if (val < 0) return 0;
        uint8_t code = val & 0x0F;
        return code * Regs::chg::CHG_CUR_STEP + Regs::chg::CHG_CUR_MIN;
    }
 
    bool setTerminationCurrent(uint16_t mA) override
    {
        bool set = (mA >= 150);
        return _core.updateBits(Regs::chg::CHARGE1, 0x10, set ? 0x10 : 0x00) >= 0;
    }
 
    uint16_t getTerminationCurrent() override
    {
        int val = _core.readReg(Regs::chg::CHARGE1);
        if (val < 0) return 0;
        return (val & 0x10) ? 150 : 0;
    }
 
    bool setChargeVoltage(uint16_t mV) override
    {
        uint8_t code;
        if (mV <= 4100) {
            code = 0;
        } else if (mV <= 4150) {
            code = 1;
        } else if (mV <= 4200) {
            code = 2;
        } else {
            code = 3;
        }
        return _core.updateBits(Regs::chg::CHARGE1, 0x60, code << 5) >= 0;
    }
 
    uint16_t getChargeVoltage() override
    {
        int val = _core.readReg(Regs::chg::CHARGE1);
        if (val < 0) return 0;
        uint8_t code = (val >> 5) & 0x03;
        switch (code) {
        case 0:  return 4100;
        case 1:  return 4150;
        case 2:  return 4200;
        case 3:  return 4360;
        default: return 0;
        }
    }
 
    Status getStatus() override
    {
        Status status{};
        int s0 = _core.readReg(Regs::bmu::STATUS);
        int s1 = _core.readReg(Regs::bmu::MODE_CHGSTATUS);
        if (s0 < 0 || s1 < 0) {
            return status;
        }
        status.online = true;
        status.vbusPresent = (s0 >> 5) & 0x01;
        status.batteryPresent = (s1 >> 5) & 0x01;
        status.charging = (s1 >> 6) & 0x01;
        status.chargeDone = false;
        status.fault = (s1 >> 7) & 0x01;
        if (status.charging) {
            status.chargingStatus = ChargingStatus::FAST_CHARGE;
        } else {
            status.chargingStatus = ChargingStatus::NO_CHARGING;
        }
        return status;
    }
 
protected:
    SensorCommWrapper &_core;
};