stepper motor - using single PIO - guidance

[jkozniewski]

Hello,

I'm trying t implement PIO-based stepper motor controller capable of driving _ 8 _ independent motors.
Seen quite a few approaches, but most of them use more than one PIO per stepper which doesn't suit my needs.
I know that I might be jus trying to implement something that's beyond capabilities of Pico Pi running micropython - so the first question is - is it at all feasible (given some concessions like max motor speed etc.) ?

So far I have managed to write such PIO method (after days of banging my head against the wall and reading all examples of PIO on the internet :D - taking some inspiration from https://github.com/ktritz/stepper_pio which unfortunately is writen for Circuitpython ):

@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, autopull=True)
def step():

    out( x, 16 )        # copy first 16 bits from FIFO to X (steps count)  
    out( y, 16 )        # copy next 16 bits from FIFO to Y (step delay) 

    mov( isr, y )       # copy Y to ISR     

    label("loop")       # steps loop - X times
    set(pins, 1) [1]    # pin high, delay 1 cycle
    set(pins, 0)        # pin low
                
    mov( y, isr )       # retrieve Y from ISR to keep the delay after decrementing to 0
    label( "delay")     # delay loop - just wait Y cycles
    jmp(y_dec, "delay") # decrement Y, do next iteration of "delay"

    jmp(x_dec,"loop")   # decrement X, do next iteration of "loop"
    irq(rel(0))         # raise interupt - to get more data into FIFO

And that works when state machine is provided with 32bit value combined by merging two 16bit numbers - first containing steps, second the delay. I calculate acceleration - full speed - deceleration array containing sequence of such values and retrieving them from within IRQ:

def increment():
    global counter
    counter += 1
    mod = counter%motionSteps
    
    sm.put( motionArr[mod] )

So that kind of works - probably using DMA would speed up acceleration phase (when IRQ is raised frequently),
I should also add direction pin support in PIO (sacrificing one bit form either step delay or step count). All hintns regarding those things would be much appreciated.

Though - my biggest problem for now is how can I keep track of the amount of steps taken so I can access them from within regular micropython code. Tried to add push() in the "loop" so I can use rx_fifo() and 'get()` and methods to increment the step counter accordingly, but that messes up Y register since I use ISR as a temp Y value storage so I can reuse it in consecutive delays in between the steps. Is it at all possible to keep accurate step count using only one PIO - and if so, how shall I modify the code to be able to do this ?

[rkompass]

In your code X is the steps count. So in every interrupt you may add the X value to a micropython class steps_count variable.

In the asm_pio code you may substitute osr for isr, because once the two out() instructions are done osr is not needed any longer within the outer loop and the storage of the Y value is only needed within the outer loop.

So you have isr available and you may add a mov(isr, x) followed by push(noblock) into the outer loop.

So in your stepper class you may at any time get the actual steps count value by something like:

def steps(self):
    for _ in range(self.qenc.rx_fifo()):
        self.qenc.get()
    return self.steps_count + self.qenc.get()

which reads the RX FIFO as often as needed to get the next pushed value and adds the stored steps_count to it.

[jkozniewski]

Thanks! Unfortunately I'll be away for a week so can't try out your suggestions right now, though regarding first remark about keeping track of steps in interrupt handler - that won't really work if I put more than one step in FIFO (and only then it makes sense really) since I'll only could then update step count before they actually happened (before I put them in FIFO) or on next FIFO update after PIO is done with previous data (and there could be even ~ 65k steps without any update)

What you suggest about using OSR rather than ISR for temp Y storage seems much more promising, though I kind of tried go this route and there was some strange behavior, but maybe I got lost and messed something - I'd be immensely grateful if you could show the modified PIO code implementing this change since devil is in details and I'll try it out and repot as soon as I get back. I intend to make some library for handling steppers and share with community if it will work well so any help would be much appreciated!

[rkompass]

Thanks for the feedback.

Reading your comment about the first remark: The class variable steps_count should be incremented in the interrupt with the last, not the actual step count, so it may be the base to add the count read from the PIO to it.

For the OSR I see the need of a correction:
The OSR should be pushed non-blockingly in the inner loop, which is re-iterating fast. This way the above function steps(self) which will usually try to get the value from the FIFO 5 times in a row will not block at all or only for a very small time.
The 5th value is that which is actually written to the FIFO after making space, i.e. getting at least once from the FIFO.