Main code in deepsleep loop, unable to connect over serial

[MrTinkerman]

Ok...

So I got myself into a 'bricked not bricked' situation here.
I hope you can help me.

Sorry I cant show you the code since it's on the 'bricked' board.

I programmed a XIAO ESP32-S3 to be a ESPnow reciever.

• It is mainly in deepsleep, waking up for 150ms, every 10 seconds.
• In this 150ms window it listens for messages.
• I have built in a safeguard (so I thought).
• Upon receiving a message {'stop':1} it goes into a 'normal' sleep mode (while True: time.sleep_ms(1000)).

If I monitor the power consumption, as shown below, this works.

But I can not connect to it over serial using thonny,

mpremote says:

C:\Users.....>mpremote connect com41
Connected to MicroPython at com41

But CTRL-C doesn't do anything.

I have a main.py file that imports the code, could i delete that main.py file with some mpremote command?

Thanks in advance!

[Josverl]

If you have a copy of your code, you could simply erase and reflash your board.

If you don't you could copy the flash to a binary file on your pc, then try to recover the code from that. There are some tools for littlefs to do just that.

OH, and look at using git to avoid this a next time

[kjm1102]

I wish I had a dollar for every time I've had to reflash a board because my safeguard didn't! When I'm in development I tend to use the Thonny green arrow a lot. This runs your program from ram instead of flash so all you have to do is remove power is it locks up. I bought one of those inline USB cables with a switch (& led so you know when it's on) & I do a lot less reflashing these days.

[MrTinkerman]

Thanks for your answers.

I reflashed it. I didn't really lose anything, it was test code and I did save a copy.
But I'm back to square one now. Below is the code I have on the board, main.py and test_deepsleep.py

I can confirm the 'stop' message is being received by the code.
What code could I use to stop the code to make the board accessible over serial?
(Board: XIAO ESP32-S3, micropython v1.22.1)

main.py

import time


##########################################################
# startup delay needed to connect serial before sleepcycle
start = time.ticks_ms()
while time.ticks_ms() - start < 5000: time.sleep_ms(100)
##########################################################

import test_deepsleep

test_deepsleep.py

import machine, network, espnow, json
from time import sleep_ms as sms


sta = network.WLAN(network.STA_IF)
sta.active(True)					# Setting to active and disconnecting
sta.disconnect()      					# needed for yet unknown reason

espn = espnow.ESPNow()
espn.active(True)


def recv(e):
    
    while True:  																			
        
        org, payl = espn.irecv(0)  			# Read message(s) waiting in the buffer (origin, payload)
        if org is None: return				# Exit on empty buffer
        
        msg = json.loads(payl)
        
        if 'stop' in msg:
            
            ????????????                                 # <<< What code could go here?
           

def init():
    
    espn.irq(recv)					# Interrupt on receive
    main()
    
   
def main():
    
    while True:
        
        sms(110)					# Normal sleep to wait for messages
    
        machine.deepsleep(10000)
        

init()

[kjm1102]

I guess the answer to 'what code goes here' depends on what you want to happen after you receive a STOP. If you want to enter a prolonged normal sleep that you can ctrlC into over the USB then you need something like your startup delay, ie lots of little sleeps instead of one long one. Maybe put a sys.exit() after it in case it doesn't work.

[MrTinkerman]

Ok, yes I should define what it supposed to happen:

• When deployed the device should be in deepsleep and only wake up for 150ms every 10 seconds
• When testing I can use the startup delay in main.py
• When deployed I don't want to use the startup delay since it runs after every deepsleep and increases average power consumption considerably
• I do want to be able to re-program it after it has been deployed

So yeah, entering a 'normal' sleep after receiving a 'stop' msg sounds like an option.
But that is what my code did in my opening post, see below.

After receiving a 'stop' the code goes into the loop:
while True: sleep_ms(1000)
But when plugin in the USB while the code is in that loop, a connection over USB cannot be made.
I also tried sys.exit() and machine.soft_reset() but both reboot the board.

So I'm looking for a command that will stop all running code but not reset/reboot the board.

I have been testing with a button connected, if hold it down when powering the board the deepsleep code doesn't run.

main.py

import machine

btn = machine.Pin(1, machine.Pin.IN, machine.Pin.PULL_UP)

if btn.value():
    
    import test_deepsleep

test_deepsleep

import machine, network, espnow, json, sys
from time import sleep_ms


sta = network.WLAN(network.STA_IF)
sta.active(True)											# Setting to active and disconnecting
sta.disconnect()      										# needed for yet unknown reason

espn = espnow.ESPNow()
espn.active(True)


def enable_connect():
    
    #while True: sleep_ms(1000)								# USB connection not possible
    #machine.soft_reset()                                                                          
    sys.exit()												# Resets/reboots
    
    
def recv(e):
    
    while True:  																			
        
        org, payl = espn.irecv(0)  							# Read message(s) waiting in the buffer (origin, payload)
        if org is None: return								# Exit on empty buffer
        
        msg = json.loads(payl)
        
        if 'stop' in msg: enable_connect()
           

def init():
    
    espn.irq(recv)											# Interrupt on receive
    main()
    
   
def main():
    
    while True:
        
        sleep_ms(110)										# Normal sleep to wait for messages
    
        machine.deepsleep(10000)
        

init()

[shariltumin]

I would try to solve it this way:

1. make a global flag GO=True
2. use global GO in recv and main
3. in main() change while True: to while GO:
4. in recv() set GO=False when receiving 'stop'

Maybe this will work. This will break the main() loop and go back to REPL.
I do not know about the espn.irq recv() callback, which may still be running in the background. GO=True; main() will restart the main loop.

[MrTinkerman]

Thanks for this suggestion!

This works now:

def main():
    while True:
        sleep_ms(110)						# Normal sleep to wait for messages
        if go: machine.deepsleep(10000)
        else: break

If the 'stop' msg is received it will be within sleep_ms(110).
If go is false the 'while true' loop will exit and the code ends.
It is then possible to connect over serial.

If I were to use

def main():
    while go:
        sleep_ms(110)						# Normal sleep to wait for messages
        machine.deepsleep(10000)

'go' would be set to false by the message but after a deepsleep reboot,
'go' would be set to true again when the main code starts over.

See complete code below.

Thanks!

import machine, network, espnow, json
from time import sleep_ms


sta = network.WLAN(network.STA_IF)
sta.active(True)							# Setting to active and disconnecting
sta.disconnect()      						# needed for yet unknown reason

espn = espnow.ESPNow()
espn.active(True)

go = True


def recv(e):
    
    global go
    
    while True:  																			
        
        org, payl = espn.irecv(0)  				# Read message(s) waiting in the buffer (origin, payload)
        if org is None: return					# Exit on empty buffer
        
        msg = json.loads(payl)
        
        if 'stop' in msg: go = False
           

def init():
    
    espn.irq(recv)							# Interrupt on receive
    main()
    
   
def main():
    
    while True:
        
        sleep_ms(110)										# Normal sleep to wait for messages
    
        if go: machine.deepsleep(10000)
        else: break

init()

[ThinkTransit]

Another tip for when you need to catch a short wakeup is to use a terminal application like tio

You can hold down ctrl+c while waiting for the device to wakeup. It will spam the device and you will have more chance of catching it. From my experience I believe programs like thonny need to detect the board before allowing you to send input, by which time it is too late.