asyncio help with multiple tasks

[davefes]

The following code does not run, I suspect I am not creating tasks or waiting properly. When that problem is sorted I think there would be another problem if I do not cancel all the current tasks before changing direction ... near the bottom of the code. The steppers start to move ... but, why won't they run to completion?

Based on this code:
https://how2electronics.com/control-stepper-motor-with-a4988-raspberry-pi-pico/

# line 53 - in Python, the “//” operator works as a
# floor division for integer and float arguments.


from machine import Pin, Timer
import time
import asyncio

dir_pin_1 = Pin(26, Pin.OUT, value=0)
step_pin_1 = Pin(27, Pin.OUT, value=0)
motor_power_1 = Pin(14, Pin.OUT, value=0)
dir_pin_2 = Pin(32, Pin.OUT, value=0)
step_pin_2 = Pin(33, Pin.OUT, value=0)
motor_power_2 = Pin(25, Pin.OUT, value=0)
dir_pin_3 = Pin(19, Pin.OUT, value=0)
step_pin_3 = Pin(18, Pin.OUT, value=0)
motor_power_3 = Pin(17, Pin.OUT, value=0)

position_1 = 0
position_2 = 0
position_3 = 0

tim_1 = Timer(0)
tim_2 = Timer(1)
tim_3 = Timer(2)


def step_1(t):
    global step_pin_1
    step_pin_1.value(not step_pin_1.value())


def step_2(t):
    global step_pin_2
    step_pin_2.value(not step_pin_2.value())


def step_3(t):
    global step_pin_3
    step_pin_3.value(not step_pin_3.value())


def rotate_motor_1(delay):
  # set up timer for stepping
    tim_1.init(freq=1000000//delay, mode=Timer.PERIODIC, callback=step_1)


def rotate_motor_2(delay):
  # set up timer for stepping
    tim_2.init(freq=1000000//delay, mode=Timer.PERIODIC, callback=step_2)


def rotate_motor_3(delay):
  # set up timer for stepping
    tim_3.init(freq=1000000//delay, mode=Timer.PERIODIC, callback=step_3)


async def motor_1(direction, steps_per_rev, speed):
    global position_1
    global dir_pin_1

        
    dir_pin_1.value(direction)
    motor_power_1.on()
    rotate_motor_1(speed)
    await asyncio.sleep_ms(steps_per_rev)
    tim_1.deinit()  # stop the timer
    motor_power_1.off()
     
    position_1 = position_1 + steps_per_rev
    print(f'position_1 is {position_1}')


async def motor_2(direction, steps_per_rev, speed):
    global position_2
    global dir_pin_2


    dir_pin_2.value(direction)
    motor_power_2.on()
    rotate_motor_2(speed)
    await asyncio.sleep_ms(steps_per_rev)
    tim_2.deinit()  # stop the timer
    motor_power_2.off()

    position_2 = position_2 + steps_per_rev
    print(f'position_2 is {position_2}')


async def motor_3(direction, steps_per_rev, speed):
    global position_3
    global dir_pin_3


    dir_pin_3.value(direction)
    motor_power_3.on()
    rotate_motor_3(speed)
    await asyncio.sleep_ms(steps_per_rev)
    tim_3.deinit()  # stop the timer
    motor_power_3.off()

    position_3 = position_3 + steps_per_rev
    print(f'position_3 is {position_3}')


async def main():

  # actual test program   
    direction = 1
    speed = 500
    steps_per_rev = 50
    i = 0
    j = 0
    
        
    while i < 100:
        i += 1
            
        asyncio.create_task(motor_1(direction, steps_per_rev, speed))
        asyncio.create_task(motor_2(direction, steps_per_rev, speed))
        asyncio.create_task(motor_3(direction, steps_per_rev, speed))

  # now return the steppers
#    direction = 0

#    while j < 100:
#        j += 1
        
 #       asyncio.create_task(motor_1(direction, steps_per_rev, speed))
 #      asyncio.create_task(motor_2(direction, steps_per_rev, speed))
 #       asyncio.create_task(motor_3(direction, steps_per_rev, speed))
   
    await asyncio.sleep_ms(1000)


asyncio.run(main())

[mendenm]

What platform? What gets printed?

[GitHubsSilverBullet]

while i < 100:
        i += 1
        asyncio.create_task(motor_1(direction, steps_per_rev, speed))
        asyncio.create_task(motor_2(direction, steps_per_rev, speed))
        asyncio.create_task(motor_3(direction, steps_per_rev, speed))

You're rapidly creating 300 tasks. Is that intentional?

[davefes]

ESP32 generic and nothing gets printed. I hear one faint buzz and then nothing. I can throw some more print statements around.

[davefes]

@GitHubsSilverBullet No, it is not intentional! I will try again.

[davefes]

Here is my 2nd attempt. The problem I am now facing is ... task1 runs OK by itself and task 2 likewise. However, if I try to run both tasks I find that stepper 2 behaves normally ... but stepper 1 only travels about 1/2 of the distance. Do I need to do something different in the rotate_motor and/or step methods? I get print statements from all methods.

BTW, I am driving A4988 stepper modules.

from machine import Pin, Timer
import time
import asyncio

dir_pin_1 = Pin(26, Pin.OUT, value=0)
step_pin_1 = Pin(27, Pin.OUT, value=0)
motor_power_1 = Pin(14, Pin.OUT, value=0)
dir_pin_2 = Pin(32, Pin.OUT, value=0)
step_pin_2 = Pin(33, Pin.OUT, value=0)
motor_power_2 = Pin(25, Pin.OUT, value=0)

position_1 = 0
position_2 = 0

tim_1 = Timer(0)
tim_2 = Timer(1)


def step_1(t):
    global step_pin_1
    
    step_pin_1.value(not step_pin_1.value())
    print('stepping motor 1')
    

def step_2(t):
    global step_pin_2
    
    step_pin_2.value(not step_pin_2.value())
    print('stepping motor 2')
    

def rotate_motor_1(delay):
  # set up timer for stepping
    tim_1.init(freq=1000000//delay, mode=Timer.PERIODIC, callback=step_1)


def rotate_motor_2(delay):
  # set up timer for stepping
    tim_2.init(freq=1000000//delay, mode=Timer.PERIODIC, callback=step_2)


def motor_1(direction, steps_per_rev, speed):
    global position_1
    global dir_pin_1
    i = 0
    dir_pin_1.value(direction)
    motor_power_1.on()


    while i < 5:
        i +=1
       
        print('running motor 1 loop')
        rotate_motor_1(speed)
        await asyncio.sleep_ms(steps_per_rev)

    tim_1.deinit()  # stop the timer
    motor_power_1.off()
     
    position_1 = position_1 + steps_per_rev
    print(f'position_1 is {position_1}')


def motor_2(direction, steps_per_rev, speed):
    global position_2
    global dir_pin_2
    j = 0
    dir_pin_2.value(direction)

    motor_power_2.on()

    while j < 5:  
        j +=1
        
        print('running motor 2 loop')
        
        rotate_motor_2(speed)
        await asyncio.sleep_ms(steps_per_rev)

    tim_2.deinit()  # stop the timer

    motor_power_2.off()

    position_2 = position_2 + steps_per_rev
    print(f'position_2 is {position_2}')


async def main():
  # actual test program   
    direction = 1
    speed = 1000
    steps_per_rev = 200

    task1 = asyncio.create_task(motor_1(direction, steps_per_rev, speed))
    task2 = asyncio.create_task(motor_2(direction, steps_per_rev, speed))

    await task1
    print('motor 1 done')

    await task2
    print('motor 2 done')
      
    await asyncio.sleep_ms(1000)


asyncio.run(main())

[mendenm]

Another thought has to do with the fact that timer interrupts are hard interrupts. Your callbacks look safe to me (except the print statements, which might be bad in hard interrupts), but you might try callback = lambda t: schedule(step1, t) which will use micropython.schedule to turn the actual code into an effective soft interrupt, which will execute more politely in the python interpreter.

[mendenm]

@davefes Added note: actually, the print statements might be the whole problem. At 1000 steps/sec on each motor, you need to execute 2000 prints/sec to keep up with interrupts. Have you tried removing them?

[davefes]

@mendenm I think what happens with speed is the higher the number the slower the stepping. speed becomes delay in rotate_motor. Right about trying to print during a hard interrupt, I did "face" that issue recently.

Removing them fixed that problem ... thank you very much.

I did find the way that speed worked confusing. I will change to period.

[davefes]

On 2nd thought ... printing during hard interrupts on the STM32 was the issue I had recently. All interrupts on the ESP32 are supposed to be soft. Maybe, there were just too many of them.

[davefes]

Using asyncio has given an impressive increase in time-to-completion for these three motors. Next, I want to control 25 steppers and the number of timers on the end processor (STM32H723ZG, 4 * 32 bit and 10 * 16 bit) would not currently work.

The timer callback seems to be tightly-coupled to the steps on each stepper. Any suggestions on how the program could be re-structured would be appreciated.

[sosi-deadeye]

I used PWM to control 3 different Stepper Motors, but my solution is different. It is based on one timer, which calls a function and the function calculates the next frequency (ramp) for all 3 stepper motors. Later I could post the code. It's not complete, the calculation of ramp is wrong and the direction is missing.

[davefes]

Thank you. Would you think it should be possible to use multiple rp2350s and then have them talking to each other (I2C?) to coordinate efforts?

[jbodegraven]

I found this i2c slave implementation in uPython
https://github.com/ifurusato/rp2040-i2c-slave

[davefes]

Thanks for the link.

[mendenm]

@davefes I have a question about this project. Is it something you need to do in a cost-sensitive way (DIY, then) or is this a one-off controller for something you need to get done? If it is a one-off, a Duet 3 card (duet3d.com) with a bunch of extenders would get it done off the shelf, and with much more elegant stepper controllers than the A4988. The Duets use controllers that can do things like dynamically adjust drive current, detect missed steps, etc.

[davefes]

@mendenm Cost is important as it is DIY. I am helping a retired mechanical engineer make a prototype that will possibly end up being a master's project at a local university. Speed is important, but after a meeting yesterday it seems I was too focused on speed.

At the moment, moving 25 steppers 1-2mm to designated positions within 5 seconds seems adequate. Ramping, accurate positioning and increasing rate of overall system response by 10 to 100 times might become challenges for someone else.

Thank you for your comments, I will have a look Duet 3.