kopia lustrzana https://github.com/russhughes/st7789py_mpy
821 wiersze
24 KiB
Python
821 wiersze
24 KiB
Python
'''
|
|
MIT License
|
|
|
|
Copyright (c) 2019 lewis he
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
|
|
axp20x.py - MicroPython library for X-Power AXP202 chip.
|
|
Created by Lewis he on June 24, 2019.
|
|
github:https://github.com/lewisxhe/AXP202X_Libraries
|
|
|
|
Modified by Russ Hughes on Mar 26, 2021 to use optionally use an initalized I2c
|
|
bus object.
|
|
|
|
'''
|
|
|
|
|
|
import gc
|
|
from machine import Pin, SoftI2C
|
|
import micropython
|
|
from ustruct import unpack
|
|
|
|
|
|
# Chip Address
|
|
AXP202_SLAVE_ADDRESS = 0x35
|
|
AXP192_SLAVE_ADDRESS = 0x34
|
|
|
|
# Chip ID
|
|
AXP202_CHIP_ID = 0x41
|
|
AXP192_CHIP_ID = 0x03
|
|
|
|
default_pin_scl = 22
|
|
default_pin_sda = 21
|
|
default_pin_intr = 35
|
|
default_chip_type = AXP202_CHIP_ID
|
|
|
|
|
|
# REG MAP
|
|
AXP202_STATUS = 0x00
|
|
AXP202_MODE_CHGSTATUS = 0x01
|
|
AXP202_OTG_STATUS = 0x02
|
|
AXP202_IC_TYPE = 0x03
|
|
AXP202_DATA_BUFFER1 = 0x04
|
|
AXP202_DATA_BUFFER2 = 0x05
|
|
AXP202_DATA_BUFFER3 = 0x06
|
|
AXP202_DATA_BUFFER4 = 0x07
|
|
AXP202_DATA_BUFFER5 = 0x08
|
|
AXP202_DATA_BUFFER6 = 0x09
|
|
AXP202_DATA_BUFFER7 = 0x0A
|
|
AXP202_DATA_BUFFER8 = 0x0B
|
|
AXP202_DATA_BUFFER9 = 0x0C
|
|
AXP202_DATA_BUFFERA = 0x0D
|
|
AXP202_DATA_BUFFERB = 0x0E
|
|
AXP202_DATA_BUFFERC = 0x0F
|
|
AXP202_LDO234_DC23_CTL = 0x12
|
|
AXP202_DC2OUT_VOL = 0x23
|
|
AXP202_LDO3_DC2_DVM = 0x25
|
|
AXP202_DC3OUT_VOL = 0x27
|
|
AXP202_LDO24OUT_VOL = 0x28
|
|
AXP202_LDO3OUT_VOL = 0x29
|
|
AXP202_IPS_SET = 0x30
|
|
AXP202_VOFF_SET = 0x31
|
|
AXP202_OFF_CTL = 0x32
|
|
AXP202_CHARGE1 = 0x33
|
|
AXP202_CHARGE2 = 0x34
|
|
AXP202_BACKUP_CHG = 0x35
|
|
AXP202_POK_SET = 0x36
|
|
AXP202_DCDC_FREQSET = 0x37
|
|
AXP202_VLTF_CHGSET = 0x38
|
|
AXP202_VHTF_CHGSET = 0x39
|
|
AXP202_APS_WARNING1 = 0x3A
|
|
AXP202_APS_WARNING2 = 0x3B
|
|
AXP202_TLTF_DISCHGSET = 0x3C
|
|
AXP202_THTF_DISCHGSET = 0x3D
|
|
AXP202_DCDC_MODESET = 0x80
|
|
AXP202_ADC_EN1 = 0x82
|
|
AXP202_ADC_EN2 = 0x83
|
|
AXP202_ADC_SPEED = 0x84
|
|
AXP202_ADC_INPUTRANGE = 0x85
|
|
AXP202_ADC_IRQ_RETFSET = 0x86
|
|
AXP202_ADC_IRQ_FETFSET = 0x87
|
|
AXP202_TIMER_CTL = 0x8A
|
|
AXP202_VBUS_DET_SRP = 0x8B
|
|
AXP202_HOTOVER_CTL = 0x8F
|
|
AXP202_GPIO0_CTL = 0x90
|
|
AXP202_GPIO0_VOL = 0x91
|
|
AXP202_GPIO1_CTL = 0x92
|
|
AXP202_GPIO2_CTL = 0x93
|
|
AXP202_GPIO012_SIGNAL = 0x94
|
|
AXP202_GPIO3_CTL = 0x95
|
|
AXP202_INTEN1 = 0x40
|
|
AXP202_INTEN2 = 0x41
|
|
AXP202_INTEN3 = 0x42
|
|
AXP202_INTEN4 = 0x43
|
|
AXP202_INTEN5 = 0x44
|
|
AXP202_INTSTS1 = 0x48
|
|
AXP202_INTSTS2 = 0x49
|
|
AXP202_INTSTS3 = 0x4A
|
|
AXP202_INTSTS4 = 0x4B
|
|
AXP202_INTSTS5 = 0x4C
|
|
|
|
# Irq control register
|
|
AXP192_INTEN1 = 0x40
|
|
AXP192_INTEN2 = 0x41
|
|
AXP192_INTEN3 = 0x42
|
|
AXP192_INTEN4 = 0x43
|
|
AXP192_INTEN5 = 0x4A
|
|
|
|
# Irq status register
|
|
AXP192_INTSTS1 = 0x44
|
|
AXP192_INTSTS2 = 0x45
|
|
AXP192_INTSTS3 = 0x46
|
|
AXP192_INTSTS4 = 0x47
|
|
AXP192_INTSTS5 = 0x4D
|
|
|
|
AXP192_LDO23OUT_VOL = 0x28
|
|
AXP192_DC1_VLOTAGE = 0x26
|
|
|
|
# axp 20 adc data register
|
|
AXP202_BAT_AVERVOL_H8 = 0x78
|
|
AXP202_BAT_AVERVOL_L4 = 0x79
|
|
AXP202_BAT_AVERCHGCUR_H8 = 0x7A
|
|
AXP202_BAT_AVERCHGCUR_L4 = 0x7B
|
|
AXP202_BAT_VOL_H8 = 0x50
|
|
AXP202_BAT_VOL_L4 = 0x51
|
|
AXP202_ACIN_VOL_H8 = 0x56
|
|
AXP202_ACIN_VOL_L4 = 0x57
|
|
AXP202_ACIN_CUR_H8 = 0x58
|
|
AXP202_ACIN_CUR_L4 = 0x59
|
|
AXP202_VBUS_VOL_H8 = 0x5A
|
|
AXP202_VBUS_VOL_L4 = 0x5B
|
|
AXP202_VBUS_CUR_H8 = 0x5C
|
|
AXP202_VBUS_CUR_L4 = 0x5D
|
|
AXP202_INTERNAL_TEMP_H8 = 0x5E
|
|
AXP202_INTERNAL_TEMP_L4 = 0x5F
|
|
AXP202_TS_IN_H8 = 0x62
|
|
AXP202_TS_IN_L4 = 0x63
|
|
AXP202_GPIO0_VOL_ADC_H8 = 0x64
|
|
AXP202_GPIO0_VOL_ADC_L4 = 0x65
|
|
AXP202_GPIO1_VOL_ADC_H8 = 0x66
|
|
AXP202_GPIO1_VOL_ADC_L4 = 0x67
|
|
|
|
AXP202_BAT_AVERDISCHGCUR_H8 = 0x7C
|
|
AXP202_BAT_AVERDISCHGCUR_L5 = 0x7D
|
|
AXP202_APS_AVERVOL_H8 = 0x7E
|
|
AXP202_APS_AVERVOL_L4 = 0x7F
|
|
AXP202_INT_BAT_CHGCUR_H8 = 0xA0
|
|
AXP202_INT_BAT_CHGCUR_L4 = 0xA1
|
|
AXP202_EXT_BAT_CHGCUR_H8 = 0xA2
|
|
AXP202_EXT_BAT_CHGCUR_L4 = 0xA3
|
|
AXP202_INT_BAT_DISCHGCUR_H8 = 0xA4
|
|
AXP202_INT_BAT_DISCHGCUR_L4 = 0xA5
|
|
AXP202_EXT_BAT_DISCHGCUR_H8 = 0xA6
|
|
AXP202_EXT_BAT_DISCHGCUR_L4 = 0xA7
|
|
AXP202_BAT_CHGCOULOMB3 = 0xB0
|
|
AXP202_BAT_CHGCOULOMB2 = 0xB1
|
|
AXP202_BAT_CHGCOULOMB1 = 0xB2
|
|
AXP202_BAT_CHGCOULOMB0 = 0xB3
|
|
AXP202_BAT_DISCHGCOULOMB3 = 0xB4
|
|
AXP202_BAT_DISCHGCOULOMB2 = 0xB5
|
|
AXP202_BAT_DISCHGCOULOMB1 = 0xB6
|
|
AXP202_BAT_DISCHGCOULOMB0 = 0xB7
|
|
AXP202_COULOMB_CTL = 0xB8
|
|
AXP202_BAT_POWERH8 = 0x70
|
|
AXP202_BAT_POWERM8 = 0x71
|
|
AXP202_BAT_POWERL8 = 0x72
|
|
|
|
AXP202_VREF_TEM_CTRL = 0xF3
|
|
AXP202_BATT_PERCENTAGE = 0xB9
|
|
|
|
|
|
# AXP202 bit definitions for AXP events irq event
|
|
AXP202_IRQ_USBLO = 1
|
|
AXP202_IRQ_USBRE = 2
|
|
AXP202_IRQ_USBIN = 3
|
|
AXP202_IRQ_USBOV = 4
|
|
AXP202_IRQ_ACRE = 5
|
|
AXP202_IRQ_ACIN = 6
|
|
AXP202_IRQ_ACOV = 7
|
|
|
|
AXP202_IRQ_TEMLO = 8
|
|
AXP202_IRQ_TEMOV = 9
|
|
AXP202_IRQ_CHAOV = 10
|
|
AXP202_IRQ_CHAST = 11
|
|
AXP202_IRQ_BATATOU = 12
|
|
AXP202_IRQ_BATATIN = 13
|
|
AXP202_IRQ_BATRE = 14
|
|
AXP202_IRQ_BATIN = 15
|
|
|
|
AXP202_IRQ_POKLO = 16
|
|
AXP202_IRQ_POKSH = 17
|
|
AXP202_IRQ_LDO3LO = 18
|
|
AXP202_IRQ_DCDC3LO = 19
|
|
AXP202_IRQ_DCDC2LO = 20
|
|
AXP202_IRQ_CHACURLO = 22
|
|
AXP202_IRQ_ICTEMOV = 23
|
|
|
|
AXP202_IRQ_EXTLOWARN2 = 24
|
|
AXP202_IRQ_EXTLOWARN1 = 25
|
|
AXP202_IRQ_SESSION_END = 26
|
|
AXP202_IRQ_SESS_AB_VALID = 27
|
|
AXP202_IRQ_VBUS_UN_VALID = 28
|
|
AXP202_IRQ_VBUS_VALID = 29
|
|
AXP202_IRQ_PDOWN_BY_NOE = 30
|
|
AXP202_IRQ_PUP_BY_NOE = 31
|
|
|
|
AXP202_IRQ_GPIO0TG = 32
|
|
AXP202_IRQ_GPIO1TG = 33
|
|
AXP202_IRQ_GPIO2TG = 34
|
|
AXP202_IRQ_GPIO3TG = 35
|
|
AXP202_IRQ_PEKFE = 37
|
|
AXP202_IRQ_PEKRE = 38
|
|
AXP202_IRQ_TIMER = 39
|
|
|
|
|
|
# Signal Capture
|
|
AXP202_BATT_VOLTAGE_STEP = 1.1
|
|
AXP202_BATT_DISCHARGE_CUR_STEP = 0.5
|
|
AXP202_BATT_CHARGE_CUR_STEP = 0.5
|
|
AXP202_ACIN_VOLTAGE_STEP = 1.7
|
|
AXP202_ACIN_CUR_STEP = 0.625
|
|
AXP202_VBUS_VOLTAGE_STEP = 1.7
|
|
AXP202_VBUS_CUR_STEP = 0.375
|
|
AXP202_INTENAL_TEMP_STEP = 0.1
|
|
AXP202_APS_VOLTAGE_STEP = 1.4
|
|
AXP202_TS_PIN_OUT_STEP = 0.8
|
|
AXP202_GPIO0_STEP = 0.5
|
|
AXP202_GPIO1_STEP = 0.5
|
|
|
|
# axp202 power channel
|
|
AXP202_EXTEN = 0
|
|
AXP202_DCDC3 = 1
|
|
AXP202_LDO2 = 2
|
|
AXP202_LDO4 = 3
|
|
AXP202_DCDC2 = 4
|
|
AXP202_LDO3 = 6
|
|
|
|
# axp192 power channel
|
|
AXP192_DCDC1 = 0
|
|
AXP192_DCDC3 = 1
|
|
AXP192_LDO2 = 2
|
|
AXP192_LDO3 = 3
|
|
AXP192_DCDC2 = 4
|
|
AXP192_EXTEN = 6
|
|
|
|
# AXP202 ADC channel
|
|
AXP202_ADC1 = 1
|
|
AXP202_ADC2 = 2
|
|
|
|
|
|
# axp202 adc1 args
|
|
AXP202_BATT_VOL_ADC1 = 7
|
|
AXP202_BATT_CUR_ADC1 = 6
|
|
AXP202_ACIN_VOL_ADC1 = 5
|
|
AXP202_ACIN_CUR_ADC1 = 4
|
|
AXP202_VBUS_VOL_ADC1 = 3
|
|
AXP202_VBUS_CUR_ADC1 = 2
|
|
AXP202_APS_VOL_ADC1 = 1
|
|
AXP202_TS_PIN_ADC1 = 0
|
|
|
|
# axp202 adc2 args
|
|
AXP202_TEMP_MONITORING_ADC2 = 7
|
|
AXP202_GPIO1_FUNC_ADC2 = 3
|
|
AXP202_GPIO0_FUNC_ADC2 = 2
|
|
|
|
|
|
# AXP202 IRQ1
|
|
AXP202_VBUS_VHOLD_LOW_IRQ = 1 << 1
|
|
AXP202_VBUS_REMOVED_IRQ = 1 << 2
|
|
AXP202_VBUS_CONNECT_IRQ = 1 << 3
|
|
AXP202_VBUS_OVER_VOL_IRQ = 1 << 4
|
|
AXP202_ACIN_REMOVED_IRQ = 1 << 5
|
|
AXP202_ACIN_CONNECT_IRQ = 1 << 6
|
|
AXP202_ACIN_OVER_VOL_IRQ = 1 << 7
|
|
|
|
# AXP202 IRQ2
|
|
AXP202_BATT_LOW_TEMP_IRQ = 1 << 8
|
|
AXP202_BATT_OVER_TEMP_IRQ = 1 << 9
|
|
AXP202_CHARGING_FINISHED_IRQ = 1 << 10
|
|
AXP202_CHARGING_IRQ = 1 << 11
|
|
AXP202_BATT_EXIT_ACTIVATE_IRQ = 1 << 12
|
|
AXP202_BATT_ACTIVATE_IRQ = 1 << 13
|
|
AXP202_BATT_REMOVED_IRQ = 1 << 14
|
|
AXP202_BATT_CONNECT_IRQ = 1 << 15
|
|
|
|
# AXP202 IRQ3
|
|
AXP202_PEK_LONGPRESS_IRQ = 1 << 16
|
|
AXP202_PEK_SHORTPRESS_IRQ = 1 << 17
|
|
AXP202_LDO3_LOW_VOL_IRQ = 1 << 18
|
|
AXP202_DC3_LOW_VOL_IRQ = 1 << 19
|
|
AXP202_DC2_LOW_VOL_IRQ = 1 << 20
|
|
AXP202_CHARGE_LOW_CUR_IRQ = 1 << 21
|
|
AXP202_CHIP_TEMP_HIGH_IRQ = 1 << 22
|
|
|
|
# AXP202 IRQ4
|
|
AXP202_APS_LOW_VOL_LEVEL2_IRQ = 1 << 24
|
|
APX202_APS_LOW_VOL_LEVEL1_IRQ = 1 << 25
|
|
AXP202_VBUS_SESSION_END_IRQ = 1 << 26
|
|
AXP202_VBUS_SESSION_AB_IRQ = 1 << 27
|
|
AXP202_VBUS_INVALID_IRQ = 1 << 28
|
|
AXP202_VBUS_VAILD_IRQ = 1 << 29
|
|
AXP202_NOE_OFF_IRQ = 1 << 30
|
|
AXP202_NOE_ON_IRQ = 1 << 31
|
|
AXP202_ALL_IRQ = 0xFFFF
|
|
|
|
# AXP202 LDO3 Mode
|
|
AXP202_LDO3_LDO_MODE = 0
|
|
AXP202_LDO3_DCIN_MODE = 1
|
|
|
|
# AXP202 LDO4 voltage setting args
|
|
AXP202_LDO4_1250MV = 0
|
|
AXP202_LDO4_1300MV = 1
|
|
AXP202_LDO4_1400MV = 2
|
|
AXP202_LDO4_1500MV = 3
|
|
AXP202_LDO4_1600MV = 4
|
|
AXP202_LDO4_1700MV = 5
|
|
AXP202_LDO4_1800MV = 6
|
|
AXP202_LDO4_1900MV = 7
|
|
AXP202_LDO4_2000MV = 8
|
|
AXP202_LDO4_2500MV = 9
|
|
AXP202_LDO4_2700MV = 10
|
|
AXP202_LDO4_2800MV = 11
|
|
AXP202_LDO4_3000MV = 12
|
|
AXP202_LDO4_3100MV = 13
|
|
AXP202_LDO4_3200MV = 14
|
|
AXP202_LDO4_3300MV = 15
|
|
|
|
|
|
# Boot time setting
|
|
AXP202_STARTUP_TIME_128MS = 0
|
|
AXP202_STARTUP_TIME_3S = 1
|
|
AXP202_STARTUP_TIME_1S = 2
|
|
AXP202_STARTUP_TIME_2S = 3
|
|
|
|
|
|
# Long button time setting
|
|
AXP202_LONGPRESS_TIME_1S = 0
|
|
AXP202_LONGPRESS_TIME_1S5 = 1
|
|
AXP202_LONGPRESS_TIME_2S = 2
|
|
AXP202_LONGPRESS_TIME_2S5 = 3
|
|
|
|
|
|
# Shutdown duration setting
|
|
AXP202_SHUTDOWN_TIME_4S = 0
|
|
AXP202_SHUTDOWN_TIME_6S = 1
|
|
AXP202_SHUTDOWN_TIME_8S = 2
|
|
AXP202_SHUTDOWN_TIME_10S = 3
|
|
|
|
|
|
# REG 33H: Charging control 1 Charging target-voltage setting
|
|
AXP202_TARGET_VOL_4_1V = 0
|
|
AXP202_TARGET_VOL_4_15V = 1
|
|
AXP202_TARGET_VOL_4_2V = 2
|
|
AXP202_TARGET_VOL_4_36V = 3
|
|
|
|
# AXP202 LED CONTROL
|
|
AXP20X_LED_OFF = 0
|
|
AXP20X_LED_BLINK_1HZ = 1
|
|
AXP20X_LED_BLINK_4HZ = 2
|
|
AXP20X_LED_LOW_LEVEL = 3
|
|
|
|
|
|
class PMU(object):
|
|
def __init__(self, i2c=None, scl=None, sda=None,
|
|
intr=None, address=None):
|
|
self.device = None
|
|
self.bus = i2c
|
|
if self.bus is None:
|
|
self.scl = scl if scl is not None else default_pin_scl
|
|
self.sda = sda if sda is not None else default_pin_sda
|
|
|
|
self.intr = intr if intr is not None else default_pin_intr
|
|
self.chip = default_chip_type
|
|
self.address = address if address else AXP202_SLAVE_ADDRESS
|
|
|
|
self.buffer = bytearray(16)
|
|
self.bytebuf = memoryview(self.buffer[0:1])
|
|
self.wordbuf = memoryview(self.buffer[0:2])
|
|
self.irqbuf = memoryview(self.buffer[0:5])
|
|
|
|
self.init_pins()
|
|
if self.bus is None:
|
|
self.init_i2c()
|
|
|
|
self.init_device()
|
|
|
|
def init_i2c(self):
|
|
if self.bus is None:
|
|
print('* initializing i2c')
|
|
self.bus = SoftI2C(scl=self.pin_scl, sda=self.pin_sda)
|
|
|
|
def init_pins(self):
|
|
print('* initializing pins')
|
|
if self.bus is None:
|
|
self.pin_sda = Pin(self.sda)
|
|
self.pin_scl = Pin(self.scl)
|
|
self.pin_intr = Pin(self.intr, mode=Pin.IN)
|
|
|
|
def write_byte(self, reg, val):
|
|
self.bytebuf[0] = val
|
|
self.bus.writeto_mem(self.address, reg, self.bytebuf)
|
|
|
|
def read_byte(self, reg):
|
|
self.bus.readfrom_mem_into(self.address, reg, self.bytebuf)
|
|
return self.bytebuf[0]
|
|
|
|
def read_word(self, reg):
|
|
self.bus.readfrom_mem_into(self.address, reg, self.wordbuf)
|
|
return unpack('>H', self.wordbuf)[0]
|
|
|
|
def read_word2(self, reg):
|
|
self.bus.readfrom_mem_into(self.address, reg, self.wordbuf)
|
|
return unpack('>h', self.wordbuf)[0]
|
|
|
|
def init_device(self):
|
|
print('* initializing mpu')
|
|
self.chip = self.read_byte(AXP202_IC_TYPE)
|
|
if(self.chip == AXP202_CHIP_ID):
|
|
self.chip = AXP202_CHIP_ID
|
|
print("* Detect PMU Type is AXP202")
|
|
elif(self.chip == AXP192_CHIP_ID):
|
|
print("* Detect PMU Type is AXP192")
|
|
self.chip = AXP192_CHIP_ID
|
|
else:
|
|
raise Exception("Invalid Chip ID!")
|
|
|
|
def enablePower(self, ch):
|
|
data = self.read_byte(AXP202_LDO234_DC23_CTL)
|
|
data = data | (1 << ch)
|
|
self.write_byte(AXP202_LDO234_DC23_CTL, data)
|
|
|
|
def disablePower(self, ch):
|
|
data = self.read_byte(AXP202_LDO234_DC23_CTL)
|
|
data = data & (~(1 << ch))
|
|
self.write_byte(AXP202_LDO234_DC23_CTL, data)
|
|
|
|
def __BIT_MASK(self, mask):
|
|
return 1 << mask
|
|
|
|
def __get_h8_l5(self, regh8, regl5):
|
|
hv = self.read_byte(regh8)
|
|
lv = self.read_byte(regl5)
|
|
return (hv << 5) | (lv & 0x1F)
|
|
|
|
def __get_h8_l4(self, regh8, regl5):
|
|
hv = self.read_byte(regh8)
|
|
lv = self.read_byte(regl5)
|
|
return (hv << 4) | (lv & 0xF)
|
|
|
|
def isChargeing(self):
|
|
data = self.read_byte(AXP202_MODE_CHGSTATUS)
|
|
return data & self.__BIT_MASK(6)
|
|
|
|
def isBatteryConnect(self):
|
|
data = self.read_byte(AXP202_MODE_CHGSTATUS)
|
|
return data & self.__BIT_MASK(5)
|
|
|
|
def getAcinCurrent(self):
|
|
data = self.__get_h8_l4(AXP202_ACIN_CUR_H8, AXP202_ACIN_CUR_L4)
|
|
return data * AXP202_ACIN_CUR_STEP
|
|
|
|
def getAcinVoltage(self):
|
|
data = self.__get_h8_l4(AXP202_ACIN_VOL_H8, AXP202_ACIN_VOL_L4)
|
|
return data * AXP202_ACIN_VOLTAGE_STEP
|
|
|
|
def getVbusVoltage(self):
|
|
data = self.__get_h8_l4(AXP202_VBUS_VOL_H8, AXP202_VBUS_VOL_L4)
|
|
return data * AXP202_VBUS_VOLTAGE_STEP
|
|
|
|
def getVbusCurrent(self):
|
|
data = self.__get_h8_l4(AXP202_VBUS_CUR_H8, AXP202_VBUS_CUR_L4)
|
|
return data * AXP202_VBUS_CUR_STEP
|
|
|
|
def getTemp(self):
|
|
hv = self.read_byte(AXP202_INTERNAL_TEMP_H8)
|
|
lv = self.read_byte(AXP202_INTERNAL_TEMP_L4)
|
|
data = (hv << 8) | (lv & 0xF)
|
|
return data / 1000
|
|
|
|
def getTSTemp(self):
|
|
data = self.__get_h8_l4(AXP202_TS_IN_H8, AXP202_TS_IN_L4)
|
|
return data * AXP202_TS_PIN_OUT_STEP
|
|
|
|
def getGPIO0Voltage(self):
|
|
data = self.__get_h8_l4(AXP202_GPIO0_VOL_ADC_H8,
|
|
AXP202_GPIO0_VOL_ADC_L4)
|
|
return data * AXP202_GPIO0_STEP
|
|
|
|
def getGPIO1Voltage(self):
|
|
data = self.__get_h8_l4(AXP202_GPIO1_VOL_ADC_H8,
|
|
AXP202_GPIO1_VOL_ADC_L4)
|
|
return data * AXP202_GPIO1_STEP
|
|
|
|
def getBattInpower(self):
|
|
h8 = self.read_byte(AXP202_BAT_POWERH8)
|
|
m8 = self.read_byte(AXP202_BAT_POWERM8)
|
|
l8 = self.read_byte(AXP202_BAT_POWERL8)
|
|
data = (h8 << 16) | (m8 << 8) | l8
|
|
return 2 * data * 1.1 * 0.5 / 1000
|
|
|
|
def getBattVoltage(self):
|
|
data = self.__get_h8_l4(AXP202_BAT_AVERVOL_H8, AXP202_BAT_AVERVOL_L4)
|
|
return data * AXP202_BATT_VOLTAGE_STEP
|
|
|
|
def getBattChargeCurrent(self):
|
|
data = 0
|
|
if(self.chip == AXP202_CHIP_ID):
|
|
data = self.__get_h8_l4(
|
|
AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L4) * AXP202_BATT_CHARGE_CUR_STEP
|
|
elif (self.chip == AXP192_CHIP_ID):
|
|
data = self.__get_h8_l5(
|
|
AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L4) * AXP202_BATT_CHARGE_CUR_STEP
|
|
return data
|
|
|
|
def getBattDischargeCurrent(self):
|
|
data = self.__get_h8_l4(
|
|
AXP202_BAT_AVERDISCHGCUR_H8, AXP202_BAT_AVERDISCHGCUR_L5) * AXP202_BATT_DISCHARGE_CUR_STEP
|
|
return data
|
|
|
|
def getSysIPSOUTVoltage(self):
|
|
hv = self.read_byte(AXP202_APS_AVERVOL_H8)
|
|
lv = self.read_byte(AXP202_APS_AVERVOL_L4)
|
|
data = (hv << 4) | (lv & 0xF)
|
|
return data
|
|
|
|
def enableADC(self, ch, val):
|
|
if(ch == 1):
|
|
data = self.read_byte(AXP202_ADC_EN1)
|
|
data = data | (1 << val)
|
|
self.write_byte(AXP202_ADC_EN1, data)
|
|
elif(ch == 2):
|
|
data = self.read_byte(AXP202_ADC_EN2)
|
|
data = data | (1 << val)
|
|
self.write_byte(AXP202_ADC_EN1, data)
|
|
else:
|
|
return
|
|
|
|
def disableADC(self, ch, val):
|
|
if(ch == 1):
|
|
data = self.read_byte(AXP202_ADC_EN1)
|
|
data = data & (~(1 << val))
|
|
self.write_byte(AXP202_ADC_EN1, data)
|
|
elif(ch == 2):
|
|
data = self.read_byte(AXP202_ADC_EN2)
|
|
data = data & (~(1 << val))
|
|
self.write_byte(AXP202_ADC_EN1, data)
|
|
else:
|
|
return
|
|
|
|
def enableIRQ(self, val):
|
|
if(val & 0xFF):
|
|
data = self.read_byte(AXP202_INTEN1)
|
|
data = data | (val & 0xFF)
|
|
self.write_byte(AXP202_INTEN1, data)
|
|
|
|
if(val & 0xFF00):
|
|
data = self.read_byte(AXP202_INTEN2)
|
|
data = data | (val >> 8)
|
|
self.write_byte(AXP202_INTEN2, data)
|
|
|
|
if(val & 0xFF0000):
|
|
data = self.read_byte(AXP202_INTEN3)
|
|
data = data | (val >> 16)
|
|
self.write_byte(AXP202_INTEN3, data)
|
|
|
|
if(val & 0xFF000000):
|
|
data = self.read_byte(AXP202_INTEN4)
|
|
data = data | (val >> 24)
|
|
self.write_byte(AXP202_INTEN4, data)
|
|
|
|
def disableIRQ(self, val):
|
|
if(val & 0xFF):
|
|
data = self.read_byte(AXP202_INTEN1)
|
|
data = data & (~(val & 0xFF))
|
|
self.write_byte(AXP202_INTEN1, data)
|
|
|
|
if(val & 0xFF00):
|
|
data = self.read_byte(AXP202_INTEN2)
|
|
data = data & (~(val >> 8))
|
|
self.write_byte(AXP202_INTEN2, data)
|
|
|
|
if(val & 0xFF0000):
|
|
data = self.read_byte(AXP202_INTEN3)
|
|
data = data & (~(val >> 16))
|
|
self.write_byte(AXP202_INTEN3, data)
|
|
|
|
if(val & 0xFF000000):
|
|
data = self.read_byte(AXP202_INTEN4)
|
|
data = data & (~(val >> 24))
|
|
self.write_byte(AXP202_INTEN4, data)
|
|
pass
|
|
|
|
def readIRQ(self):
|
|
if(self.chip == AXP202_CHIP_ID):
|
|
for i in range(5):
|
|
self.irqbuf[i] = self.read_byte(AXP202_INTSTS1 + i)
|
|
elif(self.chip == AXP192_CHIP_ID):
|
|
for i in range(4):
|
|
self.irqbuf[i] = self.read_byte(AXP192_INTSTS1 + i)
|
|
|
|
self.irqbuf[4] = self.read_byte(AXP192_INTSTS5)
|
|
|
|
def clearIRQ(self):
|
|
if(self.chip == AXP202_CHIP_ID):
|
|
for i in range(5):
|
|
self.write_byte(AXP202_INTSTS1 + i, 0xFF)
|
|
self.irqbuf[i] = 0
|
|
elif(self.chip == AXP192_CHIP_ID):
|
|
for i in range(4):
|
|
self.write_byte(AXP192_INTSTS1 + i, 0xFF)
|
|
self.write_byte(AXP192_INTSTS5, 0xFF)
|
|
|
|
def isVBUSPlug(self):
|
|
data = self.read_byte(AXP202_STATUS)
|
|
return data & self.__BIT_MASK(5)
|
|
|
|
# Only can set axp192
|
|
def setDC1Voltage(self, mv):
|
|
if(self.chip != AXP192_CHIP_ID):
|
|
return
|
|
if(mv < 700):
|
|
mv = 700
|
|
elif(mv > 3500):
|
|
mv = 3500
|
|
val = (mv - 700) / 25
|
|
self.write_byte(AXP192_DC1_VLOTAGE, int(val))
|
|
|
|
def setDC2Voltage(self, mv):
|
|
if(mv < 700):
|
|
mv = 700
|
|
elif(mv > 3500):
|
|
mv = 3500
|
|
val = (mv - 700) / 25
|
|
self.write_byte(AXP202_DC2OUT_VOL, int(val))
|
|
|
|
def setDC3Voltage(self, mv):
|
|
if(mv < 700):
|
|
mv = 700
|
|
elif(mv > 3500):
|
|
mv = 3500
|
|
val = (mv - 700) / 25
|
|
self.write_byte(AXP202_DC3OUT_VOL, int(val))
|
|
|
|
def setLDO2Voltage(self, mv):
|
|
if(mv < 1800):
|
|
mv = 1800
|
|
elif(mv > 3300):
|
|
mv = 3300
|
|
val = (mv - 1800) / 100
|
|
prev = self.read_byte(AXP202_LDO24OUT_VOL)
|
|
prev &= 0x0F
|
|
prev = prev | (int(val) << 4)
|
|
self.write_byte(AXP202_LDO24OUT_VOL, int(prev))
|
|
|
|
def setLDO3Voltage(self, mv):
|
|
if self.chip == AXP202_CHIP_ID and mv < 700:
|
|
mv = 700
|
|
elif self.chip == AXP192_CHIP_ID and mv < 1800:
|
|
mv = 1800
|
|
|
|
if self.chip == AXP202_CHIP_ID and mv > 3500:
|
|
mv = 3500
|
|
elif self.chip == AXP192_CHIP_ID and mv > 3300:
|
|
mv = 3300
|
|
|
|
if self.chip == AXP202_CHIP_ID:
|
|
val = (mv - 700) / 25
|
|
prev = self.read_byte(AXP202_LDO3OUT_VOL)
|
|
prev &= 0x80
|
|
prev = prev | int(val)
|
|
self.write_byte(AXP202_LDO3OUT_VOL, int(prev))
|
|
# self.write_byte(AXP202_LDO3OUT_VOL, int(val))
|
|
elif self.chip == AXP192_CHIP_ID:
|
|
val = (mv - 1800) / 100
|
|
prev = self.read_byte(AXP192_LDO23OUT_VOL)
|
|
prev &= 0xF0
|
|
prev = prev | int(val)
|
|
self.write_byte(AXP192_LDO23OUT_VOL, int(prev))
|
|
|
|
def setLDO4Voltage(self, arg):
|
|
data = self.read_byte(AXP202_LDO24OUT_VOL)
|
|
data = data & 0xF0
|
|
data = data | arg
|
|
self.write_byte(AXP202_LDO24OUT_VOL, data)
|
|
|
|
def setLDO3Mode(self, mode):
|
|
if(mode > AXP202_LDO3_DCIN_MODE):
|
|
return
|
|
data = self.read_byte(AXP202_LDO3OUT_VOL)
|
|
if(mode):
|
|
data = data | self.__BIT_MASK(7)
|
|
else:
|
|
data = data & (~self.__BIT_MASK(7))
|
|
self.write_byte(AXP202_LDO3OUT_VOL, data)
|
|
|
|
def setStartupTime(self, val):
|
|
startupParams = (
|
|
0b00000000,
|
|
0b01000000,
|
|
0b10000000,
|
|
0b11000000)
|
|
if(val > AXP202_STARTUP_TIME_2S):
|
|
return
|
|
data = self.read_byte(AXP202_POK_SET)
|
|
data = data & (~startupParams[3])
|
|
data = data | startupParams[val]
|
|
self.write_byte(AXP202_POK_SET, data)
|
|
|
|
def setlongPressTime(self, val):
|
|
longPressParams = (
|
|
0b00000000,
|
|
0b00010000,
|
|
0b00100000,
|
|
0b00110000)
|
|
if(val > AXP202_LONGPRESS_TIME_2S5):
|
|
return
|
|
data = self.read_byte(AXP202_POK_SET)
|
|
data = data & (~longPressParams[3])
|
|
data = data | longPressParams[val]
|
|
self.write_byte(AXP202_POK_SET, data)
|
|
|
|
def setShutdownTime(self, val):
|
|
shutdownParams = (
|
|
0b00000000,
|
|
0b00000001,
|
|
0b00000010,
|
|
0b00000011)
|
|
if(val > AXP202_SHUTDOWN_TIME_10S):
|
|
return
|
|
data = self.read_byte(AXP202_POK_SET)
|
|
data = data & (~shutdownParams[3])
|
|
data = data | shutdownParams[val]
|
|
self.write_byte(AXP202_POK_SET, data)
|
|
|
|
def setTimeOutShutdown(self, en):
|
|
data = self.read_byte(AXP202_POK_SET)
|
|
if(en):
|
|
data = data | self.__BIT_MASK(3)
|
|
else:
|
|
data = data | (~self.__BIT_MASK(3))
|
|
self.write_byte(AXP202_POK_SET, data)
|
|
|
|
def shutdown(self):
|
|
data = self.read_byte(AXP202_OFF_CTL)
|
|
data = data | self.__BIT_MASK(7)
|
|
self.write_byte(AXP202_OFF_CTL, data)
|
|
|
|
def getSettingChargeCurrent(self):
|
|
data = self.read_byte(AXP202_CHARGE1)
|
|
data = data & 0b00000111
|
|
curr = 300 + data * 100
|
|
return curr
|
|
|
|
def isChargeingEnable(self):
|
|
data = self.read_byte(AXP202_CHARGE1)
|
|
if(data & self.__BIT_MASK(7)):
|
|
return True
|
|
return False
|
|
|
|
def enableChargeing(self):
|
|
data = self.read_byte(AXP202_CHARGE1)
|
|
data = data | self.__BIT_MASK(7)
|
|
self.write_byte(AXP202_CHARGE1, data)
|
|
|
|
def setChargingTargetVoltage(self, val):
|
|
targetVolParams = (
|
|
0b00000000,
|
|
0b00100000,
|
|
0b01000000,
|
|
0b01100000)
|
|
if(val > AXP202_TARGET_VOL_4_36V):
|
|
return
|
|
data = self.read_byte(AXP202_CHARGE1)
|
|
data = data & (~targetVolParams[3])
|
|
data = data | targetVolParams[val]
|
|
self.write_byte(AXP202_CHARGE1, data)
|
|
|
|
def getBattPercentage(self):
|
|
data = self.read_byte(AXP202_BATT_PERCENTAGE)
|
|
mask = data & self.__BIT_MASK(7)
|
|
if(mask):
|
|
return 0
|
|
return data & (~self.__BIT_MASK(7))
|
|
|
|
def setChgLEDChgControl(self):
|
|
data = self.read_byte(AXP202_OFF_CTL)
|
|
data = data & 0b111110111
|
|
self.write_byte(AXP202_OFF_CTL, data)
|
|
|
|
def setChgLEDMode(self, mode):
|
|
data = self.read_byte(AXP202_OFF_CTL)
|
|
data |= self.__BIT_MASK(3)
|
|
if(mode == AXP20X_LED_OFF):
|
|
data = data & 0b11001111
|
|
elif(mode == AXP20X_LED_BLINK_1HZ):
|
|
data = data & 0b11001111
|
|
data = data | 0b00010000
|
|
elif(mode == AXP20X_LED_BLINK_4HZ):
|
|
data = data & 0b11001111
|
|
data = data | 0b00100000
|
|
elif(mode == AXP20X_LED_LOW_LEVEL):
|
|
data = data & 0b11001111
|
|
data = data | 0b00110000
|
|
self.write_byte(AXP202_OFF_CTL, data)
|