Execute a function with an infinite loop via ir_rx

[matti318]

Hello, I would like to use ir_rx in the callback function to call a function that has an endless loop, but send another command to the function depending on the state of the key pressed.
My code shown below doesn't work.
How can you do that?

import queue
from machine import Pin
from ir_rx import NEC_16

def callback(data, addr, ctrl, qu):
    if data > 0:  # NEC protocol sends repeat codes.
        print('Data {:02x} Addr {:04x}'.format(data, addr))
        uasyncio.create_task(qu.put(data))      
        
async def blink(q):
    while True:
        if q == 44:
            print(await q.get())
          
async def main():
    q = queue.Queue()
    await q.put(1)
    ir = NEC_16(Pin(16, Pin.IN), callback, q)
    await blink(q)

uasyncio.run(main())```

[bixb922]

Could you please put three back ticks before and after the code?

[peterhinch]

Which queue library are you using? I would suggest the one described here which aims to replicate the API of CPython's asyncio queue.

In this case, the code looks OK except for

if q == 44

where this comparison would throw an exception. You'd need something like

async def blink(q):
    while True:
        if not q.empty():
            print(await q.get())

[matti318]

I used the queue module, but now I want to test the primitives one.

Which 'primitives' do you have to install on the Pico?

Edit:

If I
from primitives import Queue

then the error comes

File "/lib/primitives/init.py", line 2, in
File "/lib/_primitives/argument.py", line 15
SyntaxError: invalid syntax

[peterhinch]

I don't recognise _primitives or argument.py. I suggest you delete lib/primitives and start again. I did the following on a virgin Pico:

$ mpr mkdir :/lib
$ mpr mkdir :/lib/primitives
$ mpr cp primitives/* :/lib/primitives/
$ mpr
Connected to MicroPython at /dev/ttyACM0
Use Ctrl-] to exit this shell

>>> from primitives import Queue
>>> 

[matti318]

Where do I enter the commands?
and where can I get the right primitive from?
I don't know the "mp" command.

[bixb922]

The command mp or mpr are synonyms of mpremote. They are executed on the PC where the device is connected.

[matti318]

Ahh ok.
Where can I get the 'primitives' module?

[peterhinch]

Code is here. See the linked tutorial for docs.

[matti318]

OK that worked, but the code doesn't work like this yet.
When I start the program the output is 1 and then "Hello world".
If I then press a key, nothing comes from the blink() function.

def callback(data, addr, ctrl, qu):
    if data > 0:  # NEC protocol sends repeat codes.
        print('Data {:02x} Addr {:04x}'.format(data, addr))
        uasyncio.create_task(qu.put(data))      
        
async def blink(q):
    while True:
        if not q.empty():
            print("hello world")
            print(await q.get())
        
          
async def main():
    q = Queue()
    await q.put(1)
    ir = NEC_16(Pin(16, Pin.IN), callback, q)
    await blink(q)

uasyncio.run(main())

The edition:

hello world
1
Data 45 Addr 0000
Data 46 Addr 0000

[karfas]

Your blink() function never gives the task created by callback() a chance to run, even if NEC_16 (have no idea what this is/does) somehow manages to call callback().

Maybe you should read a little more about (u)asyncio, e.g. @peterhinch's tutorial ?

[peterhinch]

[EDIT] Please see below.

[karfas]

@peterhinch: Why is blink() OK ? q.empty() will return true most of the time, so this is an endless loop without any await.

[peterhinch]

Well spotted. .empty() is a synchronous method so blink() locks up the scheduler. It should read:

async def blink(q):
    while True:
        if not q.empty():
            print("hello world")
            print(await q.get())
        await asyncio.sleep(0)

[peterhinch]

There is also a more subtle issue here.

The callback from the micropython_ir library runs in a soft ISR context because it is launched by a soft timer callback [code]. This means it can pre-empt uasyncio, disrupting its internal state. This is discussed here. The outcome could be rare, hard to diagnose, faults.

The callback should not launch tasks. Further, the standard Queue class (like CPython's) is not thread safe. One solution is to use the ThreadSafeFlag with the callback triggering the TSF and a task waiting on it. A simpler approach is to use the ThreadSafeQueue as below:

from threadsafe import ThreadSafeQueue
from machine import Pin
from ir_rx import NEC_16

def callback(data, addr, ctrl, qu):  # Runs in a soft ISR context
    if data > 0:  # NEC protocol sends repeat codes.
        print('Data {:02x} Addr {:04x}'.format(data, addr))
        if not qu.full():
            qu.put_sync(data)
        
async def blink(q):
    async for data in q:  # Task will pause until data available
        print("Hello world")
        print(data)
          
async def main():
    q = ThreadSafeQueue([0 for _ in range(20)])
    await q.put(1)
    ir = NEC_16(Pin(16, Pin.IN), callback, q)
    await blink(q)

uasyncio.run(main())

[peterhinch]

I have added this note to the docs.

[matti318]

Since I get the error that int does not contain 'len':

Traceback (most recent call last):
File "", line 23, in
File "uasyncio/core.py", line 1, in run
File "uasyncio/core.py", line 1, in run_until_complete
File "uasyncio/core.py", line 1, in run_until_complete
File "", line 18, in main
File "/lib/threadsafe/threadsafe_queue.py", line 15, in init
TypeError: object of type 'int' has no len()

[peterhinch]

Apologies. I'm trying to do too many things at once at the moment...

I have edited the code above. The ThreadSafeQueue constructor requires a buffer as its arg.

[matti318]

Thanks, that worked fine.
Only I want to call functions that contain "while True" and end them with break depending on the state (from outside).
I want to have different functions that make the LED blink until I press another button (it's supposed to be a light tube). Would something like that be possible?

[peterhinch]

I'm not entirely sure what you have in mind but perhaps task cancellation fits the bill. Your led flash task might look like:

async def toggle_led(led_pin):  # Pass a Pin instance
    try:
        while True:
            await asyncio.sleep(1)
            led_pin(not led_pin())  # Toggle LED
    finally:  # Ensure LED turns off when cancelled
        led_pin(0)

Taking a reference to the task and cancelling it are as per the linked doc.

[matti318]

292 / 5.000
Übersetzungsergebnisse
Übersetzung
What I mean is that by checking if I then break the infinite loop.

My goal is to have different functions where some of them also have an infinite loop.
I would like to cancel as soon as any X key was pressed. like my example.

def callback(data, addr, ctrl, qu):  # Runs in a soft ISR context
    if data > 0:  # NEC protocol sends repeat codes.
       # print('Data {:02x} Addr {:04x}'.format(data, addr))
        if not qu.full():
            qu.put_sync(data)
  
  
async def blink(q):
    async for data in q:
        print(data)
        while True:
            print("Hello world")
            if  data == 70:
                break
            await uasyncio.sleep(1)
          
async def main():
    q = ThreadSafeQueue([0 for _ in range(20)])
    await q.put(1)
    ir = NEC_16(Pin(6, Pin.IN), callback, q)
    await blink(q)
    

uasyncio.run(main())```

[peterhinch]

I'm still not entirely sure what you have in mind. Something like this?

tasks = []
async def check_queue(q):  # Runs forever
    async for data in q:
        if data == 70:
            for task in tasks:
                task.cancel()

async def blink():
    while True:
        await asyncio.sleep(1)
       print("Hello world")

async def main():
    q = ThreadSafeQueue([0 for _ in range(20)])
    await q.put(1)
    ir = NEC_16(Pin(6, Pin.IN), callback, q)
    tasks.append(asyncio.create_task(blink)  # Could add other tasks
    await check_queue(q)

[matti318]

Thank you very much, that's exactly what I was looking for.
Here my code:

from machine import Pin
from ir_rx import NEC_16
import uasyncio



def callback(data, addr, ctrl, qu):  # Runs in a soft ISR context
    if data > 0:  # NEC protocol sends repeat codes.
        print('Data {:02x} Addr {:04x}'.format(data, addr))
        if not qu.full():
            qu.put_sync(data)
  
tasks = []
async def check_queue(q):  # Runs forever
    print("w")
    async for data in q:
        print(data)
        for task in tasks:
            task.cancel()
        if data == 69:
            tasks.append(uasyncio.create_task(blink1()))
        elif data == 70:
            tasks.append(uasyncio.create_task(blink2()))
        
       
async def blink1():
    while True:
        await uasyncio.sleep(1)
        print("blink1")
        
async def blink2():
    while True:
        await uasyncio.sleep(1)
        print("plink2")

async def main():
    q = ThreadSafeQueue([0 for _ in range(20)])
    await q.put(1)
    ir = NEC_16(Pin(6, Pin.IN), callback, q)
   # tasks.append(uasyncio.create_task(blink())) # Could add other tasks
    await check_queue(q)

uasyncio.run(main())

It probably works in python3 too, doesn't it?

[peterhinch]

In general uasyncio code is portable. The IR library is not tested under Python3 because of its need for external hardware.