Simple stepper driver using the pio

[jbodegraven]

As per this thread https://github.com/orgs/micropython/discussions/16868#discussioncomment-12452613 I coded a simple stepper driver in pio to see if it's feasable.

I guess it maxes the pio out but supports linear ramp up and ramp down.

3 parameters pushed on the fifo configure the run:

• Ramp Up Count, which will also defines the final speed
• Step Count
• Ramp Down Count, should be the same as Ramp Up but has to be provided due to a lack of registers

Once these parameters are provided the pio executes a complete run.

Other parameters are hardwired, but together with the state machine's execution frequency allow for a lot of flexibility.

import rp2
from machine import Pin

# Rudimentary stepper driver with pio

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW)
def stepper():
    RampMult = 1
    InitPulseLen = 4
    
    # ToDo: Move setup to StateMachine.exec
    pull(block)                     # Ramp Up Count
    mov(x, osr)
    set(y, InitPulseLen)               # Initial Pulse Length
    
    # Ramp Up ===================
    label("RampUp")
    mov(osr, x)                       # Save Current Count in osr and
    mov(isr, y)                        # current pulse length in isr

    set(x, RampMult)                       # Ramp multiplier

    label("RampUpPulse")
    mov(y, isr)       .side(1)  [7]         # isr = current pulse length
    
    label("RampUpDelay")
    jmp(y_dec, "RampUpDelay")  .side(0) [7]    # 8 uSec @ 1 Mhz

    jmp(x_dec, "RampUpPulse")  

    mov(y, isr)   
    jmp(y_dec, "RampUpDecY")          # Never Jump
    label("RampUpDecY")
    
    mov(x, osr)                       # Ramp Up Count
    jmp(x_dec, "RampUp")
    
    # Main Loop ====================
    pull(block)                       # Step Count
    mov(x, osr)

    label("MainLoop")
    mov(isr, y)         .side(1) [7]  # Y speed after Ramp Up

    label("MainDelay")
    jmp(y_dec, "MainDelay") .side(0) [7] 

    mov(y, isr)         
    jmp(x_dec, "MainLoop")          # Step Count
    
    # Ramp Down =====================
    pull(block)                  # Ramp Down Count
    mov(x, osr)
    
    label("RampDn")
    mov(osr, x)
    mov(isr, y)                     # isr = current pulse length

    set(x, RampMult)                       # Ramp multiplier

    label("RampDnPulse")
    mov(y, isr)       .side(1) [7]       # isr = current pulse length
    
    label("RampDnDelay")
    jmp(y_dec, "RampDnDelay") .side(0) [7]

    jmp(x_dec, "RampDnPulse")  

    mov(y, invert(isr))               # Invert to increment !
    jmp(y_dec, "RampDnDecY")          # Never Jump
    label("RampDnDecY")
    mov(y, invert(y))   
    
    mov(x, osr)   
    jmp(x_dec, "RampDn")


StepPin = Pin(2)
SMD = rp2.StateMachine(0, stepper, freq=1_000_000, sideset_base=StepPin)
SMD.active(1)
SMD.put(2)     # Ramp Up
SMD.put(2)     # Steps
SMD.put(2)     # Ramp Dn

All my steppers are in machines right now ;) but I've checked the signal with my scope:

Timing isn't going to be super perfect but i guess it will be good enough.

This would need more support in uPython to set the stepper's direction and enable pins, check parameters etc.

Not sure if this is the right place to post. If there's interest I can create a github repository.

[davefes]

Interesting, thanks for the example. Probably a Github repository is best. Then a link from:
https://awesome-micropython.com/
gives it some visibility.

[jbodegraven]

I've thought of some extra functionality:

• run until a pin gets low
• run indefinitely until stopped

A stepper is on the way as well, so let me code a bit more and then upload this to github