Broadcast from multitasked routine ?

[zus2]

Getting "this resource cannot be used in two tasks at once." but I am only calling hub.ble.broadcast() in one place in one coroutine ?

Thanks.

[dlech]

Are you missing await?

https://docs.pybricks.com/en/latest/hubs/primehub.html#pybricks.hubs.PrimeHub.ble.broadcast

[zus2]

Hi David - yes that has helped except now there are intermittent errors which I can only catch with try: - throws an exception but the call still executes ??? - I suspect a timing thing to the broadcast call - what exactly does await function do at api/system level ?

[dlech]

await suspends the coroutine until the operation finishes. The broadcast function has to write the info to the Bluetooth chip, which takes some amount of time to complete.

[zus2]

As opposed to , for a non-await function call ? How is that different to normal blocking?

…

On 28 Apr 2025, at 21:53, David Lechner ***@***.***> wrote: await suspends the coroutine until the operation finishes. The broadcast function has to write the info to the Bluetooth chip, which takes some amount of time to complete. — Reply to this email directly, view it on GitHub <#2171 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AKHCFEY6C652HNZINRYLIZD232BNPAVCNFSM6AAAAAB4A4YZAWVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTEOJXGM3TKMA>. You are receiving this because you authored the thread.

[dlech]

Anything that has to communication over an I/O bus (e.g. UART, SPI, I2C) takes significantly longer than executing CPU instructions. So we consider these "blocking" functions and need to be awaited. This way, they don't prevent other coroutines from running.

Similarly, if you have long running or infinite loops, they need at least one await inside the loop to yield to other coroutines (await wait(0) is enough).

[zus2]

So Await basically sends the processor back to the main thread but with a note to return to the coroutine task once the function call completes? Thanks / I read that thread programming is even harder .. P

…

On 28 Apr 2025, at 22:32, David Lechner ***@***.***> wrote: Anything that has to communication over an I/O bus (e.g. UART, SPI, I2C) takes significantly longer than executing CPU instructions. So we consider these "blocking" functions and need to be awaited. This way, they don't prevent other coroutines from running. Similarly, if you have long running or infinite loops, they need at least one await inside the loop to yield to other coroutines (await wait(0) is enough). — Reply to this email directly, view it on GitHub <#2171 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AKHCFE7AONTQ2ABN7T5GBQL232F6XAVCNFSM6AAAAAB4A4YZAWVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTEOJXGQYDCMA>. You are receiving this because you authored the thread.

[dlech]

Not to the main thread directly, just to the caller. But each coroutine in the stack should do this, so eventual control gets back to the main thread after each coroutine has had a chance to run to the next await (or stays at a blocked await if it isn't done yet).

In Pybricks, we are a bit simplistic and usually just keep polling (asking is it done yet?) instead of scheduling the resume when done. But from a high-level it basically looks the same either way. So yes, you have the right idea.

[zus2]

Re: Broadcast OSError
I have isolated this issue by slowly adding simplified blocks of my program. This code repeatably throws a resource error on pressing Button.LEFT - I suspect it is not a bug but rather a problem in my code but I cannot see it? It also throws OSError on remote.light.on() occasionally. So it seems to be a resource clash between remote.light.on() and hub.ble.broadcast() ?

from pybricks.hubs import ThisHub
from pybricks.pupdevices import Remote
from pybricks.parameters import Button, Color
from pybricks.tools import wait, run_task, multitask

hub = ThisHub(broadcast_channel=1)

async def bt():

    await wait(0)
    
    while True:

        data = (1, 0)
        try:
            await hub.ble.broadcast(data)
            print("broadcast updated")
        except OSError as ex:
            print("broadcast error",ex)
        
        #print("broadcasting ..")

        await wait(200)

async def task1():
    while True:
        print("here 1")

        await wait(300)

async def task2():
    while True:
        print("here 2")

        await wait(300)

async def controller():
    while True:
        pressed = ()
        try:
            await remote.light.on(Color.GREEN)
                #print("light updated")
        except OSError as ex:
                print("remote light error",ex)
                
        while not pressed:
            await wait(0)
            pressed =  remote.buttons.pressed()

        if Button.LEFT in pressed:
            try:
                await remote.light.on(Color.RED)
                #print("light updated")
            except OSError as ex:
                print("remote light error",ex)
                
        await wait(50)

def main():
    await multitask(bt(),
    task1(),
    task2(),
    controller()
    )

print ("Looking for remote ..")
try:
    remote = Remote(timeout=20000)
except OSError as ex:
    print ("Not found ..")

run_task(main())

[laurensvalk]

remote.light.on and hub.ble.broadcast both use Bluetooth. When both are called at the same time, you'll see this resource cannot be used in two tasks at once.

You could resolve it as follows:

• Instead of calling hub.ble.broadcast directly, instead set a variable such as broadcast_data to your desired value.
• Instead of calling remote.light.on directly, instead set a variable such as remote_color to your desired value.
• In a new parallel task, do the following in a loop:
  • if broadcast_data does not equal old_broadcast_data (depending on your data, perhaps check equality by element)
    • then broadcast(broadcast_data)
    • set old_broadcast_data equal to broadcast_data
  • if remote_color does not equal old_remote_color
    • then remote.light.on(remote_color)
    • set old_remote_color equal to remote_color
  • await wait(0)

Then you can still keep your code almost unchanged, and let this one parallel task take care of Bluetooth. This will always do one at a time, but still be very fast.

[zus2]

So the 100ms BT broadcast cycle starts afresh when broadcast() is called ? , and at the same time as I am updating remote.light.

Fab thanks 👍

( I am not actually repeatedly calling broadcast() like in the example above , only when data changes , but the same result )

[laurensvalk]

I think the cycle is actually even faster than that, but indeed. The key is to ensure to call methods that use Bluetooth after one another instead of simultaneously. You can implement it any way you like. You could also build your own queue, for example, but the approach above is nice and simple.

[zus2]

Yes that does it. I would have thought that the async interleaving cannot clash - and would therefore give the same result as the procedured BT calls - which is basically instant. But It mustn't work like that. Many thanks guys. Amazing projet.