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)

[glenn20]

Re. Qn 2, microdot will print that meessage if you set debug=True ie: app.start_server(debug=True).

Re. Qn 1, I'm not sure about that, but I suggest trying the following: rename async def shutdown(request) to something else (it may clash with some internal microdot functions) and possibly rename '/shutdown' as well - in case microdot treats that route specially.

[PatLub85]

Hi,
Qn2 : ok, thanks
Qn1: I made the changes but I have the same result.
However, it seems to me that the callback function of the main program does not increment the counter variable (only when I press the stop button on the web page). Which makes main.py restart prog1
Otherwise, the counter increments normally
main.py

from debounced_input import DebouncedInput
compteur=0

def callback(pin, pressed,duration_ms ):
    global compteur
    if (pressed):
        compteur +=1
        prog_ctrl.stop = True

DebouncedInput(18, callback, pin_pull=Pin.PULL_DOWN)

def main():
    while True:
        print("compteur",compteur)
        if compteur % 2 :
            prog_ctrl.stop = False with microdot
            car_web() #prog1
        else:
            prog_ctrl.stop = False
            autonome() #prog2

In summary, if I run main.py we have the following sequences:
counter=0 -> prog2
press push button
counter=1 -> prog1
press push button
counter=2 -> prog2
press push button
counter=3 -> prog1
Stop button on the web page
counter=3 -> prog1

[glenn20]

Ah, I can see that you have changed the logic in the main() function. That would explain the problem.

When you press the button, proctrl.stop is set AND the counter is incremented. The microdot shudown() route sets prog_ctrl.stop but does NOT increment the counter. So, when you press the stop button on the web page, it stops microdot and then starts it up again (because the counter has not been changed.

TO fix, either:

• increment the counter in microdot as well (you will need to make it globally accessible to the microdot code - like we did for prog_ctrl.stop) OR
• Change main() to:

def main():
    while True:
        print("compteur",compteur)
        prog_ctrl.stop = False
        car_web() #prog1
        print("compteur",compteur)
        prog_ctrl.stop = False
        autonome() #prog2

I would recommend the second approach. The use of the counter is unnecessary for toggling between the programs (and just complicates the business logic, leading to possible errors like this), but it has usefulness as a diagnostic that your button presses are being detected.

[PatLub85]

Thinking about it I realize that what is happening is logical. If I am in prog1 (microdot) and I press stop, I stop the server and I return to main.py WITHOUT going through the interruption, therefore without incrementing the counter!
In this logic we can simplify in this way:
main.py

def callback(pin, pressed,duration_ms ):
    if (pressed):
        prog_ctrl.compteur = not prog_ctrl.compteur
        prog_ctrl.stop = True
DebouncedInput(18, callback, pin_pull=Pin.PULL_DOWN)
def main():
    while True:
        if prog_ctrl.compteur :
            prog_ctrl.stop = False
            car_web()
        else:
            prog_ctrl.stop = False
            autonome() 

and car_web() ->prog1

@app.route('/fin')
async def termine(request):
    prog_ctrl.stop = True
    prog_ctrl.compteur = not prog_ctrl.compteur # the modification

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

On the other hand, in your second approach I don't understand how the switch between the two programs happens.

[PatLub85]

After thinking, I understood your second approach and now everything works
Thanks to all for your help.
With this project I learned to better use async, microdot, javascript.
My only regret is that I didn't get a response to my thread 13529 about fetch.
I didn't get any on javascript forums either!