Very confused on how to use ASYNCIO, why is my code not working?

[dumbnerd08]

So basically, I need to blink an LED upon an interrupt. Pretend that the redblink function is run upon an IRQ interrupt. I need that function to run while the rest of my code continues running like nothing happens. I also need to be able to run multiple blink functions at the same time, with different PWMs.

Right now, when I execute the redblink function, nothing happens. No error, just nothing.

from machine import Pin, PWM
import asyncio

r = PWM(Pin(5), freq=60, duty=1023)
async def red_set_color(a):
    r.duty(1023-a)
async def redset_color(a):
    asyncio.create_task(red_set_color(a))

async def red_slow_set(end, tim):
    duty = 1023 - r.duty()
    if duty > end:
        for i in range(duty, end, -1):
            redset_color(i)
            await asyncio.sleep(tim/(duty - end))
    elif duty < end:
        for i in range(duty, end, 1):
            redset_color(i)
            await asyncio.sleep(tim/(end - duty))
    elif duty == end:
        redset_color(end)
async def redslow_set(end, tim):
    asyncio.create_task(red_slow_set(end, tim))

async def red_blink(tim):
    redslow_set(1023, 3)
    await asyncio.sleep(tim)
    redslow_set(0, 3)
async def redblink(tim):
    asyncio.create_task(red_set_color(tim))

asyncio.run(redblink(10))

[sosi-deadeye]

You forgot to await on the task. There are also unnecessary function definitions.

You could test this:

import asyncio
import micropython
import time

from machine import Pin, PWM


LED1 = PWM(Pin(5), freq=60, duty=0)
LED2 = PWM(Pin(6), freq=60, duty=0)
# Maximum PWM value for duty_u16()
U16 = micropython.const(65535)
# AFIK 10 ms is the intervall of micropython asyncio
INTERVALL = micropython.const(50)


async def slow_on_off(led: PWM, duration_on_ms: int, duration_off_ms: int, reverse=False):

    if duration_off_ms < INTERVALL:
        raise RuntimeError("On time is too short.")
    if duration_off_ms < INTERVALL:
        raise RuntimeError("Off time is too short")

    step_on_per_ms = max(1, int(U16 / duration_on_ms * INTERVALL))
    step_off_per_ms = max(1, int(U16 / duration_off_ms * INTERVALL))


    async def on():
        """
        Fade from 0 to 65535
        """
        for u16 in range(0, U16, step_on_per_ms):
            led.duty_u16(u16)
            await asyncio.sleep_ms(INTERVALL)

        led.duty_u16(U16)


    async def off():
        """
        Fade from 65535 to 0
        """
        for u16 in range(U16, -1, -step_off_per_ms):
            led.duty_u16(u16)
            await asyncio.sleep_ms(INTERVALL)
    
        led.duty_u16(0)

    # do not use asyncio.gather here
    # otherwise on/off is run the cuncurrently
    # but it should run one after other
    if reverse:
        # missing the await won't run the coro in the eventloop
        await off() # blocks until off is done
        await on() # blocks until on is done
    else:
        await on()
        await off()


async def main():
    task1 = asyncio.create_task(slow_on_off(LED1, 5000, 5000))
    task2 = asyncio.create_task(slow_on_off(LED2, 2000, 2000))
    # task1 and task2 are started, but if the eventloop ends,
    # the tasks do not finish

    # this blocks until both tasks are done
    # if this is missing, the coro returns immediatly
    await asyncio.gather(task1, task2)
    

if __name__ == "__main__":
    start_ms = time.ticks_ms()
    asyncio.run(main()) # <- this blocks until main() is finished
    print("Duration:", time.ticks_diff(time.ticks_ms(), start_ms), "ms")

[peterhinch]

@dumbnerd08 Most of your code is never called. Code which is actually executed reduces to

from machine import Pin, PWM
import asyncio

r = PWM(Pin(5), freq=60, duty=1023)
async def red_set_color(a):
    r.duty(1023-a)

async def redblink(tim):
    asyncio.create_task(red_set_color(tim))

asyncio.run(redblink(10))

The task redblink launches red_set_color and terminates, ending program execution.

I suggest you look at the asyncio tutorial.