asyncio newbie question

[kb6nu]

I’m a newbie to the Pico and Micropython. I’ve started a project that uses a Pico and five pushbuttons for input. I did some coding with interrupts and polling and got some basic functionality to work, but then I discovered asyncio. It seems to me a better way of handling the pushbuttons than the way I was doing it.

I found some code in the documentation for micropython-async for the Pushbutton class in the DRIVERS.md file, and played around with it. Here’s what I came up with:

from machine import Pin
import asyncio
from primitives import Pushbutton

led = Pin(25, Pin.OUT)  #onboard LED

def short_press():
    print ("SHORT PRESS")
    led.high()

def long_press():
    print ("LONG PRESS")
    led.low()

async def my_app():
    pin = Pin(6, Pin.IN, Pin.PULL_UP)  # Pushbutton to gnd
    pb = Pushbutton(pin)
    pb.long_func(long_press, ())  # Note how function and args are passed
    pb.press_func( short_press, ())  # Note how function and args are passed
    await asyncio.sleep(60)  # Dummy
    print ("DONE!")

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

This detects short and long presses, but I’m either not using this properly, or the pushbutton presses aren’t getting debounced, because I’m getting output like this:

SHORT PRESS
SHORT PRESS
SHORT PRESS
SHORT PRESS
SHORT PRESS
SHORT PRESS
LONG PRESS
LONG PRESS
LONG PRESS
LONG PRESS
LONG PRESS
LONG PRESS

Anticipating a future question, what I would also like to do is to call a function when I press a button and then recall that very same function if the button is still pressed once that function has completed. Is there a way to do that?

[beetlegigg]

I did a similar bit of playing just last weekend with the aim of working through some of @peterhinch tutorials and code he produces on async and switches and pushbuttons. The way I learn is to pinch his code but type it in to some code I produce to see if I can follow along. So your best bet is to have a deep peruse of https://github.com/peterhinch/micropython-async/blob/master/v3/README.md and some of Peters other readme files and to look at his switches and pushbutton classes. You will find interesting stuff relating to IRQ's v async polling for pushbuttons.

In case it helps I give my weekend snippet all mostly copied from Peter Hinches examples. I was using it on a rpi pico w that was put on one of those nice Cryton makerboards that includes three pushbuttons attached. (not sure if those pushbuttons have any on board pullups but they work splendidly with the debounce interval that Peter puts in his code)

from machine import Pin
import asyncio

debounce_ms = 50

lopen=1
pin = Pin(22, Pin.IN, Pin.PULL_UP)

press_event = asyncio.Event()  
release_event = asyncio.Event()
long_press_event = asyncio.Event()
vlong_press_event = asyncio.Event()

state = pin() ^ lopen  # Get initial state
print('state: ', state)
     
async def poll(pin,lopen, state, bounce):
    print('polling button')
    while True:
        if (s := pin() ^ lopen) != state:
            state = s
            press_event.set() if s else release_event.set()
        await asyncio.sleep_ms(bounce)  # Wait out bounce
    
# timers
async def long_press():
    while True:
        await long_press_event.wait()
        await asyncio.sleep_ms(500)
        long_press_event.clear()

async def vlong_press():
    while True:
        await vlong_press_event.wait()
        await asyncio.sleep_ms(1000)
        vlong_press_event.clear()
        
# button released 
async def released():
    while True:
        await release_event.wait()
        release_event.clear()
        #print('switch is off')

# button pressed        
async def pressed():    
    while True:
        await press_event.wait()
        print('switch is on')
        # start timers and await button release event
        long_press_event.set()
        vlong_press_event.set()
        await release_event.wait()
        # now check if timers are still running
        if long_press_event.is_set():
            print('a short press')
            long_press_event.clear()
            vlong_press_event.clear()
        elif vlong_press_event.is_set():
            print('a long press')
            vlong_press_event.clear()
        else:
            print('a very long press')
        press_event.clear()
        
async def main():
    asyncio.create_task(poll(pin, lopen, state, debounce_ms))
    asyncio.create_task(pressed())
    asyncio.create_task(released())
    asyncio.create_task(long_press())
    asyncio.create_task(vlong_press())
    print('waiting for button 22 to be pressed')
    while True:
        await asyncio.sleep(10)

try:
    asyncio.run(main())
except KeyboardInterrupt:
    print('Ctl C')

finally:
    print('finally is being actioned')
    asyncio.new_event_loop()

And if Peter happens to peruse this perhaps you could comment on
if (s := pin() ^ lopen) != state:
state = s
I had to remind myself what the jolly old walrus did. I did not think is was in Micropython as I thought it was only introduced into Python as a later date, and in any case I've never used it. Anyway is it coded as above because it gives a speed advantage to that line of code or would have done just as well.

 s = pin()   
 if s ^ lopen != state:
        state = s

Anyway a big thanks to Peter for making my push buttons work with short, long, and very long pushes. Splendid stuff.

[beetlegigg]

And its the next morning and I see I did not allude to your question of:

" Anticipating a future question, what I would also like to do is to call a function when I press a button and then recall that very same function if the button is still pressed once that function has completed. Is there a way to do that? "

I would think there is probably a solution based on asyncio button pressed, button released and function done events, but probably not if one is running different functions based on whether its a short or long press. ( but maybe the long press function to be run could be repeated I guess)

The repeated calling of a function if the button is still pressed Im thinking along the lines that the button pressed function will call this other function which will need to send a flag (or event) to indicate its finished so as only to run one version of this function at a time. I may have a go at this tomorrow to help complete my foray into push buttons as its an interesting thought. However I expect you may well get to a good solution before I do :-)

Just in case its of interest, the snippet I posted in previous reply was my first go at using the Peter Hinch event based push button stuff. I did go on to produce a more involved snippet based on a push button class and used it on a couple of pushbuttons to run some functions based on long and short presses that simply sleep for differing amounts of time for illustrative purposes. I post this more sophisticated code (all based on the Peter Hinch examples of course)

import asyncio

class PinWatch():
    pin_debounce_ms = 50
    
    def __init__(self, the_pin, short_func, long_func, vlong_func, pin_open = 1):
        self.the_pin = the_pin
        self.short_func = short_func
        self.long_func = long_func
        self.vlong_func = vlong_func
        self.pin_open = pin_open
        self.press_event = asyncio.Event()  
        self.release_event = asyncio.Event()
        self.long_press_event = asyncio.Event()
        self.vlong_press_event = asyncio.Event()
        self.state = self.the_pin() ^ self.pin_open  # Get initial state
        asyncio.create_task(self.pin_poll(PinWatch.pin_debounce_ms))
        asyncio.create_task(self.long_press())
        asyncio.create_task(self.vlong_press())
        asyncio.create_task(self.released())
        asyncio.create_task(self.pressed())
                            
    async def pin_poll(self, bounce):
        while True:
            if (s := self.the_pin() ^ self.pin_open) != self.state:
                self.state = s
                self.press_event.set() if s else self.release_event.set()
            await asyncio.sleep_ms(bounce)  # Wait out bounce

    # timers
    async def long_press(self):
        while True:
            await self.long_press_event.wait()
            await asyncio.sleep_ms(500)
            self.long_press_event.clear()

    async def vlong_press(self):
        while True:
            await self.vlong_press_event.wait()
            await asyncio.sleep_ms(1000)
            self.vlong_press_event.clear()
                           
    # button released 
    async def released(self):
        while True:
            await self.release_event.wait()
            self.release_event.clear()
            
    # button pressed        
    async def pressed(self):
        while True:
            await self.press_event.wait()
            # start timers and await button release event
            self.long_press_event.set()
            self.vlong_press_event.set()
            await self.release_event.wait()
            # now check if timers are still running
            if self.long_press_event.is_set():
                asyncio.create_task(self.short_func())
                await asyncio.sleep(0)
                print('short')
                self.long_press_event.clear()
                self.vlong_press_event.clear()
            elif self.vlong_press_event.is_set():
                asyncio.create_task(self.long_func())
                await asyncio.sleep(0)
                print('long')
                self.vlong_press_event.clear()
            else:
                asyncio.create_task(self.vlong_func())
                await asyncio.sleep(0)
                print('verylong')
            self.press_event.clear()
            
if __name__ == '__main__':
    from machine import Pin
    numf1 = 0
    numf2 = 0
    numf3 = 0
    numf4 = 0
    
    async def func_1():
        global numf1
        numf1 += 1
        loc_numf1 = numf1
        print('starting func 1 - num: ', loc_numf1)
        await asyncio.sleep(2)
        print('finishing func1 - num: ', loc_numf1)
        
    async def func_2():
        global numf2
        numf2 +=1
        loc_numf2 = numf2
        print('starting func 2 - num: ', loc_numf2)
        await asyncio.sleep(3)
        print('finishing func2 - num: ', loc_numf2)
        
    async def func_3():
        global numf3
        numf3 +=1
        loc_numf3 = numf3
        print('starting func 3 - num: ', loc_numf3)
        await asyncio.sleep(4)
        print('finishing func3 - num: ', loc_numf3)
        
    async def func_4():
        global numf4
        numf4 +=1
        loc_numf4 = numf4
        print('starting func 4 - num: ', loc_numf4)
        await asyncio.sleep(2)
        print('finishing func4 - num: ', loc_numf4)
        
    # instantiate push button instances of PinWatch class
    pin21 = PinWatch(Pin(21, Pin.IN, Pin.PULL_UP), func_1, func_2, func_3)
    pin22 = PinWatch(Pin(22, Pin.IN, Pin.PULL_UP), func_4, func_4, func_4)
    
    async def main():
        print('main is running')
        while True:
            await asyncio.sleep(0)

    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print('Ctl C')

    finally:
        print('finally is being actioned')
        asyncio.new_event_loop()

[kb6nu]

Thanks for your replies. I’ve been reading the documentation on this stuff and I’m still trying to bang this stuff into my head. I’m now thinking that using events is the way to go here, but I’m still flailing around.

[beetlegigg]

Well I gave the run a function when button pushed and run it again if still pushed a quick go with the asyncio events malarky and it was really rather a trivial task that took all of 10 minutes with a bit of cut and past. In the trivial example I enclose below the function blinks the pico on board LED on a button push and runs the function repeatedly whilst the button is still pressed. Not suggesting one would need all this asyncio event based push button polling to just blink on a button press, but I hope it illustrates the sort of code I was alluding to in my comment in the previous post. (now I will have to think of a more complicated thing to do for my Sunday programming hour :-o )

from machine import Pin
import asyncio

debounce_ms = 50

# pin connected to push button
button_pin = Pin(22, Pin.IN, Pin.PULL_UP)

# LED on rpi picoW
led = Pin("LED", Pin.OUT)

# create Events
press_event = asyncio.Event()  
release_event = asyncio.Event()
led_blink_event = asyncio.Event()

button_open = True  # button is open or closed circuit on program start.

state = button_pin() ^ button_open  # Get initial state of push buttion
     
async def poll(button_pin, button_open, state, bounce):
    print('polling button') 
    while True:
        if (s := button_pin() ^ button_open) != state:
            state = s
            press_event.set() if s else release_event.set()
        await asyncio.sleep_ms(bounce)  # Wait out bounce
 
# button released 
async def released():
    while True:
        await release_event.wait()
        release_event.clear()

# button pressed        
async def pressed():    
    while True:
        await press_event.wait()
        led_blink_event.set()
        await release_event.wait()
        press_event.clear()

async def led_blink():
    while True:
        await led_blink_event.wait()
        while press_event.is_set():
            led.on()
            await asyncio.sleep(0.5)
            led.off()
            await asyncio.sleep(0.5)
        led_blink_event.clear()
            
async def main():
    asyncio.create_task(poll(button_pin, button_open, state, debounce_ms))
    asyncio.create_task(pressed())
    asyncio.create_task(released())
    asyncio.create_task(led_blink())
    print('waiting for button 22 to be pressed')
    while True:
        await asyncio.sleep(0)

try:
    asyncio.run(main())
except KeyboardInterrupt:
    print('Ctl C')
finally:
    print('finally is being actioned')
    asyncio.new_event_loop()

[peterhinch]

@kb6nu Your code works fine here. Note that a long press causes the short press function to run once, followed by the long press. This is discussed under suppress in the docs. The cause of your problem is not obvious. Check electrical connections.

Re your second question here are three alternatives. Firstly using functions:

def func():
    # Actual payload code

def short_press(button):
    func()
    if button():
        func()

    pb = Pushbutton(pin)
    pb.press_func( short_press, (pb,))  # Pass the button as an arg

The second approach is to use coroutines. This is usually better because func, if correctly written, can take time to complete without hogging the processor.

async def func():
    # Actual payload code

async def short_press(button):
    await func()
    if button():
        await func()

    pb = Pushbutton(pin)
    pb.press_func( short_press, (pb,))  # Pass the button as an arg

The final option is to use an Event. This is functionally equivalent to the above coroutine approach, but I prefer the coding style:

async def func():
    # Actual payload code

async def do_short_press(button):
    while True:
        button.press.clear()  # Clear any pending event
        await button.press.wait()  # Wait for a button press
        await func()  # Launch the coroutine and wait for completion
        if button():  # If still pressed, launch the function again
            await func()

    pb = Pushbutton(pin)
    pb.press_func(None)  # use an Event
    asyncio.create_task(do_short_press(pb))

[kb6nu]

Thanks again for all your help so far. Can I ask another dumb question?

I have four buttons on this hardware I’m trying to program. I’d like to call a single function if the user presses one of those buttons. Is there a way to simply pass an int to the routine called by the press_func method? Failing that, how do I extract the pin number form the pb instance of the Pushbutton object?

And, more generally, is there a way to print the attributes of a MicroPython object? I tried a few things from the web that do this for Python objects, but they don’t seem to work in MicroPython.

[beetlegigg]

This is the the way I'm interpreting your question. I'm thinking that you want some different actions to take place depending on the button that is pressed, but you want just one function to be called initially (perhaps to determine a long or short press or something like that) and that function must see which button was actually pressed to cause the desired action to run.

But that what one of the examples above does in effect. In the example of the PinWatch class each instantiation of that class nominates the pin to watch and the function to run for that particular pin depending on a short, long or very long press. The example shows just two pins being used, but of course you can have as many pins as you want.

However I fear I may not be grasping what you require and there are no doubt lots of different ways to achieve to same outcome so the example may not be what you want but on the face of it, it appears to do the job.

I'm also not too clear on the printing attributes question and I presume a print(dir(pin22)) as taken from the instantiation of a PinWatch class is not what you are after. So hopefully over to a more enlighten one to give some better or alternative answers for you, but I though I would chime in with my answer in the hope that it helps.

[peterhinch]

Is there a way to simply pass an int to the routine called by the press_func method?

You can pass anything you want. Consider these two lines from my above examples:

    pb = Pushbutton(pin)
    pb.press_func(short_press, (pb,))  # Pass the button as an arg

It's possible to pass short_press to multiple pushbuttons so that each button runs the same function. Each button's press_func could pass a different tuple of args, enabling short_press(args) to determine which button was pressed.

In fact, passing the button itself as an arg (as in the example) also enables this to be done. Assume the buttons are global objects with names Button1, Button2, .. ButtonN:

def short_press(button):
    button_id = id(button)
    if buttonid == id(Button1):
        # Button 1 was pushed
    elif buttonid == id(Button2):
        # Button 2 was pushed

[kb6nu]

Thanks again. As I said, I’m a real newbie when it comes to Python, and I didn’t really understand the idea of a tuple of arguments. When I got my mind around that, I got it to work how I wanted.