Making an ESP32 controlled MicroPyhton Power Management script

[MatthewPolewiak]

Hi, I'm a Product design student and as one of my projects during the previous year I had to design a voice recorder that fulfilled specific requirements. I ended up with a project that I liked so to have something to do over the summer holidays as well as expand my limited knowledge about designing electronic devices I decided to try to make a working prototype.

The prototype I'm making is based on an ESP32, coded in MicroPython (Since that's what we've learned to work with in class, and I already had some of the required electronic components for the project)

The device is supposed to have a battery, which is supposed to be charged via USB C. I am currently working on creating a solution that allows for power management for the device. I already have a battery for the prototype (980mAh 3.7V single cell LiPo battery) and a dedicated USB C LiPo Battery charging module

From what I understand about Power Management systems they usually work by taking Voltage measurements of the battery to access the charge level (for 3.7V battery it should be between 3.3V and 4.2V), which is then converted to a % value, they also turn off the device when the battery falls below 3.3V to prevent wearing out the battery.

I have created some code based on my understanding of the problem. In theory the code works and (sometimes) provides voltage readings very similar to those of a multimeter while connected to my laptop. In practice however I've tried setting up two experiments. In one of them I attach the battery to the ESP32, and a few green LEDs, then run the code for a while in hopes of getting the reading that the battery level is decreasing over time. In the other one I attach the battery to the ESP32 and the charging module and run the code for a while in hopes of getting a reading that the battery level is increasing over time. The experiments haven't worked correctly yet, either returning values that don't change as expected or showing that the battery is at over 4.2V which doesn't line up with the multimeter readings. (I tried running the experiments both with the ESP32 powered by the battery and disconnected from any external power sources and with the ESP32 powered by the micro USB port)

The Voltage values also change when attaching the charging module or connecting the LEDs/ using the battery to power the ESP32 by connecting the + rail to the VIN Pin, in a way that I'm unable to predict, but even if they didn't have any impact on the Voltage values I would still expect the code to detect gradual increase/decrease of the Voltage values (even if the Voltage/Battery percentage values weren't accurately reflecting the charge state of the battery)

This is my code:

from machine import Pin,ADC
from time import sleep_ms

#Defining the Pin for the battery voltage reading
#(I'm using 10bit 1024 value instead of 4095, because based on this article: https://www.upesy.com/blogs/tutorials/measure-voltage-on-esp32-with-adc-with-arduino-code
#and my own experimentation the 1024 channel seems to be more accurate for measuring Voltage levels than 4095 channel)

Input=ADC(Pin(35))
Input.atten(ADC.ATTN_11DB)
Input.width(ADC.WIDTH_10BIT)

#Taking the average of the measurements to get a more streamlined reading that should hopefully be more accurate and prevent situations in which the device seems to
#loose battery while charging or gain battery while working

def AVERAGE(Rounds,Delay):
    S100=[]
    for i in range(0,Rounds):
        S100.append(Input.read())
        sleep_ms(Delay)
    return round(sum(S100)/Rounds)

#Converting the ADC 0-1024 reading into Volts, from what I know the 1024 ADC reading pin reads current between 0 and 3.6 Volts, the value is also adjusted for the voltage divider
#Which is in place to prevent a fully charged battery sending 4.2V to the 3.6V pin. (Voltage divider uses a 4.7kOhm resistor and a 10kOhm resistor)

def BINARY_TO_VOLT(AVERAGE):
    Volt=(AVERAGE/10*14.7/1024*3.6)
    return round(Volt,2)

#Converting the Voltage levels to approximate percentage readings based on a conversion ratio from chatGPT

def VOLT_TO_PERCENTAGE(VOLT):
    if VOLT<=3.3:
        return 0
    elif 3.3 <VOLT<3.5:
        return VOLT*25-82.5
    elif 3.5 <=VOLT<3.6:
        return VOLT*50-175
    elif 3.6 <=VOLT<3.9:
        return VOLT*200-710
    elif 3.9 <=VOLT<4:
        return VOLT*150-515
    elif 4.0 <VOLT<4.2:
        return VOLT*75-215
    else:
        return 101 

#Saving the value on a text file, which makes it possible for me to leave the ESP32 disconnected from my laptop when testing 

def SAVE_VALUE(VALUE,DIRECTORY):
    try:
        with open(DIRECTORY, 'a') as file:
            file.write(VALUE +'\n')
            print("Saved")
    except Exception as e:
            print("Failed to save value")


#Defining required variables

perCentage="/saved/percentage.txt"
vOltage="/saved/voltage.txt"
biNary="/saved/binary.txt"
SAVE_VALUE("New Log",perCentage)
SAVE_VALUE("New Log",vOltage)
SAVE_VALUE("New Log",biNary)


#Main loop (Runs 60 times, every Minute takes an average of 50 different measurements)

for i in range(60):

    Average=AVERAGE(50,600)

    print(Average)
    SAVE_VALUE(str(Average),biNary)

    Volt=BINARY_TO_VOLT(Average)
    print(Volt)
    SAVE_VALUE(str(Volt),vOltage)
    Percent = f"{round(VOLT_TO_PERCENTAGE(Volt))}%"
    print(Percent)
    SAVE_VALUE(Percent,perCentage)

This is a picture of the very simple ESP32 testing setup I'm using

The battery, and the charging module are connected to the + and - rails respectively, ESP32 is connected to the - rail with the GND Pin, Pin 35, is connected with a 10kOhm resistor to the - Rail, and with a 4.7kOhm resistor to the + rail. (When testing discharging the battery the + and - rails to which the LEDs are connected get connected to the already utilized + and - rails with jumper cables)

[bixb922]

To get a voltage reading, try ADC.read_uv() instead of converting the raw reading. That's easier and is already factory calibrated.

See https://docs.micropython.org/en/latest/esp32/quickref.html

[davefes]

You need to look at the electrical characteristics of the on-board ADC. I use this as a rough check for Li-ion battery check:

adc1_ch4 = ADC(Pin(32)) #  create ADC object on ADC pin 32
adc1_ch4.atten(ADC.ATTN_11DB) #  set 11dB input attenuation (voltage range roughly 0.1v - 3.0v)
adc1_ch4.width(ADC.WIDTH_12BIT) #  set 12 bit return values (returned range 0-4095)

count = 0
result = 0

# read remote battery voltage
while count < 8:
    battery_ADC_reading = adc1_ch4.read()
    result = result + battery_ADC_reading
    time.sleep_ms(10)
    count += 1

battery = (result * 3) / 1675 / 8 #  8 samples
battery = round(battery, 2)
remote_status =  str(battery)

For better ADC performance use something like an ADS1015. Multiple samples helps to remove small variations, I don't think it will improve accuracy.

It really sounds like you have a hardware connection problem, maybe how the battery negative is referenced back to the ground on the ESP32. Draw-up a schematic.

[davefes]

Also, trying to determine SOC of a Li-ion battery from voltage readings is problematic. Keyword search - coulomb-counting

[MatthewPolewiak]

I tried what @bixb922 using adc.read_uv() instead of adc.read() like @bixb922 recommended and it does seem to be a bit more accurate than trying to convert the ADC input. I adjusted the code for the new input, then set up a buzzer to have a physical feedback when the data is saved so I would know if the code was working correctly when it was disconnected from my laptop and I could no longer see the printed outputs. Then I realized that the voltage decrease from the attached LEDs was an issue because I attached them directly to the battery. So I fixed that by attaching them to the 3V3 pin on the esp. Then I ran the code with a bunch of LEDs connected, and the text document did correctly show decreasing battery percentage. It also somewhat worked while charging.

Since the device won't have any user interface, only a buzzer for physical feedback and Bluetooth connection for file management, I figure I'll just use the somewhat accurate voltage reading I get to display the battery through Bluetooth, and have buzzer warnings when the battery is below a certain threshold.

I also read up some more about the components I have and from what I understand the LiPo battery has a built in system that prevents it from discharging to an unhealthy level and the LiPo charging module has a built in system that prevents overcharging, so since I don't need to worry about battery health I think I'll just settle on what I have so far, and maybe look into a more advanced system after I figure out the other components.