Asyncio comprehension problem

[PatLub85]

Hi,
I'm trying to use asyncio with an ESP32 but I'm having some difficulty understanding!
Here is what I would like to do:
I start prog_1 because the flag is True
If I press the push button, the flag is False and I switch to prog_2, press again the push button, prog_1, etc.
I use Peter Hinch's pushbutton.py

import uasyncio as asyncio
from primitives import Switch
from machine import Pin
from time import sleep
flag = True

async def prog_1():
    while True:
        print('program 1')
        await asyncio.sleep(1)

async def prog_2():
    while True:
        print('program 2')
        await asyncio.sleep(1)
        
async def pulse(led,ms):
    global flag
    flag=not flag
    led.value(1)
    await asyncio.sleep_ms(ms)
    led.value(0)

async def button():
    led = Pin(2, Pin.OUT)
    sw = Switch(pin)
    sw.close_func(pulse, (led,1000))  # Note how coro and args are passed
    await asyncio.sleep(5)  

async def main():
    global pin
    pin = Pin(18, Pin.IN, Pin.PULL_UP)  # Hardware: switch to gnd
    while True:
        print('flag',flag)
        await asyncio.sleep(1)
        if flag:
            task = asyncio.create_task(prog_1())
            await task 
        else:
            task = asyncio.create_task(prog_2())
            await task 
        
asyncio.run(asyncio.gather(main(), button()))

What I get is prog_1, when I press the push button, the led turns on and off normally, but prog_1 loops and don't give back hand to prog_2.
Where is my mistake?
Thanks in advance

[peterhinch]

Your prog_x tasks never terminate because they are infinite loops. So issuing await task will stall forever. One option is to rewrite them:

async def prog|_1():
    print('program 1')
    await asyncio.sleep(1)

[PatLub85]

Hi Peter,
prog_1 and prog_2 are two independent programs, each with a while True loop. And my idea is to switch them with the push button.
To avoid bounces, I used your solution and this allows me to try to understand the use of asyncio.

[shariltumin]

If you have several independent tasks, for example; prog_1 and prog_2 and you want to use an event-driven style of programming then you need to signal the event (go) and the event value (flag).

The simple code below shows the basic principle:

import asyncio
from time import sleep, ticks_ms
flag,go = True,False # value and trigger

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 = ticks_ms()%4 == 0 # simulate button press
        go = True                # set button event
        print('flag',flag)
        await asyncio.sleep(5)

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

I hope you find this example code useful.

[PatLub85]

Hi,
your program works wonderfully
Thanks a lot

[peterhinch]

The key point is not to await a task with an infinite loop, as you'll wait forever.

To run such a task you need to launch it. One way is with gather as in the example of @shariltumin. The other way is to use task = asyncio.create_task(coro()) as in your original example but let the task run free. Don't await it!

[PatLub85]

Hi,
I understood that the principle was the following:

• launching an async function def foo() with asyncio.run(foo())
• execution of async def foo() until the next await asyncio.sleep(x) which returns control to the scheduler
  So I thought that when my prog_1 and prog_2 came to await asyncio.sleep(1), the scheduler let async def button() do its job correctly.
  I don't think I've fully understood the principle yet.

[shariltumin]

You can think of async functions as a special type of function, but they behave in a similar way to normal functions.

In normal functions like v = t(s(4)), where the assignment to v waits for t to finish, and t has to wait for s to finish.

Now for w = await ta( await sa(4)), w waits for ta, and ta waits for sa. But these awaits are special, they are non-blocking. This means that while ta is waiting for sa, another (if any) async function in the run-queue ready to run will be executed.

The await asyncio.sleep(x) is used to pause a running function so that other functions in the run-queue have a chance to continue running.

Like a normal function, await will wait for the called function to return. If the called function never returns, then the caller will stall indefinitely.

To show how similar normal and async functions are, here is a simple example:

import asyncio

def s(n):
    return n*2
 
def t(n):
    return n/2
    
v = t(s(4))
print(v)

async def sa(n):
      return n*2

async def ta(n):
      return n/2
 
async def w():
     w = await ta( await sa(4))
     print(w)
 
asyncio.run(w()) # cant use await outside async function

[PatLub85]

Hi, question for Peter,
In the switch.py program, there are two functions def open_func and def close_func. How should we use them. In the example I used, there is only the function sw.close_func.

async def pulse():
    global flag
    flag=not flag
    await asyncio.sleep_ms(10)

async def button():
    pin = Pin(18, Pin.IN, Pin.PULL_UP)  # Hardware: switch to gnd
    sw = Switch(pin)
    sw.close_func(pulse)
    await asyncio.sleep(2)

Thanks in advance

[peterhinch]

You can assign a callback to open, close, both or neither; in the last case you use Event instance(s) in place of callbacks. Let's assume you want a callback on closure. Your code can look like this:

import uasyncio as asyncio
from primitives import Switch
from machine import Pin

pin = Pin(18, Pin.IN, Pin.PULL_UP)
sw = Switch(pin)
led = Pin(2, Pin.OUT)
flag = False

async def pulse(led,ms):
    global flag
    flag = not flag
    led.value(1)
    await asyncio.sleep_ms(ms)
    led.value(0)

async def prog_1():
    while True:
        print('program 1')
        await asyncio.sleep(1)

async def prog_2():
    while True:
        print('program 2')
        await asyncio.sleep(1)

async def main():
    sw.close_func(pulse, (led, 1000))   # Assign the callback once only
    while True:
        print('flag',flag)
        await asyncio.sleep(5)

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

Here is an example using the Event-based interface

```python
import uasyncio as asyncio
from primitives import Switch
from machine import Pin

pin = Pin(18, Pin.IN, Pin.PULL_UP)
sw = Switch(pin)
sw.close_func(None)   # Instantiate a .close Event
led = Pin(2, Pin.OUT)
flag = False

async def pulse(led, ms):
    global flag
    while True:
        await sw.close.wait()   # Wait for switch closure
        sw.close.clear()  # Clear the Event
        flag = not flag
        led.value(1)
        await asyncio.sleep_ms(ms)
        led.value(0)

async def prog_1():
    while True:
        print('program 1')
        await asyncio.sleep(1)

async def prog_2():
    while True:
        print('program 2')
        await asyncio.sleep(1)

async def main():
    while True:
        print('flag',flag)
        await asyncio.sleep(5)

asyncio.run(asyncio.gather(main(), prog_1(), prog_2()), pulse(led, 1_000))