button callback complex task handling

[tedx]

What is the proper way to handling complex tasks that are initiated by a button click?

[tedx]

Really, nobody has dealt with this before?? I'm making a watch part washing machine. The GUI has 2 buttons one to start the 'agitation' and one to stop it. If agitation is happening I want stop to interrupt it. I'm using asyncio to run the agitate and stop coroutines. There is some other voodoo here that's got me baffled in that if in the agitate routine I use await asyncio.sleep(1) instead of time.sleep(1) the routine seems to finish immediately that is I see the 'agitate done' message and the motor doesn't run at all. When using time.sleep the motor runs as expected but I haven't figured out how to get stop to interrupt agitate. Here's the code:

import gc

mem_free_startup = gc.mem_free()

import lvgl as lv
import lcd_bus
import ili9341
import xpt2046
from machine import SPI, Pin
import i2c
import machine
import micropython
import task_handler
import time
import math
import asyncio
from select import poll, POLLIN

_DISPLAY_WIDTH = micropython.const(320)
_DISPLAY_HEIGHT = micropython.const(240)
_DISPLAY_ROT = micropython.const(0x80)
_DISPLAY_BGR = micropython.const(0)
_DISPLAY_RGB565_BYTE_SWAP = micropython.const(1)
_ALLOW_TOUCH_CAL = micropython.const(1)
_DISPLAY_SHOW_TOUCH_INDICATOR = micropython.const(1)

# ============== Display / Indev initialization ============== #

_SPI_BUS_HOST = micropython.const(1)
_SPI_BUS_MOSI = micropython.const(13)
_SPI_BUS_MISO = micropython.const(12)
_SPI_BUS_SCK = micropython.const(14)
_INDEV_BUS_HOST = micropython.const(2)
_INDEV_BUS_MOSI = micropython.const(32)
_INDEV_BUS_MISO = micropython.const(39)
_INDEV_BUS_SCK = micropython.const(25)
_INDEV_DEVICE_FREQ = micropython.const(2000000)
_INDEV_DEVICE_CS = micropython.const(33)
_DISPLAY_BUS_FREQ = micropython.const(24000000)
_DISPLAY_BUS_DC = micropython.const(2)
_DISPLAY_BUS_CS = micropython.const(15)
_DISPLAY_BACKLIGHT_PIN = micropython.const(21)

s1 = None
stopFlag = asyncio.ThreadSafeFlag()
agitate_click_event = asyncio.Event()
stop_click_event = asyncio.Event()

class Stepper:
    def __init__(self,step_pin,dir_pin,en_pin=None,steps_per_rev=200,speed_sps=10,invert_dir=False,timer_id=-1):
        
        if not isinstance(step_pin, machine.Pin):
            step_pin=machine.Pin(step_pin,machine.Pin.OUT)
        if not isinstance(dir_pin, machine.Pin):
            dir_pin=machine.Pin(dir_pin,machine.Pin.OUT)
        if (en_pin != None) and (not isinstance(en_pin, machine.Pin)):
            en_pin=machine.Pin(en_pin,machine.Pin.OUT)
                 
        self.step_value_func = step_pin.value
        self.dir_value_func = dir_pin.value
        self.en_pin = en_pin
        self.invert_dir = invert_dir

        self.timer = machine.Timer(timer_id)
        self.timer_is_running=False
        self.free_run_mode=0
        self.enabled=True
        
        self.target_pos = 0
        self.pos = 0
        self.steps_per_sec = speed_sps
        self.steps_per_rev = steps_per_rev
        
        self.track_target()
        
    def speed(self,sps):
        self.steps_per_sec = sps
        if self.timer_is_running:
            self.track_target()
    
    def speed_rps(self,rps):
        self.speed(rps*self.steps_per_rev)

    def target(self,t):
        self.target_pos = t

    def target_deg(self,deg):
        self.target(self.steps_per_rev*deg/360.0)
    
    def target_rad(self,rad):
        self.target(self.steps_per_rev*rad/(2.0*math.pi))
    
    def get_pos(self):
        return self.pos
    
    def get_pos_deg(self):
        return self.get_pos()*360.0/self.steps_per_rev
    
    def get_pos_rad(self):
        return self.get_pos()*(2.0*math.pi)/self.steps_per_rev
    
    def overwrite_pos(self,p):
        self.pos = 0
    
    def overwrite_pos_deg(self,deg):
        self.overwrite_pos(deg*self.steps_per_rev/360.0)
    
    def overwrite_pos_rad(self,rad):
        self.overwrite_pos(rad*self.steps_per_rev/(2.0*math.pi))

    def step(self,d):
        if d>0:
            if self.enabled:
                self.dir_value_func(1^self.invert_dir)
                self.step_value_func(1)
                self.step_value_func(0)
            self.pos+=1
        elif d<0:
            if self.enabled:
                self.dir_value_func(0^self.invert_dir)
                self.step_value_func(1)
                self.step_value_func(0)
            self.pos-=1

    def _timer_callback(self,t):
        if self.free_run_mode>0:
            self.step(1)
        elif self.free_run_mode<0:
            self.step(-1)
        elif self.target_pos>self.pos:
            self.step(1)
        elif self.target_pos<self.pos:
            self.step(-1)
    
    def free_run(self,d):
        self.free_run_mode=d
        if self.timer_is_running:
            self.timer.deinit()
        if d!=0:
            self.timer.init(freq=self.steps_per_sec,callback=self._timer_callback)
            self.timer_is_running=True
        else:
            self.dir_value_func(0)

    def track_target(self):
        self.free_run_mode=0
        if self.timer_is_running:
            self.timer.deinit()
        self.timer.init(freq=self.steps_per_sec,callback=self._timer_callback)
        self.timer_is_running=True

    def stop(self):
        self.free_run_mode=0
        if self.timer_is_running:
            self.timer.deinit()
        self.timer_is_running=False
        self.dir_value_func(0)

    def enable(self,e):
        if self.en_pin:
            self.en_pin.value(e)
        self.enabled=e
        if not e:
            self.dir_value_func(0)
    
    def is_enabled(self):
        return self.enabled


# Define event callback function.
def ready(tsf, poller):  # Return a function which returns tsf status
    r = (tsf, POLLIN)
    poller.register(*r)

    def is_rdy():
        return r in poller.ipoll(0)  # Immediate return

    return is_rdy

def agitate():
    print("Agitate")
    global s1
#    global stopFlag

    mpoll = poll()
    stopNow = ready(stopFlag, mpoll)  # Create a ready function

    s1.free_run(1)
    for _ in range(10):
        if stopNow():
            s1.stop()
            stopFlag.clear()
            print("agitate stopped")
            return
        time.sleep(1)

    s1.free_run(-1)
    for _ in range(10):
        if stopNow():
            s1.stop()
            stopFlag.clear()
            print("agitate stopped")
            return
        time.sleep(1)
#        await asyncio.sleep(1)
    s1.free_run(0)
    print("agitate done")
        
def stop():
    global s1
    global stopFlag
    print("stop")
    stopFlag.set()
    s1.stop()

async def handle_agitate_button_clicks():
    while True:
        await agitate_click_event.wait() # Wait for the click
        
        print("Agitate button was clicked.")
        agitate()
        agitate_click_event.clear()      # Reset the event for the next click
        print("Async agitate task finished.")

async def handle_stop_button_clicks():
    while True:
        await stop_click_event.wait() # Wait for the click
        
        print("Stop button was clicked.")
        stop()
        stop_click_event.clear()      # Reset the event for the next click
        print("Async stop task finished.")

def agitate_button_event_handler(evt):
    print("agitate_button_event_handler")
    agitate_click_event.set()

def stop_button_event_handler(evt):
    print("stop_button_event_handler")
    stop_click_event.set()

async def main():
    await asyncio.gather(handle_agitate_button_clicks(), handle_stop_button_clicks())
    
    
if __name__ == "__main__":
    
    spi_bus = machine.SPI.Bus(
        host=_SPI_BUS_HOST,
        mosi=_SPI_BUS_MOSI,
        miso=_SPI_BUS_MISO,
        sck=_SPI_BUS_SCK
    )

    indev_bus = machine.SPI.Bus(
        host=_INDEV_BUS_HOST,
        mosi=_INDEV_BUS_MOSI,
        miso=_INDEV_BUS_MISO,
        sck=_INDEV_BUS_SCK
    )

    indev_device = machine.SPI.Device(
        spi_bus=indev_bus,
        freq=_INDEV_DEVICE_FREQ,
        cs=_INDEV_DEVICE_CS
    )

    display_bus = lcd_bus.SPIBus(
        spi_bus=spi_bus,
        freq=_DISPLAY_BUS_FREQ,
        dc=_DISPLAY_BUS_DC,
        cs=_DISPLAY_BUS_CS
    )

    display = ili9341.ILI9341(
        data_bus=display_bus,
        display_width=_DISPLAY_WIDTH,
        display_height=_DISPLAY_HEIGHT,
        backlight_pin=_DISPLAY_BACKLIGHT_PIN,
        backlight_on_state=ili9341.STATE_PWM,
        color_space=lv.COLOR_FORMAT.RGB565,
        color_byte_order=ili9341.BYTE_ORDER_BGR if _DISPLAY_BGR else ili9341.BYTE_ORDER_RGB,
        rgb565_byte_swap=_DISPLAY_RGB565_BYTE_SWAP
    )

    display._ORIENTATION_TABLE = (
        _DISPLAY_ROT, # this value sets the rotation
        0x0, # placeholder
        0x0, # placeholder
        0x0 # placeholder
    )

    display.set_rotation(lv.DISPLAY_ROTATION._0)
    display.set_power(True)
    display.init(1)
    display.set_backlight(100)

    indev = xpt2046.XPT2046(device=indev_device)

    # Calibration data is stored in the non-volatile storage (NVS) of the Esp32
    if not indev.is_calibrated:
        indev.calibrate()

    s1 = Stepper(27, 22, steps_per_rev=200, speed_sps=750, timer_id=1)

    scrn = lv.screen_active()
    scrn.set_style_bg_color(lv.color_white(), lv.PART.MAIN)
    scrn.remove_flag(lv.obj.FLAG.SCROLLABLE)

    agitate_btn = lv.button(scrn)
    agitate_btn.add_flag(lv.obj.FLAG.CLICKABLE)
    agitate_label = lv.label(agitate_btn)
    agitate_label.set_text("Agitate")
    agitate_btn.align(lv.ALIGN.CENTER, -50, 0)

    stop_btn = lv.button(scrn)
    stop_btn.add_flag(lv.obj.FLAG.CLICKABLE)
    stop_label = lv.label(stop_btn)
    stop_label.set_text("Stop")
    stop_btn.align(lv.ALIGN.CENTER, 50, 0)

    # Add the event (triggered when clicked) to the button.
    agitate_btn.add_event_cb(agitate_button_event_handler, lv.EVENT.CLICKED, None)
    stop_btn.add_event_cb(stop_button_event_handler, lv.EVENT.CLICKED, None)

    task_handler.TaskHandler()
    asyncio.run(main())

[kdschlosser]

don't use asynchio is complicates things and it is really supposed to only be used for asynchronous IO which is not what you are dealing with.
Use the built in LVGL timers to poll for an incoming state change. and perform whatever tasks you want to perform right in the button callbacks.

[tedx]

If I try and run the agitate function directly in the callback the button stays selected (meaning the stop button can't be pushed) and the motor doesn't run. Maybe there's some interaction between the lvgl eventloop and the Stepper class timer usage?? I didn't write the Stepper class code. I think the agitate function needs to run in the background and I don't see how using a timer can accomplish this.

[kdschlosser]

you're issue with the code you have is that you are trying to do 2 things at once which is impossible to do using only a single core. What you need to be doing is letting the loop run and use timers to check things. The task manager loop runs every 33 milliseconds or there abouts. Do you need to have an accuracy that is less than 33 milliseconds?.. an agitate function on a washing machine is where it changes direction and depending on the type of machine that could happen every what? 1-2 seconds or so, or it could be every 30 seconds or so. You simply need to tell your stepper to change direction every n often where n is a measurement of time. Use the 'time.ticks_ms' and 'time.ticks_diff' to collect timestamps and to get the difference between 2 time stamps. if the diff is >= whatever duration you have set then reverse the direction and reset the start time to take a new measurement. Create an LVGL timer that points to a function where you do that timestamp test.

I believe that Micropython has code built into it specifically for dealing with stepper motors and also for handling rotary encoders which is what the position output is from a stepper motor.

https://docs.micropython.org/en/latest/esp32/quickref.html#pulse-counter-pin-pulse-edge-counting

https://docs.micropython.org/en/latest/esp32/quickref.html#pwm-pulse-width-modulation

https://docs.micropython.org/en/latest/library/esp32.html#pcnt

https://docs.micropython.org/en/latest/library/esp32.html#rmt

[tedx]

You may not approve but I got it to work just as I want it to my moving the 'agitate' and 'stop' methods code into the coroutines. Why it didn't work when the code was in a different function I don't get but whatever...

import gc

mem_free_startup = gc.mem_free()

import lvgl as lv
import lcd_bus
import ili9341
import xpt2046
from machine import SPI, Pin
import i2c
import machine
import micropython
import task_handler
import time
import math
import uasyncio as asyncio
from select import poll, POLLIN

_DISPLAY_WIDTH = micropython.const(320)
_DISPLAY_HEIGHT = micropython.const(240)
_DISPLAY_ROT = micropython.const(0x80)
_DISPLAY_BGR = micropython.const(0)
_DISPLAY_RGB565_BYTE_SWAP = micropython.const(1)
_ALLOW_TOUCH_CAL = micropython.const(1)
_DISPLAY_SHOW_TOUCH_INDICATOR = micropython.const(1)

# ============== Display / Indev initialization ============== #

_SPI_BUS_HOST = micropython.const(1)
_SPI_BUS_MOSI = micropython.const(13)
_SPI_BUS_MISO = micropython.const(12)
_SPI_BUS_SCK = micropython.const(14)
_INDEV_BUS_HOST = micropython.const(2)
_INDEV_BUS_MOSI = micropython.const(32)
_INDEV_BUS_MISO = micropython.const(39)
_INDEV_BUS_SCK = micropython.const(25)
_INDEV_DEVICE_FREQ = micropython.const(2000000)
_INDEV_DEVICE_CS = micropython.const(33)
_DISPLAY_BUS_FREQ = micropython.const(24000000)
_DISPLAY_BUS_DC = micropython.const(2)
_DISPLAY_BUS_CS = micropython.const(15)
_DISPLAY_BACKLIGHT_PIN = micropython.const(21)

s1 = None
stopFlag = asyncio.ThreadSafeFlag()
agitate_click_event = asyncio.Event()
stop_click_event = asyncio.Event()

class Stepper:
    def __init__(self,step_pin,dir_pin,en_pin=None,steps_per_rev=200,speed_sps=10,invert_dir=False,timer_id=-1):
        
        if not isinstance(step_pin, machine.Pin):
            step_pin=machine.Pin(step_pin,machine.Pin.OUT)
        if not isinstance(dir_pin, machine.Pin):
            dir_pin=machine.Pin(dir_pin,machine.Pin.OUT)
        if (en_pin != None) and (not isinstance(en_pin, machine.Pin)):
            en_pin=machine.Pin(en_pin,machine.Pin.OUT)
                 
        self.step_value_func = step_pin.value
        self.dir_value_func = dir_pin.value
        self.en_pin = en_pin
        self.invert_dir = invert_dir

        self.timer = machine.Timer(timer_id)
        self.timer_is_running=False
        self.free_run_mode=0
        self.enabled=True
        
        self.target_pos = 0
        self.pos = 0
        self.steps_per_sec = speed_sps
        self.steps_per_rev = steps_per_rev
        
        self.track_target()
        
    def speed(self,sps):
        self.steps_per_sec = sps
        if self.timer_is_running:
            self.track_target()
    
    def speed_rps(self,rps):
        self.speed(rps*self.steps_per_rev)

    def target(self,t):
        self.target_pos = t

    def target_deg(self,deg):
        self.target(self.steps_per_rev*deg/360.0)
    
    def target_rad(self,rad):
        self.target(self.steps_per_rev*rad/(2.0*math.pi))
    
    def get_pos(self):
        return self.pos
    
    def get_pos_deg(self):
        return self.get_pos()*360.0/self.steps_per_rev
    
    def get_pos_rad(self):
        return self.get_pos()*(2.0*math.pi)/self.steps_per_rev
    
    def overwrite_pos(self,p):
        self.pos = 0
    
    def overwrite_pos_deg(self,deg):
        self.overwrite_pos(deg*self.steps_per_rev/360.0)
    
    def overwrite_pos_rad(self,rad):
        self.overwrite_pos(rad*self.steps_per_rev/(2.0*math.pi))

    def step(self,d):
        if d>0:
            if self.enabled:
                self.dir_value_func(1^self.invert_dir)
                self.step_value_func(1)
                self.step_value_func(0)
            self.pos+=1
        elif d<0:
            if self.enabled:
                self.dir_value_func(0^self.invert_dir)
                self.step_value_func(1)
                self.step_value_func(0)
            self.pos-=1

    def _timer_callback(self,t):
        if self.free_run_mode>0:
            self.step(1)
        elif self.free_run_mode<0:
            self.step(-1)
        elif self.target_pos>self.pos:
            self.step(1)
        elif self.target_pos<self.pos:
            self.step(-1)
    
    def free_run(self,d):
        self.free_run_mode=d
        if self.timer_is_running:
            self.timer.deinit()
        if d!=0:
            self.timer.init(freq=self.steps_per_sec,callback=self._timer_callback)
            self.timer_is_running=True
        else:
            self.dir_value_func(0)

    def track_target(self):
        self.free_run_mode=0
        if self.timer_is_running:
            self.timer.deinit()
        self.timer.init(freq=self.steps_per_sec,callback=self._timer_callback)
        self.timer_is_running=True

    def stop(self):
        self.free_run_mode=0
        if self.timer_is_running:
            self.timer.deinit()
        self.timer_is_running=False
        self.dir_value_func(0)

    def enable(self,e):
        if self.en_pin:
            self.en_pin.value(e)
        self.enabled=e
        if not e:
            self.dir_value_func(0)
    
    def is_enabled(self):
        return self.enabled


# Define event callback function.
def ready(tsf, poller):  # Return a function which returns tsf status
    r = (tsf, POLLIN)
    poller.register(*r)

    def is_rdy():
        return r in poller.ipoll(0)  # Immediate return

    return is_rdy

async def handle_agitate_button_clicks():
    while True:
        await agitate_click_event.wait() # Wait for the click
        
        print("Agitate button was clicked.")

        mpoll = poll()
        stopNow = ready(stopFlag, mpoll)  # Create a ready function

        s1.free_run(1)
        for _ in range(10):
            if stopNow():
                print("stop flag set")
                s1.stop()
                print("agitate stopped")
                break
            await asyncio.sleep(1)
        if stopNow():
            stopFlag.clear()
            agitate_click_event.clear()      # Reset the event for the next click
            continue
            
        s1.free_run(-1)
        for _ in range(10):
            if stopNow():
                print("stop flag set")
                s1.stop()
                print("agitate stopped")
                break
            await asyncio.sleep(1)
        if stopNow():
            stopFlag.clear()
            agitate_click_event.clear()      # Reset the event for the next click
            continue
        s1.free_run(0)
        agitate_click_event.clear()      # Reset the event for the next click
        print("Async agitate task finished.")

async def handle_stop_button_clicks():
    while True:
        await stop_click_event.wait() # Wait for the click
        
        print("Stop button was clicked.")

        stopFlag.set()
        s1.stop()
        stop_click_event.clear()      # Reset the event for the next click
        print("Async stop task finished.")

def agitate_button_event_handler(evt):
    print("agitate_button_event_handler")
    agitate_click_event.set()

def stop_button_event_handler(evt):
    print("stop_button_event_handler")
    stop_click_event.set()

async def main():
    await asyncio.gather(handle_agitate_button_clicks(), handle_stop_button_clicks())
    
    
if __name__ == "__main__":
    
    spi_bus = machine.SPI.Bus(
        host=_SPI_BUS_HOST,
        mosi=_SPI_BUS_MOSI,
        miso=_SPI_BUS_MISO,
        sck=_SPI_BUS_SCK
    )

    indev_bus = machine.SPI.Bus(
        host=_INDEV_BUS_HOST,
        mosi=_INDEV_BUS_MOSI,
        miso=_INDEV_BUS_MISO,
        sck=_INDEV_BUS_SCK
    )

    indev_device = machine.SPI.Device(
        spi_bus=indev_bus,
        freq=_INDEV_DEVICE_FREQ,
        cs=_INDEV_DEVICE_CS
    )

    display_bus = lcd_bus.SPIBus(
        spi_bus=spi_bus,
        freq=_DISPLAY_BUS_FREQ,
        dc=_DISPLAY_BUS_DC,
        cs=_DISPLAY_BUS_CS
    )

    display = ili9341.ILI9341(
        data_bus=display_bus,
        display_width=_DISPLAY_WIDTH,
        display_height=_DISPLAY_HEIGHT,
        backlight_pin=_DISPLAY_BACKLIGHT_PIN,
        backlight_on_state=ili9341.STATE_PWM,
        color_space=lv.COLOR_FORMAT.RGB565,
        color_byte_order=ili9341.BYTE_ORDER_BGR if _DISPLAY_BGR else ili9341.BYTE_ORDER_RGB,
        rgb565_byte_swap=_DISPLAY_RGB565_BYTE_SWAP
    )

    display._ORIENTATION_TABLE = (
        _DISPLAY_ROT, # this value sets the rotation
        0x0, # placeholder
        0x0, # placeholder
        0x0 # placeholder
    )

    display.set_rotation(lv.DISPLAY_ROTATION._0)
    display.set_power(True)
    display.init(1)
    display.set_backlight(100)

    indev = xpt2046.XPT2046(device=indev_device)

    # Calibration data is stored in the non-volatile storage (NVS) of the Esp32
    if not indev.is_calibrated:
        indev.calibrate()

    s1 = Stepper(27, 22, steps_per_rev=200, speed_sps=750, timer_id=1)

    scrn = lv.screen_active()
    scrn.set_style_bg_color(lv.color_white(), lv.PART.MAIN)
    scrn.remove_flag(lv.obj.FLAG.SCROLLABLE)

    agitate_btn = lv.button(scrn)
    agitate_btn.add_flag(lv.obj.FLAG.CLICKABLE)
    agitate_label = lv.label(agitate_btn)
    agitate_label.set_text("Agitate")
    agitate_btn.align(lv.ALIGN.CENTER, -50, 0)

    stop_btn = lv.button(scrn)
    stop_btn.add_flag(lv.obj.FLAG.CLICKABLE)
    stop_label = lv.label(stop_btn)
    stop_label.set_text("Stop")
    stop_btn.align(lv.ALIGN.CENTER, 50, 0)

    # Add the event (triggered when clicked) to the button.
    agitate_btn.add_event_cb(agitate_button_event_handler, lv.EVENT.CLICKED, None)
    stop_btn.add_event_cb(stop_button_event_handler, lv.EVENT.CLICKED, None)

    task_handler.TaskHandler()
    asyncio.run(main())