├── .gitignore ├── CMakeLists.txt ├── LICENSE ├── README.md ├── examples ├── axp202_gpio_input │ └── axp202_gpio_input.ino ├── axp202_gpio_output │ └── axp202_gpio_output.ino ├── axp202_timer │ └── axp202_timer.ino ├── axp_adc │ └── axp_adc.ino ├── axp_base │ └── axp_base.ino ├── axp_charge_cur │ └── axp_charge_cur.ino ├── axp_sleep_mode │ └── axp_sleep_mode.ino └── axp_temp │ └── axp_temp.ino ├── keywords.txt ├── library.properties └── src ├── axp20x.cpp └── axp20x.h /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode 2 | .DS_Store -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | # set(COMPONENT_SRCS "./AXP202X_Library/src/axp20x.cpp") 3 | # set(COMPONENT_ADD_INCLUDEDIRS "./AXP202X_Library/src") 4 | # register_component() 5 | 6 | idf_component_register(SRCS "src/axp20x.cpp" 7 | INCLUDE_DIRS "src" 8 | ) -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 lewis he 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | AXP202X_Library 2 | ===================================== 3 | - How to program **AXP20x_Library** with ESP-IDF [ESP_IDF_AXP20x_Library](https://github.com/lewisxhe/ESP_IDF_AXP20x_Library) 4 | 5 | - The `setPowerOutPut` function has forced DCDC3 to be turned on and cannot be controlled because T-Watch uses DCDC3 as the esp32 to power the main chip. If it is turned off, the hardware cannot be programmed. 6 | 7 | 8 | TTGO invests time and resources to provide this open source code, please support TTGO and open source hardware by purchasing products from TTGO! 9 | 10 | Written by Lewis He for TTGO. MIT license, all text above must be included in any redistribution 11 | 12 | ## Chip resource table 13 | | CHIP | AXP173 | AXP192 | AXP202 | 14 | | -------- | ---------------- | ---------------- | ---------------- | 15 | | DC1 | 0v7~3v5 /1200mA | 0v7~3v5 /1200mA | X | 16 | | DC2 | 0v7~2v275/1600mA | 0v7~2v275/1600mA | 0v7~2v275/1600mA | 17 | | DC3 | X | 0v7~3v5 /700mA | 0v7~3v5 /1200mA | 18 | | LDO1 | 3v3 /30mA | 3v3 /30mA | 3v3 /30mA | 19 | | LDO2 | 1v8~3v3 /200mA | 1v8~3v3 /200mA | 1v8~3v3 /200mA | 20 | | LDO3 | 1v8~3v3 /200mA | 1v8~3v3 /200mA | 0v7~3v3 /200mA | 21 | | LDO4 | 0v7~3v5 /500mA | X | 1v8~3v3 /200mA | 22 | | LDO5/IO0 | X | 1v8~3v3 /50mA | 1v8~3v3 /50mA | 23 | -------------------------------------------------------------------------------- /examples/axp202_gpio_input/axp202_gpio_input.ino: -------------------------------------------------------------------------------- 1 | /* 2 | MIT License 3 | 4 | Copyright (c) 2019 lewis he 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | */ 24 | #include 25 | #include 26 | 27 | AXP20X_Class axp; 28 | 29 | const uint8_t i2c_sda = 21; 30 | const uint8_t i2c_scl = 22; 31 | 32 | void setup() 33 | { 34 | Serial.begin(115200); 35 | Wire.begin(i2c_sda, i2c_scl); 36 | 37 | int ret = axp.begin(Wire); 38 | 39 | if (ret == AXP_FAIL) { 40 | Serial.println("AXP Power begin failed"); 41 | while (1); 42 | } 43 | //! AXP202 GPIO has no internal pull-up or pull-down. 44 | //! For stability, external pull-up or pull-down resistors are required. 45 | ret = axp.setGPIOMode(AXP_GPIO_0, AXP_IO_INPUT_MODE); 46 | Serial.printf("AXP_GPIO_0 %d\n", ret); 47 | ret = axp.setGPIOMode(AXP_GPIO_1, AXP_IO_INPUT_MODE); 48 | Serial.printf("AXP_GPIO_1 %d\n", ret); 49 | ret = axp.setGPIOMode(AXP_GPIO_2, AXP_IO_INPUT_MODE); 50 | Serial.printf("AXP_GPIO_2 %d\n", ret); 51 | ret = axp.setGPIOMode(AXP_GPIO_3, AXP_IO_INPUT_MODE); 52 | Serial.printf("AXP_GPIO_3 %d\n", ret); 53 | 54 | } 55 | 56 | void loop() 57 | { 58 | Serial.printf("GPIO: [0]:%d [1]:%d [2]:%d [3]:%d\n", 59 | axp.gpioRead(AXP_GPIO_0), 60 | axp.gpioRead(AXP_GPIO_1), 61 | axp.gpioRead(AXP_GPIO_2), 62 | axp.gpioRead(AXP_GPIO_3) 63 | ); 64 | delay(1000); 65 | } 66 | 67 | -------------------------------------------------------------------------------- /examples/axp202_gpio_output/axp202_gpio_output.ino: -------------------------------------------------------------------------------- 1 | /* 2 | MIT License 3 | 4 | Copyright (c) 2019 lewis he 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | */ 24 | #include 25 | #include 26 | 27 | AXP20X_Class axp; 28 | 29 | const uint8_t i2c_sda = 21; 30 | const uint8_t i2c_scl = 22; 31 | 32 | void setup() 33 | { 34 | Serial.begin(115200); 35 | Wire.begin(i2c_sda, i2c_scl); 36 | 37 | int ret = axp.begin(Wire); 38 | 39 | if (ret == AXP_FAIL) { 40 | Serial.println("AXP Power begin failed"); 41 | while (1); 42 | } 43 | 44 | axp.setGPIOMode(AXP_GPIO_0, AXP_IO_OUTPUT_HIGH_MODE); 45 | axp.setGPIOMode(AXP_GPIO_1, AXP_IO_OUTPUT_HIGH_MODE); 46 | 47 | //! GPIO2, GPIO3 is only allowed to be configured to output low 48 | axp.gpioWrite(AXP_GPIO_2, LOW); 49 | axp.gpioWrite(AXP_GPIO_3, LOW); 50 | 51 | } 52 | 53 | void loop() 54 | { 55 | //! GPIO0, GPIO1 allows output high and low 56 | axp.gpioWrite(AXP_GPIO_0, HIGH); 57 | axp.gpioWrite(AXP_GPIO_1, HIGH); 58 | delay(1000); 59 | axp.gpioWrite(AXP_GPIO_0, LOW); 60 | axp.gpioWrite(AXP_GPIO_1, LOW); 61 | delay(1000); 62 | } 63 | 64 | -------------------------------------------------------------------------------- /examples/axp202_timer/axp202_timer.ino: -------------------------------------------------------------------------------- 1 | /* 2 | MIT License 3 | 4 | Copyright (c) 2019 lewis he 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | */ 24 | #include 25 | #include 26 | 27 | 28 | AXP20X_Class axp; 29 | bool axpIrq = 0; 30 | uint8_t second = 0; 31 | uint32_t timer = 0; 32 | 33 | const uint8_t i2c_sda = 21; 34 | const uint8_t i2c_scl = 22; 35 | const uint8_t axp_irq_pin = 35; 36 | 37 | void setup() 38 | { 39 | Serial.begin(115200); 40 | Wire.begin(i2c_sda, i2c_scl); 41 | 42 | int ret = axp.begin(Wire); 43 | 44 | if (ret == AXP_FAIL) { 45 | Serial.println("AXP Power begin failed"); 46 | while (1); 47 | } 48 | 49 | //! enable timer irq and pek key press irq channel 50 | axp.enableIRQ(AXP202_TIMER_TIMEOUT_IRQ | AXP202_PEK_SHORTPRESS_IRQ, true); 51 | 52 | //! attachInterrupt to gpio 35 53 | pinMode(axp_irq_pin, INPUT); 54 | attachInterrupt(axp_irq_pin, [] { 55 | axpIrq = 1; 56 | }, FALLING); 57 | axp.clearIRQ(); 58 | 59 | axp.setTimer(1); 60 | 61 | } 62 | 63 | 64 | void loop() 65 | { 66 | if (millis() - timer > 1000) { 67 | second++; 68 | Serial.printf("%u second\n", second); 69 | timer = millis(); 70 | } 71 | if (axpIrq) { 72 | axpIrq = 0; 73 | axp.readIRQ(); 74 | if (axp.isPEKShortPressIRQ()) { 75 | Serial.printf("AXP202 PEK key Click\n"); 76 | } 77 | if (axp.isTimerTimeoutIRQ()) { 78 | Serial.printf("AXP202 timer timeout\n"); 79 | axp.clearTimerStatus(); 80 | while (1) { 81 | delay(100); 82 | } 83 | } 84 | axp.clearIRQ(); 85 | } 86 | } 87 | 88 | -------------------------------------------------------------------------------- /examples/axp_adc/axp_adc.ino: -------------------------------------------------------------------------------- 1 | /* 2 | MIT License 3 | 4 | Copyright (c) 2019 lewis he 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | */ 24 | 25 | #include "axp20x.h" 26 | 27 | AXP20X_Class axp; 28 | const uint8_t i2c_sda = 21; 29 | const uint8_t i2c_scl = 22; 30 | const uint8_t slave_address = AXP192_SLAVE_ADDRESS; //use axp192 31 | // const uint8_t slave_address = AXP202_SLAVE_ADDRESS; //use axp202 32 | 33 | void printPowerChannel(); 34 | 35 | void setup(void) 36 | { 37 | Serial.begin(115200); 38 | 39 | Wire.begin(i2c_sda, i2c_scl); 40 | 41 | Serial.println("AXP192/AXP202 ADC Test"); 42 | 43 | /* Initialise the pmu */ 44 | int ret = axp.begin(Wire, slave_address); 45 | if (ret) { 46 | /* There was a problem detecting the AXP202/192 ... check your connections */ 47 | Serial.println("Ooops, AXP202/AXP192 power chip detected ... Check your wiring!"); 48 | while (1); 49 | } 50 | 51 | /*Enable AXP ADC function*/ 52 | axp.adc1Enable(AXP202_VBUS_VOL_ADC1 | 53 | AXP202_VBUS_CUR_ADC1 | 54 | AXP202_BATT_CUR_ADC1 | 55 | AXP202_BATT_VOL_ADC1, 56 | true); 57 | 58 | Serial.println(""); 59 | 60 | printPowerChannel(); 61 | } 62 | 63 | void loop(void) 64 | { 65 | Serial.println("========================="); 66 | Serial.print("VBUS STATUS: "); 67 | // You can use isVBUSPlug to check whether the USB connection is normal 68 | if (axp.isVBUSPlug()) { 69 | 70 | Serial.println("CONNECT"); 71 | 72 | // Get USB voltage 73 | Serial.print("VBUS Volate:"); 74 | Serial.print(axp.getVbusVoltage()); 75 | Serial.println(" mV"); 76 | 77 | // Get USB current 78 | Serial.print("VBUS Current: "); 79 | Serial.print(axp.getVbusCurrent()); 80 | Serial.println(" mA"); 81 | 82 | } else { 83 | Serial.println("DISCONNECT"); 84 | } 85 | 86 | Serial.println("========================="); 87 | 88 | Serial.print("BATTERY STATUS: "); 89 | 90 | // You can use isBatteryConnect() to check whether the battery is connected properly 91 | if (axp.isBatteryConnect()) { 92 | 93 | Serial.println("CONNECT"); 94 | 95 | // Get battery voltage 96 | Serial.print("BAT Volate:"); 97 | Serial.print(axp.getBattVoltage()); 98 | Serial.println(" mV"); 99 | 100 | // To display the charging status, you must first discharge the battery, 101 | // and it is impossible to read the full charge when it is fully charged 102 | if (axp.isChargeing()) { 103 | Serial.print("Charge:"); 104 | Serial.print(axp.getBattChargeCurrent()); 105 | Serial.println(" mA"); 106 | } else { 107 | // Show current consumption 108 | Serial.print("Discharge:"); 109 | Serial.print(axp.getBattDischargeCurrent()); 110 | Serial.println(" mA"); 111 | 112 | /*getBattPercentage just only support axp202 */ 113 | if (slave_address == AXP202_SLAVE_ADDRESS) { 114 | Serial.print("Per: "); 115 | Serial.print(axp.getBattPercentage()); 116 | Serial.println(" %"); 117 | } 118 | } 119 | } else { 120 | Serial.println("DISCONNECT"); 121 | } 122 | Serial.println(); 123 | Serial.println(); 124 | delay(3000); 125 | } 126 | 127 | 128 | void printPowerChannel() 129 | { 130 | Serial.print("DC2:"); 131 | Serial.print(axp.isDCDC2Enable() ? String(axp.getDCDC2Voltage()) + " mv" : "DISABLE"); 132 | Serial.print(" "); 133 | 134 | Serial.print("DC3:"); 135 | Serial.print(axp.isDCDC3Enable() ? String(axp.getDCDC3Voltage()) + " mv" : "DISABLE"); 136 | Serial.print(" "); 137 | 138 | Serial.print("LDO2:"); 139 | Serial.print(axp.isLDO2Enable() ? String(axp.getLDO2Voltage()) + " mv" : "DISABLE"); 140 | Serial.print(" "); 141 | 142 | Serial.print("LDO3:"); 143 | Serial.print(axp.isLDO3Enable() ? String(axp.getLDO3Voltage()) + " mv" : "DISABLE"); 144 | Serial.print(" "); 145 | 146 | Serial.print("LDO4:"); 147 | Serial.print(axp.isLDO4Enable() ? "ENABLE" : "DISABLE"); 148 | Serial.print(" "); 149 | 150 | Serial.print("Exten:"); 151 | Serial.print(axp.isExtenEnable() ? "ENABLE" : "DISABLE"); 152 | Serial.print("\r\n"); 153 | } -------------------------------------------------------------------------------- /examples/axp_base/axp_base.ino: -------------------------------------------------------------------------------- 1 | /* 2 | MIT License 3 | 4 | Copyright (c) 2019 lewis he 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | */ 24 | #include 25 | #include 26 | 27 | AXP20X_Class axp; 28 | bool axpIrq = 0; 29 | 30 | const uint8_t i2c_sda = 21; 31 | const uint8_t i2c_scl = 22; 32 | const uint8_t axp_irq_pin = 35; 33 | 34 | void setFlag(void) 35 | { 36 | axpIrq = true; 37 | } 38 | 39 | void setup() 40 | { 41 | Serial.begin(115200); 42 | Wire.begin(i2c_sda, i2c_scl); 43 | 44 | //! Use the Wire port 45 | int ret = axp.begin(Wire, AXP192_SLAVE_ADDRESS); 46 | // int ret = axp.begin(Wire); 47 | if (ret == AXP_FAIL) { 48 | Serial.println("AXP Power begin failed"); 49 | while (1); 50 | } 51 | 52 | Serial.println(); 53 | axp.setVWarningLevel1(3450); 54 | axp.setVWarningLevel2(3400); 55 | uint16_t level1 = axp.getVWarningLevel1(); 56 | uint16_t level2 = axp.getVWarningLevel2(); 57 | Serial.printf("getVWarningLevel1:%u mV \n", level1 ); 58 | Serial.printf("getVWarningLevel2:%u mV \n", level2); 59 | Serial.printf("getPowerDonwVoltage:%u mV \n", axp.getPowerDownVoltage()); 60 | axp.setPowerDownVoltage(2600); 61 | Serial.printf("getPowerDonwVoltage:%u mV \n", axp.getPowerDownVoltage()); 62 | Serial.println(); 63 | 64 | //! attachInterrupt to gpio 35 65 | pinMode(axp_irq_pin, INPUT_PULLUP); 66 | attachInterrupt(axp_irq_pin, setFlag, FALLING); 67 | axp.clearIRQ(); 68 | 69 | //! enable all irq channel 70 | axp.enableIRQ(AXP202_ALL_IRQ, true); 71 | 72 | axp.setPowerOutPut(AXP202_DCDC3, AXP202_ON); 73 | axp.setPowerOutPut(AXP202_EXTEN, AXP202_ON); 74 | axp.setPowerOutPut(AXP202_LDO2, AXP202_ON); 75 | axp.setPowerOutPut(AXP202_LDO4, AXP202_ON); 76 | axp.setPowerOutPut(AXP202_DCDC2, AXP202_ON); 77 | axp.setLDO4Voltage(AXP202_LDO4_3300MV); 78 | axp.setLDO3Voltage(3500); 79 | axp.setPowerOutPut(AXP202_LDO3, AXP202_ON); 80 | 81 | Serial.print("DC2:"); 82 | Serial.print(axp.isDCDC2Enable() ? String(axp.getDCDC2Voltage()) + " mv" : "DISABLE"); 83 | Serial.print(" "); 84 | 85 | Serial.print("DC3:"); 86 | Serial.print(axp.isDCDC3Enable() ? String(axp.getDCDC3Voltage()) + " mv" : "DISABLE"); 87 | Serial.print(" "); 88 | 89 | Serial.print("LDO2:"); 90 | Serial.print(axp.isLDO2Enable() ? String(axp.getLDO2Voltage()) + " mv" : "DISABLE"); 91 | Serial.print(" "); 92 | 93 | Serial.print("LDO3:"); 94 | Serial.print(axp.isLDO3Enable() ? String(axp.getLDO3Voltage()) + " mv" : "DISABLE"); 95 | Serial.print(" "); 96 | 97 | Serial.print("LDO4:"); 98 | Serial.print(axp.isLDO4Enable() ? "ENABLE" : "DISABLE"); 99 | Serial.print(" "); 100 | 101 | Serial.print("Exten:"); 102 | Serial.print(axp.isExtenEnable() ? "ENABLE" : "DISABLE"); 103 | Serial.print("\r\n"); 104 | 105 | axp.setTimer(1); 106 | } 107 | 108 | 109 | void loop() 110 | { 111 | if (axpIrq) { 112 | axpIrq = 0; 113 | axp.readIRQ(); 114 | Serial.println("axp20x irq enter!"); 115 | if (axp.isAcinOverVoltageIRQ()) { 116 | Serial.printf("isAcinOverVoltageIRQ\n"); 117 | } 118 | if (axp.isAcinPlugInIRQ()) { 119 | Serial.printf("isAcinPlugInIRQ\n"); 120 | } 121 | if (axp.isAcinRemoveIRQ()) { 122 | Serial.printf("isAcinRemoveIRQ\n"); 123 | } 124 | if (axp.isVbusOverVoltageIRQ()) { 125 | Serial.printf("isVbusOverVoltageIRQ\n"); 126 | } 127 | if (axp.isVbusPlugInIRQ()) { 128 | Serial.printf("isVbusPlugInIRQ\n"); 129 | } 130 | if (axp.isVbusRemoveIRQ()) { 131 | Serial.printf("isVbusRemoveIRQ\n"); 132 | } 133 | if (axp.isVbusLowVHOLDIRQ()) { 134 | Serial.printf("isVbusLowVHOLDIRQ\n"); 135 | } 136 | if (axp.isBattPlugInIRQ()) { 137 | Serial.printf("isBattPlugInIRQ\n"); 138 | } 139 | if (axp.isBattRemoveIRQ()) { 140 | Serial.printf("isBattRemoveIRQ\n"); 141 | } 142 | if (axp.isBattEnterActivateIRQ()) { 143 | Serial.printf("isBattEnterActivateIRQ\n"); 144 | } 145 | if (axp.isBattExitActivateIRQ()) { 146 | Serial.printf("isBattExitActivateIRQ\n"); 147 | } 148 | if (axp.isChargingIRQ()) { 149 | Serial.printf("isChargingIRQ\n"); 150 | } 151 | if (axp.isChargingDoneIRQ()) { 152 | Serial.printf("isChargingDoneIRQ\n"); 153 | } 154 | if (axp.isBattTempLowIRQ()) { 155 | Serial.printf("isBattTempLowIRQ\n"); 156 | } 157 | if (axp.isBattTempHighIRQ()) { 158 | Serial.printf("isBattTempHighIRQ\n"); 159 | } 160 | if (axp.isChipOvertemperatureIRQ()) { 161 | Serial.printf("isChipOvertemperatureIRQ\n"); 162 | } 163 | if (axp.isChargingCurrentLessIRQ()) { 164 | Serial.printf("isChargingCurrentLessIRQ\n"); 165 | } 166 | if (axp.isDC2VoltageLessIRQ()) { 167 | Serial.printf("isDC2VoltageLessIRQ\n"); 168 | } 169 | if (axp.isDC3VoltageLessIRQ()) { 170 | Serial.printf("isDC3VoltageLessIRQ\n"); 171 | } 172 | if (axp.isLDO3VoltageLessIRQ()) { 173 | Serial.printf("isLDO3VoltageLessIRQ\n"); 174 | } 175 | if (axp.isPEKShortPressIRQ()) { 176 | Serial.printf("isPEKShortPressIRQ\n"); 177 | } 178 | if (axp.isPEKLongtPressIRQ()) { 179 | Serial.printf("isPEKLongtPressIRQ\n"); 180 | } 181 | if (axp.isNOEPowerOnIRQ()) { 182 | Serial.printf("isNOEPowerOnIRQ\n"); 183 | } 184 | if (axp.isNOEPowerDownIRQ()) { 185 | Serial.printf("isNOEPowerDownIRQ\n"); 186 | } 187 | if (axp.isVBUSEffectiveIRQ()) { 188 | Serial.printf("isVBUSEffectiveIRQ\n"); 189 | } 190 | if (axp.isVBUSInvalidIRQ()) { 191 | Serial.printf("isVBUSInvalidIRQ\n"); 192 | } 193 | if (axp.isVUBSSessionIRQ()) { 194 | Serial.printf("isVUBSSessionIRQ\n"); 195 | } 196 | if (axp.isVUBSSessionEndIRQ()) { 197 | Serial.printf("isVUBSSessionEndIRQ\n"); 198 | } 199 | if (axp.isLowVoltageLevel1IRQ()) { 200 | Serial.printf("isLowVoltageLevel1IRQ\n"); 201 | } 202 | if (axp.isLowVoltageLevel2IRQ()) { 203 | Serial.printf("isLowVoltageLevel2IRQ\n"); 204 | } 205 | if (axp.isTimerTimeoutIRQ()) { 206 | Serial.printf("isTimerTimeoutIRQ\n"); 207 | axp.offTimer(); 208 | axp.setChgLEDMode(AXP20X_LED_BLINK_1HZ); 209 | } 210 | if (axp.isPEKRisingEdgeIRQ()) { 211 | Serial.printf("isPEKRisingEdgeIRQ\n"); 212 | } 213 | if (axp.isPEKFallingEdgeIRQ()) { 214 | Serial.printf("isPEKFallingEdgeIRQ\n"); 215 | } 216 | if (axp.isGPIO3InputEdgeTriggerIRQ()) { 217 | Serial.printf("isGPIO3InputEdgeTriggerIRQ\n"); 218 | } 219 | if (axp.isGPIO2InputEdgeTriggerIRQ()) { 220 | Serial.printf("isGPIO2InputEdgeTriggerIRQ\n"); 221 | } 222 | if (axp.isGPIO1InputEdgeTriggerIRQ()) { 223 | Serial.printf("isGPIO1InputEdgeTriggerIRQ\n"); 224 | } 225 | if (axp.isGPIO0InputEdgeTriggerIRQ()) { 226 | Serial.printf("isGPIO0InputEdgeTriggerIRQ\n"); 227 | } 228 | axp.clearIRQ(); 229 | } 230 | } 231 | 232 | -------------------------------------------------------------------------------- /examples/axp_charge_cur/axp_charge_cur.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | AXP20X_Class axp; 5 | 6 | const uint8_t i2c_sda = 21; 7 | const uint8_t i2c_scl = 22; 8 | 9 | void setup() 10 | { 11 | Serial.begin(115200); 12 | 13 | delay(3000); 14 | 15 | Wire.begin(i2c_sda, i2c_scl); 16 | 17 | int ret = axp.begin(Wire); 18 | if (ret == AXP_FAIL) { 19 | Serial.println("AXP Power begin failed"); 20 | while (1); 21 | } 22 | int cur = axp.getChargeControlCur(); 23 | Serial.printf("Current charge control current = %d mA \n", cur); 24 | 25 | 26 | //axp202 allows maximum charging current of 1800mA, minimum 300mA 27 | axp.setChargeControlCur(500); 28 | Serial.printf("Set charge control current 500 mA \n"); 29 | 30 | //When the chip is axp192 / 173, the allowed values are 0 ~ 15, 31 | //corresponding to the axp1xx_charge_current_t enumeration 32 | // axp.setChargeControlCur(AXP1XX_CHARGE_CUR_550MA); 33 | // Serial.printf("Set charge control current 550 mA \n"); 34 | 35 | cur = axp.getChargeControlCur(); 36 | Serial.printf("Current charge control current = %d mA \n", cur); 37 | 38 | 39 | } 40 | 41 | void loop() 42 | { 43 | } 44 | 45 | -------------------------------------------------------------------------------- /examples/axp_sleep_mode/axp_sleep_mode.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | AXP20X_Class axp; 5 | 6 | const uint8_t i2c_sda = 21; 7 | const uint8_t i2c_scl = 22; 8 | const uint8_t irq_pin = 35; 9 | 10 | bool pmu_irq = false; 11 | 12 | 13 | void sleepPMU() 14 | { 15 | int ret; 16 | // PEK or GPIO edge wake-up function enable setting in Sleep mode 17 | do { 18 | // In order to ensure that it is set correctly, 19 | // the loop waits for it to return the correct return value 20 | Serial.println("Set PMU in sleep mode"); 21 | ret = axp.setSleep(); 22 | delay(500); 23 | } while (ret != AXP_PASS) ; 24 | 25 | // Turn off all power channels, only use PEK or AXP GPIO to wake up 26 | 27 | // After setting AXP202/AXP192 to sleep, 28 | // it will start to record the status of the power channel that was turned off after setting, 29 | // it will restore the previously set state after PEK button or GPIO wake up 30 | 31 | 32 | // Turn off all AXP192 power channels 33 | ret = axp.setPowerOutPut(AXP192_LDO2, AXP202_OFF); 34 | Serial.printf("Set Power AXP192_LDO2:%s\n", ret == AXP_PASS ? "OK" : "FAIL"); 35 | 36 | ret = axp.setPowerOutPut(AXP192_LDO3, AXP202_OFF); 37 | Serial.printf("Set Power AXP192_LDO3:%s\n", ret == AXP_PASS ? "OK" : "FAIL"); 38 | 39 | ret = axp.setPowerOutPut(AXP192_DCDC1, AXP202_OFF); 40 | Serial.printf("Set Power AXP192_DCDC1:%s\n", ret == AXP_PASS ? "OK" : "FAIL"); 41 | 42 | ret = axp.setPowerOutPut(AXP192_DCDC2, AXP202_OFF); 43 | Serial.printf("Set Power AXP192_DCDC2:%s\n", ret == AXP_PASS ? "OK" : "FAIL"); 44 | 45 | ret = axp.setPowerOutPut(AXP192_EXTEN, AXP202_OFF); 46 | Serial.printf("Set Power AXP192_EXTEN:%s\n", ret == AXP_PASS ? "OK" : "FAIL"); 47 | 48 | Serial.flush(); 49 | delay(1000); 50 | 51 | // Tbeam v1.0 uses DC3 as the MCU power channel, turning it off as the last 52 | ret = axp.setPowerOutPut(AXP192_DCDC3, AXP202_OFF); 53 | Serial.printf("Set Power AXP192_DCDC3:%s\n", ret == AXP_PASS ? "OK" : "FAIL"); 54 | 55 | // Turn off all AXP202 power channels 56 | // axp.setPowerOutPut(AXP202_LDO2, AXP202_OFF); 57 | // axp.setPowerOutPut(AXP202_LDO3, AXP202_OFF); 58 | // axp.setPowerOutPut(AXP202_LDO4, AXP202_OFF); 59 | // axp.setPowerOutPut(AXP202_DCDC2, AXP202_OFF); 60 | // axp.setPowerOutPut(AXP202_DCDC3, AXP202_OFF); 61 | // axp.setPowerOutPut(AXP202_EXTEN, AXP202_OFF); 62 | 63 | 64 | // If you set the power supply to sleep mode and you turn off the power supply of the MCU, 65 | // you will not be able to use the wake-up mode provided by the MCU. 66 | // If you do not turn off the power of the MCU, you can continue to use it 67 | } 68 | 69 | void setup() 70 | { 71 | Serial.begin(115200); 72 | 73 | delay(3000); 74 | 75 | Wire.begin(i2c_sda, i2c_scl); 76 | 77 | 78 | // Test with AXP192 ,TBeam v1.0 board 79 | int ret = axp.begin(Wire, AXP192_SLAVE_ADDRESS); 80 | if (ret == AXP_FAIL) { 81 | Serial.println("AXP Power begin failed"); 82 | while (1); 83 | } 84 | 85 | // Register the PMU interrupt pin, it will be triggered on the falling edge 86 | pinMode(irq_pin, INPUT); 87 | attachInterrupt(irq_pin, [] { 88 | pmu_irq = true; 89 | }, FALLING); 90 | 91 | // Before using IRQ, remember to clear the IRQ status register 92 | axp.clearIRQ(); 93 | 94 | // Turn on the key to press the interrupt function 95 | axp.enableIRQ(AXP202_PEK_SHORTPRESS_IRQ, true); 96 | 97 | 98 | Serial.println("Wait for the PEK button to be pressed"); 99 | } 100 | 101 | void loop() 102 | { 103 | if ( pmu_irq) { 104 | pmu_irq = false; 105 | axp.readIRQ(); 106 | // When the PEK button is pressed briefly, the PMU is set to sleep 107 | if (axp.isPEKShortPressIRQ()) { 108 | // Clear all interrupt status before going to sleep 109 | axp.clearIRQ(); 110 | // Set PMU to sleep 111 | sleepPMU(); 112 | } 113 | } 114 | } 115 | 116 | -------------------------------------------------------------------------------- /examples/axp_temp/axp_temp.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | AXP20X_Class axp; 5 | 6 | const uint8_t i2c_sda = 21; 7 | const uint8_t i2c_scl = 22; 8 | 9 | void setup() 10 | { 11 | Serial.begin(115200); 12 | 13 | Wire.begin(i2c_sda, i2c_scl); 14 | 15 | // Use AXP202 by default 16 | // int ret = axp.begin(Wire); 17 | 18 | // Uncomment will use AXP192 19 | int ret = axp.begin(Wire, AXP192_SLAVE_ADDRESS); 20 | 21 | if (ret == AXP_FAIL) { 22 | Serial.println("AXP Power begin failed"); 23 | while (1); 24 | } 25 | 26 | } 27 | 28 | void loop() 29 | { 30 | float temp = axp.getTemp(); 31 | Serial.print(temp); 32 | Serial.println("*C"); 33 | 34 | // In T-Beam, T-Watch, and other products using AXP192 and AXP202 in TTGO, TS is not connected. 35 | // float ts = axp.getTSTemp(); 36 | // Serial.print(ts); 37 | // Serial.println("*C"); 38 | 39 | delay(1000); 40 | } 41 | 42 | -------------------------------------------------------------------------------- /keywords.txt: -------------------------------------------------------------------------------- 1 | ####################################### 2 | # Syntax Coloring Map For X-Power AXP20X Library By lewis He 3 | # github:https://github.com/lewisxhe 4 | ####################################### 5 | 6 | ####################################### 7 | # Datatypes (KEYWORD1) 8 | ####################################### 9 | AXP20X_Class KEYWORD1 10 | 11 | ####################################### 12 | # Methods and Functions (KEYWORD2) 13 | ####################################### 14 | 15 | begin KEYWORD2 16 | isChargeing KEYWORD2 17 | isLDO2Enable KEYWORD2 18 | isLDO3Enable KEYWORD2 19 | isLDO4Enable KEYWORD2 20 | isDCDC3Enable KEYWORD2 21 | isDCDC2Enable KEYWORD2 22 | isChargeingEnable KEYWORD2 23 | isAcinOverVoltageIRQ KEYWORD2 24 | isAcinPlugInIRQ KEYWORD2 25 | isAcinRemoveIRQ KEYWORD2 26 | isVbusOverVoltageIRQ KEYWORD2 27 | isVbusPlugInIRQ KEYWORD2 28 | isVbusRemoveIRQ KEYWORD2 29 | isVbusLowVHOLDIRQ KEYWORD2 30 | isBattPlugInIRQ KEYWORD2 31 | isBattRemoveIRQ KEYWORD2 32 | isBattEnterActivateIRQ KEYWORD2 33 | isBattExitActivateIRQ KEYWORD2 34 | isChargingIRQ KEYWORD2 35 | isChargingDoneIRQ KEYWORD2 36 | isBattTempLowIRQ KEYWORD2 37 | isBattTempHighIRQ KEYWORD2 38 | isPEKShortPressIRQ KEYWORD2 39 | isPEKLongtPressIRQ KEYWORD2 40 | getAcinVoltage KEYWORD2 41 | getAcinCurrent KEYWORD2 42 | getVbusVoltage KEYWORD2 43 | getVbusCurrent KEYWORD2 44 | getTemp KEYWORD2 45 | getTSTemp KEYWORD2 46 | getGPIO0Voltage KEYWORD2 47 | getGPIO1Voltage KEYWORD2 48 | getBattInpower KEYWORD2 49 | getBattVoltage KEYWORD2 50 | getBattChargeCurrent KEYWORD2 51 | getBattDischargeCurrent KEYWORD2 52 | getSysIPSOUTVoltage KEYWORD2 53 | getBattChargeCoulomb KEYWORD2 54 | getBattDischargeCoulomb KEYWORD2 55 | getSettingChargeCurrent KEYWORD2 56 | setChargingTargetVoltage KEYWORD2 57 | enableChargeing KEYWORD2 58 | adc1Enable KEYWORD2 59 | adc2Enable KEYWORD2 60 | setStartupTime KEYWORD2 61 | setlongPressTime KEYWORD2 62 | setShutdownTime KEYWORD2 63 | setTimeOutShutdown KEYWORD2 64 | enableIRQ KEYWORD2 65 | readIRQ KEYWORD2 66 | clearIRQ KEYWORD2 67 | setDCDC2Voltage KEYWORD2 68 | setDCDC3Voltage KEYWORD2 69 | setLDO2Voltage KEYWORD2 70 | setLDO3Voltage KEYWORD2 71 | setLDO4Voltage KEYWORD2 72 | getBattPercentage KEYWORD2 73 | setTScurrent KEYWORD2 74 | setTSfunction KEYWORD2 75 | setTSmode KEYWORD2 76 | 77 | ####################################### 78 | # Instances (KEYWORD2) 79 | ####################################### 80 | 81 | 82 | ####################################### 83 | # Constants (LITERAL1) 84 | ####################################### 85 | AXP202_LDO4_1250MV LITERAL1 86 | AXP202_LDO4_1300MV LITERAL1 87 | AXP202_LDO4_1400MV LITERAL1 88 | AXP202_LDO4_1500MV LITERAL1 89 | AXP202_LDO4_1600MV LITERAL1 90 | AXP202_LDO4_1700MV LITERAL1 91 | AXP202_LDO4_1800MV LITERAL1 92 | AXP202_LDO4_1900MV LITERAL1 93 | AXP202_LDO4_2000MV LITERAL1 94 | AXP202_LDO4_2500MV LITERAL1 95 | AXP202_LDO4_2700MV LITERAL1 96 | AXP202_LDO4_2800MV LITERAL1 97 | AXP202_LDO4_3000MV LITERAL1 98 | AXP202_LDO4_3100MV LITERAL1 99 | AXP202_LDO4_3200MV LITERAL1 100 | AXP202_LDO4_3300MV LITERAL1 101 | 102 | AXP202_VBUS_VHOLD_LOW_IRQ LITERAL1 103 | AXP202_VBUS_REMOVED_IRQ LITERAL1 104 | AXP202_VBUS_CONNECT_IRQ LITERAL1 105 | AXP202_VBUS_OVER_VOL_IRQ LITERAL1 106 | AXP202_ACIN_REMOVED_IRQ LITERAL1 107 | AXP202_ACIN_CONNECT_IRQ LITERAL1 108 | AXP202_ACIN_OVER_VOL_IRQ LITERAL1 109 | AXP202_BATT_LOW_TEMP_IRQ LITERAL1 110 | AXP202_BATT_OVER_TEMP_IRQ LITERAL1 111 | AXP202_CHARGING_FINISHED_IRQ LITERAL1 112 | AXP202_CHARGING_IRQ LITERAL1 113 | AXP202_BATT_EXIT_ACTIVATE_IRQ LITERAL1 114 | AXP202_BATT_ACTIVATE_IRQ LITERAL1 115 | AXP202_BATT_REMOVED_IRQ LITERAL1 116 | AXP202_BATT_CONNECT_IRQ LITERAL1 117 | AXP202_PEK_LONGPRESS_IRQ LITERAL1 118 | AXP202_PEL_SHORTPRESS_IRQ LITERAL1 119 | AXP202_LDO3_LOW_VOL_IRQ LITERAL1 120 | AXP202_DC3_LOW_VOL_IRQ LITERAL1 121 | AXP202_DC2_LOW_VOL_IRQ LITERAL1 122 | AXP202_CHARGE_LOW_CUR_IRQ LITERAL1 123 | AXP202_CHIP_TEMP_HIGH_IRQ LITERAL1 124 | AXP202_APS_LOW_VOL_LEVEL2_IRQ LITERAL1 125 | APX202_APS_LOW_VOL_LEVEL1_IRQ LITERAL1 126 | AXP202_VBUS_SESSION_END_IRQ LITERAL1 127 | AXP202_VBUS_SESSION_AB_IRQ LITERAL1 128 | AXP202_VBUS_INVALID_IRQ LITERAL1 129 | AXP202_VBUS_VAILD_IRQ LITERAL1 130 | AXP202_NOE_OFF_IRQ LITERAL1 131 | AXP202_NOE_ON_IRQ LITERAL1 132 | 133 | AXP202_TEMP_MONITORING_ADC2 LITERAL1 134 | AXP202_GPIO1_FUNC_ADC2 LITERAL1 135 | AXP202_GPIO0_FUNC_ADC2 LITERAL1 136 | 137 | AXP202_BATT_VOL_ADC1 LITERAL1 138 | AXP202_BATT_CUR_ADC1 LITERAL1 139 | AXP202_ACIN_VOL_ADC1 LITERAL1 140 | AXP202_ACIN_CUR_ADC1 LITERAL1 141 | AXP202_VBUS_VOL_ADC1 LITERAL1 142 | AXP202_VBUS_CUR_ADC1 LITERAL1 143 | AXP202_APS_VOL_ADC1 LITERAL1 144 | AXP202_TS_PIN_ADC1 LITERAL1 145 | 146 | AXP202_TARGET_VOL_4_1V LITERAL1 147 | AXP202_TARGET_VOL_4_15V LITERAL1 148 | AXP202_TARGET_VOL_4_2V LITERAL1 149 | AXP202_TARGET_VOL_4_36V LITERAL1 150 | AXP202_STARTUP_TIME_128MS LITERAL1 151 | AXP202_STARTUP_TIME_3S LITERAL1 152 | AXP202_STARTUP_TIME_1S LITERAL1 153 | AXP202_STARTUP_TIME_2S LITERAL1 154 | AXP202_STARTUP_TIME LITERAL1 155 | AXP202_LONGPRESS_TIME LITERAL1 156 | AXP202_SHUTDOWN_EXCEEDS_TIME LITERAL1 157 | AXP202_PWROK_SIGNAL_DELAY LITERAL1 158 | AXP202_SHUTDOWN_TIME LITERAL1 159 | 160 | AXP_TS_PIN_CURRENT_20UA LITERAL1 161 | AXP_TS_PIN_CURRENT_40UA LITERAL1 162 | AXP_TS_PIN_CURRENT_60UA LITERAL1 163 | AXP_TS_PIN_CURRENT_80UA LITERAL1 164 | AXP_TS_PIN_FUNCTION_BATT LITERAL1 165 | AXP_TS_PIN_FUNCTION_ADC LITERAL1 166 | AXP_TS_PIN_MODE_DISABLE LITERAL1 167 | AXP_TS_PIN_MODE_CHARGING LITERAL1 168 | AXP_TS_PIN_MODE_SAMPLING LITERAL1 169 | AXP_TS_PIN_MODE_ENABLE LITERAL1 170 | 171 | AXP202_EXTEN LITERAL1 172 | AXP202_DCDC3 LITERAL1 173 | AXP202_LDO2 LITERAL1 174 | AXP202_LDO4 LITERAL1 175 | AXP202_DCDC2 LITERAL1 176 | AXP202_LDO3 LITERAL1 177 | -------------------------------------------------------------------------------- /library.properties: -------------------------------------------------------------------------------- 1 | name=AXP202X_Library 2 | version=1.1.3 3 | author=Lewis He 4 | maintainer=Lewis He 5 | sentence=Arduino library for X-Power AXP202 chip 6 | paragraph=Arduino library for X-Power AXP202 chip. Tested with ESP32 7 | category=Communication 8 | url=https://github.com/lewisxhe/AXP202X_Library 9 | architectures=esp32 10 | -------------------------------------------------------------------------------- /src/axp20x.cpp: -------------------------------------------------------------------------------- 1 | ///////////////////////////////////////////////////////////////// 2 | /* 3 | __ _______ ___ ___ ___ 4 | /\ \ \ / / __ \__ \ / _ \__ \ 5 | / \ \ V /| |__) | ) | | | | ) | 6 | / /\ \ > < | ___/ / /| | | |/ / 7 | / ____ \ / . \| | / /_| |_| / /_ 8 | /_/ \_\/_/ \_\_| |____|\___/____| 9 | 10 | 11 | MIT License 12 | 13 | Copyright (c) 2019 lewis he 14 | 15 | Permission is hereby granted, free of charge, to any person obtaining a copy 16 | of this software and associated documentation files (the "Software"), to deal 17 | in the Software without restriction, including without limitation the rights 18 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 19 | copies of the Software, and to permit persons to whom the Software is 20 | furnished to do so, subject to the following conditions: 21 | 22 | The above copyright notice and this permission notice shall be included in all 23 | copies or substantial portions of the Software. 24 | 25 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 26 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 27 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 28 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 29 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 30 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 | SOFTWARE. 32 | 33 | axp20x.cpp - Arduino library for X-Power AXP202 chip. 34 | Created by Lewis he on April 1, 2019. 35 | github:https://github.com/lewisxhe/AXP202X_Libraries 36 | */ 37 | ///////////////////////////////////////////////////////////////// 38 | 39 | #include "axp20x.h" 40 | #include 41 | 42 | #define ISCONNECETD(ret) do{if(!_init)return ret;}while(0) 43 | 44 | const uint8_t AXP20X_Class::startupParams[] = { 45 | 0b00000000, 46 | 0b01000000, 47 | 0b10000000, 48 | 0b11000000 49 | }; 50 | 51 | const uint8_t AXP20X_Class::longPressParams[] = { 52 | 0b00000000, 53 | 0b00010000, 54 | 0b00100000, 55 | 0b00110000 56 | }; 57 | 58 | const uint8_t AXP20X_Class::shutdownParams[] = { 59 | 0b00000000, 60 | 0b00000001, 61 | 0b00000010, 62 | 0b00000011 63 | }; 64 | 65 | const uint8_t AXP20X_Class::targetVolParams[] = { 66 | 0b00000000, 67 | 0b00100000, 68 | 0b01000000, 69 | 0b01100000 70 | }; 71 | 72 | 73 | 74 | // Power Output Control register 75 | uint8_t AXP20X_Class::_outputReg; 76 | 77 | int AXP20X_Class::_axp_probe(void) 78 | { 79 | uint8_t data; 80 | if (_isAxp173) { 81 | //!Axp173 does not have a chip ID, read the status register to see if it reads normally 82 | _readByte(0x01, 1, &data); 83 | if (data == 0 || data == 0xFF) { 84 | return AXP_FAIL; 85 | } 86 | _chip_id = AXP173_CHIP_ID; 87 | _readByte(AXP202_LDO234_DC23_CTL, 1, &_outputReg); 88 | AXP_DEBUG("OUTPUT Register 0x%x\n", _outputReg); 89 | _init = true; 90 | return AXP_PASS; 91 | } 92 | _readByte(AXP202_IC_TYPE, 1, &_chip_id); 93 | AXP_DEBUG("chip id detect 0x%x\n", _chip_id); 94 | if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { 95 | AXP_DEBUG("Detect CHIP :%s\n", _chip_id == AXP202_CHIP_ID ? "AXP202" : "AXP192"); 96 | _readByte(AXP202_LDO234_DC23_CTL, 1, &_outputReg); 97 | AXP_DEBUG("OUTPUT Register 0x%x\n", _outputReg); 98 | _init = true; 99 | return AXP_PASS; 100 | } 101 | return AXP_FAIL; 102 | } 103 | 104 | #ifdef ARDUINO 105 | int AXP20X_Class::begin(TwoWire &port, uint8_t addr, bool isAxp173) 106 | { 107 | _i2cPort = &port; //Grab which port the user wants us to use 108 | _address = addr; 109 | _isAxp173 = isAxp173; 110 | 111 | return _axp_probe(); 112 | } 113 | #endif 114 | 115 | int AXP20X_Class::begin(axp_com_fptr_t read_cb, axp_com_fptr_t write_cb, uint8_t addr, bool isAxp173) 116 | { 117 | if (read_cb == nullptr || write_cb == nullptr)return AXP_FAIL; 118 | _read_cb = read_cb; 119 | _write_cb = write_cb; 120 | _address = addr; 121 | _isAxp173 = isAxp173; 122 | return _axp_probe(); 123 | } 124 | 125 | //Only axp192 chip 126 | bool AXP20X_Class::isDCDC1Enable(void) 127 | { 128 | if (_chip_id == AXP192_CHIP_ID) 129 | return IS_OPEN(_outputReg, AXP192_DCDC1); 130 | else if (_chip_id == AXP173_CHIP_ID) 131 | return IS_OPEN(_outputReg, AXP173_DCDC1); 132 | return false; 133 | } 134 | 135 | bool AXP20X_Class::isExtenEnable(void) 136 | { 137 | if (_chip_id == AXP192_CHIP_ID) 138 | return IS_OPEN(_outputReg, AXP192_EXTEN); 139 | else if (_chip_id == AXP202_CHIP_ID) 140 | return IS_OPEN(_outputReg, AXP202_EXTEN); 141 | else if (_chip_id == AXP173_CHIP_ID) { 142 | uint8_t data; 143 | _readByte(AXP173_EXTEN_DC2_CTL, 1, &data); 144 | return IS_OPEN(data, AXP173_CTL_EXTEN_BIT); 145 | } 146 | return false; 147 | } 148 | 149 | bool AXP20X_Class::isLDO2Enable(void) 150 | { 151 | if (_chip_id == AXP173_CHIP_ID) { 152 | return IS_OPEN(_outputReg, AXP173_LDO2); 153 | } 154 | //axp192 same axp202 ldo2 bit 155 | return IS_OPEN(_outputReg, AXP202_LDO2); 156 | } 157 | 158 | bool AXP20X_Class::isLDO3Enable(void) 159 | { 160 | if (_chip_id == AXP192_CHIP_ID) 161 | return IS_OPEN(_outputReg, AXP192_LDO3); 162 | else if (_chip_id == AXP202_CHIP_ID) 163 | return IS_OPEN(_outputReg, AXP202_LDO3); 164 | else if (_chip_id == AXP173_CHIP_ID) 165 | return IS_OPEN(_outputReg, AXP173_LDO3); 166 | return false; 167 | } 168 | 169 | bool AXP20X_Class::isLDO4Enable(void) 170 | { 171 | if (_chip_id == AXP202_CHIP_ID) 172 | return IS_OPEN(_outputReg, AXP202_LDO4); 173 | if (_chip_id == AXP173_CHIP_ID) 174 | return IS_OPEN(_outputReg, AXP173_LDO4); 175 | return false; 176 | } 177 | 178 | bool AXP20X_Class::isDCDC2Enable(void) 179 | { 180 | if (_chip_id == AXP173_CHIP_ID) { 181 | uint8_t data; 182 | _readByte(AXP173_EXTEN_DC2_CTL, 1, &data); 183 | return IS_OPEN(data, AXP173_CTL_DC2_BIT); 184 | } 185 | //axp192 same axp202 dc2 bit 186 | return IS_OPEN(_outputReg, AXP202_DCDC2); 187 | } 188 | 189 | bool AXP20X_Class::isDCDC3Enable(void) 190 | { 191 | if (_chip_id == AXP173_CHIP_ID) 192 | return false; 193 | //axp192 same axp202 dc3 bit 194 | return IS_OPEN(_outputReg, AXP202_DCDC3); 195 | } 196 | 197 | int AXP20X_Class::setPowerOutPut(uint8_t ch, bool en) 198 | { 199 | uint8_t data; 200 | uint8_t val = 0; 201 | if (!_init) 202 | return AXP_NOT_INIT; 203 | 204 | //! Axp173 cannot use the REG12H register to control 205 | //! DC2 and EXTEN. It is necessary to control REG10H separately. 206 | if (_chip_id == AXP173_CHIP_ID) { 207 | _readByte(AXP173_EXTEN_DC2_CTL, 1, &data); 208 | if (ch & AXP173_DCDC2) { 209 | data = en ? data | _BV(AXP173_CTL_DC2_BIT) : data & (~_BV(AXP173_CTL_DC2_BIT)); 210 | ch &= (~_BV(AXP173_DCDC2)); 211 | _writeByte(AXP173_EXTEN_DC2_CTL, 1, &data); 212 | } else if (ch & AXP173_EXTEN) { 213 | data = en ? data | _BV(AXP173_CTL_EXTEN_BIT) : data & (~_BV(AXP173_CTL_EXTEN_BIT)); 214 | ch &= (~_BV(AXP173_EXTEN)); 215 | _writeByte(AXP173_EXTEN_DC2_CTL, 1, &data); 216 | } 217 | } 218 | 219 | _readByte(AXP202_LDO234_DC23_CTL, 1, &data); 220 | if (en) { 221 | data |= (1 << ch); 222 | } else { 223 | data &= (~(1 << ch)); 224 | } 225 | 226 | if (_chip_id == AXP202_CHIP_ID) { 227 | FORCED_OPEN_DCDC3(data); //! Must be forced open in T-Watch 228 | } 229 | 230 | _writeByte(AXP202_LDO234_DC23_CTL, 1, &data); 231 | 232 | #ifdef ARDUINO 233 | delay(1); 234 | #endif 235 | _readByte(AXP202_LDO234_DC23_CTL, 1, &val); 236 | if (data == val) { 237 | _outputReg = val; 238 | return AXP_PASS; 239 | } 240 | return AXP_FAIL; 241 | } 242 | 243 | bool AXP20X_Class::isChargeing(void) 244 | { 245 | return isCharging(); 246 | } 247 | 248 | bool AXP20X_Class::isCharging(void) 249 | { 250 | uint8_t reg; 251 | if (!_init) 252 | return AXP_NOT_INIT; 253 | _readByte(AXP202_MODE_CHGSTATUS, 1, ®); 254 | return IS_OPEN(reg, 6); 255 | } 256 | 257 | bool AXP20X_Class::isBatteryConnect(void) 258 | { 259 | uint8_t reg; 260 | if (!_init) 261 | return AXP_NOT_INIT; 262 | _readByte(AXP202_MODE_CHGSTATUS, 1, ®); 263 | return IS_OPEN(reg, 5); 264 | } 265 | 266 | float AXP20X_Class::getAcinVoltage(void) 267 | { 268 | if (!_init) 269 | return AXP_NOT_INIT; 270 | return _getRegistResult(AXP202_ACIN_VOL_H8, AXP202_ACIN_VOL_L4) * AXP202_ACIN_VOLTAGE_STEP; 271 | } 272 | 273 | float AXP20X_Class::getAcinCurrent(void) 274 | { 275 | if (!_init) 276 | return AXP_NOT_INIT; 277 | return _getRegistResult(AXP202_ACIN_CUR_H8, AXP202_ACIN_CUR_L4) * AXP202_ACIN_CUR_STEP; 278 | } 279 | 280 | float AXP20X_Class::getVbusVoltage(void) 281 | { 282 | if (!_init) 283 | return AXP_NOT_INIT; 284 | return _getRegistResult(AXP202_VBUS_VOL_H8, AXP202_VBUS_VOL_L4) * AXP202_VBUS_VOLTAGE_STEP; 285 | } 286 | 287 | float AXP20X_Class::getVbusCurrent(void) 288 | { 289 | if (!_init) 290 | return AXP_NOT_INIT; 291 | return _getRegistResult(AXP202_VBUS_CUR_H8, AXP202_VBUS_CUR_L4) * AXP202_VBUS_CUR_STEP; 292 | } 293 | 294 | float AXP20X_Class::getTemp(void) 295 | { 296 | if (!_init) 297 | return AXP_NOT_INIT; 298 | // Internal temperature 299 | // 000H => -144.7℃ 300 | // STEP => 0.1℃ 301 | // FFFH => 264.8℃ 302 | return _getRegistResult(AXP202_INTERNAL_TEMP_H8, AXP202_INTERNAL_TEMP_L4) * AXP202_INTERNAL_TEMP_STEP - 144.7; 303 | } 304 | 305 | float AXP20X_Class::getTSTemp(void) 306 | { 307 | if (!_init) 308 | return AXP_NOT_INIT; 309 | return _getRegistResult(AXP202_TS_IN_H8, AXP202_TS_IN_L4) * AXP202_TS_PIN_OUT_STEP; 310 | } 311 | 312 | float AXP20X_Class::getGPIO0Voltage(void) 313 | { 314 | if (!_init) 315 | return AXP_NOT_INIT; 316 | return _getRegistResult(AXP202_GPIO0_VOL_ADC_H8, AXP202_GPIO0_VOL_ADC_L4) * AXP202_GPIO0_STEP; 317 | } 318 | 319 | float AXP20X_Class::getGPIO1Voltage(void) 320 | { 321 | if (!_init) 322 | return AXP_NOT_INIT; 323 | return _getRegistResult(AXP202_GPIO1_VOL_ADC_H8, AXP202_GPIO1_VOL_ADC_L4) * AXP202_GPIO1_STEP; 324 | } 325 | 326 | /* 327 | Note: the battery power formula: 328 | Pbat =2* register value * Voltage LSB * Current LSB / 1000. 329 | (Voltage LSB is 1.1mV; Current LSB is 0.5mA, and unit of calculation result is mW.) 330 | */ 331 | float AXP20X_Class::getBattInpower(void) 332 | { 333 | float rslt; 334 | uint8_t hv, mv, lv; 335 | if (!_init) 336 | return AXP_NOT_INIT; 337 | _readByte(AXP202_BAT_POWERH8, 1, &hv); 338 | _readByte(AXP202_BAT_POWERM8, 1, &mv); 339 | _readByte(AXP202_BAT_POWERL8, 1, &lv); 340 | rslt = (hv << 16) | (mv << 8) | lv; 341 | rslt = 2 * rslt * 1.1 * 0.5 / 1000; 342 | return rslt; 343 | } 344 | 345 | float AXP20X_Class::getBattVoltage(void) 346 | { 347 | if (!_init) 348 | return AXP_NOT_INIT; 349 | return _getRegistResult(AXP202_BAT_AVERVOL_H8, AXP202_BAT_AVERVOL_L4) * AXP202_BATT_VOLTAGE_STEP; 350 | } 351 | 352 | float AXP20X_Class::getBattChargeCurrent(void) 353 | { 354 | if (!_init) 355 | return AXP_NOT_INIT; 356 | switch (_chip_id) { 357 | case AXP202_CHIP_ID: 358 | return _getRegistResult(AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L4) * AXP202_BATT_CHARGE_CUR_STEP; 359 | case AXP192_CHIP_ID: 360 | return _getRegistH8L5(AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L5) * AXP202_BATT_CHARGE_CUR_STEP; 361 | default: 362 | return AXP_FAIL; 363 | } 364 | } 365 | 366 | float AXP20X_Class::getBattDischargeCurrent(void) 367 | { 368 | if (!_init) 369 | return AXP_NOT_INIT; 370 | return _getRegistH8L5(AXP202_BAT_AVERDISCHGCUR_H8, AXP202_BAT_AVERDISCHGCUR_L5) * AXP202_BATT_DISCHARGE_CUR_STEP; 371 | } 372 | 373 | float AXP20X_Class::getSysIPSOUTVoltage(void) 374 | { 375 | if (!_init) 376 | return AXP_NOT_INIT; 377 | return _getRegistResult(AXP202_APS_AVERVOL_H8, AXP202_APS_AVERVOL_L4) * AXP202_APS_VOLTAGE_STEP; 378 | } 379 | 380 | /* 381 | Coulomb calculation formula: 382 | C= 65536 * current LSB *（charge coulomb counter value - discharge coulomb counter value） / 383 | 3600 / ADC sample rate. Refer to REG84H setting for ADC sample rate；the current LSB is 384 | 0.5mA；unit of the calculation result is mAh. ） 385 | */ 386 | uint32_t AXP20X_Class::getBattChargeCoulomb(void) 387 | { 388 | uint8_t buffer[4]; 389 | if (!_init) 390 | return AXP_NOT_INIT; 391 | _readByte(0xB0, 4, buffer); 392 | return (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; 393 | } 394 | 395 | uint32_t AXP20X_Class::getBattDischargeCoulomb(void) 396 | { 397 | uint8_t buffer[4]; 398 | if (!_init) 399 | return AXP_NOT_INIT; 400 | _readByte(0xB4, 4, buffer); 401 | return (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; 402 | } 403 | 404 | float AXP20X_Class::getCoulombData(void) 405 | { 406 | if (!_init) 407 | return AXP_NOT_INIT; 408 | uint32_t charge = getBattChargeCoulomb(), discharge = getBattDischargeCoulomb(); 409 | uint8_t rate = getAdcSamplingRate(); 410 | float result = 65536.0 * 0.5 * ((float)charge - (float)discharge) / 3600.0 / rate; 411 | return result; 412 | } 413 | 414 | 415 | //------------------------------------------------------- 416 | // New Coulomb functions by MrFlexi 417 | //------------------------------------------------------- 418 | 419 | uint8_t AXP20X_Class::getCoulombRegister(void) 420 | { 421 | uint8_t buffer; 422 | if (!_init) 423 | return AXP_NOT_INIT; 424 | _readByte(AXP202_COULOMB_CTL, 1, &buffer); 425 | return buffer; 426 | } 427 | 428 | 429 | int AXP20X_Class::setCoulombRegister(uint8_t val) 430 | { 431 | if (!_init) 432 | return AXP_NOT_INIT; 433 | _writeByte(AXP202_COULOMB_CTL, 1, &val); 434 | return AXP_PASS; 435 | } 436 | 437 | 438 | int AXP20X_Class::EnableCoulombcounter(void) 439 | { 440 | 441 | if (!_init) 442 | return AXP_NOT_INIT; 443 | uint8_t val = 0x80; 444 | _writeByte(AXP202_COULOMB_CTL, 1, &val); 445 | return AXP_PASS; 446 | } 447 | 448 | int AXP20X_Class::DisableCoulombcounter(void) 449 | { 450 | 451 | if (!_init) 452 | return AXP_NOT_INIT; 453 | uint8_t val = 0x00; 454 | _writeByte(AXP202_COULOMB_CTL, 1, &val); 455 | return AXP_PASS; 456 | } 457 | 458 | int AXP20X_Class::StopCoulombcounter(void) 459 | { 460 | 461 | if (!_init) 462 | return AXP_NOT_INIT; 463 | uint8_t val = 0xB8; 464 | _writeByte(AXP202_COULOMB_CTL, 1, &val); 465 | return AXP_PASS; 466 | } 467 | 468 | 469 | int AXP20X_Class::ClearCoulombcounter(void) 470 | { 471 | if (!_init) 472 | return AXP_NOT_INIT; 473 | uint8_t val = 0xA0; 474 | _writeByte(AXP202_COULOMB_CTL, 1, &val); 475 | return AXP_PASS; 476 | } 477 | 478 | //------------------------------------------------------- 479 | // END 480 | //------------------------------------------------------- 481 | 482 | 483 | 484 | uint8_t AXP20X_Class::getAdcSamplingRate(void) 485 | { 486 | //axp192 same axp202 aregister address 0x84 487 | if (!_init) 488 | return AXP_NOT_INIT; 489 | uint8_t val; 490 | _readByte(AXP202_ADC_SPEED, 1, &val); 491 | return 25 * (int)pow(2, (val & 0xC0) >> 6); 492 | } 493 | 494 | int AXP20X_Class::setAdcSamplingRate(axp_adc_sampling_rate_t rate) 495 | { 496 | //axp192 same axp202 aregister address 0x84 497 | if (!_init) 498 | return AXP_NOT_INIT; 499 | if (rate > AXP_ADC_SAMPLING_RATE_200HZ) 500 | return AXP_FAIL; 501 | uint8_t val; 502 | _readByte(AXP202_ADC_SPEED, 1, &val); 503 | uint8_t rw = rate; 504 | val &= 0x3F; 505 | val |= (rw << 6); 506 | _writeByte(AXP202_ADC_SPEED, 1, &val); 507 | return AXP_PASS; 508 | } 509 | 510 | int AXP20X_Class::setTSfunction(axp_ts_pin_function_t func) 511 | { 512 | //axp192 same axp202 aregister address 0x84 513 | if (!_init) 514 | return AXP_NOT_INIT; 515 | if (func > AXP_TS_PIN_FUNCTION_ADC) 516 | return AXP_FAIL; 517 | uint8_t val; 518 | _readByte(AXP202_ADC_SPEED, 1, &val); 519 | uint8_t rw = func; 520 | val &= 0xFA; 521 | val |= (rw << 2); 522 | _writeByte(AXP202_ADC_SPEED, 1, &val); 523 | return AXP_PASS; 524 | } 525 | 526 | int AXP20X_Class::setTScurrent(axp_ts_pin_current_t current) 527 | { 528 | //axp192 same axp202 aregister address 0x84 529 | if (!_init) 530 | return AXP_NOT_INIT; 531 | if (current > AXP_TS_PIN_CURRENT_80UA) 532 | return AXP_FAIL; 533 | uint8_t val; 534 | _readByte(AXP202_ADC_SPEED, 1, &val); 535 | uint8_t rw = current; 536 | val &= 0xCF; 537 | val |= (rw << 4); 538 | _writeByte(AXP202_ADC_SPEED, 1, &val); 539 | return AXP_PASS; 540 | } 541 | 542 | int AXP20X_Class::setTSmode(axp_ts_pin_mode_t mode) 543 | { 544 | //axp192 same axp202 aregister address 0x84 545 | if (!_init) 546 | return AXP_NOT_INIT; 547 | if (mode > AXP_TS_PIN_MODE_ENABLE) 548 | return AXP_FAIL; 549 | uint8_t val; 550 | _readByte(AXP202_ADC_SPEED, 1, &val); 551 | uint8_t rw = mode; 552 | val &= 0xFC; 553 | val |= rw; 554 | _writeByte(AXP202_ADC_SPEED, 1, &val); 555 | 556 | // TS pin ADC function enable/disable 557 | if (mode == AXP_TS_PIN_MODE_DISABLE) 558 | adc1Enable(AXP202_TS_PIN_ADC1, false); 559 | else 560 | adc1Enable(AXP202_TS_PIN_ADC1, true); 561 | return AXP_PASS; 562 | } 563 | 564 | int AXP20X_Class::adc1Enable(uint16_t params, bool en) 565 | { 566 | if (!_init) 567 | return AXP_NOT_INIT; 568 | uint8_t val; 569 | _readByte(AXP202_ADC_EN1, 1, &val); 570 | if (en) 571 | val |= params; 572 | else 573 | val &= ~(params); 574 | _writeByte(AXP202_ADC_EN1, 1, &val); 575 | return AXP_PASS; 576 | } 577 | 578 | int AXP20X_Class::adc2Enable(uint16_t params, bool en) 579 | { 580 | if (!_init) 581 | return AXP_NOT_INIT; 582 | uint8_t val; 583 | _readByte(AXP202_ADC_EN2, 1, &val); 584 | if (en) 585 | val |= params; 586 | else 587 | val &= ~(params); 588 | _writeByte(AXP202_ADC_EN2, 1, &val); 589 | return AXP_PASS; 590 | } 591 | 592 | int AXP20X_Class::enableIRQ(uint64_t params, bool en) 593 | { 594 | if (!_init) 595 | return AXP_NOT_INIT; 596 | uint8_t val, val1; 597 | if (params & 0xFFUL) { 598 | val1 = params & 0xFF; 599 | _readByte(AXP202_INTEN1, 1, &val); 600 | if (en) 601 | val |= val1; 602 | else 603 | val &= ~(val1); 604 | AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN1, val); 605 | _writeByte(AXP202_INTEN1, 1, &val); 606 | } 607 | if (params & 0xFF00UL) { 608 | val1 = params >> 8; 609 | _readByte(AXP202_INTEN2, 1, &val); 610 | if (en) 611 | val |= val1; 612 | else 613 | val &= ~(val1); 614 | AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN2, val); 615 | _writeByte(AXP202_INTEN2, 1, &val); 616 | } 617 | 618 | if (params & 0xFF0000UL) { 619 | val1 = params >> 16; 620 | _readByte(AXP202_INTEN3, 1, &val); 621 | if (en) 622 | val |= val1; 623 | else 624 | val &= ~(val1); 625 | AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN3, val); 626 | _writeByte(AXP202_INTEN3, 1, &val); 627 | } 628 | 629 | if (params & 0xFF000000UL) { 630 | val1 = params >> 24; 631 | _readByte(AXP202_INTEN4, 1, &val); 632 | if (en) 633 | val |= val1; 634 | else 635 | val &= ~(val1); 636 | AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", AXP202_INTEN4, val); 637 | _writeByte(AXP202_INTEN4, 1, &val); 638 | } 639 | 640 | if (params & 0xFF00000000ULL) { 641 | val1 = params >> 32; 642 | uint8_t reg = _chip_id == AXP192_CHIP_ID ? AXP192_INTEN5 : AXP202_INTEN5; 643 | _readByte(reg, 1, &val); 644 | if (en) 645 | val |= val1; 646 | else 647 | val &= ~(val1); 648 | AXP_DEBUG("%s [0x%x]val:0x%x\n", en ? "enable" : "disable", reg, val); 649 | _writeByte(reg, 1, &val); 650 | } 651 | return AXP_PASS; 652 | } 653 | 654 | int AXP20X_Class::readIRQ(void) 655 | { 656 | if (!_init) 657 | return AXP_NOT_INIT; 658 | switch (_chip_id) { 659 | case AXP192_CHIP_ID: 660 | for (int i = 0; i < 4; ++i) { 661 | _readByte(AXP192_INTSTS1 + i, 1, &_irq[i]); 662 | } 663 | _readByte(AXP192_INTSTS5, 1, &_irq[4]); 664 | return AXP_PASS; 665 | 666 | case AXP202_CHIP_ID: 667 | for (int i = 0; i < 5; ++i) { 668 | _readByte(AXP202_INTSTS1 + i, 1, &_irq[i]); 669 | } 670 | return AXP_PASS; 671 | default: 672 | return AXP_FAIL; 673 | } 674 | } 675 | 676 | void AXP20X_Class::clearIRQ(void) 677 | { 678 | uint8_t val = 0xFF; 679 | switch (_chip_id) { 680 | case AXP192_CHIP_ID: 681 | for (int i = 0; i < 3; i++) { 682 | _writeByte(AXP192_INTSTS1 + i, 1, &val); 683 | } 684 | _writeByte(AXP192_INTSTS5, 1, &val); 685 | break; 686 | case AXP202_CHIP_ID: 687 | for (int i = 0; i < 5; i++) { 688 | _writeByte(AXP202_INTSTS1 + i, 1, &val); 689 | } 690 | break; 691 | default: 692 | break; 693 | } 694 | memset(_irq, 0, sizeof(_irq)); 695 | } 696 | 697 | 698 | bool AXP20X_Class::isVBUSPlug(void) 699 | { 700 | if (!_init) 701 | return AXP_NOT_INIT; 702 | uint8_t reg; 703 | _readByte(AXP202_STATUS, 1, ®); 704 | return IS_OPEN(reg, 5); 705 | } 706 | 707 | //IRQ1 REGISTER : AXP202:0x40H AXP192:0X44H 708 | bool AXP20X_Class::isAcinOverVoltageIRQ(void) 709 | { 710 | return (bool)(_irq[0] & _BV(7)); 711 | } 712 | 713 | bool AXP20X_Class::isAcinPlugInIRQ(void) 714 | { 715 | return (bool)(_irq[0] & _BV(6)); 716 | } 717 | 718 | bool AXP20X_Class::isAcinRemoveIRQ(void) 719 | { 720 | return (bool)(_irq[0] & _BV(5)); 721 | } 722 | 723 | bool AXP20X_Class::isVbusOverVoltageIRQ(void) 724 | { 725 | return (bool)(_irq[0] & _BV(4)); 726 | } 727 | 728 | bool AXP20X_Class::isVbusPlugInIRQ(void) 729 | { 730 | return (bool)(_irq[0] & _BV(3)); 731 | } 732 | 733 | bool AXP20X_Class::isVbusRemoveIRQ(void) 734 | { 735 | return (bool)(_irq[0] & _BV(2)); 736 | } 737 | 738 | bool AXP20X_Class::isVbusLowVHOLDIRQ(void) 739 | { 740 | return (bool)(_irq[0] & _BV(1)); 741 | } 742 | 743 | //IRQ2 REGISTER : AXP202:0x41H AXP192:0X45H 744 | bool AXP20X_Class::isBattPlugInIRQ(void) 745 | { 746 | return (bool)(_irq[1] & _BV(7)); 747 | } 748 | 749 | bool AXP20X_Class::isBattRemoveIRQ(void) 750 | { 751 | return (bool)(_irq[1] & _BV(6)); 752 | } 753 | 754 | bool AXP20X_Class::isBattEnterActivateIRQ(void) 755 | { 756 | return (bool)(_irq[1] & _BV(5)); 757 | } 758 | 759 | bool AXP20X_Class::isBattExitActivateIRQ(void) 760 | { 761 | return (bool)(_irq[1] & _BV(4)); 762 | } 763 | 764 | bool AXP20X_Class::isChargingIRQ(void) 765 | { 766 | return (bool)(_irq[1] & _BV(3)); 767 | } 768 | 769 | bool AXP20X_Class::isChargingDoneIRQ(void) 770 | { 771 | return (bool)(_irq[1] & _BV(2)); 772 | } 773 | 774 | bool AXP20X_Class::isBattTempHighIRQ(void) 775 | { 776 | return (bool)(_irq[1] & _BV(1)); 777 | } 778 | 779 | bool AXP20X_Class::isBattTempLowIRQ(void) 780 | { 781 | return (bool)(_irq[1] & _BV(0)); 782 | } 783 | 784 | //IRQ3 REGISTER : AXP202:0x42H AXP192:0X46H 785 | bool AXP20X_Class::isChipOvertemperatureIRQ(void) 786 | { 787 | return (bool)(_irq[2] & _BV(7)); 788 | } 789 | 790 | bool AXP20X_Class::isChargingCurrentLessIRQ(void) 791 | { 792 | return (bool)(_irq[2] & _BV(6)); 793 | } 794 | 795 | // retention bit5 796 | 797 | bool AXP20X_Class::isDC2VoltageLessIRQ(void) 798 | { 799 | return (bool)(_irq[2] & _BV(4)); 800 | } 801 | 802 | bool AXP20X_Class::isDC3VoltageLessIRQ(void) 803 | { 804 | return (bool)(_irq[2] & _BV(3)); 805 | } 806 | 807 | bool AXP20X_Class::isLDO3VoltageLessIRQ(void) 808 | { 809 | return (bool)(_irq[2] & _BV(2)); 810 | } 811 | 812 | bool AXP20X_Class::isPEKShortPressIRQ(void) 813 | { 814 | return (bool)(_irq[2] & _BV(1)); 815 | } 816 | 817 | bool AXP20X_Class::isPEKLongtPressIRQ(void) 818 | { 819 | return (bool)(_irq[2] & _BV(0)); 820 | } 821 | 822 | //IRQ4 REGISTER : AXP202:0x43H AXP192:0X47H 823 | bool AXP20X_Class::isNOEPowerOnIRQ(void) 824 | { 825 | return (bool)(_irq[3] & _BV(7)); 826 | } 827 | 828 | bool AXP20X_Class::isNOEPowerDownIRQ(void) 829 | { 830 | return (bool)(_irq[3] & _BV(6)); 831 | } 832 | 833 | bool AXP20X_Class::isVBUSEffectiveIRQ(void) 834 | { 835 | return (bool)(_irq[3] & _BV(5)); 836 | } 837 | 838 | bool AXP20X_Class::isVBUSInvalidIRQ(void) 839 | { 840 | return (bool)(_irq[3] & _BV(4)); 841 | } 842 | 843 | bool AXP20X_Class::isVUBSSessionIRQ(void) 844 | { 845 | return (bool)(_irq[3] & _BV(3)); 846 | } 847 | 848 | bool AXP20X_Class::isVUBSSessionEndIRQ(void) 849 | { 850 | return (bool)(_irq[3] & _BV(2)); 851 | } 852 | 853 | bool AXP20X_Class::isLowVoltageLevel1IRQ(void) 854 | { 855 | return (bool)(_irq[3] & _BV(1)); 856 | } 857 | 858 | bool AXP20X_Class::isLowVoltageLevel2IRQ(void) 859 | { 860 | return (bool)(_irq[3] & _BV(0)); 861 | } 862 | 863 | //IRQ5 REGISTER : AXP202:0x44H AXP192:0X4DH 864 | bool AXP20X_Class::isTimerTimeoutIRQ(void) 865 | { 866 | return (bool)(_irq[4] & _BV(7)); 867 | } 868 | 869 | bool AXP20X_Class::isPEKRisingEdgeIRQ(void) 870 | { 871 | return (bool)(_irq[4] & _BV(6)); 872 | } 873 | 874 | bool AXP20X_Class::isPEKFallingEdgeIRQ(void) 875 | { 876 | return (bool)(_irq[4] & _BV(5)); 877 | } 878 | 879 | // retention bit4 880 | 881 | bool AXP20X_Class::isGPIO3InputEdgeTriggerIRQ(void) 882 | { 883 | return (bool)(_irq[4] & _BV(3)); 884 | } 885 | 886 | bool AXP20X_Class::isGPIO2InputEdgeTriggerIRQ(void) 887 | { 888 | return (bool)(_irq[4] & _BV(2)); 889 | } 890 | 891 | bool AXP20X_Class::isGPIO1InputEdgeTriggerIRQ(void) 892 | { 893 | return (bool)(_irq[4] & _BV(1)); 894 | } 895 | 896 | bool AXP20X_Class::isGPIO0InputEdgeTriggerIRQ(void) 897 | { 898 | return (bool)(_irq[4] & _BV(0)); 899 | } 900 | 901 | 902 | int AXP20X_Class::setDCDC2Voltage(uint16_t mv) 903 | { 904 | if (!_init) 905 | return AXP_NOT_INIT; 906 | if (mv < 700) { 907 | AXP_DEBUG("DCDC2:Below settable voltage:700mV~2275mV"); 908 | mv = 700; 909 | } 910 | if (mv > 2275) { 911 | AXP_DEBUG("DCDC2:Above settable voltage:700mV~2275mV"); 912 | mv = 2275; 913 | } 914 | uint8_t val = (mv - 700) / 25; 915 | //! axp173/192/202 same register 916 | _writeByte(AXP202_DC2OUT_VOL, 1, &val); 917 | return AXP_PASS; 918 | } 919 | 920 | uint16_t AXP20X_Class::getDCDC2Voltage(void) 921 | { 922 | uint8_t val = 0; 923 | //! axp173/192/202 same register 924 | _readByte(AXP202_DC2OUT_VOL, 1, &val); 925 | return val * 25 + 700; 926 | } 927 | 928 | uint16_t AXP20X_Class::getDCDC3Voltage(void) 929 | { 930 | if (!_init) 931 | return 0; 932 | if (_chip_id == AXP173_CHIP_ID)return AXP_NOT_SUPPORT; 933 | uint8_t val = 0; 934 | _readByte(AXP202_DC3OUT_VOL, 1, &val); 935 | return val * 25 + 700; 936 | } 937 | 938 | int AXP20X_Class::setDCDC3Voltage(uint16_t mv) 939 | { 940 | if (!_init) 941 | return AXP_NOT_INIT; 942 | if (_chip_id == AXP173_CHIP_ID)return AXP_NOT_SUPPORT; 943 | if (mv < 700) { 944 | AXP_DEBUG("DCDC3:Below settable voltage:700mV~3500mV"); 945 | mv = 700; 946 | } 947 | if (mv > 3500) { 948 | AXP_DEBUG("DCDC3:Above settable voltage:700mV~3500mV"); 949 | mv = 3500; 950 | } 951 | uint8_t val = (mv - 700) / 25; 952 | _writeByte(AXP202_DC3OUT_VOL, 1, &val); 953 | return AXP_PASS; 954 | } 955 | 956 | int AXP20X_Class::setLDO2Voltage(uint16_t mv) 957 | { 958 | uint8_t rVal, wVal; 959 | if (!_init) 960 | return AXP_NOT_INIT; 961 | if (mv < 1800) { 962 | AXP_DEBUG("LDO2:Below settable voltage:1800mV~3300mV"); 963 | mv = 1800; 964 | } 965 | if (mv > 3300) { 966 | AXP_DEBUG("LDO2:Above settable voltage:1800mV~3300mV"); 967 | mv = 3300; 968 | } 969 | wVal = (mv - 1800) / 100; 970 | if (_chip_id == AXP202_CHIP_ID) { 971 | _readByte(AXP202_LDO24OUT_VOL, 1, &rVal); 972 | rVal &= 0x0F; 973 | rVal |= (wVal << 4); 974 | _writeByte(AXP202_LDO24OUT_VOL, 1, &rVal); 975 | return AXP_PASS; 976 | } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) { 977 | _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); 978 | rVal &= 0x0F; 979 | rVal |= (wVal << 4); 980 | _writeByte(AXP192_LDO23OUT_VOL, 1, &rVal); 981 | return AXP_PASS; 982 | } 983 | return AXP_FAIL; 984 | } 985 | 986 | uint16_t AXP20X_Class::getLDO2Voltage(void) 987 | { 988 | uint8_t rVal; 989 | if (_chip_id == AXP202_CHIP_ID) { 990 | _readByte(AXP202_LDO24OUT_VOL, 1, &rVal); 991 | rVal &= 0xF0; 992 | rVal >>= 4; 993 | return rVal * 100 + 1800; 994 | } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID ) { 995 | _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); 996 | AXP_DEBUG("get result:%x\n", rVal); 997 | rVal &= 0xF0; 998 | rVal >>= 4; 999 | return rVal * 100 + 1800; 1000 | } 1001 | return 0; 1002 | } 1003 | 1004 | int AXP20X_Class::setLDO3Voltage(uint16_t mv) 1005 | { 1006 | uint8_t rVal; 1007 | if (!_init) 1008 | return AXP_NOT_INIT; 1009 | if (_chip_id == AXP202_CHIP_ID && mv < 700) { 1010 | AXP_DEBUG("LDO3:Below settable voltage:700mV~3500mV"); 1011 | mv = 700; 1012 | } else if (_chip_id == AXP192_CHIP_ID && mv < 1800) { 1013 | AXP_DEBUG("LDO3:Below settable voltage:1800mV~3300mV"); 1014 | mv = 1800; 1015 | } 1016 | 1017 | if (_chip_id == AXP202_CHIP_ID && mv > 3500) { 1018 | AXP_DEBUG("LDO3:Above settable voltage:700mV~3500mV"); 1019 | mv = 3500; 1020 | } else if (_chip_id == AXP192_CHIP_ID && mv > 3300) { 1021 | AXP_DEBUG("LDO3:Above settable voltage:1800mV~3300mV"); 1022 | mv = 3300; 1023 | } 1024 | 1025 | if (_chip_id == AXP202_CHIP_ID) { 1026 | _readByte(AXP202_LDO3OUT_VOL, 1, &rVal); 1027 | rVal &= 0x80; 1028 | rVal |= ((mv - 700) / 25); 1029 | _writeByte(AXP202_LDO3OUT_VOL, 1, &rVal); 1030 | return AXP_PASS; 1031 | } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) { 1032 | _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); 1033 | rVal &= 0xF0; 1034 | rVal |= ((mv - 1800) / 100); 1035 | _writeByte(AXP192_LDO23OUT_VOL, 1, &rVal); 1036 | return AXP_PASS; 1037 | } 1038 | return AXP_FAIL; 1039 | } 1040 | 1041 | uint16_t AXP20X_Class::getLDO3Voltage(void) 1042 | { 1043 | uint8_t rVal; 1044 | if (!_init) 1045 | return AXP_NOT_INIT; 1046 | 1047 | if (_chip_id == AXP202_CHIP_ID) { 1048 | _readByte(AXP202_LDO3OUT_VOL, 1, &rVal); 1049 | if (rVal & 0x80) { 1050 | //! According to the hardware N_VBUSEN Pin selection 1051 | return getVbusVoltage() * 1000; 1052 | } else { 1053 | return (rVal & 0x7F) * 25 + 700; 1054 | } 1055 | } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) { 1056 | _readByte(AXP192_LDO23OUT_VOL, 1, &rVal); 1057 | rVal &= 0x0F; 1058 | return rVal * 100 + 1800; 1059 | } 1060 | return 0; 1061 | } 1062 | 1063 | //! Only axp173 support 1064 | int AXP20X_Class::setLDO4Voltage(uint16_t mv) 1065 | { 1066 | if (!_init) 1067 | return AXP_NOT_INIT; 1068 | if (_chip_id != AXP173_CHIP_ID) 1069 | return AXP_FAIL; 1070 | 1071 | if (mv < 700) { 1072 | AXP_DEBUG("LDO4:Below settable voltage:700mV~3500mV"); 1073 | mv = 700; 1074 | } 1075 | if (mv > 3500) { 1076 | AXP_DEBUG("LDO4:Above settable voltage:700mV~3500mV"); 1077 | mv = 3500; 1078 | } 1079 | uint8_t val = (mv - 700) / 25; 1080 | _writeByte(AXP173_LDO4_VLOTAGE, 1, &val); 1081 | return AXP_PASS; 1082 | } 1083 | 1084 | uint16_t AXP20X_Class::getLDO4Voltage(void) 1085 | { 1086 | const uint16_t ldo4_table[] = {1250, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2500, 2700, 2800, 3000, 3100, 3200, 3300}; 1087 | if (!_init) 1088 | return 0; 1089 | uint8_t val = 0; 1090 | switch (_chip_id) { 1091 | case AXP173_CHIP_ID: 1092 | _readByte(AXP173_LDO4_VLOTAGE, 1, &val); 1093 | return val * 25 + 700; 1094 | case AXP202_CHIP_ID: 1095 | _readByte(AXP202_LDO24OUT_VOL, 1, &val); 1096 | val &= 0xF; 1097 | return ldo4_table[val]; 1098 | break; 1099 | case AXP192_CHIP_ID: 1100 | default: 1101 | break; 1102 | } 1103 | return 0; 1104 | } 1105 | 1106 | 1107 | //! Only axp202 support 1108 | int AXP20X_Class::setLDO4Voltage(axp_ldo4_table_t param) 1109 | { 1110 | if (!_init) 1111 | return AXP_NOT_INIT; 1112 | if (_chip_id == AXP202_CHIP_ID) { 1113 | if (param >= AXP202_LDO4_MAX) 1114 | return AXP_INVALID; 1115 | uint8_t val; 1116 | _readByte(AXP202_LDO24OUT_VOL, 1, &val); 1117 | val &= 0xF0; 1118 | val |= param; 1119 | _writeByte(AXP202_LDO24OUT_VOL, 1, &val); 1120 | return AXP_PASS; 1121 | } 1122 | return AXP_FAIL; 1123 | } 1124 | 1125 | //! Only AXP202 support 1126 | int AXP20X_Class::setLDO3Mode(axp202_ldo3_mode_t mode) 1127 | { 1128 | uint8_t val; 1129 | if (_chip_id != AXP202_CHIP_ID) 1130 | return AXP_FAIL; 1131 | _readByte(AXP202_LDO3OUT_VOL, 1, &val); 1132 | if (mode) { 1133 | val |= _BV(7); 1134 | } else { 1135 | val &= (~_BV(7)); 1136 | } 1137 | _writeByte(AXP202_LDO3OUT_VOL, 1, &val); 1138 | return AXP_PASS; 1139 | } 1140 | 1141 | int AXP20X_Class::setStartupTime(uint8_t param) 1142 | { 1143 | uint8_t val; 1144 | if (!_init) 1145 | return AXP_NOT_INIT; 1146 | if (param > sizeof(startupParams) / sizeof(startupParams[0])) 1147 | return AXP_INVALID; 1148 | _readByte(AXP202_POK_SET, 1, &val); 1149 | val &= (~0b11000000); 1150 | val |= startupParams[param]; 1151 | _writeByte(AXP202_POK_SET, 1, &val); 1152 | return AXP_PASS; 1153 | } 1154 | 1155 | int AXP20X_Class::setlongPressTime(uint8_t param) 1156 | { 1157 | uint8_t val; 1158 | if (!_init) 1159 | return AXP_NOT_INIT; 1160 | if (param > sizeof(longPressParams) / sizeof(longPressParams[0])) 1161 | return AXP_INVALID; 1162 | _readByte(AXP202_POK_SET, 1, &val); 1163 | val &= (~0b00110000); 1164 | val |= longPressParams[param]; 1165 | _writeByte(AXP202_POK_SET, 1, &val); 1166 | return AXP_PASS; 1167 | } 1168 | 1169 | int AXP20X_Class::setShutdownTime(uint8_t param) 1170 | { 1171 | uint8_t val; 1172 | if (!_init) 1173 | return AXP_NOT_INIT; 1174 | if (param > sizeof(shutdownParams) / sizeof(shutdownParams[0])) 1175 | return AXP_INVALID; 1176 | _readByte(AXP202_POK_SET, 1, &val); 1177 | val &= (~0b00000011); 1178 | val |= shutdownParams[param]; 1179 | _writeByte(AXP202_POK_SET, 1, &val); 1180 | return AXP_PASS; 1181 | } 1182 | 1183 | int AXP20X_Class::setTimeOutShutdown(bool en) 1184 | { 1185 | uint8_t val; 1186 | if (!_init) 1187 | return AXP_NOT_INIT; 1188 | _readByte(AXP202_POK_SET, 1, &val); 1189 | if (en) 1190 | val |= (1 << 3); 1191 | else 1192 | val &= (~(1 << 3)); 1193 | _writeByte(AXP202_POK_SET, 1, &val); 1194 | return AXP_PASS; 1195 | } 1196 | 1197 | int AXP20X_Class::shutdown(void) 1198 | { 1199 | uint8_t val; 1200 | if (!_init) 1201 | return AXP_NOT_INIT; 1202 | _readByte(AXP202_OFF_CTL, 1, &val); 1203 | val |= (1 << 7); 1204 | _writeByte(AXP202_OFF_CTL, 1, &val); 1205 | return AXP_PASS; 1206 | } 1207 | 1208 | float AXP20X_Class::getSettingChargeCurrent(void) 1209 | { 1210 | uint8_t val; 1211 | if (!_init) 1212 | return AXP_NOT_INIT; 1213 | _readByte(AXP202_CHARGE1, 1, &val); 1214 | val &= 0b00000111; 1215 | float cur = 300.0 + val * 100.0; 1216 | AXP_DEBUG("Setting Charge current : %.2f mA\n", cur); 1217 | return cur; 1218 | } 1219 | 1220 | bool AXP20X_Class::isChargeingEnable(void) 1221 | { 1222 | return isChargingEnable(); 1223 | } 1224 | 1225 | bool AXP20X_Class::isChargingEnable(void) 1226 | { 1227 | uint8_t val; 1228 | if (!_init) 1229 | return false; 1230 | _readByte(AXP202_CHARGE1, 1, &val); 1231 | if (val & (1 << 7)) { 1232 | AXP_DEBUG("Charging enable is enable\n"); 1233 | val = true; 1234 | } else { 1235 | AXP_DEBUG("Charging enable is disable\n"); 1236 | val = false; 1237 | } 1238 | return val; 1239 | } 1240 | 1241 | int AXP20X_Class::enableChargeing(bool en) 1242 | { 1243 | return enableCharging(en); 1244 | } 1245 | 1246 | int AXP20X_Class::enableCharging(bool en) 1247 | { 1248 | uint8_t val; 1249 | if (!_init) 1250 | return AXP_NOT_INIT; 1251 | _readByte(AXP202_CHARGE1, 1, &val); 1252 | val = en ? (val | _BV(7)) : val & (~_BV(7)); 1253 | _writeByte(AXP202_CHARGE1, 1, &val); 1254 | return AXP_PASS; 1255 | } 1256 | 1257 | int AXP20X_Class::getChargingTargetVoltage(axp_chargeing_vol_t &chargeing_vol) 1258 | { 1259 | uint8_t val; 1260 | if (!_init) 1261 | return AXP_NOT_INIT; 1262 | _readByte(AXP202_CHARGE1, 1, &val); 1263 | val &= (0b11 << 5); 1264 | chargeing_vol = (axp_chargeing_vol_t) (val >> 5); 1265 | return AXP_PASS; 1266 | } 1267 | 1268 | int AXP20X_Class::setChargingTargetVoltage(axp_chargeing_vol_t param) 1269 | { 1270 | uint8_t val; 1271 | if (!_init) 1272 | return AXP_NOT_INIT; 1273 | if (param > sizeof(targetVolParams) / sizeof(targetVolParams[0])) 1274 | return AXP_INVALID; 1275 | _readByte(AXP202_CHARGE1, 1, &val); 1276 | val &= ~(0b01100000); 1277 | val |= targetVolParams[param]; 1278 | _writeByte(AXP202_CHARGE1, 1, &val); 1279 | return AXP_PASS; 1280 | } 1281 | 1282 | int AXP20X_Class::getBattPercentage(void) 1283 | { 1284 | if (!_init) 1285 | return AXP_NOT_INIT; 1286 | if (_chip_id != AXP202_CHIP_ID) 1287 | return AXP_NOT_SUPPORT; 1288 | uint8_t val; 1289 | if (!isBatteryConnect()) 1290 | return 0; 1291 | _readByte(AXP202_BATT_PERCENTAGE, 1, &val); 1292 | if (!(val & _BV(7))) { 1293 | return val & (~_BV(7)); 1294 | } 1295 | return 0; 1296 | } 1297 | 1298 | int AXP20X_Class::setMeteringSystem(bool en) 1299 | { 1300 | if (!_init) 1301 | return AXP_NOT_INIT; 1302 | if (_chip_id != AXP202_CHIP_ID) 1303 | return AXP_NOT_SUPPORT; 1304 | uint8_t val = 0; 1305 | _readByte(AXP202_BATT_PERCENTAGE, 1, &val); 1306 | en ? (val |= _BV(7)) : (val &= (~_BV(7))); 1307 | return AXP_PASS; 1308 | } 1309 | 1310 | 1311 | int AXP20X_Class::setChgLEDMode(axp_chgled_mode_t mode) 1312 | { 1313 | uint8_t val; 1314 | _readByte(AXP202_OFF_CTL, 1, &val); 1315 | val &= 0b11001111; 1316 | val |= _BV(3); 1317 | switch (mode) { 1318 | case AXP20X_LED_OFF: 1319 | _writeByte(AXP202_OFF_CTL, 1, &val); 1320 | break; 1321 | case AXP20X_LED_BLINK_1HZ: 1322 | val |= 0b00010000; 1323 | _writeByte(AXP202_OFF_CTL, 1, &val); 1324 | break; 1325 | case AXP20X_LED_BLINK_4HZ: 1326 | val |= 0b00100000; 1327 | _writeByte(AXP202_OFF_CTL, 1, &val); 1328 | break; 1329 | case AXP20X_LED_LOW_LEVEL: 1330 | val |= 0b00110000; 1331 | _writeByte(AXP202_OFF_CTL, 1, &val); 1332 | break; 1333 | default: 1334 | return AXP_FAIL; 1335 | } 1336 | return AXP_PASS; 1337 | } 1338 | 1339 | int AXP20X_Class::debugCharging(void) 1340 | { 1341 | uint8_t val; 1342 | _readByte(AXP202_CHARGE1, 1, &val); 1343 | AXP_DEBUG("SRC REG:0x%x\n", val); 1344 | if (val & (1 << 7)) { 1345 | AXP_DEBUG("Charging enable is enable\n"); 1346 | } else { 1347 | AXP_DEBUG("Charging enable is disable\n"); 1348 | } 1349 | AXP_DEBUG("Charging target-voltage : 0x%x\n", ((val & 0b01100000) >> 5) & 0b11); 1350 | if (val & (1 << 4)) { 1351 | AXP_DEBUG("end when the charge current is lower than 15%% of the set value\n"); 1352 | } else { 1353 | AXP_DEBUG(" end when the charge current is lower than 10%% of the set value\n"); 1354 | } 1355 | val &= 0b00000111; 1356 | AXP_DEBUG("Charge current : %.2f mA\n", 300.0 + val * 100.0); 1357 | return AXP_PASS; 1358 | } 1359 | 1360 | int AXP20X_Class::debugStatus(void) 1361 | { 1362 | if (!_init) 1363 | return AXP_NOT_INIT; 1364 | uint8_t val, val1, val2; 1365 | _readByte(AXP202_STATUS, 1, &val); 1366 | _readByte(AXP202_MODE_CHGSTATUS, 1, &val1); 1367 | _readByte(AXP202_IPS_SET, 1, &val2); 1368 | AXP_DEBUG("AXP202_STATUS: AXP202_MODE_CHGSTATUS AXP202_IPS_SET\n"); 1369 | AXP_DEBUG("0x%x\t\t\t 0x%x\t\t\t 0x%x\n", val, val1, val2); 1370 | return AXP_PASS; 1371 | } 1372 | 1373 | int AXP20X_Class::limitingOff(void) 1374 | { 1375 | if (!_init) 1376 | return AXP_NOT_INIT; 1377 | uint8_t val; 1378 | _readByte(AXP202_IPS_SET, 1, &val); 1379 | if (_chip_id == AXP202_CHIP_ID) { 1380 | val |= 0x03; 1381 | } else { 1382 | val &= ~(1 << 1); 1383 | } 1384 | _writeByte(AXP202_IPS_SET, 1, &val); 1385 | return AXP_PASS; 1386 | } 1387 | 1388 | // Only AXP129 chip and AXP173 1389 | int AXP20X_Class::setDCDC1Voltage(uint16_t mv) 1390 | { 1391 | if (!_init) 1392 | return AXP_NOT_INIT; 1393 | if (_chip_id != AXP192_CHIP_ID && _chip_id != AXP173_CHIP_ID) 1394 | return AXP_FAIL; 1395 | if (mv < 700) { 1396 | AXP_DEBUG("DCDC1:Below settable voltage:700mV~3500mV"); 1397 | mv = 700; 1398 | } 1399 | if (mv > 3500) { 1400 | AXP_DEBUG("DCDC1:Above settable voltage:700mV~3500mV"); 1401 | mv = 3500; 1402 | } 1403 | uint8_t val = (mv - 700) / 25; 1404 | //! axp192 and axp173 dc1 control register same 1405 | _writeByte(AXP192_DC1_VLOTAGE, 1, &val); 1406 | return AXP_PASS; 1407 | } 1408 | 1409 | // Only AXP129 chip and AXP173 1410 | uint16_t AXP20X_Class::getDCDC1Voltage(void) 1411 | { 1412 | if (_chip_id != AXP192_CHIP_ID && _chip_id != AXP173_CHIP_ID) 1413 | return AXP_FAIL; 1414 | uint8_t val = 0; 1415 | //! axp192 and axp173 dc1 control register same 1416 | _readByte(AXP192_DC1_VLOTAGE, 1, &val); 1417 | return val * 25 + 700; 1418 | } 1419 | 1420 | 1421 | /*********************************************** 1422 | * !!! TIMER FUNCTION !!! 1423 | * *********************************************/ 1424 | 1425 | int AXP20X_Class::setTimer(uint8_t minutes) 1426 | { 1427 | if (!_init) 1428 | return AXP_NOT_INIT; 1429 | if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { 1430 | if (minutes > 63) { 1431 | return AXP_ARG_INVALID; 1432 | } 1433 | minutes |= 0x80; //Clear timer flag 1434 | _writeByte(AXP202_TIMER_CTL, 1, &minutes); 1435 | return AXP_PASS; 1436 | } 1437 | return AXP_NOT_SUPPORT; 1438 | } 1439 | 1440 | int AXP20X_Class::offTimer(void) 1441 | { 1442 | if (!_init) 1443 | return AXP_NOT_INIT; 1444 | if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { 1445 | uint8_t minutes = 0x80; 1446 | _writeByte(AXP202_TIMER_CTL, 1, &minutes); 1447 | return AXP_PASS; 1448 | } 1449 | return AXP_NOT_SUPPORT; 1450 | } 1451 | 1452 | int AXP20X_Class::clearTimerStatus(void) 1453 | { 1454 | if (!_init) 1455 | return AXP_NOT_INIT; 1456 | if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { 1457 | uint8_t val; 1458 | _readByte(AXP202_TIMER_CTL, 1, &val); 1459 | val |= 0x80; 1460 | _writeByte(AXP202_TIMER_CTL, 1, &val); 1461 | return AXP_PASS; 1462 | } 1463 | return AXP_NOT_SUPPORT; 1464 | } 1465 | 1466 | bool AXP20X_Class::getTimerStatus(void) 1467 | { 1468 | if (!_init) 1469 | return AXP_NOT_INIT; 1470 | if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) { 1471 | uint8_t val; 1472 | _readByte(AXP202_TIMER_CTL, 1, &val); 1473 | return ( val & 0x80 ) >> 7; 1474 | } 1475 | return AXP_NOT_SUPPORT; 1476 | } 1477 | 1478 | /*********************************************** 1479 | * !!! GPIO FUNCTION !!! 1480 | * *********************************************/ 1481 | 1482 | int AXP20X_Class::_axp192_gpio_0_select( axp_gpio_mode_t mode) 1483 | { 1484 | switch (mode) { 1485 | case AXP_IO_OUTPUT_LOW_MODE: 1486 | return 0b101; 1487 | case AXP_IO_INPUT_MODE: 1488 | return 0b001; 1489 | case AXP_IO_LDO_MODE: 1490 | return 0b010; 1491 | case AXP_IO_ADC_MODE: 1492 | return 0b100; 1493 | case AXP_IO_FLOATING_MODE: 1494 | return 0b111; 1495 | case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: 1496 | return 0; 1497 | case AXP_IO_OUTPUT_HIGH_MODE: 1498 | case AXP_IO_PWM_OUTPUT_MODE: 1499 | default: 1500 | break; 1501 | } 1502 | return AXP_NOT_SUPPORT; 1503 | } 1504 | 1505 | int AXP20X_Class::_axp192_gpio_1_select( axp_gpio_mode_t mode) 1506 | { 1507 | switch (mode) { 1508 | case AXP_IO_OUTPUT_LOW_MODE: 1509 | return 0b101; 1510 | case AXP_IO_INPUT_MODE: 1511 | return 0b001; 1512 | case AXP_IO_ADC_MODE: 1513 | return 0b100; 1514 | case AXP_IO_FLOATING_MODE: 1515 | return 0b111; 1516 | case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: 1517 | return 0; 1518 | case AXP_IO_PWM_OUTPUT_MODE: 1519 | return 0b010; 1520 | case AXP_IO_OUTPUT_HIGH_MODE: 1521 | case AXP_IO_LDO_MODE: 1522 | default: 1523 | break; 1524 | } 1525 | return AXP_NOT_SUPPORT; 1526 | } 1527 | 1528 | 1529 | int AXP20X_Class::_axp192_gpio_3_select( axp_gpio_mode_t mode) 1530 | { 1531 | switch (mode) { 1532 | case AXP_IO_EXTERN_CHARGING_CTRL_MODE: 1533 | return 0; 1534 | case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: 1535 | return 1; 1536 | case AXP_IO_INPUT_MODE: 1537 | return 2; 1538 | default: 1539 | break; 1540 | } 1541 | return AXP_NOT_SUPPORT; 1542 | } 1543 | 1544 | int AXP20X_Class::_axp192_gpio_4_select( axp_gpio_mode_t mode) 1545 | { 1546 | switch (mode) { 1547 | case AXP_IO_EXTERN_CHARGING_CTRL_MODE: 1548 | return 0; 1549 | case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: 1550 | return 1; 1551 | case AXP_IO_INPUT_MODE: 1552 | return 2; 1553 | case AXP_IO_ADC_MODE: 1554 | return 3; 1555 | default: 1556 | break; 1557 | } 1558 | return AXP_NOT_SUPPORT; 1559 | } 1560 | 1561 | 1562 | int AXP20X_Class::_axp192_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode) 1563 | { 1564 | int rslt; 1565 | uint8_t val; 1566 | switch (gpio) { 1567 | case AXP_GPIO_0: { 1568 | rslt = _axp192_gpio_0_select(mode); 1569 | if (rslt < 0)return rslt; 1570 | _readByte(AXP192_GPIO0_CTL, 1, &val); 1571 | val &= 0xF8; 1572 | val |= (uint8_t)rslt; 1573 | _writeByte(AXP192_GPIO0_CTL, 1, &val); 1574 | return AXP_PASS; 1575 | } 1576 | case AXP_GPIO_1: { 1577 | rslt = _axp192_gpio_1_select(mode); 1578 | if (rslt < 0)return rslt; 1579 | _readByte(AXP192_GPIO1_CTL, 1, &val); 1580 | val &= 0xF8; 1581 | val |= (uint8_t)rslt; 1582 | _writeByte(AXP192_GPIO1_CTL, 1, &val); 1583 | return AXP_PASS; 1584 | } 1585 | case AXP_GPIO_2: { 1586 | rslt = _axp192_gpio_1_select(mode); 1587 | if (rslt < 0)return rslt; 1588 | _readByte(AXP192_GPIO2_CTL, 1, &val); 1589 | val &= 0xF8; 1590 | val |= (uint8_t)rslt; 1591 | _writeByte(AXP192_GPIO2_CTL, 1, &val); 1592 | return AXP_PASS; 1593 | } 1594 | case AXP_GPIO_3: { 1595 | rslt = _axp192_gpio_3_select(mode); 1596 | if (rslt < 0)return rslt; 1597 | _readByte(AXP192_GPIO34_CTL, 1, &val); 1598 | val &= 0xFC; 1599 | val |= (uint8_t)rslt; 1600 | _writeByte(AXP192_GPIO34_CTL, 1, &val); 1601 | return AXP_PASS; 1602 | } 1603 | case AXP_GPIO_4: { 1604 | rslt = _axp192_gpio_4_select(mode); 1605 | if (rslt < 0)return rslt; 1606 | _readByte(AXP192_GPIO34_CTL, 1, &val); 1607 | val &= 0xF3; 1608 | val |= (uint8_t)rslt; 1609 | _writeByte(AXP192_GPIO34_CTL, 1, &val); 1610 | return AXP_PASS; 1611 | } 1612 | default: 1613 | break; 1614 | } 1615 | return AXP_NOT_SUPPORT; 1616 | } 1617 | 1618 | int AXP20X_Class::_axp202_gpio_0_select( axp_gpio_mode_t mode) 1619 | { 1620 | switch (mode) { 1621 | case AXP_IO_OUTPUT_LOW_MODE: 1622 | return 0; 1623 | case AXP_IO_OUTPUT_HIGH_MODE: 1624 | return 1; 1625 | case AXP_IO_INPUT_MODE: 1626 | return 2; 1627 | case AXP_IO_LDO_MODE: 1628 | return 3; 1629 | case AXP_IO_ADC_MODE: 1630 | return 4; 1631 | default: 1632 | break; 1633 | } 1634 | return AXP_NOT_SUPPORT; 1635 | } 1636 | 1637 | int AXP20X_Class::_axp202_gpio_1_select( axp_gpio_mode_t mode) 1638 | { 1639 | switch (mode) { 1640 | case AXP_IO_OUTPUT_LOW_MODE: 1641 | return 0; 1642 | case AXP_IO_OUTPUT_HIGH_MODE: 1643 | return 1; 1644 | case AXP_IO_INPUT_MODE: 1645 | return 2; 1646 | case AXP_IO_ADC_MODE: 1647 | return 4; 1648 | default: 1649 | break; 1650 | } 1651 | return AXP_NOT_SUPPORT; 1652 | } 1653 | 1654 | int AXP20X_Class::_axp202_gpio_2_select( axp_gpio_mode_t mode) 1655 | { 1656 | switch (mode) { 1657 | case AXP_IO_OUTPUT_LOW_MODE: 1658 | return 0; 1659 | case AXP_IO_INPUT_MODE: 1660 | return 2; 1661 | case AXP_IO_FLOATING_MODE: 1662 | return 1; 1663 | default: 1664 | break; 1665 | } 1666 | return AXP_NOT_SUPPORT; 1667 | } 1668 | 1669 | 1670 | int AXP20X_Class::_axp202_gpio_3_select(axp_gpio_mode_t mode) 1671 | { 1672 | switch (mode) { 1673 | case AXP_IO_INPUT_MODE: 1674 | return 1; 1675 | case AXP_IO_OPEN_DRAIN_OUTPUT_MODE: 1676 | return 0; 1677 | default: 1678 | break; 1679 | } 1680 | return AXP_NOT_SUPPORT; 1681 | } 1682 | 1683 | int AXP20X_Class::_axp202_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode) 1684 | { 1685 | uint8_t val; 1686 | int rslt; 1687 | switch (gpio) { 1688 | case AXP_GPIO_0: { 1689 | rslt = _axp202_gpio_0_select(mode); 1690 | if (rslt < 0)return rslt; 1691 | _readByte(AXP202_GPIO0_CTL, 1, &val); 1692 | val &= 0b11111000; 1693 | val |= (uint8_t)rslt; 1694 | _writeByte(AXP202_GPIO0_CTL, 1, &val); 1695 | return AXP_PASS; 1696 | } 1697 | case AXP_GPIO_1: { 1698 | rslt = _axp202_gpio_1_select(mode); 1699 | if (rslt < 0)return rslt; 1700 | _readByte(AXP202_GPIO1_CTL, 1, &val); 1701 | val &= 0b11111000; 1702 | val |= (uint8_t)rslt; 1703 | _writeByte(AXP202_GPIO1_CTL, 1, &val); 1704 | return AXP_PASS; 1705 | } 1706 | case AXP_GPIO_2: { 1707 | rslt = _axp202_gpio_2_select(mode); 1708 | if (rslt < 0)return rslt; 1709 | _readByte(AXP202_GPIO2_CTL, 1, &val); 1710 | val &= 0b11111000; 1711 | val |= (uint8_t)rslt; 1712 | _writeByte(AXP202_GPIO2_CTL, 1, &val); 1713 | return AXP_PASS; 1714 | } 1715 | case AXP_GPIO_3: { 1716 | rslt = _axp202_gpio_3_select(mode); 1717 | if (rslt < 0)return rslt; 1718 | _readByte(AXP202_GPIO3_CTL, 1, &val); 1719 | val = rslt ? (val | _BV(2)) : (val & (~_BV(2))); 1720 | _writeByte(AXP202_GPIO3_CTL, 1, &val); 1721 | return AXP_PASS; 1722 | } 1723 | default: 1724 | break; 1725 | } 1726 | return AXP_NOT_SUPPORT; 1727 | } 1728 | 1729 | 1730 | int AXP20X_Class::setGPIOMode(axp_gpio_t gpio, axp_gpio_mode_t mode) 1731 | { 1732 | if (!_init) 1733 | return AXP_NOT_INIT; 1734 | switch (_chip_id) { 1735 | case AXP202_CHIP_ID: 1736 | return _axp202_gpio_set(gpio, mode); 1737 | break; 1738 | case AXP192_CHIP_ID: 1739 | return _axp192_gpio_set(gpio, mode); 1740 | break; 1741 | default: 1742 | break; 1743 | } 1744 | return AXP_NOT_SUPPORT; 1745 | } 1746 | 1747 | 1748 | int AXP20X_Class::_axp_irq_mask(axp_gpio_irq_t irq) 1749 | { 1750 | switch (irq) { 1751 | case AXP_IRQ_NONE: 1752 | return 0; 1753 | case AXP_IRQ_RISING: 1754 | return _BV(7); 1755 | case AXP_IRQ_FALLING: 1756 | return _BV(6); 1757 | case AXP_IRQ_DOUBLE_EDGE: 1758 | return 0b1100000; 1759 | default: 1760 | break; 1761 | } 1762 | return AXP_NOT_SUPPORT; 1763 | } 1764 | 1765 | int AXP20X_Class::_axp202_gpio_irq_set(axp_gpio_t gpio, axp_gpio_irq_t irq) 1766 | { 1767 | uint8_t reg; 1768 | uint8_t val; 1769 | int mask; 1770 | mask = _axp_irq_mask(irq); 1771 | 1772 | if (mask < 0)return mask; 1773 | switch (gpio) { 1774 | case AXP_GPIO_0: 1775 | reg = AXP202_GPIO0_CTL; 1776 | break; 1777 | case AXP_GPIO_1: 1778 | reg = AXP202_GPIO1_CTL; 1779 | break; 1780 | case AXP_GPIO_2: 1781 | reg = AXP202_GPIO2_CTL; 1782 | break; 1783 | case AXP_GPIO_3: 1784 | reg = AXP202_GPIO3_CTL; 1785 | break; 1786 | default: 1787 | return AXP_NOT_SUPPORT; 1788 | } 1789 | _readByte(reg, 1, &val); 1790 | val = mask == 0 ? (val & 0b00111111) : (val | mask); 1791 | _writeByte(reg, 1, &val); 1792 | return AXP_PASS; 1793 | } 1794 | 1795 | 1796 | int AXP20X_Class::setGPIOIrq(axp_gpio_t gpio, axp_gpio_irq_t irq) 1797 | { 1798 | if (!_init) 1799 | return AXP_NOT_INIT; 1800 | switch (_chip_id) { 1801 | case AXP202_CHIP_ID: 1802 | return _axp202_gpio_irq_set(gpio, irq); 1803 | case AXP192_CHIP_ID: 1804 | case AXP173_CHIP_ID: 1805 | return AXP_NOT_SUPPORT; 1806 | default: 1807 | break; 1808 | } 1809 | return AXP_NOT_SUPPORT; 1810 | } 1811 | 1812 | int AXP20X_Class::setLDO5Voltage(axp_ldo5_table_t vol) 1813 | { 1814 | const uint8_t params[] = { 1815 | 0b11111000, //1.8V 1816 | 0b11111001, //2.5V 1817 | 0b11111010, //2.8V 1818 | 0b11111011, //3.0V 1819 | 0b11111100, //3.1V 1820 | 0b11111101, //3.3V 1821 | 0b11111110, //3.4V 1822 | 0b11111111, //3.5V 1823 | }; 1824 | if (!_init) 1825 | return AXP_NOT_INIT; 1826 | if (_chip_id != AXP202_CHIP_ID) 1827 | return AXP_NOT_SUPPORT; 1828 | if (vol > sizeof(params) / sizeof(params[0])) 1829 | return AXP_ARG_INVALID; 1830 | uint8_t val = 0; 1831 | _readByte(AXP202_GPIO0_VOL, 1, &val); 1832 | val &= 0b11111000; 1833 | val |= params[vol]; 1834 | _writeByte(AXP202_GPIO0_VOL, 1, &val); 1835 | return AXP_PASS; 1836 | } 1837 | 1838 | 1839 | int AXP20X_Class::_axp202_gpio_write(axp_gpio_t gpio, uint8_t val) 1840 | { 1841 | uint8_t reg; 1842 | uint8_t wVal = 0; 1843 | switch (gpio) { 1844 | case AXP_GPIO_0: 1845 | reg = AXP202_GPIO0_CTL; 1846 | break; 1847 | case AXP_GPIO_1: 1848 | reg = AXP202_GPIO1_CTL; 1849 | break; 1850 | case AXP_GPIO_2: 1851 | reg = AXP202_GPIO2_CTL; 1852 | if (val) { 1853 | return AXP_NOT_SUPPORT; 1854 | } 1855 | break; 1856 | case AXP_GPIO_3: 1857 | if (val) { 1858 | return AXP_NOT_SUPPORT; 1859 | } 1860 | _readByte(AXP202_GPIO3_CTL, 1, &wVal); 1861 | wVal &= 0b11111101; 1862 | _writeByte(AXP202_GPIO3_CTL, 1, &wVal); 1863 | return AXP_PASS; 1864 | default: 1865 | return AXP_NOT_SUPPORT; 1866 | } 1867 | _readByte(reg, 1, &wVal); 1868 | wVal = val ? (wVal | 1) : (wVal & 0b11111000); 1869 | _writeByte(reg, 1, &wVal); 1870 | return AXP_PASS; 1871 | } 1872 | 1873 | int AXP20X_Class::_axp202_gpio_read(axp_gpio_t gpio) 1874 | { 1875 | uint8_t val; 1876 | uint8_t reg = AXP202_GPIO012_SIGNAL; 1877 | uint8_t offset; 1878 | switch (gpio) { 1879 | case AXP_GPIO_0: 1880 | offset = 4; 1881 | break; 1882 | case AXP_GPIO_1: 1883 | offset = 5; 1884 | break; 1885 | case AXP_GPIO_2: 1886 | offset = 6; 1887 | break; 1888 | case AXP_GPIO_3: 1889 | reg = AXP202_GPIO3_CTL; 1890 | offset = 0; 1891 | break; 1892 | default: 1893 | return AXP_NOT_SUPPORT; 1894 | } 1895 | _readByte(reg, 1, &val); 1896 | return val & _BV(offset) ? 1 : 0; 1897 | } 1898 | 1899 | int AXP20X_Class::gpioWrite(axp_gpio_t gpio, uint8_t val) 1900 | { 1901 | if (!_init) 1902 | return AXP_NOT_INIT; 1903 | switch (_chip_id) { 1904 | case AXP202_CHIP_ID: 1905 | return _axp202_gpio_write(gpio, val); 1906 | case AXP192_CHIP_ID: 1907 | case AXP173_CHIP_ID: 1908 | return AXP_NOT_SUPPORT; 1909 | default: 1910 | break; 1911 | } 1912 | return AXP_NOT_SUPPORT; 1913 | } 1914 | 1915 | int AXP20X_Class::gpioRead(axp_gpio_t gpio) 1916 | { 1917 | if (!_init) 1918 | return AXP_NOT_INIT; 1919 | switch (_chip_id) { 1920 | case AXP202_CHIP_ID: 1921 | return _axp202_gpio_read(gpio); 1922 | case AXP192_CHIP_ID: 1923 | case AXP173_CHIP_ID: 1924 | return AXP_NOT_SUPPORT; 1925 | default: 1926 | break; 1927 | } 1928 | return AXP_NOT_SUPPORT; 1929 | } 1930 | 1931 | int AXP20X_Class::getChargeControlCur(void) 1932 | { 1933 | int cur; 1934 | uint8_t val; 1935 | if (!_init) 1936 | return AXP_NOT_INIT; 1937 | switch (_chip_id) { 1938 | case AXP202_CHIP_ID: 1939 | _readByte(AXP202_CHARGE1, 1, &val); 1940 | val &= 0x0F; 1941 | cur = val * 100 + 300; 1942 | if (cur > 1800 || cur < 300)return 0; 1943 | return cur; 1944 | case AXP192_CHIP_ID: 1945 | case AXP173_CHIP_ID: 1946 | _readByte(AXP202_CHARGE1, 1, &val); 1947 | return val & 0x0F; 1948 | default: 1949 | break; 1950 | } 1951 | return AXP_NOT_SUPPORT; 1952 | } 1953 | 1954 | int AXP20X_Class::setChargeControlCur(uint16_t mA) 1955 | { 1956 | uint8_t val; 1957 | if (!_init) 1958 | return AXP_NOT_INIT; 1959 | switch (_chip_id) { 1960 | case AXP202_CHIP_ID: 1961 | _readByte(AXP202_CHARGE1, 1, &val); 1962 | val &= 0b11110000; 1963 | mA -= 300; 1964 | val |= (mA / 100); 1965 | _writeByte(AXP202_CHARGE1, 1, &val); 1966 | return AXP_PASS; 1967 | case AXP192_CHIP_ID: 1968 | case AXP173_CHIP_ID: 1969 | _readByte(AXP202_CHARGE1, 1, &val); 1970 | val &= 0b11110000; 1971 | if (mA > AXP1XX_CHARGE_CUR_1320MA) 1972 | mA = AXP1XX_CHARGE_CUR_1320MA; 1973 | val |= mA; 1974 | _writeByte(AXP202_CHARGE1, 1, &val); 1975 | return AXP_PASS; 1976 | default: 1977 | break; 1978 | } 1979 | return AXP_NOT_SUPPORT; 1980 | } 1981 | 1982 | int AXP20X_Class::setSleep() 1983 | { 1984 | int ret; 1985 | uint8_t val = 0; 1986 | ret = _readByte(AXP202_VOFF_SET, 1, &val); 1987 | if (ret != 0)return AXP_FAIL; 1988 | val |= _BV(3); 1989 | ret = _writeByte(AXP202_VOFF_SET, 1, &val); 1990 | if (ret != 0)return AXP_FAIL; 1991 | ret = _readByte(AXP202_VOFF_SET, 1, &val); 1992 | if (ret != 0)return AXP_FAIL; 1993 | return (val & _BV(3)) ? AXP_PASS : AXP_FAIL; 1994 | } 1995 | 1996 | // VOFF =[2.6+(Bit2-0)*0.1]V 1997 | int AXP20X_Class::setPowerDownVoltage(uint16_t mv) 1998 | { 1999 | int ret; 2000 | uint8_t val = 0; 2001 | ret = _readByte(AXP202_VOFF_SET, 1, &val); 2002 | if (ret != 0)return AXP_FAIL; 2003 | val &= ~(AXP202_VOFF_MASK); 2004 | val |= ((mv - 2600) / 100); 2005 | ret = _writeByte(AXP202_VOFF_SET, 1, &val); 2006 | if (ret != 0)return AXP_FAIL; 2007 | return AXP_PASS ; 2008 | } 2009 | 2010 | uint16_t AXP20X_Class::getPowerDownVoltage(void) 2011 | { 2012 | int ret = 0; 2013 | uint8_t val = 0; 2014 | ret = _readByte(AXP202_VOFF_SET, 1, &val); 2015 | if (ret != 0)return 0; 2016 | val &= AXP202_VOFF_MASK; 2017 | uint16_t voff = val * 100 + 2600; 2018 | return voff; 2019 | } 2020 | 2021 | int AXP20X_Class::setCurrentLimitControl(axp202_limit_setting_t opt) 2022 | { 2023 | uint8_t val = 0; 2024 | if (!_init) 2025 | return AXP_NOT_INIT; 2026 | if (_chip_id != AXP202_CHIP_ID) { 2027 | return AXP_NOT_SUPPORT; 2028 | } 2029 | _readByte(AXP202_IPS_SET, 1, &val); 2030 | val &= (~AXP202_LIMIT_MASK); 2031 | val |= opt; 2032 | _writeByte(AXP202_IPS_SET, 1, &val); 2033 | return AXP_PASS; 2034 | } 2035 | 2036 | int AXP20X_Class::setCurrentLimitControl(axp192_limit_setting_t opt) 2037 | { 2038 | uint8_t val = 0; 2039 | if (!_init) { 2040 | return AXP_NOT_INIT; 2041 | } 2042 | if (_chip_id != AXP192_CHIP_ID) { 2043 | return AXP_NOT_SUPPORT; 2044 | } 2045 | _readByte(AXP202_IPS_SET, 1, &val); 2046 | 2047 | if (opt == AXP192_VBUS_LIMIT_OFF) { 2048 | val &= (~AXP192_LIMIT_EN_MASK); 2049 | } else { 2050 | val &= (~AXP192_LIMIT_MASK); 2051 | val |= opt; 2052 | val |= AXP192_LIMIT_EN_MASK; 2053 | } 2054 | _writeByte(AXP202_IPS_SET, 1, &val); 2055 | return AXP_PASS; 2056 | } 2057 | 2058 | int AXP20X_Class::setVWarningLevel1(uint16_t mv) 2059 | { 2060 | ISCONNECETD(AXP_NOT_INIT); 2061 | uint8_t val = (mv - 2867) / 5.6; 2062 | AXP_DEBUG("setVWarningLevel1:0x%x\n", val); 2063 | _writeByte(AXP202_APS_WARNING1, 1, &val); 2064 | return AXP_PASS; 2065 | } 2066 | 2067 | int AXP20X_Class::setVWarningLevel2(uint16_t mv) 2068 | { 2069 | ISCONNECETD(AXP_NOT_INIT); 2070 | uint8_t val = (mv - 2867) / 5.6; 2071 | AXP_DEBUG("setVWarningLevel2:0x%x\n", val); 2072 | _writeByte(AXP202_APS_WARNING2, 1, &val); 2073 | return AXP_PASS; 2074 | } 2075 | 2076 | uint16_t AXP20X_Class::getVWarningLevel1(void) 2077 | { 2078 | ISCONNECETD(0); 2079 | uint8_t val = 0; 2080 | _readByte(AXP202_APS_WARNING1, 1, &val); 2081 | AXP_DEBUG("TarageVoltage:%.2f HEX:0x%x\n", 2.8672 + 0.0014 * val * 4.0, val); 2082 | return ( 2.8672 + 0.0014 * val * 4.0) * 1000; 2083 | } 2084 | 2085 | uint16_t AXP20X_Class::getVWarningLevel2(void) 2086 | { 2087 | ISCONNECETD(0); 2088 | uint8_t val = 0; 2089 | _readByte(AXP202_APS_WARNING2, 1, &val); 2090 | AXP_DEBUG("TarageVoltage:%.2f HEX:0x%x\n", 2.8672 + 0.0014 * val * 4.0, val); 2091 | return (2.8672 + 0.0014 * val * 4.0) * 1000; 2092 | } 2093 | 2094 | int AXP20X_Class::setDCDCMode(axp202_dc_mode_t opt) 2095 | { 2096 | uint8_t val = 0; 2097 | _readByte(AXP202_DCDC_MODESET, 1, &val); 2098 | val &= 0xF9; 2099 | val |= opt; 2100 | _writeByte(AXP202_DCDC_MODESET, 1, &val); 2101 | return AXP_PASS; 2102 | } 2103 | 2104 | axp202_dc_mode_t AXP20X_Class::getDCDCMode(void) 2105 | { 2106 | uint8_t val = 0; 2107 | _readByte(AXP202_DCDC_MODESET, 1, &val); 2108 | val &= 0x6; 2109 | return val ? AXP202_DCDC_AUTO_MODE : AXP202_DCDC_PWM_MODE; 2110 | } 2111 | 2112 | 2113 | int AXP20X_Class::enableLDO3VRC(bool en) 2114 | { 2115 | ISCONNECETD(AXP_NOT_INIT); 2116 | if (_chip_id != AXP202_CHIP_ID) { 2117 | return AXP_NOT_SUPPORT; 2118 | } 2119 | uint8_t val = 0; 2120 | _readByte(AXP202_LDO3_DC2_DVM, 1, &val); 2121 | val &= (~_BV(3)); 2122 | val |= en; 2123 | _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); 2124 | return AXP_PASS; 2125 | } 2126 | 2127 | int AXP20X_Class::enableDC2VRC(bool en) 2128 | { 2129 | ISCONNECETD(AXP_NOT_INIT); 2130 | uint8_t val = 0; 2131 | _readByte(AXP202_LDO3_DC2_DVM, 1, &val); 2132 | val &= (~_BV(2)); 2133 | val |= en; 2134 | _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); 2135 | return AXP_PASS; 2136 | } 2137 | 2138 | int AXP20X_Class::setLDO3VRC(axp202_vrc_control_t opt) 2139 | { 2140 | ISCONNECETD(AXP_NOT_INIT); 2141 | if (_chip_id != AXP202_CHIP_ID) { 2142 | return AXP_NOT_SUPPORT; 2143 | } 2144 | uint8_t val = 0; 2145 | _readByte(AXP202_LDO3_DC2_DVM, 1, &val); 2146 | val &= (~_BV(1)); 2147 | val |= opt; 2148 | _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); 2149 | return AXP_PASS; 2150 | } 2151 | 2152 | int AXP20X_Class::setDC2VRC(axp202_vrc_control_t opt) 2153 | { 2154 | ISCONNECETD(AXP_NOT_INIT); 2155 | uint8_t val = 0; 2156 | _readByte(AXP202_LDO3_DC2_DVM, 1, &val); 2157 | val &= (~_BV(0)); 2158 | val |= opt; 2159 | _writeByte(AXP202_LDO3_DC2_DVM, 1, &val); 2160 | return AXP_PASS; 2161 | } 2162 | 2163 | int AXP20X_Class::setBackupChargeControl(bool en) 2164 | { 2165 | ISCONNECETD(AXP_NOT_INIT); 2166 | uint8_t val = 0; 2167 | _readByte(AXP202_BACKUP_CHG, 1, &val); 2168 | val &= (~_BV(7)); 2169 | val |= en; 2170 | _writeByte(AXP202_BACKUP_CHG, 1, &val); 2171 | return AXP_PASS; 2172 | } 2173 | 2174 | int AXP20X_Class::setBackupChargeVoltage(axp202_backup_voltage_t opt) 2175 | { 2176 | ISCONNECETD(AXP_NOT_INIT); 2177 | uint8_t val = 0; 2178 | _readByte(AXP202_BACKUP_CHG, 1, &val); 2179 | val &= 0x9F; 2180 | val |= opt; 2181 | _writeByte(AXP202_BACKUP_CHG, 1, &val); 2182 | return AXP_PASS; 2183 | } 2184 | 2185 | int AXP20X_Class::setBackupChargeCurrent(axp202_backup_current_t opt) 2186 | { 2187 | ISCONNECETD(AXP_NOT_INIT); 2188 | uint8_t val = 0; 2189 | _readByte(AXP202_BACKUP_CHG, 1, &val); 2190 | val &= 0xFC; 2191 | val |= opt; 2192 | _writeByte(AXP202_BACKUP_CHG, 1, &val); 2193 | return AXP_PASS; 2194 | } 2195 | 2196 | int AXP20X_Class::setPrechargeTimeout(axp202_precharge_timeout_t opt) 2197 | { 2198 | ISCONNECETD(AXP_NOT_INIT); 2199 | uint8_t val = 0; 2200 | _readByte(AXP202_CHARGE2, 1, &val); 2201 | val &= 0x3F; 2202 | val |= opt; 2203 | _writeByte(AXP202_CHARGE2, 1, &val); 2204 | return AXP_PASS; 2205 | } 2206 | 2207 | int AXP20X_Class::setConstantCurrentTimeout(axp202_constant_current_t opt) 2208 | { 2209 | ISCONNECETD(AXP_NOT_INIT); 2210 | uint8_t val = 0; 2211 | _readByte(AXP202_CHARGE2, 1, &val); 2212 | val &= 0xFC; 2213 | val |= opt; 2214 | _writeByte(AXP202_CHARGE2, 1, &val); 2215 | return AXP_PASS; 2216 | } 2217 | 2218 | 2219 | 2220 | 2221 | 2222 | 2223 | 2224 | // Low-level I2C communication 2225 | uint16_t AXP20X_Class::_getRegistH8L5(uint8_t regh8, uint8_t regl5) 2226 | { 2227 | uint8_t hv, lv; 2228 | _readByte(regh8, 1, &hv); 2229 | _readByte(regl5, 1, &lv); 2230 | return (hv << 5) | (lv & 0x1F); 2231 | } 2232 | 2233 | uint16_t AXP20X_Class::_getRegistResult(uint8_t regh8, uint8_t regl4) 2234 | { 2235 | uint8_t hv, lv; 2236 | _readByte(regh8, 1, &hv); 2237 | _readByte(regl4, 1, &lv); 2238 | return (hv << 4) | (lv & 0x0F); 2239 | } 2240 | 2241 | int AXP20X_Class::_readByte(uint8_t reg, uint8_t nbytes, uint8_t *data) 2242 | { 2243 | if (_read_cb != nullptr) { 2244 | return _read_cb(_address, reg, data, nbytes); 2245 | } 2246 | #ifdef ARDUINO 2247 | if (nbytes == 0 || !data) 2248 | return -1; 2249 | _i2cPort->beginTransmission(_address); 2250 | _i2cPort->write(reg); 2251 | if (_i2cPort->endTransmission() != 0) { 2252 | return -1; 2253 | } 2254 | _i2cPort->requestFrom(_address, nbytes); 2255 | uint8_t index = 0; 2256 | while (_i2cPort->available()) 2257 | data[index++] = _i2cPort->read(); 2258 | #endif 2259 | return 0; 2260 | } 2261 | 2262 | int AXP20X_Class::_writeByte(uint8_t reg, uint8_t nbytes, uint8_t *data) 2263 | { 2264 | if (_write_cb != nullptr) { 2265 | return _write_cb(_address, reg, data, nbytes); 2266 | } 2267 | #ifdef ARDUINO 2268 | if (nbytes == 0 || !data) 2269 | return -1; 2270 | _i2cPort->beginTransmission(_address); 2271 | _i2cPort->write(reg); 2272 | for (uint8_t i = 0; i < nbytes; i++) { 2273 | _i2cPort->write(data[i]); 2274 | } 2275 | return _i2cPort->endTransmission(); 2276 | #endif 2277 | return 0; 2278 | } 2279 | -------------------------------------------------------------------------------- /src/axp20x.h: -------------------------------------------------------------------------------- 1 | ///////////////////////////////////////////////////////////////// 2 | /* 3 | 4 | __ _______ ___ ___ ___ 5 | /\ \ \ / / __ \__ \ / _ \__ \ 6 | / \ \ V /| |__) | ) | | | | ) | 7 | / /\ \ > < | ___/ / /| | | |/ / 8 | / ____ \ / . \| | / /_| |_| / /_ 9 | /_/ \_\/_/ \_\_| |____|\___/____| 10 | 11 | 12 | 13 | MIT License 14 | 15 | Copyright (c) 2019 lewis he 16 | 17 | Permission is hereby granted, free of charge, to any person obtaining a copy 18 | of this software and associated documentation files (the "Software"), to deal 19 | in the Software without restriction, including without limitation the rights 20 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 21 | copies of the Software, and to permit persons to whom the Software is 22 | furnished to do so, subject to the following conditions: 23 | 24 | The above copyright notice and this permission notice shall be included in all 25 | copies or substantial portions of the Software. 26 | 27 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 28 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 29 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 30 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 31 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 32 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 33 | SOFTWARE. 34 | 35 | axp20x.h - Arduino library for X-Power AXP202 chip. 36 | Created by Lewis he on April 1, 2019. 37 | github:https://github.com/lewisxhe/AXP202X_Libraries 38 | */ 39 | ///////////////////////////////////////////////////////////////// 40 | #pragma once 41 | 42 | #ifdef ARDUINO 43 | #include 44 | #include 45 | #else 46 | #include 47 | #include 48 | #endif 49 | 50 | // #define AXP_DEBUG_PORT Serial 51 | #ifdef AXP_DEBUG_PORT 52 | #ifdef ARDUINO 53 | #define AXP_DEBUG(fmt, ...) AXP_DEBUG_PORT.printf_P((PGM_P)PSTR(fmt), ##__VA_ARGS__) 54 | #else 55 | #define AXP_DEBUG(...) printf(__VA_ARGS__) 56 | #endif 57 | 58 | #else 59 | #define AXP_DEBUG(...) 60 | #endif 61 | 62 | #ifndef RISING 63 | #define RISING 0x01 64 | #endif 65 | 66 | #ifndef FALLING 67 | #define FALLING 0x02 68 | #endif 69 | 70 | #ifdef _BV 71 | #undef _BV 72 | #endif 73 | #define _BV(b) (1ULL << (b)) 74 | 75 | //! Error Code 76 | #define AXP_PASS (0) 77 | #define AXP_FAIL (-1) 78 | #define AXP_INVALID (-2) 79 | #define AXP_NOT_INIT (-3) 80 | #define AXP_NOT_SUPPORT (-4) 81 | #define AXP_ARG_INVALID (-5) 82 | 83 | //! Chip Address 84 | #define AXP202_SLAVE_ADDRESS (0x35U) 85 | #define AXP192_SLAVE_ADDRESS (0x34U) 86 | #define AXP173_SLAVE_ADDRESS (0x34U) 87 | 88 | //! Chip ID 89 | #define AXP202_CHIP_ID (0x41) 90 | #define AXP192_CHIP_ID (0x03) 91 | #define AXP173_CHIP_ID (0xAD) //!Axp173 does not have a chip ID, given a custom ID 92 | 93 | //! Logic states 94 | #define AXP202_ON (1) 95 | #define AXP202_OFF (0) 96 | 97 | //! REG MAP 98 | #define AXP202_STATUS (0x00) 99 | #define AXP202_MODE_CHGSTATUS (0x01) 100 | #define AXP202_OTG_STATUS (0x02) 101 | #define AXP202_IC_TYPE (0x03) 102 | #define AXP202_DATA_BUFFER1 (0x04) 103 | #define AXP202_DATA_BUFFER2 (0x05) 104 | #define AXP202_DATA_BUFFER3 (0x06) 105 | #define AXP202_DATA_BUFFER4 (0x07) 106 | #define AXP202_DATA_BUFFER5 (0x08) 107 | #define AXP202_DATA_BUFFER6 (0x09) 108 | #define AXP202_DATA_BUFFER7 (0x0A) 109 | #define AXP202_DATA_BUFFER8 (0x0B) 110 | #define AXP202_DATA_BUFFER9 (0x0C) 111 | #define AXP202_DATA_BUFFERA (0x0D) 112 | #define AXP202_DATA_BUFFERB (0x0E) 113 | #define AXP202_DATA_BUFFERC (0x0F) 114 | #define AXP202_LDO234_DC23_CTL (0x12) 115 | #define AXP202_DC2OUT_VOL (0x23) 116 | #define AXP202_LDO3_DC2_DVM (0x25) 117 | #define AXP202_DC3OUT_VOL (0x27) 118 | #define AXP202_LDO24OUT_VOL (0x28) 119 | #define AXP202_LDO3OUT_VOL (0x29) 120 | #define AXP202_IPS_SET (0x30) 121 | #define AXP202_VOFF_SET (0x31) 122 | #define AXP202_OFF_CTL (0x32) 123 | #define AXP202_CHARGE1 (0x33) 124 | #define AXP202_CHARGE2 (0x34) 125 | #define AXP202_BACKUP_CHG (0x35) 126 | #define AXP202_POK_SET (0x36) 127 | #define AXP202_DCDC_FREQSET (0x37) 128 | #define AXP202_VLTF_CHGSET (0x38) 129 | #define AXP202_VHTF_CHGSET (0x39) 130 | #define AXP202_APS_WARNING1 (0x3A) 131 | #define AXP202_APS_WARNING2 (0x3B) 132 | #define AXP202_TLTF_DISCHGSET (0x3C) 133 | #define AXP202_THTF_DISCHGSET (0x3D) 134 | #define AXP202_DCDC_MODESET (0x80) 135 | #define AXP202_ADC_EN1 (0x82) 136 | #define AXP202_ADC_EN2 (0x83) 137 | #define AXP202_ADC_SPEED (0x84) 138 | #define AXP202_ADC_INPUTRANGE (0x85) 139 | #define AXP202_ADC_IRQ_RETFSET (0x86) 140 | #define AXP202_ADC_IRQ_FETFSET (0x87) 141 | #define AXP202_TIMER_CTL (0x8A) 142 | #define AXP202_VBUS_DET_SRP (0x8B) 143 | #define AXP202_HOTOVER_CTL (0x8F) 144 | #define AXP202_GPIO0_CTL (0x90) 145 | #define AXP202_GPIO0_VOL (0x91) 146 | #define AXP202_GPIO1_CTL (0x92) 147 | #define AXP202_GPIO2_CTL (0x93) 148 | #define AXP202_GPIO012_SIGNAL (0x94) 149 | #define AXP202_GPIO3_CTL (0x95) 150 | #define AXP202_INTEN1 (0x40) 151 | #define AXP202_INTEN2 (0x41) 152 | #define AXP202_INTEN3 (0x42) 153 | #define AXP202_INTEN4 (0x43) 154 | #define AXP202_INTEN5 (0x44) 155 | #define AXP202_INTSTS1 (0x48) 156 | #define AXP202_INTSTS2 (0x49) 157 | #define AXP202_INTSTS3 (0x4A) 158 | #define AXP202_INTSTS4 (0x4B) 159 | #define AXP202_INTSTS5 (0x4C) 160 | 161 | //Irq control register 162 | #define AXP192_INTEN1 (0x40) 163 | #define AXP192_INTEN2 (0x41) 164 | #define AXP192_INTEN3 (0x42) 165 | #define AXP192_INTEN4 (0x43) 166 | #define AXP192_INTEN5 (0x4A) 167 | //Irq status register 168 | #define AXP192_INTSTS1 (0x44) 169 | #define AXP192_INTSTS2 (0x45) 170 | #define AXP192_INTSTS3 (0x46) 171 | #define AXP192_INTSTS4 (0x47) 172 | #define AXP192_INTSTS5 (0x4D) 173 | 174 | #define AXP192_DC1_VLOTAGE (0x26) 175 | #define AXP192_LDO23OUT_VOL (0x28) 176 | #define AXP192_GPIO0_CTL (0x90) 177 | #define AXP192_GPIO0_VOL (0x91) 178 | #define AXP192_GPIO1_CTL (0X92) 179 | #define AXP192_GPIO2_CTL (0x93) 180 | #define AXP192_GPIO012_SIGNAL (0x94) 181 | #define AXP192_GPIO34_CTL (0x95) 182 | 183 | 184 | 185 | /* axp 192/202 adc data register */ 186 | #define AXP202_BAT_AVERVOL_H8 (0x78) 187 | #define AXP202_BAT_AVERVOL_L4 (0x79) 188 | #define AXP202_BAT_AVERCHGCUR_H8 (0x7A) 189 | #define AXP202_BAT_AVERCHGCUR_L4 (0x7B) 190 | #define AXP202_BAT_AVERCHGCUR_L5 (0x7B) 191 | #define AXP202_ACIN_VOL_H8 (0x56) 192 | #define AXP202_ACIN_VOL_L4 (0x57) 193 | #define AXP202_ACIN_CUR_H8 (0x58) 194 | #define AXP202_ACIN_CUR_L4 (0x59) 195 | #define AXP202_VBUS_VOL_H8 (0x5A) 196 | #define AXP202_VBUS_VOL_L4 (0x5B) 197 | #define AXP202_VBUS_CUR_H8 (0x5C) 198 | #define AXP202_VBUS_CUR_L4 (0x5D) 199 | #define AXP202_INTERNAL_TEMP_H8 (0x5E) 200 | #define AXP202_INTERNAL_TEMP_L4 (0x5F) 201 | #define AXP202_TS_IN_H8 (0x62) 202 | #define AXP202_TS_IN_L4 (0x63) 203 | #define AXP202_GPIO0_VOL_ADC_H8 (0x64) 204 | #define AXP202_GPIO0_VOL_ADC_L4 (0x65) 205 | #define AXP202_GPIO1_VOL_ADC_H8 (0x66) 206 | #define AXP202_GPIO1_VOL_ADC_L4 (0x67) 207 | 208 | #define AXP202_BAT_AVERDISCHGCUR_H8 (0x7C) 209 | #define AXP202_BAT_AVERDISCHGCUR_L5 (0x7D) 210 | #define AXP202_APS_AVERVOL_H8 (0x7E) 211 | #define AXP202_APS_AVERVOL_L4 (0x7F) 212 | #define AXP202_INT_BAT_CHGCUR_H8 (0xA0) 213 | #define AXP202_INT_BAT_CHGCUR_L4 (0xA1) 214 | #define AXP202_EXT_BAT_CHGCUR_H8 (0xA2) 215 | #define AXP202_EXT_BAT_CHGCUR_L4 (0xA3) 216 | #define AXP202_INT_BAT_DISCHGCUR_H8 (0xA4) 217 | #define AXP202_INT_BAT_DISCHGCUR_L4 (0xA5) 218 | #define AXP202_EXT_BAT_DISCHGCUR_H8 (0xA6) 219 | #define AXP202_EXT_BAT_DISCHGCUR_L4 (0xA7) 220 | #define AXP202_BAT_CHGCOULOMB3 (0xB0) 221 | #define AXP202_BAT_CHGCOULOMB2 (0xB1) 222 | #define AXP202_BAT_CHGCOULOMB1 (0xB2) 223 | #define AXP202_BAT_CHGCOULOMB0 (0xB3) 224 | #define AXP202_BAT_DISCHGCOULOMB3 (0xB4) 225 | #define AXP202_BAT_DISCHGCOULOMB2 (0xB5) 226 | #define AXP202_BAT_DISCHGCOULOMB1 (0xB6) 227 | #define AXP202_BAT_DISCHGCOULOMB0 (0xB7) 228 | #define AXP202_COULOMB_CTL (0xB8) 229 | #define AXP202_BAT_POWERH8 (0x70) 230 | #define AXP202_BAT_POWERM8 (0x71) 231 | #define AXP202_BAT_POWERL8 (0x72) 232 | 233 | #define AXP202_VREF_TEM_CTRL (0xF3) 234 | #define AXP202_BATT_PERCENTAGE (0xB9) 235 | 236 | /* bit definitions for AXP events, irq event */ 237 | /* AXP202 */ 238 | #define AXP202_IRQ_USBLO (1) 239 | #define AXP202_IRQ_USBRE (2) 240 | #define AXP202_IRQ_USBIN (3) 241 | #define AXP202_IRQ_USBOV (4) 242 | #define AXP202_IRQ_ACRE (5) 243 | #define AXP202_IRQ_ACIN (6) 244 | #define AXP202_IRQ_ACOV (7) 245 | 246 | #define AXP202_IRQ_TEMLO (8) 247 | #define AXP202_IRQ_TEMOV (9) 248 | #define AXP202_IRQ_CHAOV (10) 249 | #define AXP202_IRQ_CHAST (11) 250 | #define AXP202_IRQ_BATATOU (12) 251 | #define AXP202_IRQ_BATATIN (13) 252 | #define AXP202_IRQ_BATRE (14) 253 | #define AXP202_IRQ_BATIN (15) 254 | 255 | #define AXP202_IRQ_POKLO (16) 256 | #define AXP202_IRQ_POKSH (17) 257 | #define AXP202_IRQ_LDO3LO (18) 258 | #define AXP202_IRQ_DCDC3LO (19) 259 | #define AXP202_IRQ_DCDC2LO (20) 260 | #define AXP202_IRQ_CHACURLO (22) 261 | #define AXP202_IRQ_ICTEMOV (23) 262 | 263 | #define AXP202_IRQ_EXTLOWARN2 (24) 264 | #define AXP202_IRQ_EXTLOWARN1 (25) 265 | #define AXP202_IRQ_SESSION_END (26) 266 | #define AXP202_IRQ_SESS_AB_VALID (27) 267 | #define AXP202_IRQ_VBUS_UN_VALID (28) 268 | #define AXP202_IRQ_VBUS_VALID (29) 269 | #define AXP202_IRQ_PDOWN_BY_NOE (30) 270 | #define AXP202_IRQ_PUP_BY_NOE (31) 271 | 272 | #define AXP202_IRQ_GPIO0TG (32) 273 | #define AXP202_IRQ_GPIO1TG (33) 274 | #define AXP202_IRQ_GPIO2TG (34) 275 | #define AXP202_IRQ_GPIO3TG (35) 276 | #define AXP202_IRQ_PEKFE (37) 277 | #define AXP202_IRQ_PEKRE (38) 278 | #define AXP202_IRQ_TIMER (39) 279 | 280 | //Signal Capture 281 | #define AXP202_BATT_VOLTAGE_STEP (1.1F) 282 | #define AXP202_BATT_DISCHARGE_CUR_STEP (0.5F) 283 | #define AXP202_BATT_CHARGE_CUR_STEP (0.5F) 284 | #define AXP202_ACIN_VOLTAGE_STEP (1.7F) 285 | #define AXP202_ACIN_CUR_STEP (0.625F) 286 | #define AXP202_VBUS_VOLTAGE_STEP (1.7F) 287 | #define AXP202_VBUS_CUR_STEP (0.375F) 288 | #define AXP202_INTERNAL_TEMP_STEP (0.1F) 289 | #define AXP202_APS_VOLTAGE_STEP (1.4F) 290 | #define AXP202_TS_PIN_OUT_STEP (0.8F) 291 | #define AXP202_GPIO0_STEP (0.5F) 292 | #define AXP202_GPIO1_STEP (0.5F) 293 | // AXP192 only 294 | #define AXP202_GPIO2_STEP (0.5F) 295 | #define AXP202_GPIO3_STEP (0.5F) 296 | 297 | // AXP173 298 | #define AXP173_EXTEN_DC2_CTL (0x10) 299 | #define AXP173_CTL_DC2_BIT (0) 300 | #define AXP173_CTL_EXTEN_BIT (2) 301 | #define AXP173_DC1_VLOTAGE (0x26) 302 | #define AXP173_LDO4_VLOTAGE (0x27) 303 | 304 | #define FORCED_OPEN_DCDC3(x) (x |= (AXP202_ON << AXP202_DCDC3)) 305 | #define IS_OPEN(reg, channel) (bool)(reg & _BV(channel)) 306 | 307 | 308 | #define AXP202_VOFF_MASK (0x07) 309 | #define AXP202_LIMIT_MASK (0x03) 310 | #define AXP192_LIMIT_MASK (0x01) 311 | #define AXP192_LIMIT_EN_MASK (0x02) 312 | 313 | enum { 314 | AXP202_EXTEN = 0, 315 | AXP202_DCDC3 = 1, 316 | AXP202_LDO2 = 2, 317 | AXP202_LDO4 = 3, 318 | AXP202_DCDC2 = 4, 319 | AXP202_LDO3 = 6, 320 | AXP202_OUTPUT_MAX, 321 | }; 322 | 323 | enum { 324 | AXP192_DCDC1 = 0, 325 | AXP192_DCDC3 = 1, 326 | AXP192_LDO2 = 2, 327 | AXP192_LDO3 = 3, 328 | AXP192_DCDC2 = 4, 329 | AXP192_EXTEN = 6, 330 | AXP192_OUTPUT_MAX, 331 | }; 332 | 333 | enum { 334 | AXP173_DCDC1 = 0, 335 | AXP173_LDO4 = 1, 336 | AXP173_LDO2 = 2, 337 | AXP173_LDO3 = 3, 338 | AXP173_DCDC2 = 4, 339 | AXP173_EXTEN = 6, 340 | AXP173_OUTPUT_MAX, 341 | }; 342 | 343 | typedef enum { 344 | AXP202_STARTUP_TIME_128MS, 345 | AXP202_STARTUP_TIME_3S, 346 | AXP202_STARTUP_TIME_1S, 347 | AXP202_STARTUP_TIME_2S, 348 | } axp202_startup_time_t; 349 | 350 | typedef enum { 351 | AXP192_STARTUP_TIME_128MS, 352 | AXP192_STARTUP_TIME_512MS, 353 | AXP192_STARTUP_TIME_1S, 354 | AXP192_STARTUP_TIME_2S, 355 | } axp192_startup_time_t; 356 | 357 | typedef enum { 358 | AXP_LONGPRESS_TIME_1S, 359 | AXP_LONGPRESS_TIME_1S5, 360 | AXP_LONGPRESS_TIME_2S, 361 | AXP_LONGPRESS_TIME_2S5, 362 | } axp_longPress_time_t; 363 | 364 | typedef enum { 365 | AXP_POWER_OFF_TIME_4S, 366 | AXP_POWER_OFF_TIME_6S, 367 | AXP_POWER_OFF_TIME_8S, 368 | AXP_POWER_OFF_TIME_10S, 369 | } axp_poweroff_time_t; 370 | 371 | //REG 33H: Charging control 1 Charging target-voltage setting 372 | typedef enum { 373 | AXP202_TARGET_VOL_4_1V, 374 | AXP202_TARGET_VOL_4_15V, 375 | AXP202_TARGET_VOL_4_2V, 376 | AXP202_TARGET_VOL_4_36V 377 | } axp_chargeing_vol_t; 378 | 379 | //REG 82H: ADC Enable 1 register Parameter 380 | typedef enum { 381 | AXP202_BATT_VOL_ADC1 = _BV(7), 382 | AXP202_BATT_CUR_ADC1 = _BV(6), 383 | AXP202_ACIN_VOL_ADC1 = _BV(5), 384 | AXP202_ACIN_CUR_ADC1 = _BV(4), 385 | AXP202_VBUS_VOL_ADC1 = _BV(3), 386 | AXP202_VBUS_CUR_ADC1 = _BV(2), 387 | AXP202_APS_VOL_ADC1 = _BV(1), 388 | AXP202_TS_PIN_ADC1 = _BV(0) 389 | } axp_adc1_func_t; 390 | 391 | // REG 83H: ADC Enable 2 register Parameter 392 | typedef enum { 393 | AXP202_TEMP_MONITORING_ADC2 = _BV(7), 394 | AXP202_GPIO1_FUNC_ADC2 = _BV(3), 395 | AXP202_GPIO0_FUNC_ADC2 = _BV(2) 396 | } axp_adc2_func_t; 397 | 398 | typedef enum { 399 | AXP202_LDO3_MODE_LDO, 400 | AXP202_LDO3_MODE_DCIN 401 | } axp202_ldo3_mode_t; 402 | 403 | typedef enum { 404 | //! IRQ1 REG 40H 405 | AXP202_VBUS_VHOLD_LOW_IRQ = _BV(1), //VBUS is available, but lower than V HOLD, IRQ enable 406 | AXP202_VBUS_REMOVED_IRQ = _BV(2), //VBUS removed, IRQ enable 407 | AXP202_VBUS_CONNECT_IRQ = _BV(3), //VBUS connected, IRQ enable 408 | AXP202_VBUS_OVER_VOL_IRQ = _BV(4), //VBUS over-voltage, IRQ enable 409 | AXP202_ACIN_REMOVED_IRQ = _BV(5), //ACIN removed, IRQ enable 410 | AXP202_ACIN_CONNECT_IRQ = _BV(6), //ACIN connected, IRQ enable 411 | AXP202_ACIN_OVER_VOL_IRQ = _BV(7), //ACIN over-voltage, IRQ enable 412 | 413 | //! IRQ2 REG 41H 414 | AXP202_BATT_LOW_TEMP_IRQ = _BV(8), //Battery low-temperature, IRQ enable 415 | AXP202_BATT_OVER_TEMP_IRQ = _BV(9), //Battery over-temperature, IRQ enable 416 | AXP202_CHARGING_FINISHED_IRQ = _BV(10), //Charge finished, IRQ enable 417 | AXP202_CHARGING_IRQ = _BV(11), //Be charging, IRQ enable 418 | AXP202_BATT_EXIT_ACTIVATE_IRQ = _BV(12), //Exit battery activate mode, IRQ enable 419 | AXP202_BATT_ACTIVATE_IRQ = _BV(13), //Battery activate mode, IRQ enable 420 | AXP202_BATT_REMOVED_IRQ = _BV(14), //Battery removed, IRQ enable 421 | AXP202_BATT_CONNECT_IRQ = _BV(15), //Battery connected, IRQ enable 422 | 423 | //! IRQ3 REG 42H 424 | AXP202_PEK_LONGPRESS_IRQ = _BV(16), //PEK long press, IRQ enable 425 | AXP202_PEK_SHORTPRESS_IRQ = _BV(17), //PEK short press, IRQ enable 426 | AXP202_LDO3_LOW_VOL_IRQ = _BV(18), //LDO3output voltage is lower than the set value, IRQ enable 427 | AXP202_DC3_LOW_VOL_IRQ = _BV(19), //DC-DC3output voltage is lower than the set value, IRQ enable 428 | AXP202_DC2_LOW_VOL_IRQ = _BV(20), //DC-DC2 output voltage is lower than the set value, IRQ enable 429 | //**Reserved and unchangeable BIT 5 430 | AXP202_CHARGE_LOW_CUR_IRQ = _BV(22), //Charge current is lower than the set current, IRQ enable 431 | AXP202_CHIP_TEMP_HIGH_IRQ = _BV(23), //AXP202 internal over-temperature, IRQ enable 432 | 433 | //! IRQ4 REG 43H 434 | AXP202_APS_LOW_VOL_LEVEL2_IRQ = _BV(24), //APS low-voltage, IRQ enable（LEVEL2） 435 | APX202_APS_LOW_VOL_LEVEL1_IRQ = _BV(25), //APS low-voltage, IRQ enable（LEVEL1） 436 | AXP202_VBUS_SESSION_END_IRQ = _BV(26), //VBUS Session End IRQ enable 437 | AXP202_VBUS_SESSION_AB_IRQ = _BV(27), //VBUS Session A/B IRQ enable 438 | AXP202_VBUS_INVALID_IRQ = _BV(28), //VBUS invalid, IRQ enable 439 | AXP202_VBUS_VAILD_IRQ = _BV(29), //VBUS valid, IRQ enable 440 | AXP202_NOE_OFF_IRQ = _BV(30), //N_OE shutdown, IRQ enable 441 | AXP202_NOE_ON_IRQ = _BV(31), //N_OE startup, IRQ enable 442 | 443 | //! IRQ5 REG 44H 444 | AXP202_GPIO0_EDGE_TRIGGER_IRQ = _BV(32), //GPIO0 input edge trigger, IRQ enable 445 | AXP202_GPIO1_EDGE_TRIGGER_IRQ = _BV(33), //GPIO1input edge trigger or ADC input, IRQ enable 446 | AXP202_GPIO2_EDGE_TRIGGER_IRQ = _BV(34), //GPIO2input edge trigger, IRQ enable 447 | AXP202_GPIO3_EDGE_TRIGGER_IRQ = _BV(35), //GPIO3 input edge trigger, IRQ enable 448 | //**Reserved and unchangeable BIT 4 449 | AXP202_PEK_FALLING_EDGE_IRQ = _BV(37), //PEK press falling edge, IRQ enable 450 | AXP202_PEK_RISING_EDGE_IRQ = _BV(38), //PEK press rising edge, IRQ enable 451 | AXP202_TIMER_TIMEOUT_IRQ = _BV(39), //Timer timeout, IRQ enable 452 | 453 | AXP202_ALL_IRQ = (0xFFFFFFFFFFULL) 454 | } axp_irq_t; 455 | 456 | typedef enum { 457 | AXP202_LDO4_1250MV, 458 | AXP202_LDO4_1300MV, 459 | AXP202_LDO4_1400MV, 460 | AXP202_LDO4_1500MV, 461 | AXP202_LDO4_1600MV, 462 | AXP202_LDO4_1700MV, 463 | AXP202_LDO4_1800MV, 464 | AXP202_LDO4_1900MV, 465 | AXP202_LDO4_2000MV, 466 | AXP202_LDO4_2500MV, 467 | AXP202_LDO4_2700MV, 468 | AXP202_LDO4_2800MV, 469 | AXP202_LDO4_3000MV, 470 | AXP202_LDO4_3100MV, 471 | AXP202_LDO4_3200MV, 472 | AXP202_LDO4_3300MV, 473 | AXP202_LDO4_MAX, 474 | } axp_ldo4_table_t; 475 | 476 | typedef enum { 477 | AXP202_LDO5_1800MV, 478 | AXP202_LDO5_2500MV, 479 | AXP202_LDO5_2800MV, 480 | AXP202_LDO5_3000MV, 481 | AXP202_LDO5_3100MV, 482 | AXP202_LDO5_3300MV, 483 | AXP202_LDO5_3400MV, 484 | AXP202_LDO5_3500MV, 485 | } axp_ldo5_table_t; 486 | 487 | typedef enum { 488 | AXP20X_LED_OFF, 489 | AXP20X_LED_BLINK_1HZ, 490 | AXP20X_LED_BLINK_4HZ, 491 | AXP20X_LED_LOW_LEVEL, 492 | } axp_chgled_mode_t; 493 | 494 | typedef enum { 495 | AXP_ADC_SAMPLING_RATE_25HZ = 0, 496 | AXP_ADC_SAMPLING_RATE_50HZ = 1, 497 | AXP_ADC_SAMPLING_RATE_100HZ = 2, 498 | AXP_ADC_SAMPLING_RATE_200HZ = 3, 499 | } axp_adc_sampling_rate_t; 500 | 501 | typedef enum { 502 | AXP_TS_PIN_CURRENT_20UA = 0, 503 | AXP_TS_PIN_CURRENT_40UA = 1, 504 | AXP_TS_PIN_CURRENT_60UA = 2, 505 | AXP_TS_PIN_CURRENT_80UA = 3, 506 | } axp_ts_pin_current_t; 507 | 508 | typedef enum { 509 | AXP_TS_PIN_FUNCTION_BATT = 0, 510 | AXP_TS_PIN_FUNCTION_ADC = 1, 511 | } axp_ts_pin_function_t; 512 | 513 | typedef enum { 514 | AXP_TS_PIN_MODE_DISABLE = 0, 515 | AXP_TS_PIN_MODE_CHARGING = 1, 516 | AXP_TS_PIN_MODE_SAMPLING = 2, 517 | AXP_TS_PIN_MODE_ENABLE = 3, 518 | } axp_ts_pin_mode_t; 519 | 520 | //! Only AXP192 and AXP202 have gpio function 521 | typedef enum { 522 | AXP_GPIO_0, 523 | AXP_GPIO_1, 524 | AXP_GPIO_2, 525 | AXP_GPIO_3, 526 | AXP_GPIO_4, 527 | } axp_gpio_t; 528 | 529 | typedef enum { 530 | AXP_IO_OUTPUT_LOW_MODE, 531 | AXP_IO_OUTPUT_HIGH_MODE, 532 | AXP_IO_INPUT_MODE, 533 | AXP_IO_LDO_MODE, 534 | AXP_IO_ADC_MODE, 535 | AXP_IO_FLOATING_MODE, 536 | AXP_IO_OPEN_DRAIN_OUTPUT_MODE, 537 | AXP_IO_PWM_OUTPUT_MODE, 538 | AXP_IO_EXTERN_CHARGING_CTRL_MODE, 539 | } axp_gpio_mode_t; 540 | 541 | typedef enum { 542 | AXP_IRQ_NONE, 543 | AXP_IRQ_RISING, 544 | AXP_IRQ_FALLING, 545 | AXP_IRQ_DOUBLE_EDGE, 546 | } axp_gpio_irq_t; 547 | 548 | 549 | typedef enum { 550 | AXP192_GPIO_1V8, 551 | AXP192_GPIO_1V9, 552 | AXP192_GPIO_2V0, 553 | AXP192_GPIO_2V1, 554 | AXP192_GPIO_2V2, 555 | AXP192_GPIO_2V3, 556 | AXP192_GPIO_2V4, 557 | AXP192_GPIO_2V5, 558 | AXP192_GPIO_2V6, 559 | AXP192_GPIO_2V7, 560 | AXP192_GPIO_2V8, 561 | AXP192_GPIO_2V9, 562 | AXP192_GPIO_3V0, 563 | AXP192_GPIO_3V1, 564 | AXP192_GPIO_3V2, 565 | AXP192_GPIO_3V3, 566 | } axp192_gpio_voltage_t; 567 | 568 | typedef enum { 569 | AXP1XX_CHARGE_CUR_100MA, 570 | AXP1XX_CHARGE_CUR_190MA, 571 | AXP1XX_CHARGE_CUR_280MA, 572 | AXP1XX_CHARGE_CUR_360MA, 573 | AXP1XX_CHARGE_CUR_450MA, 574 | AXP1XX_CHARGE_CUR_550MA, 575 | AXP1XX_CHARGE_CUR_630MA, 576 | AXP1XX_CHARGE_CUR_700MA, 577 | AXP1XX_CHARGE_CUR_780MA, 578 | AXP1XX_CHARGE_CUR_880MA, 579 | AXP1XX_CHARGE_CUR_960MA, 580 | AXP1XX_CHARGE_CUR_1000MA, 581 | AXP1XX_CHARGE_CUR_1080MA, 582 | AXP1XX_CHARGE_CUR_1160MA, 583 | AXP1XX_CHARGE_CUR_1240MA, 584 | AXP1XX_CHARGE_CUR_1320MA, 585 | } axp1xx_charge_current_t; 586 | 587 | 588 | typedef enum { 589 | AXP20X_VBUS_LIMIT_900MA, 590 | AXP20X_VBUS_LIMIT_500MA, 591 | AXP20X_VBUS_LIMIT_100MA, 592 | AXP20X_VBUS_LIMIT_OFF 593 | } axp202_limit_setting_t; 594 | 595 | 596 | typedef enum { 597 | AXP192_VBUS_LIMIT_500MA, 598 | AXP192_VBUS_LIMIT_100MA, 599 | AXP192_VBUS_LIMIT_OFF 600 | } axp192_limit_setting_t; 601 | 602 | 603 | typedef enum { 604 | AXP202_DCDC_AUTO_MODE, 605 | AXP202_DCDC_PWM_MODE 606 | } axp202_dc_mode_t; 607 | 608 | /** 609 | * @brief Voltage rise slope control 610 | */ 611 | typedef enum { 612 | AXP202_VRC_LEVEL0, // 25mV/15.625us=1.6mV/us 613 | AXP202_VRC_LEVEL1, //25mV/31.250us=0.8mV/us 614 | } axp202_vrc_control_t; 615 | 616 | typedef enum { 617 | AXP202_BACKUP_VOLTAGE_3V1, 618 | AXP202_BACKUP_VOLTAGE_3V0, 619 | AXP202_BACKUP_VOLTAGE_3V6, 620 | AXP202_BACKUP_VOLTAGE_2V5, 621 | } axp202_backup_voltage_t; 622 | 623 | typedef enum { 624 | AXP202_BACKUP_CURRENT_50UA, 625 | AXP202_BACKUP_CURRENT_100UA, 626 | AXP202_BACKUP_CURRENT_200UA, 627 | AXP202_BACKUP_CURRENT_400UA, 628 | } axp202_backup_current_t; 629 | 630 | typedef enum { 631 | AXP202_PRECHARGE_MINUTES_40, 632 | AXP202_PRECHARGE_MINUTES_50, 633 | AXP202_PRECHARGE_MINUTES_60, 634 | AXP202_PRECHARGE_MINUTES_70, 635 | } axp202_precharge_timeout_t; 636 | 637 | typedef enum { 638 | AXP202_CONSTANT_CUR_TIMEOUT_HOURS_6, 639 | AXP202_CONSTANT_CUR_TIMEOUT_HOURS_8, 640 | AXP202_CONSTANT_CUR_TIMEOUT_HOURS_10, 641 | AXP202_CONSTANT_CUR_TIMEOUT_HOURS_12, 642 | } axp202_constant_current_t; 643 | 644 | typedef int (*axp_com_fptr_t)(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint8_t len); 645 | 646 | class AXP20X_Class 647 | { 648 | public: 649 | 650 | #ifdef ARDUINO 651 | int begin(TwoWire &port = Wire, uint8_t addr = AXP202_SLAVE_ADDRESS, bool isAxp173 = false); 652 | #endif 653 | 654 | int begin(axp_com_fptr_t read_cb, axp_com_fptr_t write_cb, uint8_t addr = AXP202_SLAVE_ADDRESS, bool isAxp173 = false); 655 | 656 | // Power Output Control 657 | int setPowerOutPut(uint8_t channel, bool en); 658 | 659 | 660 | uint16_t getDCDC1Voltage(void); //! Only AXP192 support and AXP173 661 | uint16_t getDCDC2Voltage(void); 662 | uint16_t getDCDC3Voltage(void); 663 | uint16_t getLDO2Voltage(void); 664 | uint16_t getLDO3Voltage(void); 665 | uint16_t getLDO4Voltage(void); //! Only axp173/axp202 support 666 | 667 | int setDCDC1Voltage(uint16_t mv); //! Only AXP192 support and AXP173 668 | int setDCDC2Voltage(uint16_t mv); 669 | int setDCDC3Voltage(uint16_t mv); 670 | int setLDO2Voltage(uint16_t mv); 671 | int setLDO3Voltage(uint16_t mv); 672 | int setLDO4Voltage(uint16_t mv); //! Only axp173 support 673 | int setLDO4Voltage(axp_ldo4_table_t param); //! Only axp202 support 674 | int setLDO5Voltage(axp_ldo5_table_t vol); 675 | 676 | int setLDO3Mode(axp202_ldo3_mode_t mode); //! Only AXP202 support 677 | 678 | 679 | bool isDCDC1Enable(void); //Only axp192 chip 680 | bool isDCDC2Enable(void); 681 | bool isDCDC3Enable(void); 682 | 683 | bool isLDO2Enable(void); 684 | bool isLDO3Enable(void); 685 | bool isLDO4Enable(void); 686 | 687 | bool isChargingEnable(void); 688 | 689 | bool isChargeingEnable(void) __attribute__((deprecated)); 690 | bool isBatteryConnect(void); 691 | bool isCharging(void); 692 | bool isChargeing(void) __attribute__((deprecated)); 693 | bool isVBUSPlug(void); 694 | bool isExtenEnable(void); 695 | 696 | 697 | // ACIN overvoltage IRQ 698 | bool isAcinOverVoltageIRQ(void); 699 | // ACIN access IRQ 700 | bool isAcinPlugInIRQ(void); 701 | // ACIN out of IRQ 702 | bool isAcinRemoveIRQ(void); 703 | // VBUS overvoltage IRQ 704 | bool isVbusOverVoltageIRQ(void); 705 | // VBUS access IRQ 706 | bool isVbusPlugInIRQ(void); 707 | // VBUS shifted out of IRQ 708 | bool isVbusRemoveIRQ(void); 709 | // VBUS is available but less than V HOLD IRQ 710 | bool isVbusLowVHOLDIRQ(void); 711 | 712 | // Battery access IRQ 713 | bool isBattPlugInIRQ(void); 714 | // Battery removed IRQ 715 | bool isBattRemoveIRQ(void); 716 | // Battery activation mode IRQ 717 | bool isBattEnterActivateIRQ(void); 718 | // Exit battery activation mode IRQ 719 | bool isBattExitActivateIRQ(void); 720 | // Charging IRQ 721 | bool isChargingIRQ(void); 722 | // Charge complete IRQ 723 | bool isChargingDoneIRQ(void); 724 | // Battery over temperature IRQ 725 | bool isBattTempLowIRQ(void); 726 | // Battery temperature is too low IRQ 727 | bool isBattTempHighIRQ(void); 728 | 729 | // IC internal overheating IRQ 730 | bool isChipOvertemperatureIRQ(void); 731 | // The charging current is less than the set current IRQ 732 | bool isChargingCurrentLessIRQ(void); 733 | // DC-DC2 output voltage is less than the set value IRQ 734 | bool isDC2VoltageLessIRQ(void); 735 | // DC-DC3 output voltage is less than the set value IRQ 736 | bool isDC3VoltageLessIRQ(void); 737 | // LDO3 output voltage is less than the set value IRQ 738 | bool isLDO3VoltageLessIRQ(void); 739 | // PEK short key IRQ 740 | bool isPEKShortPressIRQ(void); 741 | // PEK long key IRQ 742 | bool isPEKLongtPressIRQ(void); 743 | 744 | // N_OE boot IRQ 745 | bool isNOEPowerOnIRQ(void); 746 | // N_OE shutdown IRQ 747 | bool isNOEPowerDownIRQ(void); 748 | // VBUS valid IRQ 749 | bool isVBUSEffectiveIRQ(void); 750 | // VBUS invalid IRQ 751 | bool isVBUSInvalidIRQ(void); 752 | // VBUS Session IRQ 753 | bool isVUBSSessionIRQ(void); 754 | // VBUS Session End IRQ 755 | bool isVUBSSessionEndIRQ(void); 756 | // APS low voltage IRQ enable (LEVEL1) 757 | bool isLowVoltageLevel1IRQ(void); 758 | // APS low voltage IRQ enable (LEVEL2) 759 | bool isLowVoltageLevel2IRQ(void); 760 | 761 | // Timer expired IRQ 762 | bool isTimerTimeoutIRQ(void); 763 | // PEK key rising edge IRQ 764 | bool isPEKRisingEdgeIRQ(void); 765 | // PEK key falling edge IRQ 766 | bool isPEKFallingEdgeIRQ(void); 767 | // GPIO3 input edge trigger IRQ 768 | bool isGPIO3InputEdgeTriggerIRQ(void); 769 | // GPIO2 input edge trigger IRQ 770 | bool isGPIO2InputEdgeTriggerIRQ(void); 771 | // GPIO1 input edge trigger or ADC input IRQ 772 | bool isGPIO1InputEdgeTriggerIRQ(void); 773 | // GPIO0 input edge trigger IRQ 774 | bool isGPIO0InputEdgeTriggerIRQ(void); 775 | 776 | 777 | //! Group4 ADC data 778 | float getAcinVoltage(void); 779 | float getAcinCurrent(void); 780 | float getVbusVoltage(void); 781 | float getVbusCurrent(void); 782 | float getTemp(void); 783 | float getTSTemp(void); 784 | float getGPIO0Voltage(void); 785 | float getGPIO1Voltage(void); 786 | float getBattInpower(void); 787 | float getBattVoltage(void); 788 | float getBattChargeCurrent(void); 789 | float getBattDischargeCurrent(void); 790 | float getSysIPSOUTVoltage(void); 791 | uint32_t getBattChargeCoulomb(void); 792 | uint32_t getBattDischargeCoulomb(void); 793 | float getSettingChargeCurrent(void); 794 | 795 | int getChargingTargetVoltage(axp_chargeing_vol_t &charging_target_voltage); 796 | int setChargingTargetVoltage(axp_chargeing_vol_t param); 797 | int enableCharging(bool en); 798 | int enableChargeing(bool en) __attribute__((deprecated)); 799 | 800 | 801 | int adc1Enable(uint16_t params, bool en); 802 | int adc2Enable(uint16_t params, bool en); 803 | 804 | int setTScurrent(axp_ts_pin_current_t current); 805 | int setTSfunction(axp_ts_pin_function_t func); 806 | int setTSmode(axp_ts_pin_mode_t mode); 807 | 808 | 809 | int setTimer(uint8_t minutes); 810 | int offTimer(void); 811 | int clearTimerStatus(void); 812 | bool getTimerStatus(void); 813 | /** 814 | * param: axp202_startup_time_t or axp192_startup_time_t 815 | */ 816 | int setStartupTime(uint8_t param); 817 | 818 | /** 819 | * param: axp_loonPress_time_t 820 | */ 821 | int setlongPressTime(uint8_t param); 822 | 823 | /** 824 | * @param param: axp_poweroff_time_t 825 | */ 826 | int setShutdownTime(uint8_t param); 827 | int setTimeOutShutdown(bool en); 828 | 829 | int shutdown(void); 830 | int setSleep(void); 831 | 832 | /** 833 | * params: axp_irq_t 834 | */ 835 | int enableIRQ(uint64_t params, bool en); 836 | int readIRQ(void); 837 | void clearIRQ(void); 838 | 839 | int setChgLEDMode(axp_chgled_mode_t mode); 840 | 841 | //! Only AXP202 support 842 | int getBattPercentage(void); 843 | int setMeteringSystem(bool en); 844 | 845 | int debugCharging(void); 846 | int debugStatus(void); 847 | int limitingOff(void); 848 | 849 | int setAdcSamplingRate(axp_adc_sampling_rate_t rate); 850 | uint8_t getAdcSamplingRate(void); 851 | uint8_t getCoulombRegister(void); 852 | float getCoulombData(void); 853 | int setCoulombRegister(uint8_t val); 854 | int EnableCoulombcounter(void); 855 | int DisableCoulombcounter(void); 856 | int StopCoulombcounter(void); 857 | int ClearCoulombcounter(void); 858 | 859 | int setGPIOMode(axp_gpio_t gpio, axp_gpio_mode_t mode); 860 | int setGPIOIrq(axp_gpio_t gpio, axp_gpio_irq_t irq); 861 | 862 | int gpioWrite(axp_gpio_t gpio, uint8_t val); 863 | int gpioRead(axp_gpio_t gpio); 864 | 865 | // When the chip is axp192 / 173, the allowed values are 0 ~ 15, corresponding to the axp1xx_charge_current_t enumeration 866 | // When the chip is axp202 allows maximum charging current of 1800mA, minimum 300mA 867 | int getChargeControlCur(void); 868 | int setChargeControlCur(uint16_t mA); 869 | 870 | uint16_t getPowerDownVoltage(void); 871 | int setPowerDownVoltage(uint16_t mv); 872 | int setCurrentLimitControl(axp202_limit_setting_t opt); 873 | int setCurrentLimitControl(axp192_limit_setting_t opt); 874 | 875 | int setVWarningLevel1(uint16_t mv); 876 | int setVWarningLevel2(uint16_t mv); 877 | 878 | uint16_t getVWarningLevel1(void); 879 | uint16_t getVWarningLevel2(void); 880 | 881 | int setDCDCMode(axp202_dc_mode_t opt); 882 | axp202_dc_mode_t getDCDCMode(void); 883 | 884 | int enableLDO3VRC(bool en); 885 | int enableDC2VRC(bool en); 886 | int setLDO3VRC(axp202_vrc_control_t opt); 887 | int setDC2VRC(axp202_vrc_control_t opt); 888 | 889 | 890 | //Backup battery charge control 891 | int setBackupChargeControl(bool en); 892 | int setBackupChargeVoltage(axp202_backup_voltage_t opt); 893 | int setBackupChargeCurrent(axp202_backup_current_t opt); 894 | 895 | 896 | // Precharge timeout setting 897 | int setPrechargeTimeout(axp202_precharge_timeout_t opt); 898 | // Set timeout in constant current mode 899 | int setConstantCurrentTimeout(axp202_constant_current_t opt); 900 | 901 | 902 | private: 903 | uint16_t _getRegistH8L5(uint8_t regh8, uint8_t regl5); 904 | uint16_t _getRegistResult(uint8_t regh8, uint8_t regl4); 905 | 906 | int _readByte(uint8_t reg, uint8_t nbytes, uint8_t *data); 907 | int _writeByte(uint8_t reg, uint8_t nbytes, uint8_t *data); 908 | 909 | int _setGpioInterrupt(uint8_t *val, int mode, bool en); 910 | int _axp_probe(void); 911 | int _axp_irq_mask(axp_gpio_irq_t irq); 912 | 913 | int _axp192_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode); 914 | int _axp192_gpio_0_select( axp_gpio_mode_t mode); 915 | int _axp192_gpio_1_select( axp_gpio_mode_t mode); 916 | int _axp192_gpio_3_select( axp_gpio_mode_t mode); 917 | int _axp192_gpio_4_select( axp_gpio_mode_t mode); 918 | 919 | int _axp202_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode); 920 | int _axp202_gpio_0_select( axp_gpio_mode_t mode); 921 | int _axp202_gpio_1_select( axp_gpio_mode_t mode); 922 | int _axp202_gpio_2_select( axp_gpio_mode_t mode); 923 | int _axp202_gpio_3_select( axp_gpio_mode_t mode); 924 | int _axp202_gpio_irq_set(axp_gpio_t gpio, axp_gpio_irq_t irq); 925 | int _axp202_gpio_write(axp_gpio_t gpio, uint8_t val); 926 | int _axp202_gpio_read(axp_gpio_t gpio); 927 | 928 | 929 | static const uint8_t startupParams[], longPressParams[], shutdownParams[], targetVolParams[]; 930 | static uint8_t _outputReg; 931 | uint8_t _address, _irq[5], _chip_id, _gpio[4]; 932 | bool _init = false; 933 | axp_com_fptr_t _read_cb = nullptr; 934 | axp_com_fptr_t _write_cb = nullptr; 935 | #ifdef ARDUINO 936 | TwoWire *_i2cPort; 937 | #endif 938 | bool _isAxp173; 939 | }; 940 | --------------------------------------------------------------------------------