Micropython interface for switching Pin and Timer IRQs on and off?

[TomFahey]

Premise

A feature which I've always been surprised to see missing in the Micropython machine.Pin and machine.Timer libraries is the ability to enable and disable an IRQ which has been created, without having to specify the callback handler and trigger conditions/timer period again.

As far as I'm aware, at the moment, the only way to disable a Timer object is to call deinit(), which gets rid of the previously specified mode, period and callback parameters, meaning that an instantiated Timer object can't simply have its underlying interrupt enabled/disabled, without having to re-specify those parameters when enabling it again.

It's a somewhat similar story with Pin.irq as far as I can tell - here, one has to call Pin.irq(trigger=0) to disable a pin interrupt, meaning that if you want the Pin interrupt to function again, you have to supply the handler and trigger parameters again.

This feels rather clumsy and somewhat limiting in my opinion, as any time Part Y of a program wants to enable/disable interrupts that were initialized by Part X - in response to some particular event, for example - it will have to know the original parameters that Part X supplied - which does feel a little clumsy to me, if I'm honest.

Suggestion

An interface to enable/disable interrupts using the machine.Pin.irq()/machine.Timer objects directly: e.g

mytimer = machine.Timer(mode=Timer.PERIODIC, period=update_interval, handler=my_callback)
mytimer.enabled(False)
.... # Some state change
mytimer.enabled(True) # Enable Timer without having to specify period/handler args again


class SPIDeviceDriver:

    def __init__(self, ..., drdy_pin, ...):
       self.drdy = machine.Pin(drdy_pin, mode=Pin.INPUT)
       self.irq = self.drdy.irq(handler=self.drdy_callback, trigger=Pin.IRQ_FALLING)
       self.irq.enabled(False)
    
    ....

mySPIDevice = SPIDeviceDriver(...)
... # Receive some kind of external 'start' command
mySPIDevice.irq.enabled(True) # Enable interrupt, without having to specify cb function/trigger condition 
... # Receive 'stop' command
mySPIDevice.irq.enabled(False) # Disable interrupt

A common implementation between Timers and Pin Interrupts might be especially useful, as it could possibly allow the same code to be reused whether the interrupt in question is triggered externally or according to a periodic count.

Implementation

As I've been primarily been using the Pico 2 as my MP development platform, I thought I'd try to explore the feasibility of implementing this feature for machine.Pin on the rp2 port, as a test case. Consulting the Pico C SDK, the gpio_set_irq_enabled function looked promising, through which I was able to come up with a working implementation which can be found here.

Pin interrupts can be created as usual,

drdy = machine.Pin(drdy_pin, mode=Pin.INPUT)  # Data ready pin of external SPI device.
drdy.irq(handler=read_rdata_register, trigger=Pin.IRQ_FALLING) # Read data on SPI bus when device drives DRDY pin low

Calling irq().enabled() without any arguments returns the state of the interrupt (whether it is enabled or not); supplying True as an argument will enable it, False disables it:

drdy.irq().enabled() # Returns True
drdy.irq().enabled(False) # Disable interrupt
dyd.irq().enabled() # Returns False
dyd.irq().enabled(True) # Enable interrupt

This was tested using v1.24.0, but I don't think there should be any problems using it on v1.25.0.

Question

Does this feature seem useful to anyone else? The fact that it hadn't already been implemented has me wondering whether there's a particular reason not to do so...am I missing anything?

[Josverl]

a third parameter, disabled can be specified, determining whether the IRQ should be enabled right away. This defaults to False

I think enabled =True as a default avoids double negative logic

[TomFahey]

Having looked at my implementation again (it's been a few weeks since I wrote it), I think I actually removed the disabled keyword argument (for much the same logic that you mentioned), but forgot to remove a comment describing it. I'll edit the original post to reflect this.

[peterhinch]

I don't think this ha ever been requested before. I guess people have worked round this in the ISR:

def my_irq_callback(_):
    if my_irq_enabled:  # Global
        # handle interrupt

[TomFahey]

That is indeed a much more simple approach! 🤦‍♂️

I suppose a small downside of this method, however, is that the ISR still has to be serviced by the microprocessor, even when my_irq_enabled is not set, although the overhead is presumably negligible - a few 10s of microseconds, I would guess?

[GitHubsSilverBullet]

Won't make a noticeable difference if one gets a few hundreds of IRQs per second.
Will make a difference at 100k IRQs per second.

[TomFahey]

I think I have the answer to my question then 😄