Continuation of the discussion #12492

[PatLub85]

Hi,
I started working on my project again. As a reminder, I want two independent programs to be able to be launched alternately each time a button is pressed..
The demo version works thanks to your help.
I added an Irq trigger to handle the push button
However, I wanted to go further and I'm stuck.
Demo version:

import asyncio
from time import sleep, sleep_ms
flag,go,value = True,False,True

led = Pin(2, Pin.OUT)
led.value(0)
button = Pin(32,Pin.IN,Pin.PULL_DOWN)

def func(v):
  global value,counter
  sleep_ms(50)
  if(button.value() == 0):
    return
  while(button.value() == 1):
    sleep_ms(100)
  sleep_ms(100)
  led.value(value)
  value = 0 if value else 1

button.irq(trigger=Pin.IRQ_RISING, handler=func)

async def prog_1():
    global flag, go
    while True:
        if flag and go:
           print('program 1')
           go = False
        await asyncio.sleep(1)

async def prog_2():
    global flag, go
    while True:
        if not flag and go:
           print('program 2')
           go = False
        await asyncio.sleep(1)

async def main():
    global flag, go
    while True:
        flag = value
        go = True                
        await asyncio.sleep(2)

asyncio.run(asyncio.gather(main(), prog_1(), prog_2()))

First question:
in this example, does prog_1 (or prog_2) run for the duration of the main coroutine's asyncio.sleep(2) wait, exit, and start again?
If so, this is not what I want

Second question:
If I run a program with an infinite loop, the button has no effect anymore

coroutine prog_1

async def prog_1():
    from program_1 import prog1
    global flag, go
    while True:
        if flag and go:
            prog1()
            go = False
        await asyncio.sleep(1)

program_1

def prog1():
    while True:
        print("prog 1")
    
if __name__ == "__main__":
    prog1()

Do you think what I want to do is possible?

[shariltumin]

I do not know the details of your project, but if what you want is to mix an interrupt trigger and three async functions, then you might find the following script useful:

import asyncio
from time import sleep, sleep_ms
from machine import Pin, disable_irq, enable_irq
value,state = True,None
go,counter = 0,-1

led = Pin(2, Pin.OUT)
led.value(0)
button = Pin(32,Pin.IN,Pin.PULL_DOWN)

def func(v):
  global value,counter,go,state
  state = disable_irq()
  if go == 0:
     counter+=1
     go=counter%2+1
     value = 0 if value else 1
  enable_irq(state)

button.irq(trigger=Pin.IRQ_RISING, handler=func)

async def prog_1():
    global go, state
    while True:
        if go==1:
           print('program 1')
           go=0
        await asyncio.sleep(1)

async def prog_2():
    global go, state
    while True:
        if go==2:
           print('program 2')
           go=0
        await asyncio.sleep(1)

async def main():
    global counter, value, go
    while True:
        led.value(value)
        if counter>1000000: counter=-1 
        await asyncio.sleep(2)

asyncio.run(asyncio.gather(main(), prog_1(), prog_2()))

The running log shows:

MicroPython v1.23.0 on 2024-06-02; Generic ESP32 module with ESP32
Type "help()" for more information.
>>> import my_p15802
program 1
program 2
program 1
program 2
program 1
program 2
program 1
program 2
program 1
program 2
program 1
...

[PatLub85]

Your program works fine but if I modify it by calling program_1, unfortunately, as shariltumin points out, prog1 enters its while True: and holds the processor forever.

async def main():
	button = Pin(32,Pin.IN,Pin.PULL_DOWN)
	while True:
		await wait_for_button_pulsed(button)
		print("run program 1 here")
		from program_1 import prog1
		prog1()
		await wait_for_button_pulsed(button)
		print("run program 2 here")

I'm afraid there is no solution to my need.

[shariltumin]

If you are using an esp32 based MCU, you may want to consider using the \_thread library. The \_thread is a preemptive multitasking system. Each task is preemptively allocated CPU time and no block of code can hold the CPU exclusively. The \_thread may introduce complexity in your code and subtle bugs that are not easy to debug. But hey, we are here to learn, so why not give it a try.

Or maybe there is an easy way to program a solution for your project using simple sequential control? "Simple is better than complex". Start a regular Python and do import this at the REPL, you will know what I mean.

[bixb922]

program1 and 2 must certainly must return when they have to stop to run. I still don't follow exactly what you need, perhaps it's something like this?

import asyncio
from machine import Pin

program_number = 0
	
async def program0():
    while True:
        if program_number != 0:
            return
        print("program 0 is running")
        # Program0 and 1 must have a await used periodically in 
        # their while True: loop for this to work.
        await asyncio.sleep(1)

async def program1():
    while True:
        if program_number != 1:
            return
        print("program 1 is running")
        await asyncio.sleep(1)

async def wait_for_button_pulsed(b):
    global program_number
    # Wait for button pressed
    while b.value() == 0:
        await asyncio.sleep_ms(50)
    # Wait for button released
    while b.value() == 1:
        await asyncio.sleep_ms(50)

async def main():
    global program_number
    led = Pin(2, Pin.OUT)
    led.value(0)
    button = Pin(32,Pin.IN,Pin.PULL_DOWN)
    while True:
        await wait_for_button_pulsed(button)
        program_number = 0
        await program0()
        led.value(1)

        await wait_for_button_pulsed(button)
        program_number = 1
        await program1()
        led.value(0)

asyncio.run(main())

[PatLub85]

I assure you my goal is not to manage a nuclear power plant !
I have a robot car that has two independent programs
With the first the car is autonomous thanks to an ultrasonic detector (hcsr04) and with the second I control it with a microdot server and a web interface on my phone.
My idea is to have the 2 programs in the ESP32 and to switch from one program to the other with a push button.
But more generally, to make several programs coexist and use them alternately? That's my challenge

[PatLub85]

For Shariltumin
At the beginning of my reflection I hesitated to use threads or asyncio
I thought that asyncio was simpler
Moreover I used them with Microdot and that's why I tried this track.
I will look at how threads work starting from scratch but as you say, we are here to learn

[glenn20]

From my understanding of your use case, I believe it is easily achieved. However, whether you use asyncio or not, your needs require that prog1 and prog2 are written to stop themselves when asked.

Note of clarification:

• In your statement you said:
  • you want prog1 and prog2 "to be launched alternately each time a button is pressed."
  • But, your program seems to run prog1 and prog2 in parallel and pauses prog1 and resumes prog2, etc.
    • In my proposed solution below, I assume the former interpretation

In either case, you need to write prog1 and prog2 to work cooperatively, eg. so that they will hear and accept a request to stop/pause. If you write an infinite loop into either, they are not working cooperatively. If you want it to work even when either prog behaves uncooperatively, you need a pre-emptive strategy (ie. one that forces a task to end or pause). You can use threads to achieve that (but it has traps for the inexperienced and limitations on interacting with hardware from both threads on some platforms).

If your progs can work cooperatively and you really do want to launch you progs on each button press, a really simple non-asyncio solution can be:

stop_prog: bool = False

def func(v):
  global stop_prog
  stop_prog = True

button.irq(trigger=Pin.IRQ_RISING, handler=func)

while True:
    time.sleep_ms(100) # Switch debounce delay
    stop_prog = False
    prog1()
    time.sleep_ms(100) # Switch debounce delay
    stop_prog = False
    prog2()

You need to write your prog1 and prog2 to periodically check the stop_prog flag and resond accordingly. eg. change your infinite loop to:

while not stop_prog:
        print("prog 1")

First question: in this example, does prog_1 (or prog_2) run for the duration of the main coroutine's asyncio.sleep(2) wait, exit, and start again? If so, this is not what I want

No. prog1 and prog2 run until they are stopped, but they may yield to each other whenever one makes an await.

Second question: If I run a program with an infinite loop, the button has no effect anymore

Yes. If you want to be able to pre-emptively kill or pause a prog unconditionally, you will need something else, eg. threads or just a soft or hard reset. asyncio (and my solution above) rely on cooperation beteween the tasks.

Unless you really have no control over the code for prog1 and/or prog2, it is much simpler just to use the non-asyncio method suggested above.

If you need asyncio for other reasons, you can make that work too, but you need to be careful to ensure prog2 does not resume execution till prog1 has agreed to suspend itself. You could use an asyncio.event to handle the synchronisation between the tasks (https://docs.micropython.org/en/latest/library/asyncio.html#class-event, https://docs.python.org/3/library/asyncio-sync.html#asyncio.Event)

[mendenm]

In the codes I run with microdot, I do put, in a slow supervisory loop, an occasional call to gc.collect() just to make sure. This is voodoo programming, but it probably doesn't hurt anything.

[glenn20]

If you mean that prog2 calls async.run() (or equivalent) to start microdot as an async task, then that should be fine. You will just need to stop all tasks (including microdot) when prog_ctrl.stop is set True before exiting prog2().

[glenn20]

If both prog1() and prog2() have large module-scoped memory buffers, they will not be cleaned up by gc.collect() and you will just have to have enough RAM to accommodate both (as well as any dynamic memory required by whichever of prog1 and prog2 is running).

IF that becomes an issue (it probably won't be), then there are techniques you can use (such as module unloading or rewriting your module to not use large module-scoped buffers or rebooting from prog1 into prog2 using techniques we have discussed before OR buying a module with more RAM 😉).

[glenn20]

If you mean that prog2 calls async.run() (or equivalent) to start microdot as an async task, then that should be fine. You will just need to stop all tasks (including microdot) when prog_ctrl.stop is set True before exiting prog2().

Eg. Something like....(Untested)...

from microdot import Microdot 
import prog_ctrl

app = Microdot() 

@app.route('/') 
async def index(request): 
      return 'Hello, world!' 

async def monitor(app):
    while not prog_ctrl.stop:
        await asyncio.sleep_ms(500)
    app.shutdown()

asyncio.run(
    asyncio.gather(
        app.start_server(),
        monitor(app),
    )
)

I believe app.shutdown() will cause the microdot server to start shutting down immediately (and not wait till after the next url access), but if it doesn't, you may need to cancel the task to force it to shutdown.

[PatLub85]

Je me suis remis sur mon projet et voici où j'en suis :
L'astuce de Glenn (stop_prog) fonctionne parfaitement.
Par contre j'ai eu des soucis avec les rebond du bouton poussoir.
J'ai trouvé une solution sur ce site https://github.com/jmcclin2/updebouncein/blob/main/README.md
qui donne satisfaction

from debounced_input import DebouncedInput
pin = (Pin(18, Pin.IN, Pin.PULL_DOWN))
compteur=0
def callback(pin, pressed,duration_ms ):
    global compteur
    if (pressed):
        compteur +=1
        prog_ctrl.stop = True

button = DebouncedInput(18, callback, pin_pull=Pin.PULL_DOWN)
# and the launch of the two programs
def main():
    while True:
        if compteur % 2 :
            prog_ctrl.stop = False
            gc.collect()
            prog1()
        else:
            prog_ctrl.stop = False
            gc.collect()
            prog2()        

if __name__ == "__main__":
    main()

But what I feared happened when I launched the second program that imports Microdot
I have this message:

Traceback (most recent call last):
  File "<stdin>", line 8, in <module>
  File "prog_1_2.py", line 10, in <module>
MemoryError: memory allocation failed, allocating 2344 bytes

The line 10

from microdot import Microdot,Response,send_file

Je vais ouvrir une autre discussion pour ce problème