Creating an asyncio task from within an interrupt handler?

[IcedRooibos]

I have the following code where I create an asyncio task from within the interrupt handler callback

import machine
import uasyncio


async def callback_async(pin):
    await uasyncio.sleep(1)
    print("async callback complete")

# Create callback_async task
def callback(pin):
    uasyncio.create_task(callback_async(pin))
    print("blocking callback complete")

# Set callback as the interrupt handler
p = machine.Pin(21, mode=machine.Pin.IN, pull=machine.Pin.PULL_UP)
p.irq(trigger=machine.Pin.IRQ_FALLING, handler=callback)

# Just a function I use to run the event loop - not important
async def runEventLoop(seconds):
    print("start running event loop")
    for i in range(seconds):
        await uasyncio.sleep(1)
    
    print("stop running event loop")    

# Run the event loop for 3 seconds
uasyncio.run(runEventLoop(3))

print("script complete")
    

And the output is as below if I press the button once (not debounced)

start running event loop
blocking callback complete
blocking callback complete
blocking callback complete
blocking callback complete
blocking callback complete
async callback complete
async callback complete
async callback complete
async callback complete
async callback complete
stop running event loop
script complete

However the micropython documentation suggests that I should avoid memory allocation from within the interrupt handler.

Avoid memory allocation: no appending to lists or insertion into dictionaries, no floating point.

Does creating an asyncio task allocate memory? Should I avoid what I'm doing here?

[IcedRooibos]

Did a quick test and checked free memory from within the callback

# Create callback_async task
def callback(pin):
    before = gc.mem_free()
    uasyncio.create_task(callback_async(pin))
    after = gc.mem_free()
    print(f"free memory after creating task: {before}")
    print(f"free memory after creating task: {after}")
    print("blocking callback complete")

And the output is:

free memory after creating task: 157616
free memory after creating task: 157536

Does this mean that creating a task does indeed allocate memory and I should avoid what I am doing? Is there a way to use a pre-existing task and just set it to run from within the callback?

[IcedRooibos]

Is this the better way to do it then?

triggered = False

async def callback_async():
    global triggered
    while True:
        if triggered:
            await uasyncio.sleep(1)
            print("async callback complete")
            triggered = False
        await uasyncio.sleep(0.2)

# Create callback_async task
def callback(pin):
    global triggered
    triggered = True
    print("sync callback completed")

Seems to work ok - but bit more convoluted so if I can just create tasks from within the callback that would be ideal but if not I'm happy to use this. Nice thing about this is it pretty much has built-in debouncing.

[peterhinch]

There are subtle hazards in creating a task in a callback. I suggest you read this doc which goes into interfacing interrupts with uasyncio. If you are interfacing switches or pushbuttons, see this tutorial section. There are ready-made classes to do this.

[IcedRooibos]

Wow this is extremely helpful Peter, thank you for pointing me in the right direction. Yes I am in-fact interfacing to a push button in this case and those ready-made classes look great.

Much appreciated.

[IcedRooibos]

Edit: Apologies - found the code here: https://github.com/peterhinch/micropython-async/tree/master/v3. I am just going to download it and place it in my lib folder - is that the correct approach?

Original message:

I can't seem to figure out how to install the primitives library from this example: https://github.com/peterhinch/micropython-async/blob/master/v3/docs/DRIVERS.md#41-pushbutton-class

from pyb import LED
from machine import Pin
import uasyncio as asyncio
from primitives import Pushbutton

def toggle(led):
    led.toggle()

async def my_app():
    pin = Pin('X1', Pin.IN, Pin.PULL_UP)  # Pushbutton to gnd
    red = LED(1)
    pb = Pushbutton(pin)
    pb.press_func(toggle, (red,))  # Note how function and args are passed
    await asyncio.sleep(60)  # Dummy

asyncio.run(my_app())  # Run main application code

I checked uasyncio.version and I seem to have 3 but trying to load primitives leads to an error. Currently using a Pi Pico W but had the same issue on an ESP8266.

>>> uasyncio.__version__
(3, 0, 0)
>>> import primitives
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: no module named 'primitives'
>>> import uasycnio.primitives
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: no module named 'uasycnio'

[peterhinch]

Installation is documented here. The primitives (and the tests if you want to run them) should be placed in subdirectories on the target.

[IcedRooibos]

Thank you Peter, much appreciated.