From 24f520a32d4eb40160f58428476e2a82b385dcea Mon Sep 17 00:00:00 2001 From: YuXifeng <2860280851@qq.com> Date: Mon, 31 Mar 2025 22:09:47 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0PMIC:axp202=E6=94=AF=E6=8C=81?= =?UTF-8?q?=EF=BC=8CC/C++=E6=B7=B7=E5=90=88=E7=BC=96=E7=A8=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/pmic_axp202/CMakeLists.txt | 8 + components/pmic_axp202/src/axp20x.cpp | 2298 +++++++++++++++++++++++++ components/pmic_axp202/src/axp20x.hpp | 961 +++++++++++ main/CMakeLists.txt | 3 + main/Kconfig.projbuild | 33 + main/bsp_driver/i2c_port.c | 78 + main/bsp_driver/i2c_port.h | 31 + main/bsp_pmic.cpp | 247 +++ main/main.c | 19 +- 9 files changed, 3676 insertions(+), 2 deletions(-) create mode 100644 components/pmic_axp202/CMakeLists.txt create mode 100644 components/pmic_axp202/src/axp20x.cpp create mode 100644 components/pmic_axp202/src/axp20x.hpp create mode 100644 main/bsp_driver/i2c_port.c create mode 100644 main/bsp_driver/i2c_port.h create mode 100644 main/bsp_pmic.cpp diff --git a/components/pmic_axp202/CMakeLists.txt b/components/pmic_axp202/CMakeLists.txt new file mode 100644 index 0000000..d3eeef0 --- /dev/null +++ b/components/pmic_axp202/CMakeLists.txt @@ -0,0 +1,8 @@ + +# set(COMPONENT_SRCS "./AXP202X_Library/src/axp20x.cpp") +# set(COMPONENT_ADD_INCLUDEDIRS "./AXP202X_Library/src") +# register_component() + +idf_component_register(SRCS "src/axp20x.cpp" + INCLUDE_DIRS "src" + ) \ No newline at end of file diff --git a/components/pmic_axp202/src/axp20x.cpp b/components/pmic_axp202/src/axp20x.cpp new file mode 100644 index 0000000..e52f3d3 --- /dev/null +++ b/components/pmic_axp202/src/axp20x.cpp @@ -0,0 +1,2298 @@ +///////////////////////////////////////////////////////////////// +/* + __ _______ ___ ___ ___ + /\ \ \ / / __ \__ \ / _ \__ \ + / \ \ V /| |__) | ) | | | | ) | + / /\ \ > < | ___/ / /| | | |/ / + / ____ \ / . \| | / /_| |_| / /_ + /_/ \_\/_/ \_\_| |____|\___/____| + + +MIT License + +Copyright (c) 2019 lewis he + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +axp20x.cpp - Arduino library for X-Power AXP202 chip. +Created by Lewis he on April 1, 2019. +github:https://github.com/lewisxhe/AXP202X_Libraries +*/ +///////////////////////////////////////////////////////////////// + +#include "axp20x.hpp" +#include + +#define ISCONNECETD(ret) do{if(!_init)return ret;}while(0) + +const uint8_t AXP20X_Class::startupParams[] = { + 0b00000000, + 0b01000000, + 0b10000000, + 0b11000000 +}; + +const uint8_t AXP20X_Class::longPressParams[] = { + 0b00000000, + 0b00010000, + 0b00100000, + 0b00110000 +}; + +const uint8_t AXP20X_Class::shutdownParams[] = { + 0b00000000, + 0b00000001, + 0b00000010, + 0b00000011 +}; + +const uint8_t AXP20X_Class::targetVolParams[] = { + 0b00000000, + 0b00100000, + 0b01000000, + 0b01100000 +}; + + + +// Power Output Control register +uint8_t AXP20X_Class::_outputReg; + +int AXP20X_Class::_axp_probe(void) +{ + uint8_t data; + if (_isAxp173) { + //!Axp173 does not have a chip ID, read the status register to see if it reads normally + _readByte(0x01, 1, &data); + if (data == 0 || data == 0xFF) { + return AXP_FAIL; + } + _chip_id = AXP173_CHIP_ID; + _readByte(AXP202_LDO234_DC23_CTL, 1, &_outputReg); + AXP_DEBUG("OUTPUT Register 0x%x\n", _outputReg); + _init = true; + return AXP_PASS; + } + _readByte(AXP202_IC_TYPE, 1, &_chip_id); + AXP_DEBUG("chip id detect 0x%x\n", _chip_id); + if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { + AXP_DEBUG("Detect CHIP :%s\n", _chip_id == AXP202_CHIP_ID ? "AXP202" : "AXP192"); + _readByte(AXP202_LDO234_DC23_CTL, 1, &_outputReg); + AXP_DEBUG("OUTPUT Register 0x%x\n", _outputReg); + _init = true; + return AXP_PASS; + } + return AXP_FAIL; +} + +#ifdef ARDUINO +int AXP20X_Class::begin(TwoWire &port, uint8_t addr, bool isAxp173) +{ + _i2cPort = &port; //Grab which port the user wants us to use + _address = addr; + _isAxp173 = isAxp173; + + return _axp_probe(); +} +#endif + +int AXP20X_Class::begin(axp_com_fptr_t read_cb, axp_com_fptr_t write_cb, uint8_t addr, bool isAxp173) +{ + if (read_cb == nullptr || write_cb == nullptr)return AXP_FAIL; + _read_cb = read_cb; + _write_cb = write_cb; + _address = addr; + _isAxp173 = isAxp173; + return _axp_probe(); +} + +//Only axp192 chip +bool AXP20X_Class::isDCDC1Enable(void) +{ + if (_chip_id == AXP192_CHIP_ID) + return IS_OPEN(_outputReg, AXP192_DCDC1); + else if (_chip_id == AXP173_CHIP_ID) + return IS_OPEN(_outputReg, AXP173_DCDC1); + return false; +} + +bool AXP20X_Class::isExtenEnable(void) +{ + if (_chip_id == AXP192_CHIP_ID) + return IS_OPEN(_outputReg, AXP192_EXTEN); + else if (_chip_id == AXP202_CHIP_ID) + return IS_OPEN(_outputReg, AXP202_EXTEN); + else if (_chip_id == AXP173_CHIP_ID) { + uint8_t data; + _readByte(AXP173_EXTEN_DC2_CTL, 1, &data); + return IS_OPEN(data, AXP173_CTL_EXTEN_BIT); + } + return false; +} + +bool AXP20X_Class::isLDO2Enable(void) +{ + if (_chip_id == AXP173_CHIP_ID) { + return IS_OPEN(_outputReg, AXP173_LDO2); + } + //axp192 same axp202 ldo2 bit + return IS_OPEN(_outputReg, AXP202_LDO2); +} + +bool AXP20X_Class::isLDO3Enable(void) +{ + if (_chip_id == AXP192_CHIP_ID) + return IS_OPEN(_outputReg, AXP192_LDO3); + else if (_chip_id == AXP202_CHIP_ID) + return IS_OPEN(_outputReg, AXP202_LDO3); + else if (_chip_id == AXP173_CHIP_ID) + return IS_OPEN(_outputReg, AXP173_LDO3); + return false; +} + +bool AXP20X_Class::isLDO4Enable(void) +{ + if (_chip_id == AXP202_CHIP_ID) + return IS_OPEN(_outputReg, AXP202_LDO4); + if (_chip_id == AXP173_CHIP_ID) + return IS_OPEN(_outputReg, AXP173_LDO4); + return false; +} + +bool AXP20X_Class::isDCDC2Enable(void) +{ + if (_chip_id == AXP173_CHIP_ID) { + uint8_t data; + _readByte(AXP173_EXTEN_DC2_CTL, 1, &data); + return IS_OPEN(data, AXP173_CTL_DC2_BIT); + } + //axp192 same axp202 dc2 bit + return IS_OPEN(_outputReg, AXP202_DCDC2); +} + +bool AXP20X_Class::isDCDC3Enable(void) +{ + if (_chip_id == AXP173_CHIP_ID) + return false; + //axp192 same axp202 dc3 bit + return IS_OPEN(_outputReg, AXP202_DCDC3); +} + +int AXP20X_Class::setPowerOutPut(uint8_t ch, bool en) +{ + uint8_t data; + uint8_t val = 0; + if (!_init) + return AXP_NOT_INIT; + + //! Axp173 cannot use the REG12H register to control + //! DC2 and EXTEN. It is necessary to control REG10H separately. + if (_chip_id == AXP173_CHIP_ID) { + _readByte(AXP173_EXTEN_DC2_CTL, 1, &data); + if (ch & AXP173_DCDC2) { + data = en ? data | _BV(AXP173_CTL_DC2_BIT) : data & (~_BV(AXP173_CTL_DC2_BIT)); + ch &= (~_BV(AXP173_DCDC2)); + _writeByte(AXP173_EXTEN_DC2_CTL, 1, &data); + } else if (ch & AXP173_EXTEN) { + data = en ? data | _BV(AXP173_CTL_EXTEN_BIT) : data & (~_BV(AXP173_CTL_EXTEN_BIT)); + ch &= (~_BV(AXP173_EXTEN)); + _writeByte(AXP173_EXTEN_DC2_CTL, 1, &data); + } + } + + _readByte(AXP202_LDO234_DC23_CTL, 1, &data); + if (en) { + data |= (1 << ch); + } else { + data &= (~(1 << ch)); + } + + if (_chip_id == AXP202_CHIP_ID) { + FORCED_OPEN_DCDC3(data); //! Must be forced open in T-Watch + } + + _writeByte(AXP202_LDO234_DC23_CTL, 1, &data); + +#ifdef ARDUINO + delay(1); +#endif + _readByte(AXP202_LDO234_DC23_CTL, 1, &val); + if (data == val) { + _outputReg = val; + return AXP_PASS; + } + return AXP_FAIL; +} + +bool AXP20X_Class::isChargeing(void) +{ + return isCharging(); +} + +bool AXP20X_Class::isCharging(void) +{ + uint8_t reg; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_MODE_CHGSTATUS, 1, ®); + return IS_OPEN(reg, 6); +} + +bool AXP20X_Class::isBatteryConnect(void) +{ + uint8_t reg; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_MODE_CHGSTATUS, 1, ®); + return IS_OPEN(reg, 5); +} + +float AXP20X_Class::getAcinVoltage(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_ACIN_VOL_H8, AXP202_ACIN_VOL_L4) * AXP202_ACIN_VOLTAGE_STEP; +} + +float AXP20X_Class::getAcinCurrent(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_ACIN_CUR_H8, AXP202_ACIN_CUR_L4) * AXP202_ACIN_CUR_STEP; +} + +float AXP20X_Class::getVbusVoltage(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_VBUS_VOL_H8, AXP202_VBUS_VOL_L4) * AXP202_VBUS_VOLTAGE_STEP; +} + +float AXP20X_Class::getVbusCurrent(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_VBUS_CUR_H8, AXP202_VBUS_CUR_L4) * AXP202_VBUS_CUR_STEP; +} + +float AXP20X_Class::getTemp(void) +{ + if (!_init) + return AXP_NOT_INIT; + // Internal temperature + // 000H => -144.7℃ + // STEP => 0.1℃ + // FFFH => 264.8℃ + return _getRegistResult(AXP202_INTERNAL_TEMP_H8, AXP202_INTERNAL_TEMP_L4) * AXP202_INTERNAL_TEMP_STEP - 144.7; +} + +float AXP20X_Class::getTSTemp(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_TS_IN_H8, AXP202_TS_IN_L4) * AXP202_TS_PIN_OUT_STEP; +} + +float AXP20X_Class::getGPIO0Voltage(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_GPIO0_VOL_ADC_H8, AXP202_GPIO0_VOL_ADC_L4) * AXP202_GPIO0_STEP; +} + +float AXP20X_Class::getGPIO1Voltage(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_GPIO1_VOL_ADC_H8, AXP202_GPIO1_VOL_ADC_L4) * AXP202_GPIO1_STEP; +} + +/* +Note: the battery power formula: +Pbat =2* register value * Voltage LSB * Current LSB / 1000. +(Voltage LSB is 1.1mV; Current LSB is 0.5mA, and unit of calculation result is mW.) +*/ +float AXP20X_Class::getBattInpower(void) +{ + float rslt; + uint8_t hv, mv, lv; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_BAT_POWERH8, 1, &hv); + _readByte(AXP202_BAT_POWERM8, 1, &mv); + _readByte(AXP202_BAT_POWERL8, 1, &lv); + rslt = (hv << 16) | (mv << 8) | lv; + rslt = 2 * rslt * 1.1 * 0.5 / 1000; + return rslt; +} + +float AXP20X_Class::getBattVoltage(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_BAT_AVERVOL_H8, AXP202_BAT_AVERVOL_L4) * AXP202_BATT_VOLTAGE_STEP; +} + +float AXP20X_Class::getBattChargeCurrent(void) +{ + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP202_CHIP_ID: + return _getRegistResult(AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L4) * AXP202_BATT_CHARGE_CUR_STEP; + case AXP192_CHIP_ID: + return _getRegistH8L5(AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L5) * AXP202_BATT_CHARGE_CUR_STEP; + default: + return AXP_FAIL; + } +} + +float AXP20X_Class::getBattDischargeCurrent(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistH8L5(AXP202_BAT_AVERDISCHGCUR_H8, AXP202_BAT_AVERDISCHGCUR_L5) * AXP202_BATT_DISCHARGE_CUR_STEP; +} + +float AXP20X_Class::getSysIPSOUTVoltage(void) +{ + if (!_init) + return AXP_NOT_INIT; + return _getRegistResult(AXP202_APS_AVERVOL_H8, AXP202_APS_AVERVOL_L4) * AXP202_APS_VOLTAGE_STEP; +} + +/* +Coulomb calculation formula: +C= 65536 * current LSB *(charge coulomb counter value - discharge coulomb counter value) / +3600 / ADC sample rate. Refer to REG84H setting for ADC sample rate;the current LSB is +0.5mA;unit of the calculation result is mAh. ) +*/ +uint32_t AXP20X_Class::getBattChargeCoulomb(void) +{ + uint8_t buffer[4]; + if (!_init) + return AXP_NOT_INIT; + _readByte(0xB0, 4, buffer); + return (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; +} + +uint32_t AXP20X_Class::getBattDischargeCoulomb(void) +{ + uint8_t buffer[4]; + if (!_init) + return AXP_NOT_INIT; + _readByte(0xB4, 4, buffer); + return (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; +} + +float AXP20X_Class::getCoulombData(void) +{ + if (!_init) + return AXP_NOT_INIT; + uint32_t charge = getBattChargeCoulomb(), discharge = getBattDischargeCoulomb(); + uint8_t rate = getAdcSamplingRate(); + float result = 65536.0 * 0.5 * ((float)charge - (float)discharge) / 3600.0 / rate; + return result; +} + + +//------------------------------------------------------- +// New Coulomb functions by MrFlexi +//------------------------------------------------------- + +uint8_t AXP20X_Class::getCoulombRegister(void) +{ + uint8_t buffer; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_COULOMB_CTL, 1, &buffer); + return buffer; +} + + +int AXP20X_Class::setCoulombRegister(uint8_t val) +{ + if (!_init) + return AXP_NOT_INIT; + _writeByte(AXP202_COULOMB_CTL, 1, &val); + return AXP_PASS; +} + + +int AXP20X_Class::EnableCoulombcounter(void) +{ + + if (!_init) + return AXP_NOT_INIT; + uint8_t val = 0x80; + _writeByte(AXP202_COULOMB_CTL, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::DisableCoulombcounter(void) +{ + + if (!_init) + return AXP_NOT_INIT; + uint8_t val = 0x00; + _writeByte(AXP202_COULOMB_CTL, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::StopCoulombcounter(void) +{ + + if (!_init) + return AXP_NOT_INIT; + uint8_t val = 0xB8; + _writeByte(AXP202_COULOMB_CTL, 1, &val); + return AXP_PASS; +} + + +int AXP20X_Class::ClearCoulombcounter(void) +{ + if (!_init) + return AXP_NOT_INIT; + uint8_t val = 0xA0; + _writeByte(AXP202_COULOMB_CTL, 1, &val); + return AXP_PASS; +} + +//------------------------------------------------------- +// END +//------------------------------------------------------- + + + +uint8_t AXP20X_Class::getAdcSamplingRate(void) +{ + //axp192 same axp202 aregister address 0x84 + if (!_init) + return AXP_NOT_INIT; + uint8_t val; + _readByte(AXP202_ADC_SPEED, 1, &val); + return 25 * (int)pow(2, (val & 0xC0) >> 6); +} + +int AXP20X_Class::setAdcSamplingRate(axp_adc_sampling_rate_t rate) +{ + //axp192 same axp202 aregister address 0x84 + if (!_init) + return AXP_NOT_INIT; + if (rate > AXP_ADC_SAMPLING_RATE_200HZ) + return AXP_FAIL; + uint8_t val; + _readByte(AXP202_ADC_SPEED, 1, &val); + uint8_t rw = rate; + val &= 0x3F; + val |= (rw << 6); + _writeByte(AXP202_ADC_SPEED, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setTSfunction(axp_ts_pin_function_t func) +{ + //axp192 same axp202 aregister address 0x84 + if (!_init) + return AXP_NOT_INIT; + if (func > AXP_TS_PIN_FUNCTION_ADC) + return AXP_FAIL; + uint8_t val; + _readByte(AXP202_ADC_SPEED, 1, &val); + uint8_t rw = func; + val &= 0xFA; + val |= (rw << 2); + _writeByte(AXP202_ADC_SPEED, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setTScurrent(axp_ts_pin_current_t current) +{ + //axp192 same axp202 aregister address 0x84 + if (!_init) + return AXP_NOT_INIT; + if (current > AXP_TS_PIN_CURRENT_80UA) + return AXP_FAIL; + uint8_t val; + _readByte(AXP202_ADC_SPEED, 1, &val); + uint8_t rw = current; + val &= 0xCF; + val |= (rw << 4); + _writeByte(AXP202_ADC_SPEED, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setTSmode(axp_ts_pin_mode_t mode) +{ + //axp192 same axp202 aregister address 0x84 + if (!_init) + return AXP_NOT_INIT; + if (mode > AXP_TS_PIN_MODE_ENABLE) + return AXP_FAIL; + uint8_t val; + _readByte(AXP202_ADC_SPEED, 1, &val); + uint8_t rw = mode; + val &= 0xFC; + val |= rw; + _writeByte(AXP202_ADC_SPEED, 1, &val); + + // TS pin ADC function enable/disable + if (mode == AXP_TS_PIN_MODE_DISABLE) + adc1Enable(AXP202_TS_PIN_ADC1, false); + else + adc1Enable(AXP202_TS_PIN_ADC1, true); + return AXP_PASS; +} + +int AXP20X_Class::adc1Enable(uint16_t params, bool en) +{ + if (!_init) + return AXP_NOT_INIT; + uint8_t val; + _readByte(AXP202_ADC_EN1, 1, &val); + if (en) + val |= params; + else + val &= ~(params); + _writeByte(AXP202_ADC_EN1, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::adc2Enable(uint16_t params, bool en) +{ + if (!_init) + return AXP_NOT_INIT; + uint8_t val; + _readByte(AXP202_ADC_EN2, 1, &val); + if (en) + val |= params; + else + val &= ~(params); + _writeByte(AXP202_ADC_EN2, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::enableIRQ(uint64_t params, bool en) +{ + if (!_init) + return AXP_NOT_INIT; + uint8_t val, val1; + if (params & 0xFFUL) { + val1 = params & 0xFF; + _readByte(AXP202_INTEN1, 1, &val); + if (en) + val |= val1; + else + val &= ~(val1); + AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN1, val); + _writeByte(AXP202_INTEN1, 1, &val); + } + if (params & 0xFF00UL) { + val1 = params >> 8; + _readByte(AXP202_INTEN2, 1, &val); + if (en) + val |= val1; + else + val &= ~(val1); + AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN2, val); + _writeByte(AXP202_INTEN2, 1, &val); + } + + if (params & 0xFF0000UL) { + val1 = params >> 16; + _readByte(AXP202_INTEN3, 1, &val); + if (en) + val |= val1; + else + val &= ~(val1); + AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN3, val); + _writeByte(AXP202_INTEN3, 1, &val); + } + + if (params & 0xFF000000UL) { + val1 = params >> 24; + _readByte(AXP202_INTEN4, 1, &val); + if (en) + val |= val1; + else + val &= ~(val1); + AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN4, val); + _writeByte(AXP202_INTEN4, 1, &val); + } + + if (params & 0xFF00000000ULL) { + val1 = params >> 32; + uint8_t reg = _chip_id == AXP192_CHIP_ID ? AXP192_INTEN5 : AXP202_INTEN5; + _readByte(reg, 1, &val); + if (en) + val |= val1; + else + val &= ~(val1); + AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", reg, val); + _writeByte(reg, 1, &val); + } + return AXP_PASS; +} + +int AXP20X_Class::readIRQ(void) +{ + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP192_CHIP_ID: + for (int i = 0; i < 4; ++i) { + _readByte(AXP192_INTSTS1 + i, 1, &_irq[i]); + } + _readByte(AXP192_INTSTS5, 1, &_irq[4]); + return AXP_PASS; + + case AXP202_CHIP_ID: + for (int i = 0; i < 5; ++i) { + _readByte(AXP202_INTSTS1 + i, 1, &_irq[i]); + } + return AXP_PASS; + default: + return AXP_FAIL; + } +} + +void AXP20X_Class::clearIRQ(void) +{ + uint8_t val = 0xFF; + switch (_chip_id) { + case AXP192_CHIP_ID: + for (int i = 0; i < 3; i++) { + _writeByte(AXP192_INTSTS1 + i, 1, &val); + } + _writeByte(AXP192_INTSTS5, 1, &val); + break; + case AXP202_CHIP_ID: + for (int i = 0; i < 5; i++) { + _writeByte(AXP202_INTSTS1 + i, 1, &val); + } + break; + default: + break; + } + memset(_irq, 0, sizeof(_irq)); +} + + +bool AXP20X_Class::isVBUSPlug(void) +{ + if (!_init) + return AXP_NOT_INIT; + uint8_t reg; + _readByte(AXP202_STATUS, 1, ®); + return IS_OPEN(reg, 5); +} + +//IRQ1 REGISTER : AXP202:0x40H AXP192:0X44H +bool AXP20X_Class::isAcinOverVoltageIRQ(void) +{ + return (bool)(_irq[0] & _BV(7)); +} + +bool AXP20X_Class::isAcinPlugInIRQ(void) +{ + return (bool)(_irq[0] & _BV(6)); +} + +bool AXP20X_Class::isAcinRemoveIRQ(void) +{ + return (bool)(_irq[0] & _BV(5)); +} + +bool AXP20X_Class::isVbusOverVoltageIRQ(void) +{ + return (bool)(_irq[0] & _BV(4)); +} + +bool AXP20X_Class::isVbusPlugInIRQ(void) +{ + return (bool)(_irq[0] & _BV(3)); +} + +bool AXP20X_Class::isVbusRemoveIRQ(void) +{ + return (bool)(_irq[0] & _BV(2)); +} + +bool AXP20X_Class::isVbusLowVHOLDIRQ(void) +{ + return (bool)(_irq[0] & _BV(1)); +} + +//IRQ2 REGISTER : AXP202:0x41H AXP192:0X45H +bool AXP20X_Class::isBattPlugInIRQ(void) +{ + return (bool)(_irq[1] & _BV(7)); +} + +bool AXP20X_Class::isBattRemoveIRQ(void) +{ + return (bool)(_irq[1] & _BV(6)); +} + +bool AXP20X_Class::isBattEnterActivateIRQ(void) +{ + return (bool)(_irq[1] & _BV(5)); +} + +bool AXP20X_Class::isBattExitActivateIRQ(void) +{ + return (bool)(_irq[1] & _BV(4)); +} + +bool AXP20X_Class::isChargingIRQ(void) +{ + return (bool)(_irq[1] & _BV(3)); +} + +bool AXP20X_Class::isChargingDoneIRQ(void) +{ + return (bool)(_irq[1] & _BV(2)); +} + +bool AXP20X_Class::isBattTempHighIRQ(void) +{ + return (bool)(_irq[1] & _BV(1)); +} + +bool AXP20X_Class::isBattTempLowIRQ(void) +{ + return (bool)(_irq[1] & _BV(0)); +} + +//IRQ3 REGISTER : AXP202:0x42H AXP192:0X46H +bool AXP20X_Class::isChipOvertemperatureIRQ(void) +{ + return (bool)(_irq[2] & _BV(7)); +} + +bool AXP20X_Class::isChargingCurrentLessIRQ(void) +{ + return (bool)(_irq[2] & _BV(6)); +} + +// retention bit5 + +bool AXP20X_Class::isDC2VoltageLessIRQ(void) +{ + return (bool)(_irq[2] & _BV(4)); +} + +bool AXP20X_Class::isDC3VoltageLessIRQ(void) +{ + return (bool)(_irq[2] & _BV(3)); +} + +bool AXP20X_Class::isLDO3VoltageLessIRQ(void) +{ + return (bool)(_irq[2] & _BV(2)); +} + +bool AXP20X_Class::isPEKShortPressIRQ(void) +{ + return (bool)(_irq[2] & _BV(1)); +} + +bool AXP20X_Class::isPEKLongtPressIRQ(void) +{ + return (bool)(_irq[2] & _BV(0)); +} + +//IRQ4 REGISTER : AXP202:0x43H AXP192:0X47H +bool AXP20X_Class::isNOEPowerOnIRQ(void) +{ + return (bool)(_irq[3] & _BV(7)); +} + +bool AXP20X_Class::isNOEPowerDownIRQ(void) +{ + return (bool)(_irq[3] & _BV(6)); +} + +bool AXP20X_Class::isVBUSEffectiveIRQ(void) +{ + return (bool)(_irq[3] & _BV(5)); +} + +bool AXP20X_Class::isVBUSInvalidIRQ(void) +{ + return (bool)(_irq[3] & _BV(4)); +} + +bool AXP20X_Class::isVUBSSessionIRQ(void) +{ + return (bool)(_irq[3] & _BV(3)); +} + +bool AXP20X_Class::isVUBSSessionEndIRQ(void) +{ + return (bool)(_irq[3] & _BV(2)); +} + +bool AXP20X_Class::isLowVoltageLevel1IRQ(void) +{ + return (bool)(_irq[3] & _BV(1)); +} + +bool AXP20X_Class::isLowVoltageLevel2IRQ(void) +{ + return (bool)(_irq[3] & _BV(0)); +} + +//IRQ5 REGISTER : AXP202:0x44H AXP192:0X4DH +bool AXP20X_Class::isTimerTimeoutIRQ(void) +{ + return (bool)(_irq[4] & _BV(7)); +} + +bool AXP20X_Class::isPEKRisingEdgeIRQ(void) +{ + return (bool)(_irq[4] & _BV(6)); +} + +bool AXP20X_Class::isPEKFallingEdgeIRQ(void) +{ + return (bool)(_irq[4] & _BV(5)); +} + +// retention bit4 + +bool AXP20X_Class::isGPIO3InputEdgeTriggerIRQ(void) +{ + return (bool)(_irq[4] & _BV(3)); +} + +bool AXP20X_Class::isGPIO2InputEdgeTriggerIRQ(void) +{ + return (bool)(_irq[4] & _BV(2)); +} + +bool AXP20X_Class::isGPIO1InputEdgeTriggerIRQ(void) +{ + return (bool)(_irq[4] & _BV(1)); +} + +bool AXP20X_Class::isGPIO0InputEdgeTriggerIRQ(void) +{ + return (bool)(_irq[4] & _BV(0)); +} + + +int AXP20X_Class::setDCDC2Voltage(uint16_t mv) +{ + if (!_init) + return AXP_NOT_INIT; + if (mv < 700) { + AXP_DEBUG("DCDC2:Below settable voltage:700mV~2275mV"); + mv = 700; + } + if (mv > 2275) { + AXP_DEBUG("DCDC2:Above settable voltage:700mV~2275mV"); + mv = 2275; + } + uint8_t val = (mv - 700) / 25; + //! axp173/192/202 same register + _writeByte(AXP202_DC2OUT_VOL, 1, &val); + return AXP_PASS; +} + +uint16_t AXP20X_Class::getDCDC2Voltage(void) +{ + uint8_t val = 0; + //! axp173/192/202 same register + _readByte(AXP202_DC2OUT_VOL, 1, &val); + return val * 25 + 700; +} + +uint16_t AXP20X_Class::getDCDC3Voltage(void) +{ + if (!_init) + return 0; + if (_chip_id == AXP173_CHIP_ID)return AXP_NOT_SUPPORT; + uint8_t val = 0; + _readByte(AXP202_DC3OUT_VOL, 1, &val); + return val * 25 + 700; +} + +int AXP20X_Class::setDCDC3Voltage(uint16_t mv) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id == AXP173_CHIP_ID)return AXP_NOT_SUPPORT; + if (mv < 700) { + AXP_DEBUG("DCDC3:Below settable voltage:700mV~3500mV"); + mv = 700; + } + if (mv > 3500) { + AXP_DEBUG("DCDC3:Above settable voltage:700mV~3500mV"); + mv = 3500; + } + uint8_t val = (mv - 700) / 25; + _writeByte(AXP202_DC3OUT_VOL, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setLDO2Voltage(uint16_t mv) +{ + uint8_t rVal, wVal; + if (!_init) + return AXP_NOT_INIT; + if (mv < 1800) { + AXP_DEBUG("LDO2:Below settable voltage:1800mV~3300mV"); + mv = 1800; + } + if (mv > 3300) { + AXP_DEBUG("LDO2:Above settable voltage:1800mV~3300mV"); + mv = 3300; + } + wVal = (mv - 1800) / 100; + if (_chip_id == AXP202_CHIP_ID) { + _readByte(AXP202_LDO24OUT_VOL, 1, &rVal); + rVal &= 0x0F; + rVal |= (wVal << 4); + _writeByte(AXP202_LDO24OUT_VOL, 1, &rVal); + return AXP_PASS; + } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) { + _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); + rVal &= 0x0F; + rVal |= (wVal << 4); + _writeByte(AXP192_LDO23OUT_VOL, 1, &rVal); + return AXP_PASS; + } + return AXP_FAIL; +} + +uint16_t AXP20X_Class::getLDO2Voltage(void) +{ + uint8_t rVal; + if (_chip_id == AXP202_CHIP_ID) { + _readByte(AXP202_LDO24OUT_VOL, 1, &rVal); + rVal &= 0xF0; + rVal >>= 4; + return rVal * 100 + 1800; + } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID ) { + _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); + AXP_DEBUG("get result:%x\n", rVal); + rVal &= 0xF0; + rVal >>= 4; + return rVal * 100 + 1800; + } + return 0; +} + +int AXP20X_Class::setLDO3Voltage(uint16_t mv) +{ + uint8_t rVal; + if (!_init) + return AXP_NOT_INIT; + if (_chip_id == AXP202_CHIP_ID && mv < 700) { + AXP_DEBUG("LDO3:Below settable voltage:700mV~3500mV"); + mv = 700; + } else if (_chip_id == AXP192_CHIP_ID && mv < 1800) { + AXP_DEBUG("LDO3:Below settable voltage:1800mV~3300mV"); + mv = 1800; + } + + if (_chip_id == AXP202_CHIP_ID && mv > 3500) { + AXP_DEBUG("LDO3:Above settable voltage:700mV~3500mV"); + mv = 3500; + } else if (_chip_id == AXP192_CHIP_ID && mv > 3300) { + AXP_DEBUG("LDO3:Above settable voltage:1800mV~3300mV"); + mv = 3300; + } + + if (_chip_id == AXP202_CHIP_ID) { + _readByte(AXP202_LDO3OUT_VOL, 1, &rVal); + rVal &= 0x80; + rVal |= ((mv - 700) / 25); + _writeByte(AXP202_LDO3OUT_VOL, 1, &rVal); + return AXP_PASS; + } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) { + _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); + rVal &= 0xF0; + rVal |= ((mv - 1800) / 100); + _writeByte(AXP192_LDO23OUT_VOL, 1, &rVal); + return AXP_PASS; + } + return AXP_FAIL; +} + +uint16_t AXP20X_Class::getLDO3Voltage(void) +{ + uint8_t rVal; + if (!_init) + return AXP_NOT_INIT; + + if (_chip_id == AXP202_CHIP_ID) { + _readByte(AXP202_LDO3OUT_VOL, 1, &rVal); + if (rVal & 0x80) { + //! According to the hardware N_VBUSEN Pin selection + return getVbusVoltage() * 1000; + } else { + return (rVal & 0x7F) * 25 + 700; + } + } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) { + _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); + rVal &= 0x0F; + return rVal * 100 + 1800; + } + return 0; +} + +//! Only axp173 support +int AXP20X_Class::setLDO4Voltage(uint16_t mv) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id != AXP173_CHIP_ID) + return AXP_FAIL; + + if (mv < 700) { + AXP_DEBUG("LDO4:Below settable voltage:700mV~3500mV"); + mv = 700; + } + if (mv > 3500) { + AXP_DEBUG("LDO4:Above settable voltage:700mV~3500mV"); + mv = 3500; + } + uint8_t val = (mv - 700) / 25; + _writeByte(AXP173_LDO4_VLOTAGE, 1, &val); + return AXP_PASS; +} + +uint16_t AXP20X_Class::getLDO4Voltage(void) +{ + const uint16_t ldo4_table[] = {1250, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2500, 2700, 2800, 3000, 3100, 3200, 3300}; + if (!_init) + return 0; + uint8_t val = 0; + switch (_chip_id) { + case AXP173_CHIP_ID: + _readByte(AXP173_LDO4_VLOTAGE, 1, &val); + return val * 25 + 700; + case AXP202_CHIP_ID: + _readByte(AXP202_LDO24OUT_VOL, 1, &val); + val &= 0xF; + return ldo4_table[val]; + break; + case AXP192_CHIP_ID: + default: + break; + } + return 0; +} + + +//! Only axp202 support +int AXP20X_Class::setLDO4Voltage(axp_ldo4_table_t param) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id == AXP202_CHIP_ID) { + if (param >= AXP202_LDO4_MAX) + return AXP_INVALID; + uint8_t val; + _readByte(AXP202_LDO24OUT_VOL, 1, &val); + val &= 0xF0; + val |= param; + _writeByte(AXP202_LDO24OUT_VOL, 1, &val); + return AXP_PASS; + } + return AXP_FAIL; +} + +//! Only AXP202 support +int AXP20X_Class::setLDO3Mode(axp202_ldo3_mode_t mode) +{ + uint8_t val; + if (_chip_id != AXP202_CHIP_ID) + return AXP_FAIL; + _readByte(AXP202_LDO3OUT_VOL, 1, &val); + if (mode) { + val |= _BV(7); + } else { + val &= (~_BV(7)); + } + _writeByte(AXP202_LDO3OUT_VOL, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setStartupTime(uint8_t param) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + if (param > sizeof(startupParams) / sizeof(startupParams[0])) + return AXP_INVALID; + _readByte(AXP202_POK_SET, 1, &val); + val &= (~0b11000000); + val |= startupParams[param]; + _writeByte(AXP202_POK_SET, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setlongPressTime(uint8_t param) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + if (param > sizeof(longPressParams) / sizeof(longPressParams[0])) + return AXP_INVALID; + _readByte(AXP202_POK_SET, 1, &val); + val &= (~0b00110000); + val |= longPressParams[param]; + _writeByte(AXP202_POK_SET, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setShutdownTime(uint8_t param) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + if (param > sizeof(shutdownParams) / sizeof(shutdownParams[0])) + return AXP_INVALID; + _readByte(AXP202_POK_SET, 1, &val); + val &= (~0b00000011); + val |= shutdownParams[param]; + _writeByte(AXP202_POK_SET, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setTimeOutShutdown(bool en) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_POK_SET, 1, &val); + if (en) + val |= (1 << 3); + else + val &= (~(1 << 3)); + _writeByte(AXP202_POK_SET, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::shutdown(void) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_OFF_CTL, 1, &val); + val |= (1 << 7); + _writeByte(AXP202_OFF_CTL, 1, &val); + return AXP_PASS; +} + +float AXP20X_Class::getSettingChargeCurrent(void) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_CHARGE1, 1, &val); + val &= 0b00000111; + float cur = 300.0 + val * 100.0; + AXP_DEBUG("Setting Charge current : %.2f mA\n", cur); + return cur; +} + +bool AXP20X_Class::isChargeingEnable(void) +{ + return isChargingEnable(); +} + +bool AXP20X_Class::isChargingEnable(void) +{ + uint8_t val; + if (!_init) + return false; + _readByte(AXP202_CHARGE1, 1, &val); + if (val & (1 << 7)) { + AXP_DEBUG("Charging enable is enable\n"); + val = true; + } else { + AXP_DEBUG("Charging enable is disable\n"); + val = false; + } + return val; +} + +int AXP20X_Class::enableChargeing(bool en) +{ + return enableCharging(en); +} + +int AXP20X_Class::enableCharging(bool en) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_CHARGE1, 1, &val); + val = en ? (val | _BV(7)) : val & (~_BV(7)); + _writeByte(AXP202_CHARGE1, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::getChargingTargetVoltage(axp_chargeing_vol_t &chargeing_vol) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + _readByte(AXP202_CHARGE1, 1, &val); + val &= (0b11 << 5); + chargeing_vol = (axp_chargeing_vol_t) (val >> 5); + return AXP_PASS; +} + +int AXP20X_Class::setChargingTargetVoltage(axp_chargeing_vol_t param) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + if (param > sizeof(targetVolParams) / sizeof(targetVolParams[0])) + return AXP_INVALID; + _readByte(AXP202_CHARGE1, 1, &val); + val &= ~(0b01100000); + val |= targetVolParams[param]; + _writeByte(AXP202_CHARGE1, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::getBattPercentage(void) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id != AXP202_CHIP_ID) + return AXP_NOT_SUPPORT; + uint8_t val; + if (!isBatteryConnect()) + return 0; + _readByte(AXP202_BATT_PERCENTAGE, 1, &val); + if (!(val & _BV(7))) { + return val & (~_BV(7)); + } + return 0; +} + +int AXP20X_Class::setMeteringSystem(bool en) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id != AXP202_CHIP_ID) + return AXP_NOT_SUPPORT; + uint8_t val = 0; + _readByte(AXP202_BATT_PERCENTAGE, 1, &val); + en ? (val |= _BV(7)) : (val &= (~_BV(7))); + return AXP_PASS; +} + +int AXP20X_Class::setChgLEDContrl(axp_chgled_control_t opt) +{ + uint8_t val = 0; + _readByte(AXP202_OFF_CTL, 1, &val); + val &= 0b11110111; + val |= opt; + _writeByte(AXP202_OFF_CTL, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setChgLEDMode(axp_chgled_mode_t mode) +{ + uint8_t val; + _readByte(AXP202_OFF_CTL, 1, &val); + val &= 0b11001111; + val |= _BV(3); + switch (mode) { + case AXP20X_LED_OFF: + _writeByte(AXP202_OFF_CTL, 1, &val); + break; + case AXP20X_LED_BLINK_1HZ: + val |= 0b00010000; + _writeByte(AXP202_OFF_CTL, 1, &val); + break; + case AXP20X_LED_BLINK_4HZ: + val |= 0b00100000; + _writeByte(AXP202_OFF_CTL, 1, &val); + break; + case AXP20X_LED_LOW_LEVEL: + val |= 0b00110000; + _writeByte(AXP202_OFF_CTL, 1, &val); + break; + default: + return AXP_FAIL; + } + return AXP_PASS; +} + +int AXP20X_Class::debugCharging(void) +{ + uint8_t val; + _readByte(AXP202_CHARGE1, 1, &val); + AXP_DEBUG("SRC REG:0x%x\n", val); + if (val & (1 << 7)) { + AXP_DEBUG("Charging enable is enable\n"); + } else { + AXP_DEBUG("Charging enable is disable\n"); + } + AXP_DEBUG("Charging target-voltage : 0x%x\n", ((val & 0b01100000) >> 5) & 0b11); + if (val & (1 << 4)) { + AXP_DEBUG("end when the charge current is lower than 15%% of the set value\n"); + } else { + AXP_DEBUG(" end when the charge current is lower than 10%% of the set value\n"); + } + val &= 0b00000111; + AXP_DEBUG("Charge current : %.2f mA\n", 300.0 + val * 100.0); + return AXP_PASS; +} + +int AXP20X_Class::debugStatus(void) +{ + if (!_init) + return AXP_NOT_INIT; + uint8_t val, val1, val2; + _readByte(AXP202_STATUS, 1, &val); + _readByte(AXP202_MODE_CHGSTATUS, 1, &val1); + _readByte(AXP202_IPS_SET, 1, &val2); + AXP_DEBUG("AXP202_STATUS: AXP202_MODE_CHGSTATUS AXP202_IPS_SET\n"); + AXP_DEBUG("0x%x\t\t\t 0x%x\t\t\t 0x%x\n", val, val1, val2); + return AXP_PASS; +} + +int AXP20X_Class::limitingOff(void) +{ + if (!_init) + return AXP_NOT_INIT; + uint8_t val; + _readByte(AXP202_IPS_SET, 1, &val); + if (_chip_id == AXP202_CHIP_ID) { + val |= 0x03; + } else { + val &= ~(1 << 1); + } + _writeByte(AXP202_IPS_SET, 1, &val); + return AXP_PASS; +} + +// Only AXP129 chip and AXP173 +int AXP20X_Class::setDCDC1Voltage(uint16_t mv) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id != AXP192_CHIP_ID && _chip_id != AXP173_CHIP_ID) + return AXP_FAIL; + if (mv < 700) { + AXP_DEBUG("DCDC1:Below settable voltage:700mV~3500mV"); + mv = 700; + } + if (mv > 3500) { + AXP_DEBUG("DCDC1:Above settable voltage:700mV~3500mV"); + mv = 3500; + } + uint8_t val = (mv - 700) / 25; + //! axp192 and axp173 dc1 control register same + _writeByte(AXP192_DC1_VLOTAGE, 1, &val); + return AXP_PASS; +} + +// Only AXP129 chip and AXP173 +uint16_t AXP20X_Class::getDCDC1Voltage(void) +{ + if (_chip_id != AXP192_CHIP_ID && _chip_id != AXP173_CHIP_ID) + return AXP_FAIL; + uint8_t val = 0; + //! axp192 and axp173 dc1 control register same + _readByte(AXP192_DC1_VLOTAGE, 1, &val); + return val * 25 + 700; +} + + +/*********************************************** + * !!! TIMER FUNCTION !!! + * *********************************************/ + +int AXP20X_Class::setTimer(uint8_t minutes) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { + if (minutes > 63) { + return AXP_ARG_INVALID; + } + minutes |= 0x80; //Clear timer flag + _writeByte(AXP202_TIMER_CTL, 1, &minutes); + return AXP_PASS; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::offTimer(void) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { + uint8_t minutes = 0x80; + _writeByte(AXP202_TIMER_CTL, 1, &minutes); + return AXP_PASS; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::clearTimerStatus(void) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { + uint8_t val; + _readByte(AXP202_TIMER_CTL, 1, &val); + val |= 0x80; + _writeByte(AXP202_TIMER_CTL, 1, &val); + return AXP_PASS; + } + return AXP_NOT_SUPPORT; +} + +bool AXP20X_Class::getTimerStatus(void) +{ + if (!_init) + return AXP_NOT_INIT; + if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { + uint8_t val; + _readByte(AXP202_TIMER_CTL, 1, &val); + return ( val & 0x80 ) >> 7; + } + return AXP_NOT_SUPPORT; +} + +/*********************************************** + * !!! GPIO FUNCTION !!! + * *********************************************/ + +int AXP20X_Class::_axp192_gpio_0_select( axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_OUTPUT_LOW_MODE: + return 0b101; + case AXP_IO_INPUT_MODE: + return 0b001; + case AXP_IO_LDO_MODE: + return 0b010; + case AXP_IO_ADC_MODE: + return 0b100; + case AXP_IO_FLOATING_MODE: + return 0b111; + case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: + return 0; + case AXP_IO_OUTPUT_HIGH_MODE: + case AXP_IO_PWM_OUTPUT_MODE: + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::_axp192_gpio_1_select( axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_OUTPUT_LOW_MODE: + return 0b101; + case AXP_IO_INPUT_MODE: + return 0b001; + case AXP_IO_ADC_MODE: + return 0b100; + case AXP_IO_FLOATING_MODE: + return 0b111; + case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: + return 0; + case AXP_IO_PWM_OUTPUT_MODE: + return 0b010; + case AXP_IO_OUTPUT_HIGH_MODE: + case AXP_IO_LDO_MODE: + default: + break; + } + return AXP_NOT_SUPPORT; +} + + +int AXP20X_Class::_axp192_gpio_3_select( axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_EXTERN_CHARGING_CTRL_MODE: + return 0; + case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: + return 1; + case AXP_IO_INPUT_MODE: + return 2; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::_axp192_gpio_4_select( axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_EXTERN_CHARGING_CTRL_MODE: + return 0; + case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: + return 1; + case AXP_IO_INPUT_MODE: + return 2; + case AXP_IO_ADC_MODE: + return 3; + default: + break; + } + return AXP_NOT_SUPPORT; +} + + +int AXP20X_Class::_axp192_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode) +{ + int rslt; + uint8_t val; + switch (gpio) { + case AXP_GPIO_0: { + rslt = _axp192_gpio_0_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP192_GPIO0_CTL, 1, &val); + val &= 0xF8; + val |= (uint8_t)rslt; + _writeByte(AXP192_GPIO0_CTL, 1, &val); + return AXP_PASS; + } + case AXP_GPIO_1: { + rslt = _axp192_gpio_1_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP192_GPIO1_CTL, 1, &val); + val &= 0xF8; + val |= (uint8_t)rslt; + _writeByte(AXP192_GPIO1_CTL, 1, &val); + return AXP_PASS; + } + case AXP_GPIO_2: { + rslt = _axp192_gpio_1_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP192_GPIO2_CTL, 1, &val); + val &= 0xF8; + val |= (uint8_t)rslt; + _writeByte(AXP192_GPIO2_CTL, 1, &val); + return AXP_PASS; + } + case AXP_GPIO_3: { + rslt = _axp192_gpio_3_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP192_GPIO34_CTL, 1, &val); + val &= 0xFC; + val |= (uint8_t)rslt; + _writeByte(AXP192_GPIO34_CTL, 1, &val); + return AXP_PASS; + } + case AXP_GPIO_4: { + rslt = _axp192_gpio_4_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP192_GPIO34_CTL, 1, &val); + val &= 0xF3; + val |= (uint8_t)rslt; + _writeByte(AXP192_GPIO34_CTL, 1, &val); + return AXP_PASS; + } + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::_axp202_gpio_0_select( axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_OUTPUT_LOW_MODE: + return 0; + case AXP_IO_OUTPUT_HIGH_MODE: + return 1; + case AXP_IO_INPUT_MODE: + return 2; + case AXP_IO_LDO_MODE: + return 3; + case AXP_IO_ADC_MODE: + return 4; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::_axp202_gpio_1_select( axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_OUTPUT_LOW_MODE: + return 0; + case AXP_IO_OUTPUT_HIGH_MODE: + return 1; + case AXP_IO_INPUT_MODE: + return 2; + case AXP_IO_ADC_MODE: + return 4; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::_axp202_gpio_2_select( axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_OUTPUT_LOW_MODE: + return 0; + case AXP_IO_INPUT_MODE: + return 2; + case AXP_IO_FLOATING_MODE: + return 1; + default: + break; + } + return AXP_NOT_SUPPORT; +} + + +int AXP20X_Class::_axp202_gpio_3_select(axp_gpio_mode_t mode) +{ + switch (mode) { + case AXP_IO_INPUT_MODE: + return 1; + case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: + return 0; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::_axp202_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode) +{ + uint8_t val; + int rslt; + switch (gpio) { + case AXP_GPIO_0: { + rslt = _axp202_gpio_0_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP202_GPIO0_CTL, 1, &val); + val &= 0b11111000; + val |= (uint8_t)rslt; + _writeByte(AXP202_GPIO0_CTL, 1, &val); + return AXP_PASS; + } + case AXP_GPIO_1: { + rslt = _axp202_gpio_1_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP202_GPIO1_CTL, 1, &val); + val &= 0b11111000; + val |= (uint8_t)rslt; + _writeByte(AXP202_GPIO1_CTL, 1, &val); + return AXP_PASS; + } + case AXP_GPIO_2: { + rslt = _axp202_gpio_2_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP202_GPIO2_CTL, 1, &val); + val &= 0b11111000; + val |= (uint8_t)rslt; + _writeByte(AXP202_GPIO2_CTL, 1, &val); + return AXP_PASS; + } + case AXP_GPIO_3: { + rslt = _axp202_gpio_3_select(mode); + if (rslt < 0)return rslt; + _readByte(AXP202_GPIO3_CTL, 1, &val); + val = rslt ? (val | _BV(2)) : (val & (~_BV(2))); + _writeByte(AXP202_GPIO3_CTL, 1, &val); + return AXP_PASS; + } + default: + break; + } + return AXP_NOT_SUPPORT; +} + + +int AXP20X_Class::setGPIOMode(axp_gpio_t gpio, axp_gpio_mode_t mode) +{ + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP202_CHIP_ID: + return _axp202_gpio_set(gpio, mode); + break; + case AXP192_CHIP_ID: + return _axp192_gpio_set(gpio, mode); + break; + default: + break; + } + return AXP_NOT_SUPPORT; +} + + +int AXP20X_Class::_axp_irq_mask(axp_gpio_irq_t irq) +{ + switch (irq) { + case AXP_IRQ_NONE: + return 0; + case AXP_IRQ_RISING: + return _BV(7); + case AXP_IRQ_FALLING: + return _BV(6); + case AXP_IRQ_DOUBLE_EDGE: + return 0b1100000; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::_axp202_gpio_irq_set(axp_gpio_t gpio, axp_gpio_irq_t irq) +{ + uint8_t reg; + uint8_t val; + int mask; + mask = _axp_irq_mask(irq); + + if (mask < 0)return mask; + switch (gpio) { + case AXP_GPIO_0: + reg = AXP202_GPIO0_CTL; + break; + case AXP_GPIO_1: + reg = AXP202_GPIO1_CTL; + break; + case AXP_GPIO_2: + reg = AXP202_GPIO2_CTL; + break; + case AXP_GPIO_3: + reg = AXP202_GPIO3_CTL; + break; + default: + return AXP_NOT_SUPPORT; + } + _readByte(reg, 1, &val); + val = mask == 0 ? (val & 0b00111111) : (val | mask); + _writeByte(reg, 1, &val); + return AXP_PASS; +} + + +int AXP20X_Class::setGPIOIrq(axp_gpio_t gpio, axp_gpio_irq_t irq) +{ + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP202_CHIP_ID: + return _axp202_gpio_irq_set(gpio, irq); + case AXP192_CHIP_ID: + case AXP173_CHIP_ID: + return AXP_NOT_SUPPORT; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::setLDO5Voltage(axp_ldo5_table_t vol) +{ + const uint8_t params[] = { + 0b11111000, //1.8V + 0b11111001, //2.5V + 0b11111010, //2.8V + 0b11111011, //3.0V + 0b11111100, //3.1V + 0b11111101, //3.3V + 0b11111110, //3.4V + 0b11111111, //3.5V + }; + if (!_init) + return AXP_NOT_INIT; + if (_chip_id != AXP202_CHIP_ID) + return AXP_NOT_SUPPORT; + if (vol > sizeof(params) / sizeof(params[0])) + return AXP_ARG_INVALID; + uint8_t val = 0; + _readByte(AXP202_GPIO0_VOL, 1, &val); + val &= 0b11111000; + val |= params[vol]; + _writeByte(AXP202_GPIO0_VOL, 1, &val); + return AXP_PASS; +} + + +int AXP20X_Class::_axp202_gpio_write(axp_gpio_t gpio, uint8_t val) +{ + uint8_t reg; + uint8_t wVal = 0; + switch (gpio) { + case AXP_GPIO_0: + reg = AXP202_GPIO0_CTL; + break; + case AXP_GPIO_1: + reg = AXP202_GPIO1_CTL; + break; + case AXP_GPIO_2: + reg = AXP202_GPIO2_CTL; + if (val) { + return AXP_NOT_SUPPORT; + } + break; + case AXP_GPIO_3: + if (val) { + return AXP_NOT_SUPPORT; + } + _readByte(AXP202_GPIO3_CTL, 1, &wVal); + wVal &= 0b11111101; + _writeByte(AXP202_GPIO3_CTL, 1, &wVal); + return AXP_PASS; + default: + return AXP_NOT_SUPPORT; + } + _readByte(reg, 1, &wVal); + wVal = val ? (wVal | 1) : (wVal & 0b11111000); + _writeByte(reg, 1, &wVal); + return AXP_PASS; +} + +int AXP20X_Class::_axp202_gpio_read(axp_gpio_t gpio) +{ + uint8_t val; + uint8_t reg = AXP202_GPIO012_SIGNAL; + uint8_t offset; + switch (gpio) { + case AXP_GPIO_0: + offset = 4; + break; + case AXP_GPIO_1: + offset = 5; + break; + case AXP_GPIO_2: + offset = 6; + break; + case AXP_GPIO_3: + reg = AXP202_GPIO3_CTL; + offset = 0; + break; + default: + return AXP_NOT_SUPPORT; + } + _readByte(reg, 1, &val); + return val & _BV(offset) ? 1 : 0; +} + +int AXP20X_Class::gpioWrite(axp_gpio_t gpio, uint8_t val) +{ + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP202_CHIP_ID: + return _axp202_gpio_write(gpio, val); + case AXP192_CHIP_ID: + case AXP173_CHIP_ID: + return AXP_NOT_SUPPORT; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::gpioRead(axp_gpio_t gpio) +{ + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP202_CHIP_ID: + return _axp202_gpio_read(gpio); + case AXP192_CHIP_ID: + case AXP173_CHIP_ID: + return AXP_NOT_SUPPORT; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::getChargeControlCur(void) +{ + int cur; + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP202_CHIP_ID: + _readByte(AXP202_CHARGE1, 1, &val); + val &= 0x0F; + cur = val * 100 + 300; + if (cur > 1800 || cur < 300)return 0; + return cur; + case AXP192_CHIP_ID: + case AXP173_CHIP_ID: + _readByte(AXP202_CHARGE1, 1, &val); + return val & 0x0F; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::setChargeControlCur(uint16_t mA) +{ + uint8_t val; + if (!_init) + return AXP_NOT_INIT; + switch (_chip_id) { + case AXP202_CHIP_ID: + _readByte(AXP202_CHARGE1, 1, &val); + val &= 0b11110000; + mA -= 300; + val |= (mA / 100); + _writeByte(AXP202_CHARGE1, 1, &val); + return AXP_PASS; + case AXP192_CHIP_ID: + case AXP173_CHIP_ID: + _readByte(AXP202_CHARGE1, 1, &val); + val &= 0b11110000; + if (mA > AXP1XX_CHARGE_CUR_1320MA) + mA = AXP1XX_CHARGE_CUR_1320MA; + val |= mA; + _writeByte(AXP202_CHARGE1, 1, &val); + return AXP_PASS; + default: + break; + } + return AXP_NOT_SUPPORT; +} + +int AXP20X_Class::setSleep() +{ + int ret; + uint8_t val = 0; + ret = _readByte(AXP202_VOFF_SET, 1, &val); + if (ret != 0)return AXP_FAIL; + val |= _BV(3); + ret = _writeByte(AXP202_VOFF_SET, 1, &val); + if (ret != 0)return AXP_FAIL; + ret = _readByte(AXP202_VOFF_SET, 1, &val); + if (ret != 0)return AXP_FAIL; + return (val & _BV(3)) ? AXP_PASS : AXP_FAIL; +} + +// VOFF =[2.6+(Bit2-0)*0.1]V +int AXP20X_Class::setPowerDownVoltage(uint16_t mv) +{ + int ret; + uint8_t val = 0; + ret = _readByte(AXP202_VOFF_SET, 1, &val); + if (ret != 0)return AXP_FAIL; + val &= ~(AXP202_VOFF_MASK); + val |= ((mv - 2600) / 100); + ret = _writeByte(AXP202_VOFF_SET, 1, &val); + if (ret != 0)return AXP_FAIL; + return AXP_PASS ; +} + +uint16_t AXP20X_Class::getPowerDownVoltage(void) +{ + int ret = 0; + uint8_t val = 0; + ret = _readByte(AXP202_VOFF_SET, 1, &val); + if (ret != 0)return 0; + val &= AXP202_VOFF_MASK; + uint16_t voff = val * 100 + 2600; + return voff; +} + +int AXP20X_Class::setCurrentLimitControl(axp202_limit_setting_t opt) +{ + uint8_t val = 0; + if (!_init) + return AXP_NOT_INIT; + if (_chip_id != AXP202_CHIP_ID) { + return AXP_NOT_SUPPORT; + } + _readByte(AXP202_IPS_SET, 1, &val); + val &= (~AXP202_LIMIT_MASK); + val |= opt; + _writeByte(AXP202_IPS_SET, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setCurrentLimitControl(axp192_limit_setting_t opt) +{ + uint8_t val = 0; + if (!_init) { + return AXP_NOT_INIT; + } + if (_chip_id != AXP192_CHIP_ID) { + return AXP_NOT_SUPPORT; + } + _readByte(AXP202_IPS_SET, 1, &val); + + if (opt == AXP192_VBUS_LIMIT_OFF) { + val &= (~AXP192_LIMIT_EN_MASK); + } else { + val &= (~AXP192_LIMIT_MASK); + val |= opt; + val |= AXP192_LIMIT_EN_MASK; + } + _writeByte(AXP202_IPS_SET, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setVWarningLevel1(uint16_t mv) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = (mv - 2867) / 5.6; + AXP_DEBUG("setVWarningLevel1:0x%x\n", val); + _writeByte(AXP202_APS_WARNING1, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setVWarningLevel2(uint16_t mv) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = (mv - 2867) / 5.6; + AXP_DEBUG("setVWarningLevel2:0x%x\n", val); + _writeByte(AXP202_APS_WARNING2, 1, &val); + return AXP_PASS; +} + +uint16_t AXP20X_Class::getVWarningLevel1(void) +{ + ISCONNECETD(0); + uint8_t val = 0; + _readByte(AXP202_APS_WARNING1, 1, &val); + AXP_DEBUG("TarageVoltage:%.2f HEX:0x%x\n", 2.8672 + 0.0014 * val * 4.0, val); + return ( 2.8672 + 0.0014 * val * 4.0) * 1000; +} + +uint16_t AXP20X_Class::getVWarningLevel2(void) +{ + ISCONNECETD(0); + uint8_t val = 0; + _readByte(AXP202_APS_WARNING2, 1, &val); + AXP_DEBUG("TarageVoltage:%.2f HEX:0x%x\n", 2.8672 + 0.0014 * val * 4.0, val); + return (2.8672 + 0.0014 * val * 4.0) * 1000; +} + +int AXP20X_Class::setDCDCMode(axp202_dc_mode_t opt) +{ + uint8_t val = 0; + _readByte(AXP202_DCDC_MODESET, 1, &val); + val &= 0xF9; + val |= opt; + _writeByte(AXP202_DCDC_MODESET, 1, &val); + return AXP_PASS; +} + +axp202_dc_mode_t AXP20X_Class::getDCDCMode(void) +{ + uint8_t val = 0; + _readByte(AXP202_DCDC_MODESET, 1, &val); + val &= 0x6; + return val ? AXP202_DCDC_AUTO_MODE : AXP202_DCDC_PWM_MODE; +} + + +int AXP20X_Class::enableLDO3VRC(bool en) +{ + ISCONNECETD(AXP_NOT_INIT); + if (_chip_id != AXP202_CHIP_ID) { + return AXP_NOT_SUPPORT; + } + uint8_t val = 0; + _readByte(AXP202_LDO3_DC2_DVM, 1, &val); + val &= (~_BV(3)); + val |= en; + _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::enableDC2VRC(bool en) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_LDO3_DC2_DVM, 1, &val); + val &= (~_BV(2)); + val |= en; + _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setLDO3VRC(axp202_vrc_control_t opt) +{ + ISCONNECETD(AXP_NOT_INIT); + if (_chip_id != AXP202_CHIP_ID) { + return AXP_NOT_SUPPORT; + } + uint8_t val = 0; + _readByte(AXP202_LDO3_DC2_DVM, 1, &val); + val &= (~_BV(1)); + val |= opt; + _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setDC2VRC(axp202_vrc_control_t opt) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_LDO3_DC2_DVM, 1, &val); + val &= (~_BV(0)); + val |= opt; + _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setBackupChargeControl(bool en) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_BACKUP_CHG, 1, &val); + val &= (~_BV(7)); + val |= en; + _writeByte(AXP202_BACKUP_CHG, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setBackupChargeVoltage(axp202_backup_voltage_t opt) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_BACKUP_CHG, 1, &val); + val &= 0x9F; + val |= opt; + _writeByte(AXP202_BACKUP_CHG, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setBackupChargeCurrent(axp202_backup_current_t opt) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_BACKUP_CHG, 1, &val); + val &= 0xFC; + val |= opt; + _writeByte(AXP202_BACKUP_CHG, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setPrechargeTimeout(axp202_precharge_timeout_t opt) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_CHARGE2, 1, &val); + val &= 0x3F; + val |= opt; + _writeByte(AXP202_CHARGE2, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setConstantCurrentTimeout(axp202_constant_current_t opt) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_CHARGE2, 1, &val); + val &= 0xFC; + val |= opt; + _writeByte(AXP202_CHARGE2, 1, &val); + return AXP_PASS; +} + +int AXP20X_Class::setChgLEDChargingMode(axp_chgled_charging_mode_t opt) +{ + ISCONNECETD(AXP_NOT_INIT); + uint8_t val = 0; + _readByte(AXP202_CHARGE2, 1, &val); + val &= 0xEF; + val |= opt; + _writeByte(AXP202_CHARGE2, 1, &val); + return AXP_PASS; +} + + + + + +// Low-level I2C communication +uint16_t AXP20X_Class::_getRegistH8L5(uint8_t regh8, uint8_t regl5) +{ + uint8_t hv, lv; + _readByte(regh8, 1, &hv); + _readByte(regl5, 1, &lv); + return (hv << 5) | (lv & 0x1F); +} + +uint16_t AXP20X_Class::_getRegistResult(uint8_t regh8, uint8_t regl4) +{ + uint8_t hv, lv; + _readByte(regh8, 1, &hv); + _readByte(regl4, 1, &lv); + return (hv << 4) | (lv & 0x0F); +} + +int AXP20X_Class::_readByte(uint8_t reg, uint8_t nbytes, uint8_t *data) +{ + if (_read_cb != nullptr) { + return _read_cb(_address, reg, data, nbytes); + } +#ifdef ARDUINO + if (nbytes == 0 || !data) + return -1; + _i2cPort->beginTransmission(_address); + _i2cPort->write(reg); + if (_i2cPort->endTransmission() != 0) { + return -1; + } + _i2cPort->requestFrom(_address, nbytes); + uint8_t index = 0; + while (_i2cPort->available()) + data[index++] = _i2cPort->read(); +#endif + return 0; +} + +int AXP20X_Class::_writeByte(uint8_t reg, uint8_t nbytes, uint8_t *data) +{ + if (_write_cb != nullptr) { + return _write_cb(_address, reg, data, nbytes); + } +#ifdef ARDUINO + if (nbytes == 0 || !data) + return -1; + _i2cPort->beginTransmission(_address); + _i2cPort->write(reg); + for (uint8_t i = 0; i < nbytes; i++) { + _i2cPort->write(data[i]); + } + return _i2cPort->endTransmission(); +#endif + return 0; +} + +AXP20X_Class axp; diff --git a/components/pmic_axp202/src/axp20x.hpp b/components/pmic_axp202/src/axp20x.hpp new file mode 100644 index 0000000..0fcc7f8 --- /dev/null +++ b/components/pmic_axp202/src/axp20x.hpp @@ -0,0 +1,961 @@ +///////////////////////////////////////////////////////////////// +/* + + __ _______ ___ ___ ___ + /\ \ \ / / __ \__ \ / _ \__ \ + / \ \ V /| |__) | ) | | | | ) | + / /\ \ > < | ___/ / /| | | |/ / + / ____ \ / . \| | / /_| |_| / /_ + /_/ \_\/_/ \_\_| |____|\___/____| + + + +MIT License + +Copyright (c) 2019 lewis he + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +axp20x.h - Arduino library for X-Power AXP202 chip. +Created by Lewis he on April 1, 2019. +github:https://github.com/lewisxhe/AXP202X_Libraries +*/ +///////////////////////////////////////////////////////////////// +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef ARDUINO +#include +#include +#else +#include +#include +#endif + +// #define AXP_DEBUG_PORT Serial +#ifdef AXP_DEBUG_PORT +#ifdef ARDUINO +#define AXP_DEBUG(fmt, ...) AXP_DEBUG_PORT.printf_P((PGM_P)PSTR(fmt), ##__VA_ARGS__) +#else +#define AXP_DEBUG(...) printf(__VA_ARGS__) +#endif + +#else +#define AXP_DEBUG(...) +#endif + +#ifndef RISING +#define RISING 0x01 +#endif + +#ifndef FALLING +#define FALLING 0x02 +#endif + +#ifdef _BV +#undef _BV +#endif +#define _BV(b) (1ULL << (b)) + +//! Error Code +#define AXP_PASS (0) +#define AXP_FAIL (-1) +#define AXP_INVALID (-2) +#define AXP_NOT_INIT (-3) +#define AXP_NOT_SUPPORT (-4) +#define AXP_ARG_INVALID (-5) + +//! Chip Address +#define AXP202_SLAVE_ADDRESS (0x34U) //! 定制地址?(0x35U) +#define AXP192_SLAVE_ADDRESS (0x34U) +#define AXP173_SLAVE_ADDRESS (0x34U) + +//! Chip ID +#define AXP202_CHIP_ID (0x41) +#define AXP192_CHIP_ID (0x03) +#define AXP173_CHIP_ID (0xAD) //! Axp173 does not have a chip ID, given a custom ID + +//! Logic states +#define AXP202_ON (1) +#define AXP202_OFF (0) + +//! REG MAP +#define AXP202_STATUS (0x00) +#define AXP202_MODE_CHGSTATUS (0x01) +#define AXP202_OTG_STATUS (0x02) +#define AXP202_IC_TYPE (0x03) +#define AXP202_DATA_BUFFER1 (0x04) +#define AXP202_DATA_BUFFER2 (0x05) +#define AXP202_DATA_BUFFER3 (0x06) +#define AXP202_DATA_BUFFER4 (0x07) +#define AXP202_DATA_BUFFER5 (0x08) +#define AXP202_DATA_BUFFER6 (0x09) +#define AXP202_DATA_BUFFER7 (0x0A) +#define AXP202_DATA_BUFFER8 (0x0B) +#define AXP202_DATA_BUFFER9 (0x0C) +#define AXP202_DATA_BUFFERA (0x0D) +#define AXP202_DATA_BUFFERB (0x0E) +#define AXP202_DATA_BUFFERC (0x0F) +#define AXP202_LDO234_DC23_CTL (0x12) +#define AXP202_DC2OUT_VOL (0x23) +#define AXP202_LDO3_DC2_DVM (0x25) +#define AXP202_DC3OUT_VOL (0x27) +#define AXP202_LDO24OUT_VOL (0x28) +#define AXP202_LDO3OUT_VOL (0x29) +#define AXP202_IPS_SET (0x30) +#define AXP202_VOFF_SET (0x31) +#define AXP202_OFF_CTL (0x32) +#define AXP202_CHARGE1 (0x33) +#define AXP202_CHARGE2 (0x34) +#define AXP202_BACKUP_CHG (0x35) +#define AXP202_POK_SET (0x36) +#define AXP202_DCDC_FREQSET (0x37) +#define AXP202_VLTF_CHGSET (0x38) +#define AXP202_VHTF_CHGSET (0x39) +#define AXP202_APS_WARNING1 (0x3A) +#define AXP202_APS_WARNING2 (0x3B) +#define AXP202_TLTF_DISCHGSET (0x3C) +#define AXP202_THTF_DISCHGSET (0x3D) +#define AXP202_DCDC_MODESET (0x80) +#define AXP202_ADC_EN1 (0x82) +#define AXP202_ADC_EN2 (0x83) +#define AXP202_ADC_SPEED (0x84) +#define AXP202_ADC_INPUTRANGE (0x85) +#define AXP202_ADC_IRQ_RETFSET (0x86) +#define AXP202_ADC_IRQ_FETFSET (0x87) +#define AXP202_TIMER_CTL (0x8A) +#define AXP202_VBUS_DET_SRP (0x8B) +#define AXP202_HOTOVER_CTL (0x8F) +#define AXP202_GPIO0_CTL (0x90) +#define AXP202_GPIO0_VOL (0x91) +#define AXP202_GPIO1_CTL (0x92) +#define AXP202_GPIO2_CTL (0x93) +#define AXP202_GPIO012_SIGNAL (0x94) +#define AXP202_GPIO3_CTL (0x95) +#define AXP202_INTEN1 (0x40) +#define AXP202_INTEN2 (0x41) +#define AXP202_INTEN3 (0x42) +#define AXP202_INTEN4 (0x43) +#define AXP202_INTEN5 (0x44) +#define AXP202_INTSTS1 (0x48) +#define AXP202_INTSTS2 (0x49) +#define AXP202_INTSTS3 (0x4A) +#define AXP202_INTSTS4 (0x4B) +#define AXP202_INTSTS5 (0x4C) + +//Irq control register +#define AXP192_INTEN1 (0x40) +#define AXP192_INTEN2 (0x41) +#define AXP192_INTEN3 (0x42) +#define AXP192_INTEN4 (0x43) +#define AXP192_INTEN5 (0x4A) +//Irq status register +#define AXP192_INTSTS1 (0x44) +#define AXP192_INTSTS2 (0x45) +#define AXP192_INTSTS3 (0x46) +#define AXP192_INTSTS4 (0x47) +#define AXP192_INTSTS5 (0x4D) + +#define AXP192_DC1_VLOTAGE (0x26) +#define AXP192_LDO23OUT_VOL (0x28) +#define AXP192_GPIO0_CTL (0x90) +#define AXP192_GPIO0_VOL (0x91) +#define AXP192_GPIO1_CTL (0X92) +#define AXP192_GPIO2_CTL (0x93) +#define AXP192_GPIO012_SIGNAL (0x94) +#define AXP192_GPIO34_CTL (0x95) + + + +/* axp 192/202 adc data register */ +#define AXP202_BAT_AVERVOL_H8 (0x78) +#define AXP202_BAT_AVERVOL_L4 (0x79) +#define AXP202_BAT_AVERCHGCUR_H8 (0x7A) +#define AXP202_BAT_AVERCHGCUR_L4 (0x7B) +#define AXP202_BAT_AVERCHGCUR_L5 (0x7B) +#define AXP202_ACIN_VOL_H8 (0x56) +#define AXP202_ACIN_VOL_L4 (0x57) +#define AXP202_ACIN_CUR_H8 (0x58) +#define AXP202_ACIN_CUR_L4 (0x59) +#define AXP202_VBUS_VOL_H8 (0x5A) +#define AXP202_VBUS_VOL_L4 (0x5B) +#define AXP202_VBUS_CUR_H8 (0x5C) +#define AXP202_VBUS_CUR_L4 (0x5D) +#define AXP202_INTERNAL_TEMP_H8 (0x5E) +#define AXP202_INTERNAL_TEMP_L4 (0x5F) +#define AXP202_TS_IN_H8 (0x62) +#define AXP202_TS_IN_L4 (0x63) +#define AXP202_GPIO0_VOL_ADC_H8 (0x64) +#define AXP202_GPIO0_VOL_ADC_L4 (0x65) +#define AXP202_GPIO1_VOL_ADC_H8 (0x66) +#define AXP202_GPIO1_VOL_ADC_L4 (0x67) + +#define AXP202_BAT_AVERDISCHGCUR_H8 (0x7C) +#define AXP202_BAT_AVERDISCHGCUR_L5 (0x7D) +#define AXP202_APS_AVERVOL_H8 (0x7E) +#define AXP202_APS_AVERVOL_L4 (0x7F) +#define AXP202_INT_BAT_CHGCUR_H8 (0xA0) +#define AXP202_INT_BAT_CHGCUR_L4 (0xA1) +#define AXP202_EXT_BAT_CHGCUR_H8 (0xA2) +#define AXP202_EXT_BAT_CHGCUR_L4 (0xA3) +#define AXP202_INT_BAT_DISCHGCUR_H8 (0xA4) +#define AXP202_INT_BAT_DISCHGCUR_L4 (0xA5) +#define AXP202_EXT_BAT_DISCHGCUR_H8 (0xA6) +#define AXP202_EXT_BAT_DISCHGCUR_L4 (0xA7) +#define AXP202_BAT_CHGCOULOMB3 (0xB0) +#define AXP202_BAT_CHGCOULOMB2 (0xB1) +#define AXP202_BAT_CHGCOULOMB1 (0xB2) +#define AXP202_BAT_CHGCOULOMB0 (0xB3) +#define AXP202_BAT_DISCHGCOULOMB3 (0xB4) +#define AXP202_BAT_DISCHGCOULOMB2 (0xB5) +#define AXP202_BAT_DISCHGCOULOMB1 (0xB6) +#define AXP202_BAT_DISCHGCOULOMB0 (0xB7) +#define AXP202_COULOMB_CTL (0xB8) +#define AXP202_BAT_POWERH8 (0x70) +#define AXP202_BAT_POWERM8 (0x71) +#define AXP202_BAT_POWERL8 (0x72) + +#define AXP202_VREF_TEM_CTRL (0xF3) +#define AXP202_BATT_PERCENTAGE (0xB9) + +/* bit definitions for AXP events, irq event */ +/* AXP202 */ +#define AXP202_IRQ_USBLO (1) +#define AXP202_IRQ_USBRE (2) +#define AXP202_IRQ_USBIN (3) +#define AXP202_IRQ_USBOV (4) +#define AXP202_IRQ_ACRE (5) +#define AXP202_IRQ_ACIN (6) +#define AXP202_IRQ_ACOV (7) + +#define AXP202_IRQ_TEMLO (8) +#define AXP202_IRQ_TEMOV (9) +#define AXP202_IRQ_CHAOV (10) +#define AXP202_IRQ_CHAST (11) +#define AXP202_IRQ_BATATOU (12) +#define AXP202_IRQ_BATATIN (13) +#define AXP202_IRQ_BATRE (14) +#define AXP202_IRQ_BATIN (15) + +#define AXP202_IRQ_POKLO (16) +#define AXP202_IRQ_POKSH (17) +#define AXP202_IRQ_LDO3LO (18) +#define AXP202_IRQ_DCDC3LO (19) +#define AXP202_IRQ_DCDC2LO (20) +#define AXP202_IRQ_CHACURLO (22) +#define AXP202_IRQ_ICTEMOV (23) + +#define AXP202_IRQ_EXTLOWARN2 (24) +#define AXP202_IRQ_EXTLOWARN1 (25) +#define AXP202_IRQ_SESSION_END (26) +#define AXP202_IRQ_SESS_AB_VALID (27) +#define AXP202_IRQ_VBUS_UN_VALID (28) +#define AXP202_IRQ_VBUS_VALID (29) +#define AXP202_IRQ_PDOWN_BY_NOE (30) +#define AXP202_IRQ_PUP_BY_NOE (31) + +#define AXP202_IRQ_GPIO0TG (32) +#define AXP202_IRQ_GPIO1TG (33) +#define AXP202_IRQ_GPIO2TG (34) +#define AXP202_IRQ_GPIO3TG (35) +#define AXP202_IRQ_PEKFE (37) +#define AXP202_IRQ_PEKRE (38) +#define AXP202_IRQ_TIMER (39) + +//Signal Capture +#define AXP202_BATT_VOLTAGE_STEP (1.1F) +#define AXP202_BATT_DISCHARGE_CUR_STEP (0.5F) +#define AXP202_BATT_CHARGE_CUR_STEP (0.5F) +#define AXP202_ACIN_VOLTAGE_STEP (1.7F) +#define AXP202_ACIN_CUR_STEP (0.625F) +#define AXP202_VBUS_VOLTAGE_STEP (1.7F) +#define AXP202_VBUS_CUR_STEP (0.375F) +#define AXP202_INTERNAL_TEMP_STEP (0.1F) +#define AXP202_APS_VOLTAGE_STEP (1.4F) +#define AXP202_TS_PIN_OUT_STEP (0.8F) +#define AXP202_GPIO0_STEP (0.5F) +#define AXP202_GPIO1_STEP (0.5F) +// AXP192 only +#define AXP202_GPIO2_STEP (0.5F) +#define AXP202_GPIO3_STEP (0.5F) + +// AXP173 +#define AXP173_EXTEN_DC2_CTL (0x10) +#define AXP173_CTL_DC2_BIT (0) +#define AXP173_CTL_EXTEN_BIT (2) +#define AXP173_DC1_VLOTAGE (0x26) +#define AXP173_LDO4_VLOTAGE (0x27) + +#define FORCED_OPEN_DCDC3(x) (x |= (AXP202_ON << AXP202_DCDC3)) +#define IS_OPEN(reg, channel) (bool)(reg & _BV(channel)) + + +#define AXP202_VOFF_MASK (0x07) +#define AXP202_LIMIT_MASK (0x03) +#define AXP192_LIMIT_MASK (0x01) +#define AXP192_LIMIT_EN_MASK (0x02) + +enum { + AXP202_EXTEN = 0, + AXP202_DCDC3 = 1, + AXP202_LDO2 = 2, + AXP202_LDO4 = 3, + AXP202_DCDC2 = 4, + AXP202_LDO3 = 6, + AXP202_OUTPUT_MAX, +}; + +enum { + AXP192_DCDC1 = 0, + AXP192_DCDC3 = 1, + AXP192_LDO2 = 2, + AXP192_LDO3 = 3, + AXP192_DCDC2 = 4, + AXP192_EXTEN = 6, + AXP192_OUTPUT_MAX, +}; + +enum { + AXP173_DCDC1 = 0, + AXP173_LDO4 = 1, + AXP173_LDO2 = 2, + AXP173_LDO3 = 3, + AXP173_DCDC2 = 4, + AXP173_EXTEN = 6, + AXP173_OUTPUT_MAX, +}; + +typedef enum { + AXP202_STARTUP_TIME_128MS, + AXP202_STARTUP_TIME_3S, + AXP202_STARTUP_TIME_1S, + AXP202_STARTUP_TIME_2S, +} axp202_startup_time_t; + +typedef enum { + AXP192_STARTUP_TIME_128MS, + AXP192_STARTUP_TIME_512MS, + AXP192_STARTUP_TIME_1S, + AXP192_STARTUP_TIME_2S, +} axp192_startup_time_t; + +typedef enum { + AXP_LONGPRESS_TIME_1S, + AXP_LONGPRESS_TIME_1S5, + AXP_LONGPRESS_TIME_2S, + AXP_LONGPRESS_TIME_2S5, +} axp_longPress_time_t; + +typedef enum { + AXP_POWER_OFF_TIME_4S, + AXP_POWER_OFF_TIME_6S, + AXP_POWER_OFF_TIME_8S, + AXP_POWER_OFF_TIME_10S, +} axp_poweroff_time_t; + +//REG 33H: Charging control 1 Charging target-voltage setting +typedef enum { + AXP202_TARGET_VOL_4_1V, + AXP202_TARGET_VOL_4_15V, + AXP202_TARGET_VOL_4_2V, + AXP202_TARGET_VOL_4_36V +} axp_chargeing_vol_t; + +//REG 82H: ADC Enable 1 register Parameter +typedef enum { + AXP202_BATT_VOL_ADC1 = _BV(7), + AXP202_BATT_CUR_ADC1 = _BV(6), + AXP202_ACIN_VOL_ADC1 = _BV(5), + AXP202_ACIN_CUR_ADC1 = _BV(4), + AXP202_VBUS_VOL_ADC1 = _BV(3), + AXP202_VBUS_CUR_ADC1 = _BV(2), + AXP202_APS_VOL_ADC1 = _BV(1), + AXP202_TS_PIN_ADC1 = _BV(0) +} axp_adc1_func_t; + +// REG 83H: ADC Enable 2 register Parameter +typedef enum { + AXP202_TEMP_MONITORING_ADC2 = _BV(7), + AXP202_GPIO1_FUNC_ADC2 = _BV(3), + AXP202_GPIO0_FUNC_ADC2 = _BV(2) +} axp_adc2_func_t; + +typedef enum { + AXP202_LDO3_MODE_LDO, + AXP202_LDO3_MODE_DCIN +} axp202_ldo3_mode_t; + +typedef enum { + //! IRQ1 REG 40H + AXP202_VBUS_VHOLD_LOW_IRQ = _BV(1), //VBUS is available, but lower than V HOLD, IRQ enable + AXP202_VBUS_REMOVED_IRQ = _BV(2), //VBUS removed, IRQ enable + AXP202_VBUS_CONNECT_IRQ = _BV(3), //VBUS connected, IRQ enable + AXP202_VBUS_OVER_VOL_IRQ = _BV(4), //VBUS over-voltage, IRQ enable + AXP202_ACIN_REMOVED_IRQ = _BV(5), //ACIN removed, IRQ enable + AXP202_ACIN_CONNECT_IRQ = _BV(6), //ACIN connected, IRQ enable + AXP202_ACIN_OVER_VOL_IRQ = _BV(7), //ACIN over-voltage, IRQ enable + + //! IRQ2 REG 41H + AXP202_BATT_LOW_TEMP_IRQ = _BV(8), //Battery low-temperature, IRQ enable + AXP202_BATT_OVER_TEMP_IRQ = _BV(9), //Battery over-temperature, IRQ enable + AXP202_CHARGING_FINISHED_IRQ = _BV(10), //Charge finished, IRQ enable + AXP202_CHARGING_IRQ = _BV(11), //Be charging, IRQ enable + AXP202_BATT_EXIT_ACTIVATE_IRQ = _BV(12), //Exit battery activate mode, IRQ enable + AXP202_BATT_ACTIVATE_IRQ = _BV(13), //Battery activate mode, IRQ enable + AXP202_BATT_REMOVED_IRQ = _BV(14), //Battery removed, IRQ enable + AXP202_BATT_CONNECT_IRQ = _BV(15), //Battery connected, IRQ enable + + //! IRQ3 REG 42H + AXP202_PEK_LONGPRESS_IRQ = _BV(16), //PEK long press, IRQ enable + AXP202_PEK_SHORTPRESS_IRQ = _BV(17), //PEK short press, IRQ enable + AXP202_LDO3_LOW_VOL_IRQ = _BV(18), //LDO3output voltage is lower than the set value, IRQ enable + AXP202_DC3_LOW_VOL_IRQ = _BV(19), //DC-DC3output voltage is lower than the set value, IRQ enable + AXP202_DC2_LOW_VOL_IRQ = _BV(20), //DC-DC2 output voltage is lower than the set value, IRQ enable + //**Reserved and unchangeable BIT 5 + AXP202_CHARGE_LOW_CUR_IRQ = _BV(22), //Charge current is lower than the set current, IRQ enable + AXP202_CHIP_TEMP_HIGH_IRQ = _BV(23), //AXP202 internal over-temperature, IRQ enable + + //! IRQ4 REG 43H + AXP202_APS_LOW_VOL_LEVEL2_IRQ = _BV(24), //APS low-voltage, IRQ enable(LEVEL2) + APX202_APS_LOW_VOL_LEVEL1_IRQ = _BV(25), //APS low-voltage, IRQ enable(LEVEL1) + AXP202_VBUS_SESSION_END_IRQ = _BV(26), //VBUS Session End IRQ enable + AXP202_VBUS_SESSION_AB_IRQ = _BV(27), //VBUS Session A/B IRQ enable + AXP202_VBUS_INVALID_IRQ = _BV(28), //VBUS invalid, IRQ enable + AXP202_VBUS_VAILD_IRQ = _BV(29), //VBUS valid, IRQ enable + AXP202_NOE_OFF_IRQ = _BV(30), //N_OE shutdown, IRQ enable + AXP202_NOE_ON_IRQ = _BV(31), //N_OE startup, IRQ enable + + //! IRQ5 REG 44H + AXP202_GPIO0_EDGE_TRIGGER_IRQ = _BV(32), //GPIO0 input edge trigger, IRQ enable + AXP202_GPIO1_EDGE_TRIGGER_IRQ = _BV(33), //GPIO1input edge trigger or ADC input, IRQ enable + AXP202_GPIO2_EDGE_TRIGGER_IRQ = _BV(34), //GPIO2input edge trigger, IRQ enable + AXP202_GPIO3_EDGE_TRIGGER_IRQ = _BV(35), //GPIO3 input edge trigger, IRQ enable + //**Reserved and unchangeable BIT 4 + AXP202_PEK_FALLING_EDGE_IRQ = _BV(37), //PEK press falling edge, IRQ enable + AXP202_PEK_RISING_EDGE_IRQ = _BV(38), //PEK press rising edge, IRQ enable + AXP202_TIMER_TIMEOUT_IRQ = _BV(39), //Timer timeout, IRQ enable + + AXP202_ALL_IRQ = (0xFFFFFFFFFFULL) +} axp_irq_t; + +typedef enum { + AXP202_LDO4_1250MV, + AXP202_LDO4_1300MV, + AXP202_LDO4_1400MV, + AXP202_LDO4_1500MV, + AXP202_LDO4_1600MV, + AXP202_LDO4_1700MV, + AXP202_LDO4_1800MV, + AXP202_LDO4_1900MV, + AXP202_LDO4_2000MV, + AXP202_LDO4_2500MV, + AXP202_LDO4_2700MV, + AXP202_LDO4_2800MV, + AXP202_LDO4_3000MV, + AXP202_LDO4_3100MV, + AXP202_LDO4_3200MV, + AXP202_LDO4_3300MV, + AXP202_LDO4_MAX, +} axp_ldo4_table_t; + +typedef enum { + AXP202_LDO5_1800MV, + AXP202_LDO5_2500MV, + AXP202_LDO5_2800MV, + AXP202_LDO5_3000MV, + AXP202_LDO5_3100MV, + AXP202_LDO5_3300MV, + AXP202_LDO5_3400MV, + AXP202_LDO5_3500MV, +} axp_ldo5_table_t; + +typedef enum { + AXP20X_LED_CHARGING_CTL = 0, + AXP20X_LED_REG_32H_CTL = 1, +} axp_chgled_control_t; + +typedef enum { + AXP20X_LED_OFF, + AXP20X_LED_BLINK_1HZ, + AXP20X_LED_BLINK_4HZ, + AXP20X_LED_LOW_LEVEL, //Still Light +} axp_chgled_mode_t; + +typedef enum { + AXP20X_LED_LIGHT_WHEN_CHARGING = 0, + AXP20X_LED_BLINK_WHEN_CHARGING = 1, +} axp_chgled_charging_mode_t; + +typedef enum { + AXP_ADC_SAMPLING_RATE_25HZ = 0, + AXP_ADC_SAMPLING_RATE_50HZ = 1, + AXP_ADC_SAMPLING_RATE_100HZ = 2, + AXP_ADC_SAMPLING_RATE_200HZ = 3, +} axp_adc_sampling_rate_t; + +typedef enum { + AXP_TS_PIN_CURRENT_20UA = 0, + AXP_TS_PIN_CURRENT_40UA = 1, + AXP_TS_PIN_CURRENT_60UA = 2, + AXP_TS_PIN_CURRENT_80UA = 3, +} axp_ts_pin_current_t; + +typedef enum { + AXP_TS_PIN_FUNCTION_BATT = 0, + AXP_TS_PIN_FUNCTION_ADC = 1, +} axp_ts_pin_function_t; + +typedef enum { + AXP_TS_PIN_MODE_DISABLE = 0, + AXP_TS_PIN_MODE_CHARGING = 1, + AXP_TS_PIN_MODE_SAMPLING = 2, + AXP_TS_PIN_MODE_ENABLE = 3, +} axp_ts_pin_mode_t; + +//! Only AXP192 and AXP202 have gpio function +typedef enum { + AXP_GPIO_0, + AXP_GPIO_1, + AXP_GPIO_2, + AXP_GPIO_3, + AXP_GPIO_4, +} axp_gpio_t; + +typedef enum { + AXP_IO_OUTPUT_LOW_MODE, + AXP_IO_OUTPUT_HIGH_MODE, + AXP_IO_INPUT_MODE, + AXP_IO_LDO_MODE, + AXP_IO_ADC_MODE, + AXP_IO_FLOATING_MODE, + AXP_IO_OPEN_DRAIN_OUTPUT_MODE, + AXP_IO_PWM_OUTPUT_MODE, + AXP_IO_EXTERN_CHARGING_CTRL_MODE, +} axp_gpio_mode_t; + +typedef enum { + AXP_IRQ_NONE, + AXP_IRQ_RISING, + AXP_IRQ_FALLING, + AXP_IRQ_DOUBLE_EDGE, +} axp_gpio_irq_t; + + +typedef enum { + AXP192_GPIO_1V8, + AXP192_GPIO_1V9, + AXP192_GPIO_2V0, + AXP192_GPIO_2V1, + AXP192_GPIO_2V2, + AXP192_GPIO_2V3, + AXP192_GPIO_2V4, + AXP192_GPIO_2V5, + AXP192_GPIO_2V6, + AXP192_GPIO_2V7, + AXP192_GPIO_2V8, + AXP192_GPIO_2V9, + AXP192_GPIO_3V0, + AXP192_GPIO_3V1, + AXP192_GPIO_3V2, + AXP192_GPIO_3V3, +} axp192_gpio_voltage_t; + +typedef enum { + AXP1XX_CHARGE_CUR_100MA, + AXP1XX_CHARGE_CUR_190MA, + AXP1XX_CHARGE_CUR_280MA, + AXP1XX_CHARGE_CUR_360MA, + AXP1XX_CHARGE_CUR_450MA, + AXP1XX_CHARGE_CUR_550MA, + AXP1XX_CHARGE_CUR_630MA, + AXP1XX_CHARGE_CUR_700MA, + AXP1XX_CHARGE_CUR_780MA, + AXP1XX_CHARGE_CUR_880MA, + AXP1XX_CHARGE_CUR_960MA, + AXP1XX_CHARGE_CUR_1000MA, + AXP1XX_CHARGE_CUR_1080MA, + AXP1XX_CHARGE_CUR_1160MA, + AXP1XX_CHARGE_CUR_1240MA, + AXP1XX_CHARGE_CUR_1320MA, +} axp1xx_charge_current_t; + + +typedef enum { + AXP20X_VBUS_LIMIT_900MA, + AXP20X_VBUS_LIMIT_500MA, + AXP20X_VBUS_LIMIT_100MA, + AXP20X_VBUS_LIMIT_OFF +} axp202_limit_setting_t; + + +typedef enum { + AXP192_VBUS_LIMIT_500MA, + AXP192_VBUS_LIMIT_100MA, + AXP192_VBUS_LIMIT_OFF +} axp192_limit_setting_t; + + +typedef enum { + AXP202_DCDC_AUTO_MODE, + AXP202_DCDC_PWM_MODE +} axp202_dc_mode_t; + +/** + * @brief Voltage rise slope control + */ +typedef enum { + AXP202_VRC_LEVEL0, // 25mV/15.625us=1.6mV/us + AXP202_VRC_LEVEL1, //25mV/31.250us=0.8mV/us +} axp202_vrc_control_t; + +typedef enum { + AXP202_BACKUP_VOLTAGE_3V1, + AXP202_BACKUP_VOLTAGE_3V0, + AXP202_BACKUP_VOLTAGE_3V6, + AXP202_BACKUP_VOLTAGE_2V5, +} axp202_backup_voltage_t; + +typedef enum { + AXP202_BACKUP_CURRENT_50UA, + AXP202_BACKUP_CURRENT_100UA, + AXP202_BACKUP_CURRENT_200UA, + AXP202_BACKUP_CURRENT_400UA, +} axp202_backup_current_t; + +typedef enum { + AXP202_PRECHARGE_MINUTES_40, + AXP202_PRECHARGE_MINUTES_50, + AXP202_PRECHARGE_MINUTES_60, + AXP202_PRECHARGE_MINUTES_70, +} axp202_precharge_timeout_t; + +typedef enum { + AXP202_CONSTANT_CUR_TIMEOUT_HOURS_6, + AXP202_CONSTANT_CUR_TIMEOUT_HOURS_8, + AXP202_CONSTANT_CUR_TIMEOUT_HOURS_10, + AXP202_CONSTANT_CUR_TIMEOUT_HOURS_12, +} axp202_constant_current_t; + +typedef uint32_t (*axp_com_fptr_t)(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint8_t len); //! 类型错误:int + +class AXP20X_Class +{ +public: + +#ifdef ARDUINO + int begin(TwoWire &port = Wire, uint8_t addr = AXP202_SLAVE_ADDRESS, bool isAxp173 = false); +#endif + + int begin(axp_com_fptr_t read_cb, axp_com_fptr_t write_cb, uint8_t addr = AXP202_SLAVE_ADDRESS, bool isAxp173 = false); + + // Power Output Control + int setPowerOutPut(uint8_t channel, bool en); + + + uint16_t getDCDC1Voltage(void); //! Only AXP192 support and AXP173 + uint16_t getDCDC2Voltage(void); + uint16_t getDCDC3Voltage(void); + uint16_t getLDO2Voltage(void); + uint16_t getLDO3Voltage(void); + uint16_t getLDO4Voltage(void); //! Only axp173/axp202 support + + int setDCDC1Voltage(uint16_t mv); //! Only AXP192 support and AXP173 + int setDCDC2Voltage(uint16_t mv); + int setDCDC3Voltage(uint16_t mv); + int setLDO2Voltage(uint16_t mv); + int setLDO3Voltage(uint16_t mv); + int setLDO4Voltage(uint16_t mv); //! Only axp173 support + int setLDO4Voltage(axp_ldo4_table_t param); //! Only axp202 support + int setLDO5Voltage(axp_ldo5_table_t vol); + + int setLDO3Mode(axp202_ldo3_mode_t mode); //! Only AXP202 support + + + bool isDCDC1Enable(void); //Only axp192 chip + bool isDCDC2Enable(void); + bool isDCDC3Enable(void); + + bool isLDO2Enable(void); + bool isLDO3Enable(void); + bool isLDO4Enable(void); + + bool isChargingEnable(void); + + bool isChargeingEnable(void) __attribute__((deprecated)); + bool isBatteryConnect(void); + bool isCharging(void); + bool isChargeing(void) __attribute__((deprecated)); + bool isVBUSPlug(void); + bool isExtenEnable(void); + + + // ACIN overvoltage IRQ + bool isAcinOverVoltageIRQ(void); + // ACIN access IRQ + bool isAcinPlugInIRQ(void); + // ACIN out of IRQ + bool isAcinRemoveIRQ(void); + // VBUS overvoltage IRQ + bool isVbusOverVoltageIRQ(void); + // VBUS access IRQ + bool isVbusPlugInIRQ(void); + // VBUS shifted out of IRQ + bool isVbusRemoveIRQ(void); + // VBUS is available but less than V HOLD IRQ + bool isVbusLowVHOLDIRQ(void); + + // Battery access IRQ + bool isBattPlugInIRQ(void); + // Battery removed IRQ + bool isBattRemoveIRQ(void); + // Battery activation mode IRQ + bool isBattEnterActivateIRQ(void); + // Exit battery activation mode IRQ + bool isBattExitActivateIRQ(void); + // Charging IRQ + bool isChargingIRQ(void); + // Charge complete IRQ + bool isChargingDoneIRQ(void); + // Battery over temperature IRQ + bool isBattTempLowIRQ(void); + // Battery temperature is too low IRQ + bool isBattTempHighIRQ(void); + + // IC internal overheating IRQ + bool isChipOvertemperatureIRQ(void); + // The charging current is less than the set current IRQ + bool isChargingCurrentLessIRQ(void); + // DC-DC2 output voltage is less than the set value IRQ + bool isDC2VoltageLessIRQ(void); + // DC-DC3 output voltage is less than the set value IRQ + bool isDC3VoltageLessIRQ(void); + // LDO3 output voltage is less than the set value IRQ + bool isLDO3VoltageLessIRQ(void); + // PEK short key IRQ + bool isPEKShortPressIRQ(void); + // PEK long key IRQ + bool isPEKLongtPressIRQ(void); + + // N_OE boot IRQ + bool isNOEPowerOnIRQ(void); + // N_OE shutdown IRQ + bool isNOEPowerDownIRQ(void); + // VBUS valid IRQ + bool isVBUSEffectiveIRQ(void); + // VBUS invalid IRQ + bool isVBUSInvalidIRQ(void); + // VBUS Session IRQ + bool isVUBSSessionIRQ(void); + // VBUS Session End IRQ + bool isVUBSSessionEndIRQ(void); + // APS low voltage IRQ enable (LEVEL1) + bool isLowVoltageLevel1IRQ(void); + // APS low voltage IRQ enable (LEVEL2) + bool isLowVoltageLevel2IRQ(void); + + // Timer expired IRQ + bool isTimerTimeoutIRQ(void); + // PEK key rising edge IRQ + bool isPEKRisingEdgeIRQ(void); + // PEK key falling edge IRQ + bool isPEKFallingEdgeIRQ(void); + // GPIO3 input edge trigger IRQ + bool isGPIO3InputEdgeTriggerIRQ(void); + // GPIO2 input edge trigger IRQ + bool isGPIO2InputEdgeTriggerIRQ(void); + // GPIO1 input edge trigger or ADC input IRQ + bool isGPIO1InputEdgeTriggerIRQ(void); + // GPIO0 input edge trigger IRQ + bool isGPIO0InputEdgeTriggerIRQ(void); + + + //! Group4 ADC data + float getAcinVoltage(void); + float getAcinCurrent(void); + float getVbusVoltage(void); + float getVbusCurrent(void); + float getTemp(void); + float getTSTemp(void); + float getGPIO0Voltage(void); + float getGPIO1Voltage(void); + float getBattInpower(void); + float getBattVoltage(void); + float getBattChargeCurrent(void); + float getBattDischargeCurrent(void); + float getSysIPSOUTVoltage(void); + uint32_t getBattChargeCoulomb(void); + uint32_t getBattDischargeCoulomb(void); + float getSettingChargeCurrent(void); + + int getChargingTargetVoltage(axp_chargeing_vol_t &charging_target_voltage); + int setChargingTargetVoltage(axp_chargeing_vol_t param); + int enableCharging(bool en); + int enableChargeing(bool en) __attribute__((deprecated)); + + + int adc1Enable(uint16_t params, bool en); + int adc2Enable(uint16_t params, bool en); + + int setTScurrent(axp_ts_pin_current_t current); + int setTSfunction(axp_ts_pin_function_t func); + int setTSmode(axp_ts_pin_mode_t mode); + + + int setTimer(uint8_t minutes); + int offTimer(void); + int clearTimerStatus(void); + bool getTimerStatus(void); + /** + * param: axp202_startup_time_t or axp192_startup_time_t + */ + int setStartupTime(uint8_t param); + + /** + * param: axp_loonPress_time_t + */ + int setlongPressTime(uint8_t param); + + /** + * @param param: axp_poweroff_time_t + */ + int setShutdownTime(uint8_t param); + int setTimeOutShutdown(bool en); + + int shutdown(void); + int setSleep(void); + + /** + * params: axp_irq_t + */ + int enableIRQ(uint64_t params, bool en); + int readIRQ(void); + void clearIRQ(void); + + int setChgLEDContrl(axp_chgled_control_t opt); + int setChgLEDMode(axp_chgled_mode_t mode); + + //! Only AXP202 support + int getBattPercentage(void); + int setMeteringSystem(bool en); + + int debugCharging(void); + int debugStatus(void); + int limitingOff(void); + + int setAdcSamplingRate(axp_adc_sampling_rate_t rate); + uint8_t getAdcSamplingRate(void); + uint8_t getCoulombRegister(void); + float getCoulombData(void); + int setCoulombRegister(uint8_t val); + int EnableCoulombcounter(void); + int DisableCoulombcounter(void); + int StopCoulombcounter(void); + int ClearCoulombcounter(void); + + int setGPIOMode(axp_gpio_t gpio, axp_gpio_mode_t mode); + int setGPIOIrq(axp_gpio_t gpio, axp_gpio_irq_t irq); + + int gpioWrite(axp_gpio_t gpio, uint8_t val); + int gpioRead(axp_gpio_t gpio); + + // When the chip is axp192 / 173, the allowed values are 0 ~ 15, corresponding to the axp1xx_charge_current_t enumeration + // When the chip is axp202 allows maximum charging current of 1800mA, minimum 300mA + int getChargeControlCur(void); + int setChargeControlCur(uint16_t mA); + + uint16_t getPowerDownVoltage(void); + int setPowerDownVoltage(uint16_t mv); + int setCurrentLimitControl(axp202_limit_setting_t opt); + int setCurrentLimitControl(axp192_limit_setting_t opt); + + int setVWarningLevel1(uint16_t mv); + int setVWarningLevel2(uint16_t mv); + + uint16_t getVWarningLevel1(void); + uint16_t getVWarningLevel2(void); + + int setDCDCMode(axp202_dc_mode_t opt); + axp202_dc_mode_t getDCDCMode(void); + + int enableLDO3VRC(bool en); + int enableDC2VRC(bool en); + int setLDO3VRC(axp202_vrc_control_t opt); + int setDC2VRC(axp202_vrc_control_t opt); + + + //Backup battery charge control + int setBackupChargeControl(bool en); + int setBackupChargeVoltage(axp202_backup_voltage_t opt); + int setBackupChargeCurrent(axp202_backup_current_t opt); + + + // Precharge timeout setting + int setPrechargeTimeout(axp202_precharge_timeout_t opt); + // Set timeout in constant current mode + int setConstantCurrentTimeout(axp202_constant_current_t opt); + // Set CHGLED mode when charging + int setChgLEDChargingMode(axp_chgled_charging_mode_t opt); + +private: + uint16_t _getRegistH8L5(uint8_t regh8, uint8_t regl5); + uint16_t _getRegistResult(uint8_t regh8, uint8_t regl4); + + int _readByte(uint8_t reg, uint8_t nbytes, uint8_t *data); + int _writeByte(uint8_t reg, uint8_t nbytes, uint8_t *data); + + int _setGpioInterrupt(uint8_t *val, int mode, bool en); + int _axp_probe(void); + int _axp_irq_mask(axp_gpio_irq_t irq); + + int _axp192_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode); + int _axp192_gpio_0_select( axp_gpio_mode_t mode); + int _axp192_gpio_1_select( axp_gpio_mode_t mode); + int _axp192_gpio_3_select( axp_gpio_mode_t mode); + int _axp192_gpio_4_select( axp_gpio_mode_t mode); + + int _axp202_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode); + int _axp202_gpio_0_select( axp_gpio_mode_t mode); + int _axp202_gpio_1_select( axp_gpio_mode_t mode); + int _axp202_gpio_2_select( axp_gpio_mode_t mode); + int _axp202_gpio_3_select( axp_gpio_mode_t mode); + int _axp202_gpio_irq_set(axp_gpio_t gpio, axp_gpio_irq_t irq); + int _axp202_gpio_write(axp_gpio_t gpio, uint8_t val); + int _axp202_gpio_read(axp_gpio_t gpio); + + + static const uint8_t startupParams[], longPressParams[], shutdownParams[], targetVolParams[]; + static uint8_t _outputReg; + uint8_t _address, _irq[5], _chip_id, _gpio[4]; + bool _init = false; + axp_com_fptr_t _read_cb = nullptr; + axp_com_fptr_t _write_cb = nullptr; +#ifdef ARDUINO + TwoWire *_i2cPort; +#endif + bool _isAxp173; +}; + +extern AXP20X_Class axp; + +#ifdef __cplusplus +} +#endif diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index 531dfd0..263c0ac 100755 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -1,3 +1,4 @@ +file(GLOB BSP_SRCS "bsp_driver/*.c" "bsp_pmic.cpp") file(GLOB PORT_SRCS "wifi/*.c" ) @@ -14,9 +15,11 @@ idf_component_register(SRCS "main.c" "Receiver.c" "flasher_tool.c" ${FILE_SYS_SRCS} ${PORT_USB} ${PORT_GUI} + ${BSP_SRCS} INCLUDE_DIRS "GUI/custom/" INCLUDE_DIRS "GUI/generated/" INCLUDE_DIRS "GUI/generated/guider_fonts/" + INCLUDE_DIRS "bsp_driver/" INCLUDE_DIRS "." INCLUDE_DIRS "GUI/" INCLUDE_DIRS "file_system/" diff --git a/main/Kconfig.projbuild b/main/Kconfig.projbuild index d9e99a8..1df8e4b 100644 --- a/main/Kconfig.projbuild +++ b/main/Kconfig.projbuild @@ -58,3 +58,36 @@ menu "ESP serial flasher" the output of the serial-flasher and the boot pin of the ESP chip. endmenu + +menu "I2C Master" + config I2C_MASTER_SCL + int "SCL GPIO Num" + default 22 + help + GPIO number for I2C Master clock line. + + config I2C_MASTER_SDA + int "SDA GPIO Num" + default 21 + help + GPIO number for I2C Master data line. + + config I2C_MASTER_PORT_NUM + int "Port Number" + default 1 + help + Port number for I2C Master device. + + config I2C_MASTER_FREQUENCY + int "Master Frequency" + default 100000 + help + I2C Speed of Master device. + + config AXPxxx_INTERRUPT_PIN + int "Interrupt Pin" + default 35 + help + axp202,192,173 interrupt pin. + +endmenu diff --git a/main/bsp_driver/i2c_port.c b/main/bsp_driver/i2c_port.c new file mode 100644 index 0000000..b167fbd --- /dev/null +++ b/main/bsp_driver/i2c_port.c @@ -0,0 +1,78 @@ +#include "i2c_port.h" + +/** + * @brief i2c master initialization + */ +esp_err_t i2c_master_init(void) +{ + int i2c_master_port = I2C_MASTER_NUM; + static i2c_config_t conf; //! i2c_config_t conf; + /* + * 报错原因:因为 conf 是函数内的局部变量,导致 conf 有成员未初始化,会从 stack 里分配内存空间,值未知 + * 解决方法:将 conf 声明为静态局部变量解决 + */ + conf.mode = I2C_MODE_MASTER; + conf.sda_io_num = I2C_MASTER_SDA_IO; + conf.sda_pullup_en = GPIO_PULLUP_ENABLE; + conf.scl_io_num = I2C_MASTER_SCL_IO; + conf.scl_pullup_en = GPIO_PULLUP_ENABLE; + conf.master.clk_speed = I2C_MASTER_FREQ_HZ; + i2c_param_config(i2c_master_port, &conf); + return i2c_driver_install(i2c_master_port, conf.mode, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0); +} + +/** + * @brief apx library i2c read callback + * + */ +uint32_t twi_read(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint8_t len) //! 类型错误:uint16_t +{ + if (len == 0) { + return ESP_OK; + } + if (data == NULL) { + return ESP_FAIL; + } + i2c_cmd_handle_t cmd; + + cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (dev_addr << 1) | WRITE_BIT, ACK_CHECK_EN); + i2c_master_write_byte(cmd, reg_addr, ACK_CHECK_EN); + i2c_master_stop(cmd); + esp_err_t ret = i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + if (ret != ESP_OK) { + return ESP_FAIL; + } + cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (dev_addr << 1) | READ_BIT, ACK_CHECK_EN); + if (len > 1) { + i2c_master_read(cmd, data, len - 1, ACK_VAL); + } + i2c_master_read_byte(cmd, &data[len - 1], NACK_VAL); + i2c_master_stop(cmd); + ret = i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + return ret; +} + +/** + * @brief apx library i2c write callback + */ +uint32_t twi_write(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint8_t len) //! 类型错误:uint16_t +{ + if (data == NULL) { + return ESP_FAIL; + } + i2c_cmd_handle_t cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (dev_addr << 1) | WRITE_BIT, ACK_CHECK_EN); + i2c_master_write_byte(cmd, reg_addr, ACK_CHECK_EN); + i2c_master_write(cmd, data, len, ACK_CHECK_EN); + i2c_master_stop(cmd); + esp_err_t ret = i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + return ret; +} diff --git a/main/bsp_driver/i2c_port.h b/main/bsp_driver/i2c_port.h new file mode 100644 index 0000000..3d00840 --- /dev/null +++ b/main/bsp_driver/i2c_port.h @@ -0,0 +1,31 @@ +#pragma once + +#include +#include "esp_log.h" +#include "driver/i2c.h" +#include "sdkconfig.h" + +//! ESP32C3只有I2C_NUM_0一个I2C通道 +#define _I2C_NUMBER(num) I2C_NUM_##num /*!< I2C port*/ +#define I2C_NUMBER(num) _I2C_NUMBER(num) + +#define AXP_ISR_GPIO (gpio_num_t)CONFIG_AXPxxx_INTERRUPT_PIN /*!< axp power chip interrupt Pin*/ +#define GPIO_INPUT_PIN_SEL (1ULL<