Asyncio: Polling + ISR's... Bad combination

[nastiliano]

Hello everybody!

I've been reading that is not recommended to use ISR interruptions in general when you are using asyncio, for multiple important reasons... (some of them I understand, others not. I'm a junior junior programmer, sorry). but I thought that it would be very usefull in some simple cases with a just little bit of code in specific cases. For example:

Executing this code (synchronous, without asyncio):

from machine import Pin # type:ignore
from time import sleep

motion = False

def handle_interrupt(pin):
    global motion
    motion = True
    global interrupt_pin
    interrupt_pin = pin 

led = Pin(2, Pin.OUT)
pir = Pin(36, Pin.IN)

pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

while True:
    if motion:
    print('Motion detected! Interrupt caused by:', interrupt_pin)
    led.value(1)
    sleep(20)
    led.value(0)
    print('Motion stopped!')
    motion = False

is completly fine and it works.

But using the same strategy inside a task/coro doesn't work:

async def Device():
...
    a_boolean = False

    def ISR(Pin):
        global a_boolean
        a_boolean = True

    in2.irq(handler = ISR , trigger = machine.Pin.IRQ_RISING)

    while True:
        if a_boolean:
            print("Very well")

The scope of "a boolean" variable is never global, so "a boolean" always is False and we don't come into "if". What I'm doing wrong?? Maybe this is one important reason for not use this mix: asyncio + isr? Is there a solution?

Thank you very much.

[dlech]

https://github.com/peterhinch/micropython-async/blob/master/v3/docs/INTERRUPTS.md

[bixb922]

This has no relationship with asyncio. The a_boolean = False declares a local variable in the scope of Device() which is different from global a_boolean. If in doubt, please revisit python scoping rules.

Don't use global variables to communicate events between ISR and main loop. The ThreadSafeFlag has been specifically designed to do that signaling safely as described in the links provided above by @dlech. Please see the examples there.

Just curiosity: What is the reaction time you need for the interrupt?

[bixb922]

Just to clarify: "Polling a device" means a code like this:

    while True:
        while pin.value()==0:
            await asyncio.sleep_ms( 100 )
        ... Do something because the signal went from 0 to 1
        while pin.value()==1:
            await asyncio.sleep_ms( 100 )

No ISR is needed when polling.

[2dof]

So if You want to just "stop switch" , go to link given by @peterhinch ( Switch class in his tutorial (also read other uasyncio related issues Linking uasyncio and other contexts

Aware that ""Stop switch" that stops all execution" means a " kill switch" ( == power off -> another protection mechanism), but That what are you doing is controlling motor drive and all other (protection) sequences should be running.

I do not know what type of gate You want control (size, weigh etc), but that what You implementing is control unit for drive gate motor with protection it should be done with time sampling mechanism if You want to control gate speed too, then all sensors/protection switches have to be check in the control loop.

[rolandvs]

The STM timers/pwm have a feature to kill the pwm using a single gpio, independent from software. It can be configured in mpy. This is a nice feature to have.

[nastiliano]

So if You want to just "stop switch" , go to link given by @peterhinch ( Switch class in his tutorial (also read other uasyncio related issues Linking uasyncio and other contexts

Aware that ""Stop switch" that stops all execution" means a " kill switch" ( == power off -> another protection mechanism), but That what are you doing is controlling motor drive and all other (protection) sequences should be running.

I do not know what type of gate You want control (size, weigh etc), but that what You implementing is control unit for drive gate motor with protection it should be done with time sampling mechanism if You want to control gate speed too, then all sensors/protection switches have to be check in the control loop.

Hello again.

Exactly, this is what I want.
For example, my code was something like (I'm inventing and improvising):

...
def async Device():
    in_1= machine.Pin(36 , machine.Pin.IN)
    
    def stop(pin):
        print("hello?")
        global boolean_variable
        boolean_variable = True
    stop = machine.Pin(36 , machine.Pin.IN)
    stop.irq(handler = stop , trigger = machine.Pin.IRQ_FALLING)

    while True:
        if boolean_variable:
            boolean_variable = False
            break

         if in1.value() == 0:
             if boolean_variable:
                 boolean_variable = False
                 break
            #Start OPEN relay...

    await uasyncio.sleep_ms(50)

But this simple code doesn't work:
-1st: Interrupt is handled forever, when I execute this code, prints: hello, hello, hello, hello...
-2nd: A variable scope error occurs. It seems like "global" parameter don't work

I'm stuck here for weeks :)

[2dof]

in Your code:

• 2 times you defining machine.Pin(36 , machine.Pin.IN) as input in_1 and stop as this same pin and you are using
  these two objects: as irq source and for reading pin value - not need do that.
• do not define inside async function pins , better outside or in class object which will be your devise , all other functions ( irq handler, async can be then a define as members of class
• global boolean_variable is declared in stop(pin) function but should be also in def async Device()
• do not use break on if condition - make no sense since it is already end of 'if'

If source of interrupt is a mechanical (switch) it will be multiple triggering iqr because of connection vibrations , better learn how to use
Switch class - as example it is almost ready solution for your code ( you can define close_func() as your stop() , and open_func() to reset boolean_variable

see my demo (based on example from switch doc):

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

stop_flag = False

async def closed_switch():
    global stop_flag
    stop_flag = True 
    print('switch closed',stop_flag )

async def opened_switch():
    global stop_flag
    stop_flag = False 
    print('switch opened',stop_flag)
    
async def my_app():
    global stop_flag 
    stop_flag = False
    pin = Pin(4, Pin.IN, Pin.PULL_UP)                    # 
    sw = Switch(pin)
    sw.close_func(closed_switch)   
    sw.open_func(opened_switch)    
    await asyncio.sleep(100)  # Dummy application code

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

I said earlier that better define gpio outside function, but in this case my_app() is my main application (not a 'device')

Note that Switch class and other depended primitives form uasyncio drivers library must be downloaded and loaded to your
device ( they are not installed in uasyncio).

[nastiliano]

This is what I wanted! Thank you.

I re-adapted your code to mine and is working good with "polling"!
Now I can poll the device and make "important" interruptions.

I'm going to follow with my work :)

Thanks again to everybody.

Best regards.