uasyncio.create_task does not run coro

[webdeb]

Before I start an issue, just wanted to know, if I am doing smth wrong. This basic example should start a loop and after one calls the stop method it should stop. However, the print("while loop") gets not executed at all.

• rp2040 Zero (Pico)
• Thonny IDE

import uasyncio
import utime

class Test:
    def __init__(self):
        pass
    
    def run_loop(self):
        self.should_run = 1
        uasyncio.create_task(self._while_loop())

    async def _while_loop(self):
        print("while loop") # gets never called!
        counter = 0
        while self.should_run == 1:
            counter += 1
            print(counter)
            await uasyncio.sleep_ms(100)
    
    def stop(self):
        self.should_run = 0
        print("should stop now")

test = Test()
test.run_loop()
print("looop started.. wait..")
utime.sleep(3)
print("...waited..")
test.stop()

[rkompass]

As you can see in Peter Hinchs asyncio tutorial also the statements below, that wait, should be in an asyncio context, e.g. in an async def main(): ... function.
There you may use await asyncio.sleep(3) instead of utime.sleep(3) and this way asyncio has a chance to get control and pass it over to another async function.
I'm not sure whether it is necessary to make run_loop(self) async too, the linked example would suggest this. In this case probably also the instantiation of the Test class and test.run_loop() have to be in an async context.

[webdeb]

Hmm, ok, I guess I got it, the whole app lives better in an asyncio.run context. And then its possible to start tasks from there. Not all functions have to be async for sure, only those where you are calling other async functions with await as I understood.

[webdeb]

Modified the code, this works.

import uasyncio as asyncio
import utime

class Test:
    run = 0
    def __init__(self):
        pass
    
    def run_loop(self):
        self.run = 1
        asyncio.create_task(self._while_loop())

    async def _while_loop(self):
        print("while loop, should_run:", self.run)
        counter = 0
        while self.run == 1:
            counter += 1
            print(counter)
            await asyncio.sleep_ms(100)

    def stop(self):
        self.run = 0
        print("should stop now")

async def main():
    test = Test()
    test.run_loop()
    print("looop started.. wait..")
    await asyncio.sleep(2)
    test.stop()

asyncio.run(main())

[peterhinch]

@rkompass test.run_loop does not need to be a coroutine because create_task() is a synchronous method.

@webdeb A uasyncio application is started with asyncio.run(coro()) where coro is asynchronous. Any line of code after .run() will not execute until coro terminates. While coro is running uasyncio has control, scheduling tasks as required.

[webdeb]

Hello Peter! Coming from JS programming it first felt a bit unusual, but as python is not async by default, it does make sense. Thank you!