I was wondering if many users would want a stick that can run off battery power in a low power mode for perhaps a week, like a cell phone can...

(I just demonstrated the M5stickC to a user group, with 5 different apps merged into one, had to worry about having LCD backlight turned down to get more than 20 minutes battery life)

This may require some improvement of peripheral power management and an E-Paper display, which can be 'on' all the time (but with severe limits to interactivity) may need to rely on USB connection for setting up WiFi connection, etc, or an attached OLED "terminal" for basic setup interface in the field (a screen mirror mode would be fun)

Applications that come to mind include:

• Environmental readings display that updates Temperature, etc readings once per minute.
• Bitcoin price display that updates from the web every 15 minutes.
• Data logger that stores low volume data in ram, and transmits hourly packets via WiFi.
• Should be able to run as a BLE beacon for a reasonable amount of time.

There's one E-Paper display prospect that may be suitable.
http://www.e-paper-display.com/products_detail/productId=412.html

GooDisplay 1.02 inch Flexible E-Paper Screen : 128x80 resolution, B&W part# GDEW0102I4F
Outline: 32.57 x 18.6 x0 .3mm, Active Area: 21.76 x 14mm
Some tricky folding of the connector end would be needed,
the 0°C~50°C operating range is an issue as well.

Sales Page:
http://www.eink-display.com/product/60800721960-805897889/E_good_display_flexible_1_inch_1_02_inch_e_ink_e_paper_display.html

(Alibaba has considerably lower price offerings)

Eval board.
https://buyepaper.com/demo-kit-driver-development-board-for-102-inch-e-paper-e-ink-display-despi-102-p0091-p0091.html

To counter the large visual feedback delays of E-paper, more inputs, like 5 touch sensor hot spots embedded in the case along 1 edge of the display would be useful for menu designs.

Even the ideal ESP32 hardware is a challenge to run from an 80mah battery. The work done on stick watch software should be very helpful.

I understand that the overhead to wake from a deeps sleep makes it only practical to sleep for more than 1 minute at a time.

The 200mA overhead of running the radio, would probably limit connections to very short bursts.

This example post concluding that 20-25mA is required to maintain an AP association, is the sort of ESP32 issue that may be quite challenging.
https://esp32.com/viewtopic.php?t=8070

One E-paper article noted:
“an e-paper display will use around 3 mA for 2 seconds each time it updates its contents”

@m5-docs

Block diagram level documentation showing the power management chip connections, would help those attempting to improve code to reduce sleep mode power consumption.

Good going oliv, looks like you have all the right electronic and intellectual tools.

@oliv said in Getting Longer Battery Run Time:

There is also 0.5 mA from something activated after AXP.Begin()

The microphone uses 0.5 mA when it has the active 1 Mhz clock, 0.025 mA with < 1 khz clock.

(Power off current rating of the ESP32 chip 0.1 μA) 1.92 mA power off must be the AXP192? which must still be active when shutdown, even with charging disabled.

My getting 16+ hours of sleep time with the StickWatch2 sleep code suggests a sleep battery current < 5ma (80mah/16)

LDO2 is controling just? the LCD backlight, not the chip power.

Fumbling around with attempting to make LCD controler chip sleep to save 2mA:

M5.Lcd.writecommand(ST7735_SLPIN); // this line compiles under arduino

(It didn't reduce the sleep load)

May needs to be put in a proper command object structure? including a delay.

// Here's the IMU sleep code from the StickWatch2PowerManagment demo

void shutdownSH200Q() {
Wire.beginTransmission(0x6C);
Wire.write(0x75);
byte success = Wire.endTransmission(false);
Serial.printf("success: %d \n", success);
byte byteCount = Wire.requestFrom(0x6C, 1);
Serial.printf("byteCount: %d \n", byteCount);
uint8_t data = Wire.read();
// uint8_t b = read_register(0x6C, 0x0E);
Serial.print("byte: ");
Serial.println(data, BIN);

Wire.beginTransmission(0x6C);
Wire.write(0x75);
Wire.write(0x80); // SH200Q shutdown mode (only i2c alive)
byte succ = Wire.endTransmission();
Serial.printf("succ: %d \n", succ);
}

Just to exclude the ESP32, which does draw a tiny amount of power when off, but the spec is:

Power off CHIP_PU is set to low level, the chip is powered off. 0.1 μA load

It wold take some hundreds of hours for that standby current to make a dent in the battery charge

Some Sipeed demos that should work, I have a couple of Sipeed boards with the same functionality as the M5StickV, so far I have just played around with the demos that run under python (which comes preinstalled on their boards) I am guessing that all of their software also works on the M5StickV, although the screen size difference will have to be dealt with, it might just require adjusting the sensor.set_windowing((224, 224)) along with lcd.draw_string(... statements. (I don't have a M5StickV and don't know if M5 crew has translated demos available)

(The sipeed.com site was just revised, it seems the English support is more limited at the moment than usual)

Here is a new bundle with 7 different demos, if you have difficulty you might consult the individual demos I have worked with, listed below.
MaixPy 0.3 demo firmware package
https://bbs.sipeed.com/t/topic/688

There are 2 demos running under tiny yolo2 that require a stripped down version of micro python to be installed, to make room for the class models.

MaixPy Run 20-classes object detection based on tiny-yolov2 in 30 lines~
https://bbs.sipeed.com/t/topic/683

This easier to use? M5StickV translated version speaks the 20 object names.
https://github.com/ksasao/brownie

MaixPy run face detection (tiny yolo v2)
https://bbs.sipeed.com/t/topic/600

The 2 above demos us the same custom Python, with some minor code tweaking you can load both demos together, by placing one of the 2 models on the SD card.

1000 class object recognition, using MobileNet
Packed into a 2.3Mb model file, scroll down to the topic: Run kmodel on MaixPy
https://bbs.sipeed.com/t/topic/682

Here is a video with 782 object images, some are from the Stanford training database, the remainder were hand selected from google Images for high match quality, (stacking the deck with better matches than real world random samples)
https://www.youtube.com/watch?v=mzQinEzUgdY&t=276s

Here's a text recognition demo
Train,Convert,Run MNIST on sipeed MAIX in 30mins!
https://bbs.sipeed.com/t/topic/569

These demos are previewed here:
https://www.maixhub.com/

There are articles describing getting years of ESP32 operating time from one set of batteries, relying on it being in low current sleep mode most of the time. The Esp32 consumes about 0.01 mA duing deep sleep.

A simple scenario may be waking up for 200 milliseconds to log a sensor reading, then sleeping for a minute (60,000 millisecond) so it's active only 0.3% of the time.

Using the official m5stack Arduino Lib DeepSleep function, I checked the M5stickC battery voltage in a series of 1 hour sleep periods, it averaged 0.90 volts drop per hour, which is inline with someone in the forum who reported getting no more than 5 hours of battery life with their watch, this may amount to perhaps 5-10mA of current drawn during sleep. (I have to wonder if something else can be turned off)

M5stack Engineers: I just tested the Sleep function in the standalone StickWatch2PowerManagment demo, it delivered 16 hours of sleep time, which may be a big deal for some users. (Total voltage drop was 0.398v, that's 25mv/hr)
The difference from the official DeepSleep() code used in the sleep.ino example may be trivial, they are shutting down the IMU chip which has a current spec. of 2.5ma, the added function that handles it is: shutdownSH200Q() (example code seems to need the same Arduino setup as the StickWatch2 described below)
https://github.com/eggfly/M5StickCProjects/tree/master/demo/StickWatch2PowerManagment

I tested am M5stickC running with the LCD back-light at full brightness and found the battery reached a "dangerously low" 8% charge condition after 20 minutes. (Relying on the AXP192 battery management chip's voltage and idischarge readings)

(The processor seems to start up with the radio sleeping, WiFi and Bluetooth are the biggest energy eating offenders.)

THE SIMPLEST WAY TO GET A LONGER LIFE is to lower the brightness of the LCD backlight, at full brightness you may see a total battery load of 125 mA, one could predict a 38 minute to totally discharge the 80 mAH battery with that load, while the real world life is more like 20 minutes.

This user reports the battery current for various LCD backlight brightness setting, which is a close match to my findings.
http://community.m5stack.com/topic/1119/unreal-power-discharge-charge-current

idischg: 42mA @ ScreenBreath(7)
idischg: 44mA @ ScreenBreath(8)
idischg: 51mA @ ScreenBreath(9)
idischg: 58mA @ ScreenBreath(10)
idischg: 65mA @ ScreenBreath(11)
idischg: 75mA @ ScreenBreath(12)
idischg: 90mA @ ScreenBreath(13)
idischg: 105mA @ ScreenBreath(14)
idischg: 116mA @ ScreenBreath(15)

ScreenBreath(10) seems quite usable, doubling your battery life. Another benefit of lower backlight energy is lower operating temperature, components tightly packed in a little box tend to run hotter, battery performance degrades and charge time increases under higher temperatures. (on my copy of the stick ScreenBreath(6) gave a very dim image readable in a blacked out room, but the energy saving is negligible)

The AXP192 (Power management) Document shows: ScreenBreath(), GetVbatData(), GetIchargeData()
https://docs.m5stack.com/#/en/api/axp192_m5stickc

The AXP192 power management chip example uses more functions to provide a detailed report
https://github.com/m5stack/M5StickC/tree/master/examples/Basics/AXP192

This article touching on Coulomb Counting in a Battery Fuel Gauge, might show the value of Coulomb reporting by the AXP192.
https://batteryuniversity.com/learn/article/the_battery_fuel_gauge

I made some battery tests using the Power reporting section of StickWatch2, which display the percentage of power remaining, their algorithm uses a 12 segment lookup table apparently to fit a discharge curve, (it's not a linear calculation)
https://github.com/eggfly/M5StickCProjects

There is a trick to get the updated StickWatch2 code to run on the M5stickC in the Arduino IDE:
You have to change the Board setting to "ESP32 Pico Kit" and correct the upload speed to 115200.

Here is a rough guideline for estimating remaining energy, developed by the RC people:
4.2 volts 100%
4.1 about 90%
4.0 about 80%
3.9 about 60%
3.8 about 40%
3.7 about 20%
3.6 empty for practical purposes

The AXP192 sleep example can be useful for extending battery life in some applications.
https://github.com/m5stack/M5StickC/tree/master/examples/Advanced/AXP192/sleep

M5stack engineers could help those attempting to further extend battery life, with further documentation, perhaps in a tutorial on battery conservation describing what goes on behind the sleep command.

A block diagram showing the power supply path of the various components may help, (I would like to see what the power manager LDO, LDO2, LDO3 & LDOIO drives) those chips that are not powered down by the AXP192 might be reprogrammed to a lower power idle mode, (it appears that 2ma would be saved with an LCD controler Sleep-in setting)

Here are a few tutorials on ESP32 Sleep modes, the essential thing to know is you code is lost when memory is powered down, waking up amounts to rebooting the board, you can store the state of your program in the RTC processor's 8K of ram before sleeping.

ESP32 Deep Sleep with Arduino IDE and Wake Up Sources
https://randomnerdtutorials.com/esp32-deep-sleep-arduino-ide-wake-up-sources/

ESP32 Deep Sleep Tutorial -- speaks of 5 year battery life
https://www.hackster.io/nickthegreek82/esp32-deep-sleep-tutorial-4398a7

ESP32 Timer Wake Up from Deep Sleep
https://randomnerdtutorials.com/esp32-timer-wake-up-deep-sleep/

@multihelix

How are you getting 5 hours of life? it seems you would need <16 ma total drain

Are you sleeping the ESP32?