AXP517Charger.cpp

Go to the documentation of this file.

 
#include "../../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_PMIC_AXP517
 
#include "AXP517Charger.hpp"
#include "AXP517Regs.hpp"
 
 
AXP517Charger::AXP517Charger(AXP517Core &core) : _core(core)
{
 
}
 
bool AXP517Charger::enableCharging(bool enable)
{
    return _core.updateBits(axp517_regs::ctrl::MODULE_EN1, 0x02, enable ? 0x02 : 0x00) >= 0;
}
 
bool AXP517Charger::isCharging()
{
    return getStatus().charging;
}
 
bool AXP517Charger::setPreChargeCurrent(uint16_t mA)
{
    return setCurrentWithStep(axp517_regs::chg::IPRECHG_ITRICHG, mA, 960, 64, 0x0F);
}
 
uint16_t AXP517Charger::getPreChargeCurrent()
{
    return getCurrentWithStep(axp517_regs::chg::IPRECHG_ITRICHG, 64, 0x0F);
}
 
bool AXP517Charger::setFastChargeCurrent(uint16_t mA)
{
    return setCurrentWithStep(axp517_regs::chg::ICC_SETTING, mA, 5120, 64, 0x7F);
}
 
uint16_t AXP517Charger::getFastChargeCurrent()
{
    return getCurrentWithStep(axp517_regs::chg::ICC_SETTING, 64, 0x7F);
}
 
bool AXP517Charger::setTerminationCurrent(uint16_t mA)
{
    return setCurrentWithStep(axp517_regs::chg::ITERM_CTRL, mA, 960, 64, 0x0F);
}
 
uint16_t AXP517Charger::getTerminationCurrent()
{
    return getCurrentWithStep(axp517_regs::chg::ITERM_CTRL, 64, 0x0F);
}
 
bool AXP517Charger::setChargeVoltage(uint16_t mV)
{
    uint8_t voltCode = 0;
    int regValue = 0;
    switch (mV) {
    case 4000: voltCode = 0x00; break;
    case 4100: voltCode = 0x01; break;
    case 4200: voltCode = 0x02; break;
    case 4350: voltCode = 0x03; break;
    case 4400: voltCode = 0x04; break;
    case 3800: voltCode = 0x05; break;
    case 3600: voltCode = 0x06; break;
    case 5000: voltCode = 0x07; break;
    default: return false;
    }
    regValue =  _core.readReg(axp517_regs::chg::CV_CHG_VOLTAGE);
    if (regValue < 0) {
        return false;
    }
    regValue = (regValue &  0xF8) | voltCode;
    if (_core.writeReg(axp517_regs::chg::CV_CHG_VOLTAGE, regValue) < 0) {
        return false;
    }
    return true;
}
 
uint16_t AXP517Charger::getChargeVoltage()
{
    int regValue = _core.readReg(axp517_regs::chg::CV_CHG_VOLTAGE);
    if (regValue < 0) {
        return 0;
    }
    uint8_t voltCode = regValue & 0x07;
    switch (voltCode) {
    case 0x00: return 4000;
    case 0x01: return 4100;
    case 0x02: return 4200;
    case 0x03: return 4350;
    case 0x04: return 4400;
    case 0x05: return 3800;
    case 0x06: return 3600;
    case 0x07: return 5000;
    default: break;
    }
    return 0;
}
 
AXP517Charger::Status AXP517Charger::getStatus()
{
    Status status {};
    uint8_t buffer[2] {};
    if (_core.readRegBuff(axp517_regs::bmu::STATUS0, buffer, sizeof(buffer)) < 0) {
        return status;
    }
    status.online = true;
    status.vbusPresent = (buffer[0] >> 5) & 0x01;
    status.batteryPresent = (buffer[0] >> 3) & 0x01;
    if (status.batteryPresent && status.vbusPresent) {
        uint8_t charging_status = buffer[1] & 0x03;
        status.charging = charging_status < 3;
        status.chargeDone = charging_status == 4;
    } else {
        status.charging = false;
        status.chargeDone = false;
    }
    status.fault = false; //TODO: Implement fault detection
    return status;
}
 
bool AXP517Charger::setCurrentWithStep(uint8_t reg, uint16_t milliamps,
                                       uint16_t max, uint16_t step, uint8_t mask)
{
    if (milliamps > max) milliamps = max;
    uint8_t code = milliamps / step;
    milliamps = code * step;
    int regValue = _core.readReg(reg);
    if (regValue < 0) {
        return false;
    }
    regValue = (regValue & ~mask) | code;
    if (_core.writeReg(reg, regValue) < 0) {
        return false;
    }
    return true;
}
 
uint16_t AXP517Charger::getCurrentWithStep(uint8_t reg, uint16_t step, uint8_t mask)
{
    int regValue = _core.readReg(reg);
    if (regValue < 0) {
        return 0;
    }
    return (regValue & mask) * step;
}
 
#endif