Hi guys
an M5CoreInk with ESP32 in light or deep sleep still consumes a couple of mA (which is to be expected given the hardware architecture). However M5CoreInk allows to shutdown ESP32 completely and later wake it up from the RTC timer or alarm.
For an M5CoreInk in shutdown mode I've measured a current (at the battery) of only about 2.5 uA which is pretty good. And yes, the ink display retains the last image.
Cheers
Felix
Hi guys
I've started to code a simple touch keyboard. I am still experimenting but I thought I'll share what I have so far.
You can find more pictures here: https://www.gwendesign.com/kb/m5stack/m5core2/#simple-touch-keyboard
You can find the code here: https://github.com/felmue/M5Core2/blob/fm-touch-keyboard-1/examples/Basics/keyboard/keyboard.ino
Happy Stacking!
Felix
Hello @koreanEggCoffee
yes, that is possible - I am powering my M5Atom this way.
However please note: There is no protection against wrong polarity so please be careful not to accidentally swapping 5 volts and GND.
I also suggest you disconnect the external 5 volts before connecting USB-C. Or in other words only connect one power source at the same time.
Please also refer to the M5Atom schematics which outlines the 5 volts connections between USB, 5v pin, Groove, LEDs and 3.3 volts regulator.
https://docs.m5stack.com/#/en/core/atom_matrix
Cheers
Felix
Hi guys
I've created an example showing how to partially update the ink display after the system gets powered on via RTC from a full shutdown. Pull-request
Cheers
Felix
Hello @jimbo_s
you'll need to have two I2C instances, Wire1 for internal stuff (AXP, Touch, RTC, etc.) on pins GPIO21 and GPIO22 and Wire for your sensor on pins GPIO32, GPIO33.
The M5Core2 library already set Wire1 up for the internal stuff:
Wire1.begin(21, 22);
so your sensor should use Wire. You can enable that on the correct pins by calling:
M5.begin(true, true, true, true);
the last true sets Wire up:
Wire.begin(32, 33);
You probably need to change the library for the sensor to use Wire instead of Wire1. How that is done depends on the library. Some allow to pass in the I2C instance to be used and some need to have every instance of Wire1 replaced manually to Wire.
The key here is to not mess with Wire1 else you loose all I2C communication within M5Core2.
Cheers
Felix
Hello @Zontex
Understood. Thank you for checking.
Maybe it could still be wired to a GPIO, but via a solder bridge, so it could be used optionally?
Anyways, I've soldered a wire from AXP IRQ to ESP32 GPIO35. I can detect now when USB (aka ACIN) has been connected or disconnected while ESP32 is in light sleep and use that to wake up.
Cheers
Felix
Hi guys
I think I found the issue. By default M5Core2 (running UIFlow 1.7.1) does not enable the internal 5 volts boost, therefore the LEDs are not powered.
@greenleaf when I add the following two lines to your Python code it works for me:
from m5stack import *
power.setBusPowerMode(0)
@veryalien for UIFlow add: Hardwares - Power - Set bus power mode (0), then use RGB LED unit set to Custom and SDA/TX set to 25 and Number set to 10.
Happy Stacking!
Felix
Hi guys
Power consumption update: even though the example keeps the M5CoreInk in shutdown mode (everything off except for the RTC) most of the time and only powers up for about 2 seconds every minute to do the update, the built in battery only last for about one week.
Thanks
Felix
Hi guys
UIFlow 1.7.1.1 for M5Core2 is out and it seems to fix the power issue on port A. I can now scan and use units on port A w/o the need to add the Set bus power mode 0 instruction.
Happy Stacking!
Felix
Hi guys
today I did a charging experiment with a fully depleted M5Paper battery. After about 2 hours the charger IC switched from charging to standby (according to the two LEDs I've soldered to the corresponding charger IC outputs).
I used a multimeter (connected directly to the battery) to measure the battery voltage. The voltage from the internal ADC, read via M5.getBatteryVoltage(), was about 5% higher than the voltage read by the multimeter for voltages below 4.2V. Above that the two values were pretty close. The reason for that is the voltage divider (3k / 11k) which when fed with 4.2V produces about 3.3V to the ADC input which is about the maximum a GPIO can take.
The highest voltage I've seen on the multimeter was 4.31V before the charging stopped. After which the voltage dropped back to 4.25V. I think that means the charger IC actually is setup for a 4.35V battery, but for some reason doesn't go all the way up to 4.35V.
Update: a possible reason is explained in the datasheet (Google translated):
==========
_______________Charge termination voltage setting The default full termination voltage V FLOAT set inside the chip is approximately 4.35V, but due to the large charging current, the internal resistance of the battery and the line Loss will cause the actual full-charge termination voltage to be lower than this value, resulting in battery failure The law is full enough. SLM6635 by an external resistor RPV to increase V FLOAT of Voltage, used to compensate various losses, or to satisfy different applications Special requirements for voltage.The compensation voltage can be calculated by the following formula:
Delta V = I bat (Standby mode) * RPV
If there is no need to compensate the V FLOAT voltage, it is recommended that RPV be set to 1kΩ.
==========
Thanks
Felix
Hello @gcormier
Unfortunately M5Paper doesn't have a charging indicator (eg. LED) and as you already noticed yourself the reported voltage is of almost no use either.
The thing is that the charger IC used in M5Paper has two outputs (charging and standby) which would indicate if the battery is being charged or not. Sadly though the M5Stack engineers decided to not use those outputs.
I did some measurements with my M5Paper and on average it did not take more than 3 hours to fully charge the battery.
So I suggest you keep it charging for at least 3 hours and it should be full.
Thanks
Felix
In my M5Stack Grey the two ICs (MPU6886 and BMM150) are on a small daughter board which was soldered to the underside of the Groove connector (GND, 5V, SDA, SCK). An additional pin provides 3.3V for the two ICs. But I am afraid the interrupt line coming out of the MPU6886 is not connected at all.
Please note: My M5Stack Grey board reads 2018.3, so maybe the daughter board was merged with the main board in later revisions?
Felix
Desoldered daughter board:
Hi @gabriele
I've just checked UIFlow (Desktop and online) with my Fire. Here are my steps:
Note: When you're happy with your program you can download it into your M5Stack using 'Download'. What's not really obvious though is that this will automatically switch the mode back to 'App Mode' before running the program. (That is the reason the connection is lost.)
You'll need to manually enter setup and switch the mode to 'Internet Mode' again if you want to reconnect and continue on your program from within UIFlow.
For reference: https://m5stack.github.io/UIFlow_doc/en/en/base/Run_Program.html
Hope this helps
Felix
Hi @Skink
here is a Python solution. Button A decreases, Btn C increases intensity. Btn B turns vibration motor on and off:
from m5stack import *
from m5stack_ui import *
from uiflow import *
import i2c_bus
screen = M5Screen()
screen.clean_screen()
screen.set_screen_bg_color(0xFFFFFF)
label0 = M5Label('Text', x=52, y=67, color=0x000, font=FONT_MONT_24, parent=None)
from numbers import Number
motorOnOff = None
motorValue = None
temp = None
def setMotorValue():
global motorOnOff, motorValue, temp
label0.set_text(str(motorValue))
temp = (i2c0.read_u8(0x28)) & 0xF0
temp = temp | motorValue
i2c0.write_mem_data(0x28, temp, i2c_bus.UINT8LE)
def buttonA_wasPressed():
global motorOnOff, motorValue, temp
if motorValue > 0:
motorValue -= 1
setMotorValue()
pass
btnA.wasPressed(buttonA_wasPressed)
def buttonC_wasPressed():
global motorOnOff, motorValue, temp
if motorValue < 15:
motorValue += 1
setMotorValue()
pass
btnC.wasPressed(buttonC_wasPressed)
def buttonB_wasPressed():
global motorOnOff, motorValue, temp
motorOnOff = not motorOnOff
power.setVibrationEnable(motorOnOff)
pass
btnB.wasPressed(buttonB_wasPressed)
i2c0 = i2c_bus.easyI2C(i2c_bus.PORTA, 0x34, freq=400000)
motorOnOff = False
motorValue = 7
setMotorValue()
Cheers
Felix
Hi guys
Touch Keyboard is now available as library: https://github.com/felmue/GDTouchKeyboard
Cheers
Felix
Hi Van
you're very welcome. I don't have a partition map and so far I didn't need one. For the additional PSRAM I've added these two lines for M5Core2:
build_flags =
-DBOARD_HAS_PSRAM
-mfix-esp32-psram-cache-issue
(I am not sure if the second line actually is really needed still, but it doesn't seem to hurt.)
Cheers
Felix
Hi Van
you could try to define two environments and use lib_ignore to only compile one of the two libraries, depending on the selected device:
[platformio]
default_envs = m5stack
;default_envs = m5core2
[env:m5stack]
platform = espressif32
board = m5stack-core-esp32
framework = arduino
lib_ignore = M5Core2
[env:m5core2]
platform = espressif32
board = m5stack-fire
framework = arduino
lib_ignore = M5Stack
Cheers
Felix
Hi Van
thank you for the test application. I've added my test (using a finger) in the issues section. I think I have a stylus somewhere and when I find it I'll give it another go.
Cheers
Felix
Hi @Kris
that is entirely up to you - pin0-4 are just variables.
In UIFlow use the first statement to initialise the desired GPIO (0-36) to be used with one of the 5 variables (pin0-4).
MicroPython example: variable pin0 is used for GPIO18:
pin0 = machine.Pin(18, mode=machine.Pin.IN, pull=machine.Pin.PULL_UP)
Cheers
Felix
Hello all
the reason nothing can be seen on the LCD during deep sleep is that the backlight is off. The LCD backlight is driven by GPIO32 (PWM) which is stopped when the ESP32 goes into deep sleep. Luckily GPIO32 can be controlled by the Ultra Low Processor (ULP) too. Below is a small test program which implements PWM for GPIO32 with ULP C macros / assembler.
Cheers
Felix
#include <M5Stack.h>
#include "esp32/ulp.h"
#include "driver/rtc_io.h"
const int lcdBrightness = 1; // (1-255)
void ulp_start(void) {
// Slow memory initialization
memset(RTC_SLOW_MEM, 0, 8192);
// M5Stack LCD backlight is connected to GPIO32 (specify by +14)
const gpio_num_t lcdPWMPin = GPIO_NUM_32;
const int lcdPWMBit = RTCIO_GPIO32_CHANNEL + 14;
// GPIO32 initialization (set to output and initial value is 0)
rtc_gpio_init(lcdPWMPin);
rtc_gpio_set_direction(lcdPWMPin, RTC_GPIO_MODE_OUTPUT_ONLY);
rtc_gpio_set_level(lcdPWMPin, 0);
// Define ULP program
const ulp_insn_t ulp_prog[] = {
M_LABEL(1),
I_WR_REG(RTC_GPIO_OUT_REG, lcdPWMBit, lcdPWMBit, 1), // on
I_DELAY(lcdBrightness * 100),
I_WR_REG(RTC_GPIO_OUT_REG, lcdPWMBit, lcdPWMBit, 0), // off
I_DELAY(25500),
M_BX(1),
};
// Run ULP program
size_t size = sizeof(ulp_prog) / sizeof(ulp_insn_t);
ulp_process_macros_and_load(0, ulp_prog, &size);
ulp_run(0);
}
void setup() {
M5.begin(true, false, true, false);
M5.Power.begin();
M5.Lcd.println("Put something onto the LCD...");
ulp_start();
M5.Lcd.println("Going to deep sleep");
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
esp_deep_sleep_start();
}
void loop() {
}