import time
import stepper
import board

s = stepper.Stepper(
    step_pin=board.GP3, limit_pins=(board.GP10, board.GP11), dir_pin=board.GP2, count_pin=board.GP0
)
s.dir_active = "HIGH"
s._setup_sm()

s.velocity = 0.2
print("hello")

time.sleep(10)
s.velocity = 3
print("hello")

time.sleep(10)
s.velocity = -10
print("hello")

time.sleep(10)
s.velocity = 10
time.sleep(10)


code.py

diagram.json

# SPDX-FileCopyrightText: Copyright (c) 2021 Scott Shawcroft for Adafruit Industries LLC
#
# SPDX-License-Identifier: MIT
"""
`adafruit_pioasm`
================================================================================

Simple assembler to convert pioasm to bytes


* Author(s): Scott Shawcroft
"""

import array
import re

splitter = re.compile(r",\s*|\s+(?:,\s*)?").split
mov_splitter = re.compile("!|~|::").split

__version__ = "0.0.0+auto.0"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_PIOASM.git"

CONDITIONS = ["", "!x", "x--", "!y", "y--", "x!=y", "pin", "!osre"]
IN_SOURCES = ["pins", "x", "y", "null", None, None, "isr", "osr"]
OUT_DESTINATIONS = ["pins", "x", "y", "null", "pindirs", "pc", "isr", "exec"]
WAIT_SOURCES = ["gpio", "pin", "irq", None]
MOV_DESTINATIONS = ["pins", "x", "y", None, "exec", "pc", "isr", "osr"]
MOV_SOURCES = ["pins", "x", "y", "null", None, "status", "isr", "osr"]
MOV_OPS = [None, "~", "::", None]
SET_DESTINATIONS = ["pins", "x", "y", None, "pindirs", None, None, None]


class Program:  # pylint: disable=too-few-public-methods
    """Encapsulates a program's instruction stream and configuration flags

    Example::

        program = adafruit_pioasm.Program(...)
        state_machine = rp2pio.StateMachine(program.assembled, ..., **program.pio_kwargs)

    """

    def __init__(self, text_program: str, *, build_debuginfo=False) -> None:
        """Converts pioasm text to encoded instruction bytes"""
        # pylint: disable=too-many-branches,too-many-statements,too-many-locals
        assembled = []
        program_name = None
        labels = {}
        linemap = []
        instructions = []
        sideset_count = 0
        sideset_enable = 0
        wrap = None
        wrap_target = None
        offset = -1
        for i, line in enumerate(text_program.split("\n")):
            line = line.strip()
            if not line:
                continue
            if ";" in line:
                line = line.split(";")[0].strip()
            if line.startswith(".program"):
                if program_name:
                    raise RuntimeError("Multiple programs not supported")
                program_name = line.split()[1]
            elif line.startswith(".origin"):
                offset = int(line.split()[1], 0)
            elif line.startswith(".wrap_target"):
                wrap_target = len(instructions)
            elif line.startswith(".wrap"):
                if len(instructions) == 0:
                    raise RuntimeError("Cannot have .wrap as first instruction")
                wrap = len(instructions) - 1
            elif line.startswith(".side_set"):
                sideset_count = int(line.split()[1], 0)
                sideset_enable = "opt" in line
            elif line.endswith(":"):
                label = line[:-1]
                if label in labels:
                    raise SyntaxError(f"Duplicate label {repr(label)}")
                labels[label] = len(instructions)
            elif line:
                # Only add as an instruction if the line isn't empty
                instructions.append(line)
                linemap.append(i)

        max_delay = 2 ** (5 - sideset_count - sideset_enable) - 1
        assembled = []
        for instruction in instructions:
            # print(instruction)
            instruction = splitter(instruction.strip())
            delay = 0
            if instruction[-1].endswith("]"):  # Delay
                delay = int(instruction[-1].strip("[]"), 0)
                if delay < 0:
                    raise RuntimeError("Delay negative:", delay)
                if delay > max_delay:
                    raise RuntimeError("Delay too long:", delay)
                instruction.pop()
            if len(instruction) > 1 and instruction[-2] == "side":
                if sideset_count == 0:
                    raise RuntimeError("No side_set count set")
                sideset_value = int(instruction[-1], 0)
                if sideset_value >= 2**sideset_count:
                    raise RuntimeError("Sideset value too large")
                delay |= sideset_value << (5 - sideset_count - sideset_enable)
                delay |= sideset_enable << 4
                instruction.pop()
                instruction.pop()

            if instruction[0] == "nop":
                #                  mov delay   y op   y
                assembled.append(0b101_00000_010_00_010)
            elif instruction[0] == "jmp":
                #                instr delay cnd addr
                assembled.append(0b000_00000_000_00000)
                target = instruction[-1]
                if target[:1] in "0123456789":
                    assembled[-1] |= int(target, 0)
                elif instruction[-1] in labels:
                    assembled[-1] |= labels[target]
                else:
                    raise SyntaxError(f"Invalid jmp target {repr(target)}")

                if len(instruction) > 2:
                    try:
                        assembled[-1] |= CONDITIONS.index(instruction[1]) << 5
                    except ValueError as exc:
                        raise ValueError(
                            f"Invalid jmp condition '{instruction[1]}'"
                        ) from exc

            elif instruction[0] == "wait":
                #                instr delay p sr index
                assembled.append(0b001_00000_0_00_00000)
                polarity = int(instruction[1], 0)
                if not 0 <= polarity <= 1:
                    raise RuntimeError("Invalid polarity")
                assembled[-1] |= polarity << 7
                assembled[-1] |= WAIT_SOURCES.index(instruction[2]) << 5
                num = int(instruction[3], 0)
                if not 0 <= num <= 31:
                    raise RuntimeError("Wait num out of range")
                assembled[-1] |= num
                if instruction[-1] == "rel":
                    assembled[-1] |= 0x10  # Set the high bit of the irq value
            elif instruction[0] == "in":
                #                instr delay src count
                assembled.append(0b010_00000_000_00000)
                assembled[-1] |= IN_SOURCES.index(instruction[1]) << 5
                count = int(instruction[-1], 0)
                if not 1 <= count <= 32:
                    raise RuntimeError("Count out of range")
                assembled[-1] |= count & 0x1F  # 32 is 00000 so we mask the top
            elif instruction[0] == "out":
                #                instr delay dst count
                assembled.append(0b011_00000_000_00000)
                assembled[-1] |= OUT_DESTINATIONS.index(instruction[1]) << 5
                count = int(instruction[-1], 0)
                if not 1 <= count <= 32:
                    raise RuntimeError("Count out of range")
                assembled[-1] |= count & 0x1F  # 32 is 00000 so we mask the top
            elif instruction[0] == "push" or instruction[0] == "pull":
                #                instr delay d i b zero
                assembled.append(0b100_00000_0_0_0_00000)
                if instruction[0] == "pull":
                    assembled[-1] |= 0x80
                if instruction[-1] == "block" or not instruction[-1].endswith("block"):
                    assembled[-1] |= 0x20
                if len(instruction) > 1 and instruction[1] in ("ifempty", "iffull"):
                    assembled[-1] |= 0x40
            elif instruction[0] == "mov":
                #                instr delay dst op src
                assembled.append(0b101_00000_000_00_000)
                assembled[-1] |= MOV_DESTINATIONS.index(instruction[1]) << 5
                source = instruction[-1]
                source_split = mov_splitter(source)
                if len(source_split) == 1:
                    try:
                        assembled[-1] |= MOV_SOURCES.index(source)
                    except ValueError as exc:
                        raise ValueError(f"Invalid mov source '{source}'") from exc
                else:
                    assembled[-1] |= MOV_SOURCES.index(source_split[1])
                    if source[:1] == "!":
                        assembled[-1] |= 0x08
                    elif source[:1] == "~":
                        assembled[-1] |= 0x08
                    elif source[:2] == "::":
                        assembled[-1] |= 0x10
                    else:
                        raise RuntimeError("Invalid mov operator:", source[:1])
                if len(instruction) > 3:
                    assembled[-1] |= MOV_OPS.index(instruction[-2]) << 3
            elif instruction[0] == "irq":
                #                instr delay z c w index
                assembled.append(0b110_00000_0_0_0_00000)
                if instruction[-1] == "rel":
                    assembled[-1] |= 0x10  # Set the high bit of the irq value
                    instruction.pop()
                num = int(instruction[-1], 0)
                if not 0 <= num <= 7:
                    raise RuntimeError("Interrupt index out of range")
                assembled[-1] |= num
                if len(instruction) == 3:  # after rel has been removed
                    if instruction[1] == "wait":
                        assembled[-1] |= 0x20
                    elif instruction[1] == "clear":
                        assembled[-1] |= 0x40
                    # All other values are the default of set without waiting
            elif instruction[0] == "set":
                #                instr delay dst data
                assembled.append(0b111_00000_000_00000)
                try:
                    assembled[-1] |= SET_DESTINATIONS.index(instruction[1]) << 5
                except ValueError as exc:
                    raise ValueError(
                        f"Invalid set destination '{instruction[1]}'"
                    ) from exc
                value = int(instruction[-1], 0)
                if not 0 <= value <= 31:
                    raise RuntimeError("Set value out of range")
                assembled[-1] |= value
            else:
                raise RuntimeError("Unknown instruction:" + instruction[0])
            assembled[-1] |= delay << 8
            # print(bin(assembled[-1]))

        self.pio_kwargs = {
            "sideset_enable": sideset_enable,
        }

        if offset != -1:
            self.pio_kwargs["offset"] = offset

        if sideset_count != 0:
            self.pio_kwargs["sideset_pin_count"] = sideset_count

        if wrap is not None:
            self.pio_kwargs["wrap"] = wrap
        if wrap_target is not None:
            self.pio_kwargs["wrap_target"] = wrap_target

        self.assembled = array.array("H", assembled)

        if build_debuginfo:
            self.debuginfo = (linemap, text_program)
        else:
            self.debuginfo = None

    def print_c_program(self, name, qualifier="const"):
        """Print the program into a C program snippet"""
        if self.debuginfo is None:
            linemap = None
            program_lines = None
        else:
            linemap = self.debuginfo[0][:]  # Use a copy since we destroy it
            program_lines = self.debuginfo[1].split("\n")

        print(
            f"{qualifier} int {name}_wrap = {self.pio_kwargs.get('wrap', len(self.assembled)-1)};"
        )
        print(
            f"{qualifier} int {name}_wrap_target = {self.pio_kwargs.get('wrap_target', 0)};"
        )
        sideset_pin_count = self.pio_kwargs.get("sideset_pin_count", 0)
        print(f"{qualifier} int {name}_sideset_pin_count = {sideset_pin_count};")
        print(
            f"{qualifier} bool {name}_sideset_enable = {self.pio_kwargs['sideset_enable']};"
        )
        print(f"{qualifier} uint16_t {name}[] = " + "{")
        last_line = 0
        if linemap:
            for inst in self.assembled:
                next_line = linemap[0]
                del linemap[0]
                while last_line < next_line:
                    line = program_lines[last_line]
                    if line:
                        print(f"            // {line}")
                    last_line += 1
                line = program_lines[last_line]
                print(f"    0x{inst:04x}, // {line}")
                last_line += 1
            while last_line < len(program_lines):
                line = program_lines[last_line]
                if line:
                    print(f"            // {line}")
                last_line += 1
        else:
            for i in range(0, len(self.assembled), 8):
                print(
                    "    " + ", ".join("0x%04x" % i for i in self.assembled[i : i + 8])
                )
        print("};")
        print()


def assemble(program_text: str) -> array.array:
    """Converts pioasm text to encoded instruction bytes

    In new code, prefer to use the `Program` class so that the extra arguments
    such as the details about side-set pins can be easily passsed to the
    ``StateMachine`` constructor."""
    return Program(program_text).assembled

adafruit_pioasm.py

import time
import array
from rp2pio import StateMachine
from adafruit_pioasm import Program
import digitalio
import countio

# The following 
_asm_str = """
reload:
    {0}        ; direction bit if used              _dir_asm
    out y, {1} ; delay                              self.DELAY_BIT_LIMIT
    out x, {2} ; steps                              STEP_LIMIT
    mov isr, y
    jmp skip
step_loop:
    nop [3]     ; jmp delay                         self.PIO_DELAY
skip:
    set pins {3} [10]   ;                           step_pos
    set pins {4} ;                                  step_neg 
    {5}        ; jmp if limit switch enabled        _jmp_asm
continue:
    mov y isr
    push noblock
    mov isr y
delay_loop:
    jmp y-- delay_loop
    jmp x-- step_loop
    jmp reload
stall:
    jmp stall
 """


class Stepper:

# Private properties and methods:
# _sm: The state machine object.
# _jmp_delay: Delay for the jmp pin to prevent false triggering.
# _steps: The current step count of the motor.
# _fd: The fractional delay for the state machine.
# _set_dir: Method to set the motor's direction.
# _change_velocity: Method to change the motor's velocity
# _setup_sm: Method to setup and initialize the state machine.

    PIO_FREQ = 4e6
    DIR_BIT = False  # set direction in asm?
    DELAY_BIT_LIMIT = 16
    PIO_DELAY = 21  # additional asm clock cycles per step
    STEPS_PER_REV = 200
    MM_PER_REV = 5

    def __init__(
        # Initialize the stepper motor with configuration for pins and movement characteristics.
        # Optional parameters allow for: step counting, direction control and motor enable/disable.
        self,
        step_pin,
        max_velocity=2000,
        acceleration=0.5,
        delays="linear",
        count_pin=None,
        dir_pin=None,
        enable_pin=None,
    ):
        from linear_delay import Linear as Delay
        self.delays = Delay(self, delay_bits=self.DELAY_BIT_LIMIT, dir_bit=self.DIR_BIT)
        self.step_pin = step_pin
        self.max_velocity = max_velocity  # velocity in Hz (1 / delay)
        self.acceleration = acceleration  # time to max_velocity in sec.
        self.micro_steps = 8  # set to stepper driver microstepping

        self.direction = 0  # forward or backward direction
        self.counter = None
        if dir_pin:
            if not self.DIR_BIT:
                self.dir_pin = digitalio.DigitalInOut(dir_pin)
                self.dir_pin.switch_to_output()
            else:
                self.dir_pin = dir_pin
        else:
            self.dir_pin = None
        self.dir_active = "LOW"

        if enable_pin:
            self.enable_pin = digitalio.DigitalInOut(enable_pin)
            self.enable_pin.switch_to_output()
        else:
            self.enable_pin = None
        self.enable_active = "HIGH"

        self.jmp_pin = None  # used for stepper limit switch
        self.jmp_active = "LOW"
        self.step_active = "HIGH"
        self._jmp_delay = 0

        self.counter = None

        self._steps = 0
        self._fd = 0
        self.limit = 0
        self._setup_sm()

    def _setup_sm(self):
        # Setup and initialize the PIO state machine with the given configuration.
        try:
            self._sm.deinit()
        except:
            pass
        if self.DIR_BIT:  # asm dir control
            _dir_asm = "out pins 1"
            dir_pin = self.dir_pin
        else:  # general digital I/O dir control
            _dir_asm = ""
            dir_pin = None

        # setup pin bits for step pin active high/low
        bits = ("0b1", "0b0")
        if self.step_active == "HIGH":
            step_pos, step_neg = bits

        else:
            step_neg, step_pos = bits

        if self.jmp_pin:  # add a jmp command to stall at limit
            # note: activating jmp pin will require sm restart
            if self.jmp_active == "HIGH":
                _jmp_asm = "jmp pin stall"
                _jmp_pull = digitalio.Pull.DOWN
            if self.jmp_active == "LOW":
                _jmp_asm = "jmp pin continue\n    jmp stall"
                _jmp_pull = digitalio.Pull.UP
            self._jmp_delay = 1
        else:
            _jmp_asm = ""
            self._jmp_delay = 0
            _jmp_pull = None

        self.pio_delay = self.PIO_DELAY + self._jmp_delay

        STEP_LIMIT = 32 - self.DELAY_BIT_LIMIT - int(self.DIR_BIT)

        setup_message = "Stepper PIO setup: dir_bit={}, delay_bit_limit={}, step_limit={}, step_pos={}, step_neg={}, jmp_asm={}"
        print(setup_message.format(_dir_asm, self.DELAY_BIT_LIMIT, STEP_LIMIT, step_pos, step_neg, _jmp_asm))
        # fill in the stepper_asm variables
        _asm = _asm_str.format(
            _dir_asm, self.DELAY_BIT_LIMIT, STEP_LIMIT, step_pos, step_neg, _jmp_asm
        )
        _stepper_asm = Program(_asm)
        self._sm = StateMachine(
            _stepper_asm.assembled,
            auto_pull=True,
            pull_threshold=32,
            first_set_pin=self.step_pin,
            initial_set_pin_state=int(step_neg),
            first_out_pin=dir_pin,
            jmp_pin=self.jmp_pin,
            jmp_pin_pull=_jmp_pull,
            exclusive_pin_use=False,
            out_shift_right=False,
            frequency=int(self.PIO_FREQ),
            **_stepper_asm.pio_kwargs,
        )
        self._sm.background_write(array.array("L", [0]))
        self.limit = 0

    def _set_dir(self, direction):
        # Internal method to set the motor's direction, using either the PIO or a digital I/O pin for control.
        self.direction = direction
        if self.dir_pin:
            self.dir_pin.value = direction ^ (self.dir_active == "LOW")

    @property
    def enable(self):
        # Enable state of the motor. Uses an optional enable pin to physically enable/disable the motor.
        if not self.enable_pin:
            return None
        return self.enable_pin.value ^ (self.enable_active == "HIGH")

    @enable.setter
    def enable(self, value):
        if not self.enable_pin:
            return None
        self.enable_pin.value = bool(value) ^ (self.enable_active == "HIGH")

    @property
    def position(self):
        # Current position of the motor in millimeters.
        return self.steps / self.STEPS_PER_REV * self.MM_PER_REV

    @position.setter
    def position(self, value):
        # Motor's position in millimeters. Moves the motor to the specified position.
        delta_mm = value - self.position
        self.steps = delta_mm / self.MM_PER_REV * self.STEPS_PER_REV

    @property
    def velocity(self):
        # Current velocity of the stepper motor. Calculates velocity based on the last known delay.
        if self.stopped():
            return 0
        self._sm.clear_rxfifo()
        _timeout = time.monotonic()
        while not self._sm.in_waiting:
            if (time.monotonic() - _timeout) > 0.1:
                return 0
        delay_bits = array.array("L", [0])
        self._sm.readinto(delay_bits)
        delay = delay_bits[0] + self.pio_delay
        sign = 1 - 2 * self.direction
        return sign * self._sm.frequency / self.micro_steps / delay

    @velocity.setter
    def velocity(self, value):  # accelerate to continuous rotation
        # Setter for the motor's velocity, enabling acceleration to a specified speed.
        start_velocity = self.velocity
        if start_velocity == value:
            return
        _ = self.steps  # flush counter
        if value == 0:
            self.stop()
            return
        if value * start_velocity > 0:  # increase/decrease speed
            self._change_velocity(start_velocity, value)
            self._sm.clear_txstall()
            return
        if value * start_velocity < 0:  # changing direction
            self.stop()
            while self.velocity:
                time.sleep(0.01)
            start_velocity = 0
        self._set_dir(int(value < 0))
        if start_velocity == 0:
            self.steps = 1 - 2 * self.direction  # sometimes setting velocity glitches
        value = abs(value)
        acc_delays = self.delays._change_velocity(start_velocity, value)
        full_speed = array.array("L", [((acc_delays[-1] >> 16) << 16) + self._fd])
        self._sm.background_write(once=acc_delays, loop=full_speed)
        self._sm.clear_txstall()

    def _change_velocity(self, start_velocity, value):
        # Internal method to change the motor's velocity from a start velocity to a target velocity.
        value = abs(value)
        acc_delays = self.delays._change_velocity(start_velocity, value)
        full_speed = array.array("L", [((acc_delays[-1] >> 16) << 16) + self._fd])
        self._sm.background_write(once=acc_delays, loop=full_speed)
        self._sm.clear_txstall()

    @property
    def steps(self):
        # Property to get the current step count of the motor, optionally using a counter for precise tracking.
        if self.counter:
            sign = 1 - 2 * self.direction
            if self.velocity != 0:
                return (self._steps + sign * self.counter.count) / self.micro_steps
            else:
                self._steps += sign * self.counter.count
                self.counter.reset()
        return int(self._steps / self.micro_steps)

    @steps.setter
    def steps(self, value):
        # Setter for the motor's steps, allowing for movement by a specified number of steps.
        if self.velocity != 0:  # not while stepper is moving
            return
        _ = self.steps  # make sure counter is flushed
        self._set_dir(int(value < 0))
        self._sm.background_write(self.delays.gen_delays(abs(value)))
        self._sm.clear_txstall()
        if self.counter is None:
            sign = 1 - 2 * self.direction
            self._steps += sign * abs(value) * self.micro_steps

    def stop(self):
        # Gracefully decelerate and stop the motor.
        v = abs(self.velocity)
        if v == 0:
            return
        dec_delays = array.array(
            "L", list(self.delays._accel_delays(velocity=v)[:-1])[::-1]
        )
        self._sm.background_write(once=dec_delays)
        self._sm.clear_txstall()

    def stopped(self):  
        # Does the state machine's buffer status, indicate that the motor is stopped?
        return self._sm.txstall

    def reset(self):
         # Resets the state machine and optionally the step counter, preparing the motor for a fresh sequence of operations.
        self._sm.stop()
        self._setup_sm()
        if self.counter:
            self.counter.reset()
        self._steps = 0
        return True

    
    

stepper_pio.py

from stepper_pio import Stepper as StepperPIO


class Stepper(StepperPIO):
    ENC_TICKS_PER_MM = 50

    def __init__(self, step_pin, encoder_pins=None, limit_pins=None, **kwargs):

        self.encoder = None
        self.limit_pins = limit_pins
        super().__init__(step_pin, **kwargs)

    @property
    def position(self):
        return self.steps / self.STEPS_PER_REV * self.MM_PER_REV

    @position.setter
    def position(self, value):
        delta_mm = value - self.position
        self.steps = delta_mm / self.MM_PER_REV * self.STEPS_PER_REV

    def _set_dir(self, direction):
        self.direction = direction
        if self.limit_pins:
            self.jmp_pin = self.limit_pins[direction]
            self._setup_sm()
        super()._set_dir(direction)

    def reset(self):
        super().reset()
        if self.encoder:
            self.encoder.position = 0
        return True

stepper.py

from math import ceil, sqrt
import array
from step_gen import Delay


class Linear(Delay):
    def _accel_delays(self, velocity=None):
        if velocity is None:
            velocity = self.stepper.max_velocity
        velocity = max(velocity, 10)
        frequency = self.stepper._sm.frequency
        micro_steps = self.stepper.micro_steps
        acceleration = self.stepper.acceleration

        delay_limit = 2 ** self.delay_bits - 1

        min_delay = int(frequency / velocity / micro_steps)
        num_steps = max(int(velocity * micro_steps * acceleration / 100), 1)
        delays = [
            min(int(min_delay * num_steps / (i + 1)), delay_limit)
            for i in range(num_steps)
        ]
        delays[-1] = min_delay
        return self._unique(delays)

    def _accel_steps(self, velocity=None):
        if velocity is None:
            velocity = self.stepper.max_velocity
        micro_steps = self.stepper.micro_steps
        acceleration = self.stepper.acceleration

        n = velocity * micro_steps * acceleration / 100 + 1
        return int((n * n - n) / 2)

    def _accel_velocity(self, steps):
        micro_steps = self.stepper.micro_steps
        acceleration = self.stepper.acceleration

        n = (1 + sqrt(8 * steps + 1)) / 2 - 1
        return 100 * n / acceleration / micro_steps

    def _unique(self, delays):

        direction = self.stepper.direction
        STEP_BIT_LIMIT = 32 - self.delay_bits - int(self.dir_bit)

        u_delays = delays
        u_counts = list(range(len(u_delays)))

        # set the MSB direction bit if used
        dir_bit = int(self.dir_bit) * direction << 31

        # additional asm step delay per loop
        dd = self.stepper.pio_delay

        # build the dir|delay|step buffer for DMA writing
        return array.array(
            "L",
            [
                dir_bit | (d - dd) << STEP_BIT_LIMIT | c
                for d, c in zip(u_delays, u_counts)
            ],
        )


linear_delay.py

import array


class Delay:
    def __init__(self, stepper, delay_bits=16, dir_bit=False):
        self.stepper = stepper
        self.delay_bits = delay_bits
        self.dir_bit = dir_bit
        self._repeat = 1

    def _accel_steps(self):
        raise NotImplementedError

    def _accel_velocity(self):
        raise NotImplementedError

    def _accel_delays(self):
        raise NotImplementedError

    def gen_delays(self, steps):
        # generate delay|step buffer
        # including acceleration + cruise + deceleration
        STEP_BIT_LIMIT = 32 - self.delay_bits - int(self.dir_bit)
        dir_bit = int(self.dir_bit) * self.stepper.direction
        # scale steps for micro-stepping
        steps = int(steps) * self.stepper.micro_steps
        step_limit = 2 ** STEP_BIT_LIMIT - 1

        # number of steps during acceleration phase
        acc_steps = self._accel_steps()
        half_steps = steps // 2

        # lower max_velocity if steps won't complete acceleration
        if half_steps < acc_steps:
            velocity = self._accel_velocity(half_steps)
            acc_steps = self._accel_steps(velocity=velocity)
        else:
            velocity = self.stepper.max_velocity

        # necessary for step-accurate count
        # not exactly sure why the math works
        if acc_steps % self._repeat:
            acc_steps += self._repeat - (acc_steps % self._repeat)

        # remaining steps at cruising velocity
        acc_delays = self._accel_delays(velocity=velocity)
        sum_steps = sum(d & 0xFFFF for d in acc_delays) + len(acc_delays)
        cruise_steps = steps - 2 * sum_steps
        # deceleration mirrors acceleration curve
        dec_delays = array.array("L", list(acc_delays)[::-1])

        # fill in the buffer for the cruise steps
        c_delay = acc_delays[-1] >> STEP_BIT_LIMIT
        c_delay -= dir_bit << self.delay_bits
        # c_steps = acc_delays[-1] & (2 ** STEP_BIT_LIMIT - 1)

        # remove a step because PIO adds one
        c_steps = cruise_steps - 1
        cruise_arr = array.array("L")

        # use STEP_BIT sized chunks to break up cruise steps
        if c_steps > 0:
            while c_steps > step_limit:
                cruise_arr.append(
                    dir_bit << 31 | c_delay << STEP_BIT_LIMIT | step_limit - 1
                )
                c_steps -= step_limit
            cruise_arr.append(c_delay << 16 | c_steps)

        # final buffer for DMA writes
        return acc_delays + cruise_arr + dec_delays

    def _change_velocity(self, v_start, v_end):
        # acc/decelerate from one velocity to another
        # typically while continuously rotating

        STEP_BIT_LIMIT = 32 - self.delay_bits - int(self.dir_bit)
        # speed up or slow down
        sign = 1 - 2 * int(v_end < v_start)
        mag = abs(v_end - v_start)

        # smooth curve, but accel time != self.acceleration
        acc_delays = self._accel_delays(velocity=mag)

        # no calculations when starting from 0
        if v_start == 0:
            return acc_delays

        v_to_d = self.stepper._sm.frequency / self.stepper.micro_steps
        d_start = int(v_to_d / v_start)
        d_mask = 2 ** self.delay_bits - 1
        d_mask <<= STEP_BIT_LIMIT
        neg_mask = 0xFFFFFFFF - d_mask

        # add offset delay to delay curve
        for i, delay_bits in enumerate(acc_delays):
            d = delay_bits & d_mask
            d = (d >> STEP_BIT_LIMIT) + self.stepper.pio_delay
            d = int(d * d_start / (d + sign * d_start))
            d -= self.stepper.pio_delay
            d <<= STEP_BIT_LIMIT
            acc_delays[i] = (delay_bits & neg_mask) | d

        # final delay for highest accuracy velocity
        acc_delays[-1] = (acc_delays[-1] & neg_mask) | (
            (int(v_to_d / v_end) - self.stepper.pio_delay) << STEP_BIT_LIMIT
        )
        return acc_delays
