uasyncio + Switch class + Timers = Big mess

[nastiliano]

Hello everybody.

I have this code:

# CORO
async def maniouver(self):

    # START TIMER
    def stop(t):
        self.timer = 0
    timer.init(period = 5000 , mode = Timer.ONE_SHOT , callback = stop)

    # WHILE TIMER DOESN'T SHOT
    while self.timer >= 0:

        if switch_flag:
            relay.value(0)
            break

        relay.value(1)

The problem is when I want to use timers. With a simple "while" using switch class "interrupts" and defining a countdown inside the "while! this code is working fine, but when I define a timer to control the time accuracy the switch class "interrupts" doesn't respond any more.

Could you help me please?

Thank you very much.

PD: My boad is a ESP32 Devkit.1

[2dof]

What is goal of Your code ? You defined async method but there is no ''' await''' call.

edit: read about Writing interrupt handlers
there is some example how to Interfacing to asyncio.

-> also what time accuracy with timer do You want achieve? in ESP32 with micropython timer's ISR is a software (not hardware) so maybe simpler is use just asyncio ( I uses interchangeably 'events' controlled just by timers/asnyncio combined or just by pure async and there was no difference in functionality.

[nastiliano]

Hello and thank you for your reply.

My code is more extense, this is only summary. I have a main file with this (summarized):

# FIRMWARE (Infinite bucle)
async def firmware():

    while True:
        await # HERE I CALL ANOTHER MODULE WITH MY CODE POSTED IN MY FIRST POST
        await uasyncio.sleep_ms(50)

# MAIN
async def main():
    # BLUETOOTH MODE
    if connection == 0:
        #await config_mode_BT()
        #...
        await uasyncio.gather(Bluetooth() , firmware())

    # WIFI MODE
    else:
        try:
            await uasyncio.wait_for(config_mode_wifi() , 10)
            wifi_ok = True
        except uasyncio.TimeoutError:
            wifi_ok = False
    
        # If all ok
        if wifi_ok:
            asinc_server = uasyncio.start_server(Wifi , server_IP , port)
            await uasyncio.gather(asinc_server , firmware())
        # If not
        else:
            print("Error")

uasyncio.run(main())

And doing all this stuff all is working, the problem is when I sustitute a countdown existing in my first posted code decrementing a counter to count time for a timer (more ortodox way). The timer blocks all my Switch class interrupts that they was working fine.

Thank you very much. Best regards

[2dof]

I notice (in your first snap code) that You are creating timer.init(...) (new instance if timer inside a function (not global) ) inside asyc def but in that function You call self.timer = 0``` i guess it is for storing value (time count) incrementing somewhere else ?
to clarify I asked about function purpose - I guest You want control (by switch) a time of Relay on/off ?

[nastiliano]

Hello and thank you again for your reply.

Exactly. "sel.timer" is a decreasing variable in order to exiting of the "while".
The purpouse of my code is maintain a relay in ON during timer and "stopping" that relay when timer is reaching 0 or external Switch class "interrupts" are activated.

Maybe the problem is declaring the timer as a local scope?? I don't understand exactly how it works... Is necessary always "deinit()" the timer after its use?

Thanks. Best regards.

[2dof]

The purpouse of my code is maintain a relay in ON during timer and "stopping" that relay when timer is reaching 0 or external Switch class "interrupts" are activated.

self.timer is not needed, see my simple code below : when I close switch: Relay go On, and one_shot timer is activated, after 5 sec timer_callback will turn-off relay. but if any time o open switch (as external simulation of event) - function opened_switch() will be called and relay to go OFF.

Code is below for simplicity I'm using globals declaration but it is easy wrap it to class style OOP.
also if You read 3.1 Switch class doc and see an example then You will notice than even a timer is not needed to generate "pulse"

from machine import Pin  
import time
from primitives import Switch    # class is stored in primitives folder on esp32
import uasyncio as asyncio
from machine import Timer

stop_flag = False
Relay_value = 0 

timer0 = Timer(0)

def timer_callback(t):
     global  Relay_value
     print('turn-off relay by timer')
     Relay_value = 0 
     print('timer callback one shot after 5 sec')


async def closed_switch():           
    global stop_flag , timer0 ,counter
    stop_flag = True
    
    print('turn on relay')
    Relay_value = 1 
    print('switch closed',stop_flag )
    timer0.init(mode=Timer.ONE_SHOT, period=5000, callback=timer_callback)
    

async def opened_switch():
    global stop_flag, Relay_value
    stop_flag = False
    
    print('turn-off relay by external interrupt')
    Relay_value = 0 
    print('switch opened',stop_flag)
    
async def my_app():
    global stop_flag 
    stop_flag = False
    pin = Pin(4, Pin.IN, Pin.PULL_UP)  
    print(pin.value())
    sw = Switch(pin)
    sw.close_func(closed_switch)   
    sw.open_func(opened_switch)
    print(sw.__call__())         # of pin.value()  # print sw value( state)
   
    await asyncio.sleep(100)  # Dummy application code

print('run')
asyncio.run(my_app())  # Run main application code

[bixb922]

Hello, in the OP it seems you need a delay of exactly 5000 milliseconds. The code you posted blocks asyncio during its execution (no await). Also, relay.value(1) could be done once before the loop. It seems that code should be equivalent to:

relay.value(1)
await asyncio.sleep_ms( 5000 )
relay.value(0)

However, if other tasks are executing, asyncio.sleep_ms may take longer than 5000 ms if some other asyncio task starts just before the 5000 seconds elapse.
So if you need high precision (very exactly 5000 milliseconds), this is a way to do that:

relay.value(1)
t0 = time.ticks_ms()
await asyncio.sleep_ms( 4800 )
dt = time.ticks_diff( time.ticks_ms(), t0 )
time.sleep_ms( 5000 - dt )
relay.value(0)

(edit) The 200 ms is a figure that must be larger than the longest block of an asyncio task.

The time.sleep_ms blocks, but asyncio is free to do its scheduling during most of the time. With time.sleep_us() precision could be even better.

[peterhinch]

It rarely makes sense to use timers with asyncio because asyncio provides timing.

from machine import Pin  
import time
from primitives import Switch    # class is stored in primitives folder on esp32
import uasyncio as asyncio

Relay_value = 0 
off_task = None

async def def timed_off():
     global  Relay_value
     print('turn-off relay by timer')
     await asyncio.sleep(5)
     Relay_value = 0 
     print('timer callback one shot after 5 sec')

def closed_switch():           
    global off_task
    print('turn on relay')
    Relay_value = 1 
    off_task = asyncio.create_task(timed_off())  # Turn relay off after 5s
    print('switch closed',stop_flag )

def opened_switch():  # No need for async def here
    global Relay_value, off_task
    print('turn-off relay by external interrupt')
    Relay_value = 0 
    if off_task is not None:
        off_task.cancel()
        off_task = None
    print('switch opened',stop_flag)
    
async def my_app():
    pin = Pin(4, Pin.IN, Pin.PULL_UP)  
    print(pin.value())
    sw = Switch(pin)
    sw.close_func(closed_switch)   
    sw.open_func(opened_switch)
    print(sw.__call__())         # of pin.value()  # print sw value( state)
    await asyncio.sleep(100)  # Dummy application code

print('run')
asyncio.run(my_app())  # Run main application code

[nastiliano]

Hello everyone!

Sorry for not to respond for so long, very busy and holidays :)

Thank you very much to all people, finally I've followed the uasyncio timer tips of @peterhinch and all works great.

Thank you again. Greetings!