### Initialize BasicStepperDriver for 2-wire STEP/DIR

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Demonstrates how to instantiate and control a generic 2-wire stepper driver. It covers basic setup, enabling the motor, and performing rotational movements.

```cpp
#include <Arduino.h>
#include "BasicStepperDriver.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define ENABLE 13

BasicStepperDriver stepper(MOTOR_STEPS, DIR, STEP);

void setup() {
    stepper.begin(120, 1);
}

void loop() {
    stepper.enable();
    stepper.rotate(360);
    stepper.move(-200);
    stepper.disable();
    delay(5000);
}
```

--------------------------------

### Initialize TMC2100 SilentStepStick

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Shows the setup for a TMC2100 driver, which supports native microstepping and internal interpolation for smooth, quiet motor operation.

```cpp
#include <Arduino.h>
#include "TMC2100.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define ENABLE 13
#define CFG1 10
#define CFG2 11

TMC2100 stepper(MOTOR_STEPS, DIR, STEP, ENABLE, CFG1, CFG2);

void setup() {
    stepper.begin(60, 16);
    stepper.enable();
}

void loop() {
    stepper.rotate(360);
    delay(1000);
    stepper.rotate(-360);
    delay(1000);
}
```

--------------------------------

### Basic Stepper Motor Control with A4988

Source: https://github.com/laurb9/stepperdriver/blob/master/README.md

This example demonstrates basic control of a stepper motor using the A4988 driver. It configures the motor steps, direction, and microstepping pins, then sets the motor to rotate 360 degrees at 1 RPM with full step mode.

```C++
#include <Arduino.h>
#include "A4988.h"

// using a 200-step motor (most common)
#define MOTOR_STEPS 200
// configure the pins connected
#define DIR 8
#define STEP 9
#define MS1 10
#define MS2 11
#define MS3 12
A4988 stepper(MOTOR_STEPS, DIR, STEP, MS1, MS2, MS3);

void setup() {
    // Set target motor RPM to 1RPM and microstepping to 1 (full step mode)
    stepper.begin(1, 1);
}

void loop() {
    // Tell motor to rotate 360 degrees. That's it.
    stepper.rotate(360);
}
```

--------------------------------

### Synchronized Multi-Motor Control with SyncDriver

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Enables synchronized motion for multiple motors, ensuring they all start and finish at the same time. This is ideal for CNC machines or plotters where linear trajectory is required.

```cpp
#include <Arduino.h>
#include "BasicStepperDriver.h"
#include "SyncDriver.h"

#define MOTOR_STEPS 200
#define MICROSTEPS 32
#define DIR_X 8
#define STEP_X 9
#define DIR_Y 6
#define STEP_Y 7

BasicStepperDriver stepperX(MOTOR_STEPS, DIR_X, STEP_X);
BasicStepperDriver stepperY(MOTOR_STEPS, DIR_Y, STEP_Y);
SyncDriver controller(stepperX, stepperY);

void setup() {
    stepperX.begin(60, MICROSTEPS);
    stepperY.begin(60, MICROSTEPS);
}

void loop() {
    controller.rotate(450, 900);
    delay(1000);
    controller.startMove(2000, 1000);
    while (controller.isRunning()) {
        controller.nextAction();
    }
    delay(30000);
}
```

--------------------------------

### Independent Multi-Motor Control with MultiDriver

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Controls multiple motors simultaneously where each motor operates at its own speed. Motors start together but finish at different times, creating a hockey stick trajectory pattern.

```cpp
#include <Arduino.h>
#include "BasicStepperDriver.h"
#include "MultiDriver.h"

#define MOTOR_STEPS 200
#define MICROSTEPS 32
#define DIR_X 8
#define STEP_X 9
#define DIR_Y 6
#define STEP_Y 7

BasicStepperDriver stepperX(MOTOR_STEPS, DIR_X, STEP_X);
BasicStepperDriver stepperY(MOTOR_STEPS, DIR_Y, STEP_Y);
MultiDriver controller2(stepperX, stepperY);

void setup() {
    stepperX.begin(60, MICROSTEPS);
    stepperY.begin(90, MICROSTEPS);
}

void loop() {
    controller2.rotate(360, 180);
    controller2.startRotate(720, 360);
    while (controller2.isRunning()) {
        controller2.nextAction();
    }
    delay(3000);
}
```

--------------------------------

### Driver Initialization and Parameter Management

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Covers the begin() method for initializing drivers and demonstrates how to dynamically update RPM and microstepping settings, as well as retrieve current driver state.

```cpp
#include <Arduino.h>
#include "A4988.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define MS1 10
#define MS2 11
#define MS3 12

A4988 stepper(MOTOR_STEPS, DIR, STEP, MS1, MS2, MS3);

void setup() {
    stepper.begin(120, 8);
    stepper.setRPM(60);
    stepper.setMicrostep(16);
}

void loop() {
    float currentRPM = stepper.getRPM();
    float actualRPM = stepper.getCurrentRPM();
    short microsteps = stepper.getMicrostep();
    short steps = stepper.getSteps();
    stepper.rotate(360);
    delay(2000);
}
```

--------------------------------

### Configure A4988 Driver with Microstepping

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Shows how to use the A4988 driver class with microstepping control pins. It demonstrates switching between different microstep resolutions to change motion smoothness.

```cpp
#include <Arduino.h>
#include "A4988.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define SLEEP 13
#define MS1 10
#define MS2 11
#define MS3 12

A4988 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, MS1, MS2, MS3);

void setup() {
    stepper.begin(120, 1);
    stepper.enable();
}

void loop() {
    stepper.setMicrostep(16);
    stepper.rotate(360);
    delay(2000);
}
```

--------------------------------

### Configure Acceleration Speed Profiles

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Demonstrates how to set linear acceleration or constant speed profiles for smoother motor operation, including setting acceleration and deceleration rates.

```cpp
#include <Arduino.h>
#include "DRV8834.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define SLEEP 13
#define M0 10
#define M1 11

DRV8834 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1);

void setup() {
    stepper.begin(120, 16);
    stepper.enable();
    stepper.setSpeedProfile(stepper.LINEAR_SPEED, 2000, 1000);
}

void loop() {
    stepper.rotate(720);
    BasicStepperDriver::Profile profile = stepper.getSpeedProfile();
    short accel = stepper.getAcceleration();
    short decel = stepper.getDeceleration();
    delay(2000);
}
```

--------------------------------

### Implement Non-Blocking Motor Motion

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Demonstrates how to initiate motor movement without blocking the main loop. The nextAction method is used to advance the motor one step at a time, allowing for concurrent tasks like sensor reading.

```cpp
#include <Arduino.h>
#include "DRV8834.h"

#define STOPPER_PIN 4
#define MOTOR_STEPS 200
#define MICROSTEPS 16
#define DIR 8
#define STEP 9
#define SLEEP 13
#define M0 10
#define M1 11

DRV8834 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1);

void setup() {
    Serial.begin(115200);
    pinMode(STOPPER_PIN, INPUT_PULLUP);

    stepper.begin(120, MICROSTEPS);
    stepper.setSpeedProfile(stepper.LINEAR_SPEED, 2000, 1000);
    stepper.enable();

    stepper.startMove(100 * MOTOR_STEPS * MICROSTEPS);
}

void loop() {
    if (digitalRead(STOPPER_PIN) == LOW) {
        stepper.stop();
    }

    unsigned wait_time_micros = stepper.nextAction();

    if (wait_time_micros == 0) {
        Serial.println("Motion complete");
        stepper.disable();
        delay(3600000);
    }

    if (wait_time_micros > 100) {
        Serial.print("Steps remaining: ");
        Serial.println(stepper.getStepsRemaining());
    }
}
```

--------------------------------

### BasicStepperDriver Linear Speed Test (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet shows the performance results for the BasicStepperDriver at linear speeds. It logs expected vs. elapsed time, step error, and average step time for different RPMs. Tested on ESP8266_NODEMCU.

```text
BasicStepperDriver test, linear speed
  rpm=6000 expected=    365148µs elapsed=    342337µs step_err=   114µs avgstep=  1825µs
  rpm=600  expected=    365148µs elapsed=    342328µs step_err=   114µs avgstep=  1825µs
  rpm=60   expected=   1033246µs elapsed=   1009343µs step_err=   119µs avgstep=  5166µs
  rpm=6    expected=  10000000µs elapsed=   2456407µs step_err= 37717µs avgstep= 50000µs FAIL
test_basic(s1): FAIL
```

--------------------------------

### Initialize DRV8880 with Torque Control

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Demonstrates how to instantiate and configure the DRV8880 driver, including setting motor current levels (25%, 50%, 75%, or 100%) to manage torque for different load conditions.

```cpp
#include <Arduino.h>
#include "DRV8880.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define SLEEP 13
#define M0 10
#define M1 11
#define TRQ0 6
#define TRQ1 7

DRV8880 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1, TRQ0, TRQ1);

void setup() {
    stepper.begin(60, 1);
    stepper.enable();
    stepper.setCurrent(75);
}

void loop() {
    stepper.setCurrent(100);
    stepper.rotate(180);
    stepper.setCurrent(50);
    stepper.rotate(180);
    delay(2000);
}
```

--------------------------------

### BasicStepperDriver Constant Speed Test (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet shows the performance results for the BasicStepperDriver operating at constant speeds. It logs expected vs. elapsed time, step error, and average step time for different RPMs. Tested on ESP8266_NODEMCU.

```text
BasicStepperDriver test, constant speed
  rpm=6000 expected=     10000µs elapsed=     10346µs step_err=     1µs avgstep=    50µs
  rpm=600  expected=    100000µs elapsed=     99760µs step_err=     1µs avgstep=   500µs
  rpm=60   expected=   1000000µs elapsed=    995291µs step_err=    23µs avgstep=  5000µs
  rpm=6    expected=  10000000µs elapsed=   9950300µs step_err=   248µs avgstep= 50000µs
test_basic(s1): OK
```

--------------------------------

### Control Motor Power with Enable and Disable

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Illustrates how to toggle motor power using enable and disable methods. This is useful for holding position or allowing manual rotation of the motor shaft.

```cpp
#include <Arduino.h>
#include "A4988.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define ENABLE 13
#define MS1 10
#define MS2 11
#define MS3 12

A4988 stepper(MOTOR_STEPS, DIR, STEP, ENABLE, MS1, MS2, MS3);

void setup() {
    stepper.begin(60, 1);
}

void loop() {
    stepper.enable();
    stepper.rotate(360);

    stepper.disable();
    delay(5000);

    stepper.enable();
    stepper.rotate(-360);

    delay(2000);
}
```

--------------------------------

### SyncDriver Linear Speed Test (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet shows the performance metrics for the SyncDriver under linear speed conditions. It includes expected vs. elapsed time, step error, and average step time across different RPMs. Tested on ESP8266_NODEMCU.

```text
SyncDriver test, linear speed
  rpm=6000 expected=    365148µs elapsed=    361367µs step_err=    18µs avgstep=  1825µs
  rpm=600  expected=    365148µs elapsed=    361408µs step_err=    18µs avgstep=  1825µs
  rpm=60   expected=   1033246µs elapsed=   1242580µs step_err=  1046µs avgstep=  5166µs FAIL
  rpm=6    expected=  10000000µs elapsed=   2477912µs step_err= 37610µs avgstep= 50000µs FAIL
test_sync(s1, s2, s3): FAIL
```

--------------------------------

### Execute Blocking Motion Commands

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Explains the use of move() and rotate() functions for precise angular or step-based positioning. These functions block execution until the motion is complete.

```cpp
#include <Arduino.h>
#include "BasicStepperDriver.h"

#define MOTOR_STEPS 200
#define MICROSTEPS 8
#define DIR 8
#define STEP 9

BasicStepperDriver stepper(MOTOR_STEPS, DIR, STEP);

void setup() {
    stepper.begin(120, MICROSTEPS);
}

void loop() {
    stepper.rotate(360);
    stepper.rotate(-180);
    stepper.rotate(90.5);
    stepper.move(MOTOR_STEPS * MICROSTEPS);
    stepper.move(-MOTOR_STEPS * MICROSTEPS);
    long stepsNeeded = stepper.calcStepsForRotation(45.0);
    stepper.move(stepsNeeded);
    delay(3000);
}
```

--------------------------------

### SyncDriver Constant Speed Test (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet shows the performance metrics for the SyncDriver under constant speed conditions. It includes expected vs. elapsed time, step error, and average step time across different RPMs. Tested on ESP8266_NODEMCU.

```text
SyncDriver test, constant speed
  rpm=6000 expected=     10000µs elapsed=     14511µs step_err=    22µs avgstep=    50µs FAIL
  rpm=600  expected=    100000µs elapsed=    105689µs step_err=    28µs avgstep=   500µs
  rpm=60   expected=   1000000µs elapsed=   1006867µs step_err=    34µs avgstep=  5000µs
  rpm=6    expected=  10000000µs elapsed=  10018707µs step_err=    93µs avgstep= 50000µs
test_sync(s1, s2, s3): FAIL
```

--------------------------------

### Configure DRV8834 Low-Voltage Driver

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Shows initialization and usage of the DRV8834 driver. It demonstrates moving the motor using both full steps and microsteps.

```cpp
#include <Arduino.h>
#include "DRV8834.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define SLEEP 13
#define M0 10
#define M1 11

DRV8834 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1);

void setup() {
    stepper.begin(120);
    stepper.enable();
}

void loop() {
    stepper.setMicrostep(8);
    stepper.move(8 * MOTOR_STEPS);
    delay(5000);
}
```

--------------------------------

### Commit with Agent Identity

Source: https://github.com/laurb9/stepperdriver/blob/master/AGENTS.md

Demonstrates how to commit changes while identifying the AI agent author via environment variables without modifying the global Git configuration.

```bash
GIT_AUTHOR_NAME="gemini-2.0-pro (antigravity)" GIT_COMMITTER_NAME="gemini-2.0-pro (antigravity)" git commit -m "commit message"
```

--------------------------------

### Query Motor State and Motion Progress

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Shows how to retrieve the current motion state (STOPPED, ACCELERATING, etc.) and telemetry data like steps completed, remaining steps, and current RPM during operation.

```cpp
#include <Arduino.h>
#include "BasicStepperDriver.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9

BasicStepperDriver stepper(MOTOR_STEPS, DIR, STEP);

void setup() {
    Serial.begin(115200);
    stepper.begin(60, 1);
    stepper.setSpeedProfile(stepper.LINEAR_SPEED, 1000, 1000);
    stepper.startMove(1000);
}

void loop() {
    unsigned wait = stepper.nextAction();

    if (wait > 0) {
        BasicStepperDriver::State state = stepper.getCurrentState();

        switch (state) {
            case BasicStepperDriver::STOPPED:
                Serial.println("State: STOPPED");
                break;
            case BasicStepperDriver::ACCELERATING:
                Serial.println("State: ACCELERATING");
                break;
            case BasicStepperDriver::CRUISING:
                Serial.println("State: CRUISING");
                break;
            case BasicStepperDriver::DECELERATING:
                Serial.println("State: DECELERATING");
                break;
        }

        long completed = stepper.getStepsCompleted();
        long remaining = stepper.getStepsRemaining();
        int direction = stepper.getDirection();
        float rpm = stepper.getCurrentRPM();

        Serial.print("Completed: "); Serial.print(completed);
        Serial.print(" Remaining: "); Serial.print(remaining);
        Serial.print(" Direction: "); Serial.print(direction);
        Serial.print(" RPM: "); Serial.println(rpm);
    }
}
```

--------------------------------

### Continuous Clock Rotation with A4988

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Demonstrates how to configure a stepper motor for continuous, slow rotation at 1 RPM, simulating the movement of a clock's second hand.

```cpp
#include <Arduino.h>
#include "A4988.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define MS1 10
#define MS2 11
#define MS3 12

A4988 stepper(MOTOR_STEPS, DIR, STEP, MS1, MS2, MS3);

void setup() {
    stepper.begin(1, 1);
    stepper.enable();
}

void loop() {
    stepper.rotate(360);
}
```

--------------------------------

### Configure Stepper Driver Component with CMake

Source: https://github.com/laurb9/stepperdriver/blob/master/CMakeLists.txt

This snippet shows how to register the stepper driver component in an ESP-IDF project using CMake. It specifies the source and include directories and declares a dependency on the 'arduino' component.

```cmake
cmake_minimum_required(VERSION 3.24)
idf_component_register(
    SRC_DIRS "src"
    INCLUDE_DIRS "src"
    REQUIRES "arduino"
)
```

--------------------------------

### Configure DRV8825 Driver for High Microstepping

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Initializes the DRV8825 driver, which supports up to 1:32 microstepping using MODE pins. This snippet demonstrates setting the driver to its highest resolution.

```cpp
#include <Arduino.h>
#include "DRV8825.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9
#define ENABLE 13
#define MODE0 10
#define MODE1 11
#define MODE2 12

DRV8825 stepper(MOTOR_STEPS, DIR, STEP, ENABLE, MODE0, MODE1, MODE2);

void setup() {
    stepper.begin(60, 1);
    stepper.enable();
}

void loop() {
    stepper.setMicrostep(32);
    stepper.rotate(360);
    delay(2000);
}
```

--------------------------------

### Stepper Driver Timing Calculation Test - Linear Speed (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet details the timing calculations for stepper drivers operating at linear speeds. It compares expected and estimated timings for various RPMs and microstep settings on an ESP8266_NODEMCU.

```text
Timing Calculation test, linear speed
  rpm=6000 microstep=1  expected=    365148µs estimated     365148µs
  rpm=6000 microstep=16 expected=    365148µs estimated     365148µs
  rpm=600  microstep=1  expected=    365148µs estimated     365148µs
  rpm=600  microstep=16 expected=    365148µs estimated     365148µs
  rpm=60   microstep=1  expected=   1033246µs estimated    1033246µs
  rpm=60   microstep=16 expected=   1033246µs estimated    1033333µs
  rpm=6    microstep=1  expected=  10000000µs estimated   10000000µs
  rpm=6    microstep=16 expected=  10000000µs estimated   10000000µs
test_calculations(s1, DURATION_LINEAR): OK
```

--------------------------------

### MultiDriver Linear Speed Test (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet presents the test results for the MultiDriver operating at linear speeds. It reports expected vs. elapsed time, step error, and average step time for various RPMs. Tested on ESP8266_NODEMCU.

```text
MultiDriver test, linear speed
  rpm=6000 expected=    365148µs elapsed=    360765µs step_err=    21µs avgstep=  1825µs
  rpm=600  expected=    365148µs elapsed=    360705µs step_err=    22µs avgstep=  1825µs
  rpm=60   expected=   1033246µs elapsed=   1028486µs step_err=    23µs avgstep=  5166µs
  rpm=6    expected=  10000000µs elapsed=   2477224µs step_err= 37613µs avgstep= 50000µs FAIL
test_multi(s1, s2, s3): FAIL
```

--------------------------------

### Stepper Driver Timing Calculation Test (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet details the results of timing calculations for stepper drivers operating at constant speeds. It compares expected and estimated timings across various RPMs and microstep settings. The tests are performed on an ESP8266_NODEMCU.

```text
Timing Calculation test, constant speed
  rpm=6000 microstep=1  expected=     10000µs estimated      10000µs
  rpm=6000 microstep=16 expected=     10000µs estimated      10000µs
  rpm=600  microstep=1  expected=    100000µs estimated     100000µs
  rpm=600  microstep=16 expected=    100000µs estimated     100000µs
  rpm=60   microstep=1  expected=   1000000µs estimated    1000000µs
  rpm=60   microstep=16 expected=   1000000µs estimated    1000000µs
  rpm=6    microstep=1  expected=  10000000µs estimated   10000000µs
  rpm=6    microstep=16 expected=  10000000µs estimated   10000000µs
test_calculations(s1, DURATION_CONSTANT): OK
```

--------------------------------

### Calculate Move Time with BasicStepperDriver

Source: https://context7.com/laurb9/stepperdriver/llms.txt

Calculates the time in microseconds required to complete a specific number of steps. This is essential for planning synchronized movements and ensuring motors complete tasks within a specific time window.

```cpp
#include <Arduino.h>
#include "BasicStepperDriver.h"

#define MOTOR_STEPS 200
#define DIR 8
#define STEP 9

BasicStepperDriver stepper(MOTOR_STEPS, DIR, STEP);

void setup() {
    Serial.begin(115200);
    stepper.begin(60, 1);
    stepper.setSpeedProfile(stepper.LINEAR_SPEED, 1000, 1000);
}

void loop() {
    long steps = 1000;
    long moveTime = stepper.getTimeForMove(steps);
    Serial.print("Steps: "); Serial.print(steps);
    Serial.print(" Time: "); Serial.print(moveTime / 1000.0);
    Serial.println(" ms");
    stepper.startMove(steps, moveTime);
    while (stepper.nextAction());
    delay(5000);
}
```

--------------------------------

### MultiDriver Constant Speed Test (ESP8266_NODEMCU)

Source: https://github.com/laurb9/stepperdriver/blob/master/examples/UnitTest/esp8266_nodemcu.txt

This snippet presents the test results for the MultiDriver operating at constant speeds. It reports expected vs. elapsed time, step error, and average step time for various RPMs. The tests were conducted on an ESP8266_NODEMCU.

```text
MultiDriver test, constant speed
  rpm=6000 expected=     10000µs elapsed=     12420µs step_err=    12µs avgstep=    50µs FAIL
  rpm=600  expected=    100000µs elapsed=    105190µs step_err=    25µs avgstep=   500µs
  rpm=60   expected=   1000000µs elapsed=   1006547µs step_err=    32µs avgstep=  5000µs
  rpm=6    expected=  10000000µs elapsed=  10017375µs step_err=    86µs avgstep= 50000µs
test_multi(s1, s2, s3): FAIL
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.