Help - PIO - Handshaking - Simultaneous activation

[Vendelator]

Edit

I have created a repository that does what I am asking in this thread.
Once i have been able to test with hardware that everything works i will post a solution here in this thread.
RP2040_PIO_Steppermotors

---

Hello. I need a huge favour from you guys and i hope someone can help me with this.

I need some help with PIO in Micropython because even if i find PIO code that i kind of understand and can manipulate to do what i want, i have big problems realizing how to make handshakes from state machine to state machine and also how to handshake to and from a PIO block. This means i am unable to make my own PIO projects.

What i need:

• Feed two state machines with their own data. I will try to do this from tuples withing tuples.
• To execute two state machines in different PIO blocks simultaneously. SM_0 and SM_4
• Have two state machines that have received their own data and performing hand shaking back and forth. SM_1 and SM_5

Some mock-up code with comments where i think the correct code is needed

import utime
from machine import Pin#, WDT
import rp2

#SM0/SM4 - keeps track on total steps, activates pin and informs main program
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
def counter():
    pull(block) # or maybe noblock?
    mov(x, osr)
    
    # Wait for activation from main function runner()
    set(y, 20) # to ramp up/down over 20 iterations
    label("step")
    jmp(not_x, "end") # If all steps are made, jump to "end"
    set(pins, 1) [1]
    set(pins, 0)
    # Send signal to SM_1/5
    # Wait for SM_1/5 to signal back
    jmp(x_dec, "countloop")

    label("end")
    # Signal main program that PIO-block 0/1 is complete.

#SM1/SM5 - adds a delay of around 50 us plus the time surround instructions will take.
@rp2.asm_pio()
def pacer():
    # Wait for SM_0/4
    set(x, 10)

    label("loop")
    nop() [24]
    jmp(x_dec, "loop") # x not zero, make jump.

    # Signal SM_0/4 to proceed

## Global State machine settings
sm_freq = 1_000_000 # 1_000_000 Hz = 1 MHz means each instruction in PIO is 1us long which is optimal.
## Motor 1 - Pio Block 0
step_pin_1 = Pin(16, Pin.IN, Pin.PULL_UP)
dir_pin_1 = Pin(17, Pin.IN, Pin.PULL_UP)
sm_0 = rp2.StateMachine(0, counter, freq=sm_freq, set_base=step_pin_1)
sm_1 = rp2.StateMachine(1, pacer, freq=sm_freq)
sm_0.irq(handler)
sm_1.irq(handler)
sm_0.active(1)
sm_1.active(1)
## Motor 2 - Pio Block 1
step_pin_2 = Pin(18, Pin.IN, Pin.PULL_UP)
dir_pin_2 = Pin(19, Pin.IN, Pin.PULL_UP)
sm_4 = rp2.StateMachine(4, counter, freq=sm_freq, set_base=step_pin_1)
sm_5 = rp2.StateMachine(5, pacer, freq=sm_freq)
sm_4.irq(handler)
sm_5.irq(handler)
sm_4.active(1)
sm_5.active(1)

instruction_tuple = ((100, 100), (150, 150), (120, 120), (100, 100))

def runner(x, y): # Feeds the PIO programs and activates them.
    sm_0.put(x)
    sm_4.put(y)
    # Signal sm_0 and sm_4 to activate simultaneously
    # Wait for irq from both PIO blocks before exiting function.

while True:
    for i in range(len(instruction_tuple)): # loads each item within the instruction tuple and assign to each motor.
        i = i - 1
        x = instruction_tuple[i][0]
        y = instruction_tuple[i][1]
        runner(x, y)

[Vendelator]

I have tested another method. Using the onboard LED-pin to trigger both intial SMs and then setting my main program in a while True loop until both SMs raises an interrupt that is cleared each time the statemachines run.

This almost works.

Motor turns one step, both statemachines calls the irq handler and a print is made in repl but the program does not continues from here.

If anyone has a better method that is quicker than using the onboard LED i am all ears. Maybe use a transistor and wait for a high on a pin?

import time
from machine import Pin#, WDT
import rp2

activation_pin = Pin(25, Pin.OUT)
activation_pin.value(1)
time.sleep(1)

#SM0/SM4 - keeps track on total steps, activates pin and informs main program
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
def counter():
    pull(block) # or maybe noblock?
    mov(x, osr)
    
    wait(1, gpio, 25) # Wait for activation from main function runner()
    irq(clear, rel(0))

    label("step")
    jmp(not_x, "end") # If all steps are made, jump to "end"
    set(pins, 1) [1]
    set(pins, 0)
    irq(6) # Send signal to SM_1/5
    wait(0, irq, 7) # Wait for SM_1/5 to signal back
    jmp(x_dec, "step")

    label("end")
    irq(block, rel(0))
    #irq(rel(0))# Signal main program that PIO-block 0/1 is complete.

#SM1/SM5 - adds a delay of around 50 us plus the time surround instructions will take.
@rp2.asm_pio()
def pacer():
    wait(1, irq, 6) # Wait for SM_0/4 from irq1
    set(x, 31)

    label("loop")
    set(y, 31)
    label("loopinloop")
    jmp(y_dec, "loop")
    jmp(x_dec, "loop") # x not zero, make jump.

    irq(7) # Signal SM_0/4 to proceed

def handler(sm):
    # Print a (wrapping) timestamp, and the state machine object.
    #print(time.ticks_ms(), sm)
    #motor = ("motor" ,sm)
    print(sm)

## Global State machine settings
sm_freq = 1_000_000 # 1_000_000 Hz = 1 MHz means each instruction in PIO is 1us long which is optimal.

## Motor 1 - Pio Block 0
step_pin_1 = Pin(17, Pin.IN, Pin.PULL_UP)
dir_pin_1 = Pin(16, Pin.IN, Pin.PULL_UP)
sm_0 = rp2.StateMachine(0, counter, freq=sm_freq, set_base=step_pin_1)
sm_0.irq(handler)
sm_1 = rp2.StateMachine(1, pacer, freq=sm_freq)
sm_0.active(1)
sm_1.active(1)

## Motor 2 - Pio Block 1
step_pin_2 = Pin(18, Pin.IN, Pin.PULL_UP)
dir_pin_2 = Pin(19, Pin.IN, Pin.PULL_UP)
sm_4 = rp2.StateMachine(4, counter, freq=sm_freq, set_base=step_pin_2)
sm_4.irq(handler)
sm_5 = rp2.StateMachine(5, pacer, freq=sm_freq)
sm_4.active(1)
sm_5.active(1)

instruction_tuple = ((100, 50), (150, 100), (60, 120), (24, 48))

def runner(x, y): # Feeds the PIO programs and activates them.
    sm_0.put(x)
    sm_4.put(y)
    activation_pin.value(1)
    time.sleep(0.1)
    activation_pin.value(0)
    while True:
        if sm_0.irq(counter) and sm_4.irq(counter) == True:
            return 
    # Signal sm_0 and sm_4 to activate simultaneously
    # Wait for irq from both PIO blocks before exiting function.



activation_pin.value(0)
#rp2.PIO(0).irq(lambda pio: print(pio.irq().flags()))
#rp2.PIO(1).irq(lambda pio: print(pio.irq().flags()))

while True:
    for i in range(len(instruction_tuple)): # loads each item within the instruction tuple and assign to each motor.
        i = i# - 1
        x = instruction_tuple[i][0]
        y = instruction_tuple[i][1]
        print("stepping to: " + "x:" +  str(x) + ", " + "y:" + str(y))
        runner(x, y)
        time.sleep(1)
    print("Done!")

[rkompass]

Did you solve all your problems?
I find it difficult to "work" through your code.
To synchronize the state machines you have the 8 IRQ flags, which you also may set externally with mem32 at offset 0x030. So a wait(1, irq, 7) at the start of the pio asm program would synchronize the state machines.
I just now learnt that with the above offset it implicates that the 8 IRQ flags are restricted to the four state machines in one pio, although the documentation seems to state it differently.
So in order to start the state machines in one block synchronously you rather can write some of the 4 activation bits in the pio ctrl register with mem32.
To synchronize across blocks I also see no other way than using a wait(..,pin, ..).
As you already found out apparently.

[Vendelator]

Well, I have somewhat solved it now, not entirely.

Like you said, I am using wait(,pin,) as a means to trigger two statemachines in separate PIO blocks which then operates inbetween two state machines. I am using GPIO25 as this gives me a visual feedback on when the new coordinates are activated in the state machine.
This pin is toggled in the main code. And because its only an activator i think its fast enough. Each state machine has already been fed their instruction before this happens and the pin is set low before new instructions are passed.

I do not have a spare A4988 board yet so i cant test this fully if its working. But i will update when it's done.

I am also making my first repository where i will post the final solution.

My current issue while waitng is transfering this into a separate *.py file with classes and PIO functions. So that the main program is as clean as possible. This is also fully new ground to me.

import time
from machine import Pin
import rp2

class statemachines:
    # PIO_0 SM_0 / PIO_1 SM_4
    @rp2.asm_pio(set_init=rp2.PIO.OUT_LOW) #, autopull=True ???
    def step_counter():
        wait(1, gpio, 25) 		# wait for activation from main function runner()
        
        pull(block) 			# pull data from FIFO to OSR, do not proceed if empty
        mov(x, osr) 			# copy OSR data into X

        label("count") 			# this loop counts down all steps
        jmp(not_x, "end") 		# if there are 0 steps jump to end
        set(pins, 1) [1] 		# sets Step pin high and waits for 2 us
        set(pins, 0) 			# sets step pin low again
        irq(5)					# sets IRQ 5 high
        irq(block, 4) 			# wait for IRQ flag 4 to clear
        jmp(x_dec, "count") 	# once IRQ is cleared, removes one x and starts over

        label("end")			# jump here to signal all steps have been made
        irq(block, rel(0)) 		# signals IRQ handler that all steps have been made

    # PIO_0 SM_1 / PIO_1 SM_5
    @rp2.asm_pio()
    def step_speed():
        wait(1, irq, 5)         # waiting for IRQ 2 from SM 0/5, does NOT clear
        set(y, 31)              # set a value to y

        label("delay")          # This should be 1024 us in this loop
        #jmp(not_y, "end")      # If there are 0 steps jump to end
        nop() [15]              # do nothing for 31 instructions
        jmp(y_dec, "delay")     # y not zero, make jump and remove one from y.
        
        #label("end")           # jump here to signal all steps have been made
        irq(clear, 4)           # clear IRQ 4

    def pio_0_handler(sm):
        global motor_1, x
        # Print a (wrapping) timestamp, and the state machine object.
        #print(time.ticks_ms(), sm)
        motor_1 = True
        print(sm, "x: ", x)
        
    def pio_1_handler(sm):
        global motor_2, y
        # Print a (wrapping) timestamp, and the state machine object.
        #print(time.ticks_ms(), sm)
        motor_2 = True
        print(sm, "x: ", x)

class motor:
    PIO_FREQ = 1_000_000
    NAME_MOTOR = "motor"
    def __init__(self, motor_number, step_pin, dir_pin, freq=PIO_FREQ):
        if motor_number == 4:   
            self._sm = rp2.StateMachine(motor_number + 2, statemachines.step_counter, freq=freq, set_base=Pin(step_pin))
            sm_6 = self._sm
            self._sm = rp2.StateMachine(motor_number + 3, statemachines.step_speed, freq=freq, set_base=Pin(dir_pin))
            sm_7 = self._sm
            sm_6.active(1), sm_7.active(1)
            print(sm_6, sm_7)
            print("Motor:", motor_number,"\nStep pin:", step_pin, "\nDirection pin:", dir_pin)
    def control(self, motor, steps_x, steps_y, speed_x, speed_y):
    print(sm_6)
    sm_6.put(steps_x)
    sm_7.put(speed_x)
        

motor_4 = motor(4, 28, 27)#self, motor_number, step_pin, dir_pin
motor.control(4, 100, 100, 2, 1)

This code raises an error at the last lise. So i am on the right path, i hope, but not really there yet.

I also wonder if i can have different "freq" for state machines inside the same PIO block? This would make setting speeds require less code.

[Vendelator]

Here is the current state of my progress.
https://github.com/Vendelator/PIO_Steppermotors

[rkompass]

Yes you can have different frequencies for each state machine.

As for the error: You forgot to indent the lines in the def control(self, motor, ..) function.
Also as it is a member function you should invoke it with motor_4.control(4, 100, 100, 2, 1) in the last line.

A few other observations/remarks:
There is no need to first assign the newly constructed state machines to self._sm and later assign that to sm_6. You may use sm_6 in the first place. Also I suggest to assign to self.sm6 if you want to access this state machine later in the class functions, if you just have sm_6 then this is a local variable and you have no access to it outside __init__().

With your successtion of

sm_6.put(steps_x)
sm_7.put(speed_x)

in the control functions you introduce asynchrony because this is executed by the rather slow mPy interpreter. On the state machine side you have the blocking pull(block) which waits until the put filled the FIFO and then continues. So as sm_6 gets its data first you lose the synchrony introduced with wait(1, gpio, 25). This would be avoided by placing the wait after the blocking pull.
IMHO (and according to my programming taste) there is no need to declare class statemachines just to group/embrace the many state machine PIO functions. As soon as your code is in a separate file which is imported by your other code it is thereby grouped already.
Having these functions as members of the motor class seems also very natural.
I just see you also have the pio handlers in this class, so take my critique not to serious.

[Vendelator]

I took your advice and things are coming along well. I skipped using classes all together for now to simplify things. I also made proper functions that can be called and they pass around data so that the user experience gets more streamlined. I will share the repo here as soon as it's just a little better written.

I think I have an answer to my own original question now and I will update next week as soon as I have the correct hardware to test if it works.

Also gonna attempt to make a pull request to raspberrypi/Micropython-examples so other people can find this information that I needed.