A very Simple Asynchronous Program Framework for micropython

[shaoziyang]

The purpose of this project is to create a simple and easy-to-use framework for micropython asynchronous programs. Simply create the user's own task files, then add the task file name and task function to the configuration file, and the system will automatically create and run the task.

Framework files

The framework itself has three files:

• main.py, main file for system.
• sapf_cfg.py, framework configuration file, you need define task file name and task function name in it.
• global_var.py, add any global variables you need here. To make it easier to use, class is used here as the variable container

https://github.com/shaoziyang/SimpleAsynchronousProgramFramework

[shariltumin]

Workers-Framework may be of interest if you want to do cooperative multitasking with MicroPython. Please take a look; you might find it useful.

[peterhinch]

@shariltumin I'm puzzled at what these frameworks seek to achieve. The UART example in the workers-framework readme use more code than a comparable example written in straight Python+asyncio. To my eyes the framework code is no clearer. My advice to anyone embarking on asynchronous programming would be to learn asyncio. The skill is transferable to any Python environment.

[Wind-stormger]

Not sure if I remember correctly, do you have a timer version?

[shariltumin]

Sorry @shaoziyang, I didn't mean to hijack your thread.

@Wind-stormger, I assumed you were asking me.

There is no reason why a task can't be added to a multi-tasker by a timer.

from machine import Timer
tm = Timer(0)
tm.init(period=5000, mode=Timer.ONE_SHOT, callback=lambda t:mt.worker(tk, ('hello',)))

The timer is interrupt-based. It will run in spite of other running programs, for example multitasking main loop started by mt.start().

[Wind-stormger]

Oh, I understand. Perhaps I want to combine timer with asyncio, which would allow for meeting the needs of both time-sensitive applications and non-time-sensitive coroutine applications simultaneously.

[shariltumin]

@peterhinch, I recommended asyncio to people who want to use asyncio style concurrency. My view to programming language, libraries, frameworks are as tools. Workers-frameworks have different philosophy then asyncio. The workers-frameworks is easy to understand, it is cooperative multitasking. By using yield statements a task can have more or less CPU resources programmatically and it is transparent. A task uses massage-passing to send and receive data from other tasks. The principles on which workers-framework is based are easy to understand, imagine a group of friends in a kitchen cooking food for a party.

There are a lot of things in asyncio that I do not understand. For example (from your example)

async def main():
    asyncio.create_task(sender())
    asyncio.create_task(receiver())
    while True:
        await asyncio.sleep(1)

Why do you need to run the main that practically does nothind except to create two tasks. The statement await asyncio.sleep(1) is practically amount to yield which does not actually concern with timing.

I know you have invested a lot in the asyncio work for MicroPython, we are all grateful, including me. The workers-framework is implemented in Python and is also transferable. It is up to you which concurrency model you want to use, there are many besides asyncio. These are just tools, nothing more.

Have you read this blog "The Heisenbug lurking in your async code"?

[bulletmark]

@shaoziyang actually we don't need that main() and can simplify and shrink that example significantly:

import asyncio
from machine import UART
uart = UART(4, 9600, timeout=0)

async def sender():
    swriter = asyncio.StreamWriter(uart, {})
    while True:
        swriter.write('Hello uart\n')
        await swriter.drain()
        await asyncio.sleep(2)

asyncio.create_task(sender())

async def receiver():
    sreader = asyncio.StreamReader(uart)
    while True:
        res = await sreader.readline()
        print('Received', res)

asyncio.run(receiver())

[peterhinch]

This will work but is not CPython compatible because it creates a task before instantiating an event loop (with run()). The fix is easy:

import asyncio
from machine import UART
uart = UART(4, 9600, timeout=0)

async def sender():
    swriter = asyncio.StreamWriter(uart, {})
    while True:
        swriter.write('Hello uart\n')
        await swriter.drain()
        await asyncio.sleep(2)

async def receiver():
    asyncio.create_task(sender())
    sreader = asyncio.StreamReader(uart)
    while True:
        res = await sreader.readline()
        print('Received', res)

asyncio.run(receiver())

[bulletmark]

We're only interested in MicroPython here and it is semantically inappropriate to mix code regarding the sender() in the receiver() function.

[peterhinch]

@shariltumin

The statement await asyncio.sleep(1) is practically amount to yield which does not actually concern with timing.

Issuing await asyncio.sleep(0) is the asyncio way of doing a yield. I do agree that the demo code should be simplified as discussed - the main loop is pointless. I will fix this.

The blog is very interesting but I don't believe it applies to MicroPython. The CPython docs state

The event loop only keeps weak references to tasks

If you look at the MP code, create_task instantiates a Task object and pushes it onto the task queue. This is a hard reference which will protect it from the GC.

It is obviously up to the individual how they approach coding. My personal view is that the Workers-Framework approach to handling a stream is inelegant and inefficient. A loop like

      if u.any()==0: 
         yield

is clunky and inefficient compared to the asyncio StreamReader. This uses the select.poll interface with an ioctl. It can be applied to any stream device including custom ones, enabling device drivers for streaming devices to present a unified interface. The I2S driver is an example of this.

In my opinion learning an alternative async paradigm is likely to be wasted effort. Sooner or later you will need functionality not offered by the framework: when that happens you'll have to tackle asyncio. Historically this was difficult because CPython's asyncio was under constant revision. I found it so confusing that I wrote the tutorial to try to save others from the grief! MicroPython's asyncio is mercifully stable and reliable.

All IMHO, of course :)

[bulletmark]

If you want to keep the main() then instead of your code:

async def main():
    asyncio.create_task(sender())
    asyncio.create_task(receiver())
    while True:
        await asyncio.sleep(1)

You should just use the idiomatic 1 liner, which works in both MicroPython and ordinary Python, and doesn't waste CPU:

 async def main():
    await asyncio.gather(sender(), receiver())

You can even put that gather directly in asyncio.run(asyncio.gather(sender(), receiver())) to get rid of the main().

[peterhinch]

Good idea.