TeensyStep

https://luni64.github.io/TeensyStep/
Admin
TeensyStep is a highly efficient Arduino stepper motor library for PJRC Teensy boards enabling...
Tokens:12,432
Snippets:123
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example Usage

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

A complete example demonstrating the setup and control sequence of the Winder class.

```APIDOC
```cpp
#include "Winder.h"

IntervalTimer printTimer;                           // print out info in the background
void printCurrent();

constexpr unsigned feederStpPerMM = 200 * 8 * 5.0f; // e.g. stp/rev * microstepping * leadscrew pitch
constexpr unsigned feederAcceleration = 10000;      // used for pitch changing only
constexpr unsigned spindleStpPerRev = 200 * 16;     // e.g. stp/rev * microstepping
constexpr unsigned spindleAcceleration = 30000;     // any reasonable value

Stepper spindle(0, 1);
Stepper feeder(2, 3);
Winder winder(spindle, feeder);                     

void setup()
{
  while (!Serial && millis() < 500);

  // setup background printing
  printTimer.begin(printCurrent, 25000);

  // Setup mechanical properties
  winder.setSpindleParams(spindleStpPerRev, spindleAcceleration);
  winder.setFeederParams(feederStpPerMM, feederAcceleration);
  winder.begin();

  // 1. Start the winder at a spindle speed of 1125 rpm and a pitch of 0.1mm/rev
  winder.setSpindleSpeed(1125.0f);
  winder.setPitch(0.1f);
  winder.updateSpeeds();
  delay(3000);

  // 2. Trim the pitch to 0.12 mm/rev
  winder.setPitch(0.12f);
  winder.updateSpeeds();
  delay(500);

  // 3. Trim the pitch to 0.08 mm/rev
  winder.setPitch(0.08f);
  winder.updateSpeeds();
  delay(500);

  // 4. Trim the pitch to 0.15 mm/rev
  winder.setPitch(0.15f);
  winder.updateSpeeds();
  delay(3000);

  // 5. Change the spindle speed to 300 rpm, keep pitch at 0.15 mm/rev
  winder.setSpindleSpeed(300.0f);
  winder.updateSpeeds();
  delay(2500);

  // 6. Stop the winder
  winder.setSpindleSpeed(0.0f);
  winder.updateSpeeds();
}

void loop() {
  // Nothing to do here
}

void printCurrent() {
  Serial.print("Spindle Speed: ");
  Serial.print(winder.getCurSpindleSpeed());
  Serial.print(" RPM, Feeder Speed: ");
  Serial.print(winder.getCurFeederSpeed());
  Serial.print(" steps/s, Pitch: ");
  Serial.print(winder.getCurPitch());
  Serial.println(" mm/rev");
}
```
```

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

### Stepper Setup Functions

Source: https://luni64.github.io/TeensyStep/documentation/stepper

Configure motor speed and acceleration using either a standard or fluent interface. The fluent interface allows chaining multiple setup calls.

```cpp
// you can use the standard interface for setup
motor_1.setAcceleration(5000);
motor_1.setMaxSpeed(10000);

// ...or a fluent interface
motor_2
 .setAcceleration(20000)
 .setMaxSpeed(15000)
 .setInverseRotation(true)
 .setStepPinPolarity(LOW);
```

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

### Setup and Operation of Winder Class

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Initializes and operates the winder by setting spindle and feeder parameters, starting the winder, and applying initial speed and pitch settings. Use this for the initial configuration and startup sequence.

```cpp
printTimer.priority(255); // lowest priority, don't disturb stepping

  // setup the winder
  winder
      .setSpindleParams(spindleStpPerRev, 30000)
      .setFeederParams(feederStpPerMM, 100000)
      .begin();

  // startup the winder
  winder.setSpindleSpeed(1125); // 1125 rpm
  winder.setPitch(0.1f);        // pitch = 0.10 mm / rev
  winder.updateSpeeds();        // apply new settings
```

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

### Setup Mechanical Properties

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Setting up the mechanical properties of the spindle and feeder, including steps per revolution/mm and acceleration, followed by initialization with `begin()`.

```APIDOC
## Setup Mechanical Properties

```cpp
// classic:
winder.setSpindleParams(6400, 30000);
winder.setFeederParams(12800, 10000);
winder.begin();

// fluent:
winder
  .setSpindleParams(6400, 30000)
  .setFeederParams(12800, 10000)
  .begin();
```
```

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

### Setup Functions

Source: https://luni64.github.io/TeensyStep/documentation/stepper

Functions to configure the stepper motor's maximum speed, acceleration, and signal polarities.

```APIDOC
## Stepper& setMaxSpeed(int32_t speed)

### Description
Sets the maximum speed of the motor in steps/s.

### Method
`setMaxSpeed`

### Parameters
#### Path Parameters
- **speed** (int32_t) - Required - The maximum speed in steps per second.
```

```APIDOC
## Stepper& setAcceleration(uint32_t accel)

### Description
Sets the maximum acceleration of the motor in steps/s².

### Method
`setAcceleration`

### Parameters
#### Path Parameters
- **accel** (uint32_t) - Required - The maximum acceleration in steps per second squared.
```

```APIDOC
## Stepper& setStepPinPolarity(int polarity)

### Description
Sets the polarity of the generated step pulses. `setStepPinPolarity(HIGH)` generates active high pulses. `setStepPinPolarity(LOW)` generates active low pulses.

### Method
`setStepPinPolarity`

### Parameters
#### Path Parameters
- **polarity** (int) - Required - The polarity for the step pulses (HIGH or LOW).
```

```APIDOC
## Stepper& setInverseRotation(int polarity)

### Description
Use this function to change the polarity of the generated direction signal. `setInverseRotation(true)` sets the DIR pin to LOW if the motor runs in ‘upward direction’.

### Method
`setInverseRotation`

### Parameters
#### Path Parameters
- **polarity** (int) - Required - The polarity for the direction signal (true for inverse, false otherwise).
```

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

### Start Rotating Multiple Steppers by Reference

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Starts rotating multiple stepper objects simultaneously. The rotation speeds are determined by Stepper::setMaxSpeed. This function returns immediately.

```cpp
RotateControl controller;
Stepper s1(1,2), s2(3,4);
controller.rotateAsync(s1,s2);
```

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

### Winder Construction

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Example of constructing a Winder object, passing references to the spindle and feeder stepper objects.

```APIDOC
## Construction

```cpp
Stepper spindle(0,1);             // STP pin 0, DIR pin 1
Stepper feeder(2,3);              // STP pin 2, DIR pin 3

Winder winder(spindle, feeder);   // winder uses the steppers
```
```

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

### Setup Mechanical Properties (Classic Interface)

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Sets the mechanical properties of the spindle and feeder using the classic interface. This involves calling `setSpindleParams` and `setFeederParams` followed by `begin()`.

```cpp
winder.setSpindleParams(6400, 30000);
winder.setFeederParams(12800, 10000);
winder.begin();

```

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

### Moving Motors to Targets (Async)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Starts moving multiple stepper motors to their targets in sync without blocking the program execution.

```APIDOC
## void moveAsync(Stepper& s1 [, ...Stepper& sN])

Accepts up to N=10 references to stepper objects and starts moving them to their targets in sync. I.e. all motors will reach their targets at the same time. The function returns immediately after starting the movement (non blocking).
```
   StepControl controller;
   Stepper s1(1,2), s2(3,4);
   controller.moveAsync(s1,s2);
```

## void moveAsync(Stepper* stepperArray[N])

Accepts an array of up to N=10 pointers to stepper objects and starts moving them to their targets in sync. I.e. all motors will reach their targets at the same time. The function returns immediately after starting the movement (non blocking).
```
   StepControl controller;
   Stepper* stArray[] = { new Stepper(1,2), new Stepper(3,4), newStepper(5,6)};
   controller.moveAsync(stArray);
```
```

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

### Winder Class Construction Example

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Demonstrates how to instantiate the Winder class by passing Stepper objects for the spindle and feeder. The Winder class manages its own internal controllers.

```cpp
Stepper spindle(0,1);             // STP pin 0, DIR pin 1
Stepper feeder(2,3);              // STP pin 2, DIR pin 3

Winder winder(spindle, feeder);   // winder uses the steppers

```

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

### Start Rotating Multiple Steppers by Pointer Array

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Starts rotating multiple stepper objects using an array of pointers. The rotation speeds are determined by Stepper::setMaxSpeed. This function returns immediately.

```cpp
// allocated on the stack / globally:
Stepper m1(0,1);
Stepper m2(2,3);
Stepper m3(4,5);
Stepeper* stArray[] = {&m1, &m2, &m3};
controller.rotateAsync(stArray);

// or, allocated dynamically:
Stepper* stArray[] = { new Stepper(1,2), new Stepper(3,4), newStepper(5,6)};
controller.rotateAsync(stArray);
```

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

### Setup Mechanical Properties (Fluent Interface)

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Sets the mechanical properties of the spindle and feeder using a fluent interface. This allows chaining calls to `setSpindleParams`, `setFeederParams`, and `begin()`.

```cpp
winder
  .setSpindleParams(6400, 30000)
  .setFeederParams(12800, 10000)
  .begin();

```

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

### Winder Initialization and Setup

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Initializes Stepper objects for the spindle and feeder, and then instantiates the Winder class. It also sets up constants for feeder and spindle steps per revolution/mm and their respective accelerations, and begins background serial printing.

```cpp
#include "Winder.h"

IntervalTimer printTimer;                           // print out info in the background
void printCurrent();

constexpr unsigned feederStpPerMM = 200 * 8 * 5.0f; // e.g. stp/rev * microstepping * leadscrew pitch
constexpr unsigned feederAcceleration = 10000;      // used for pitch changing only
constexpr unsigned spindleStpPerRev = 200 * 16;     // e.g. stp/rev * microstepping
constexpr unsigned spindleAcceleration = 30000;     // any reasonable value

Stepper spindle(0, 1);
Stepper feeder(2, 3);
Winder winder(spindle, feeder);                     

void setup()
{
  while (!Serial && millis() < 500);

  // setup background printing
  printTimer.begin(printCurrent, 25000);

```

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

### Moving Motors to Targets (Blocking)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Starts moving multiple stepper motors to their targets in sync and waits until the movement is finished.

```APIDOC
## void move(Stepper& s1 [, ...Stepper& sN])

Accepts up to N=10 references to stepper objects and starts moving them to their targets in sync. I.e. all motors will reach their targets at the same time. The function waits until the movement is finished (blocking).
```
   StepControl controller;
   Stepper s1(1,2), s2(3,4);
   controller.move(s1,s2);  // returns after the motors reached their targets
```

## void move(Stepper* stepperArray[N])

Accepts an array of up to N=10 pointers to stepper objects and starts moving them to their targets in sync. I.e. all motors will reach their targets at the same time. The function waits until the movement is finished (blocking).
```
   StepControl controller;
   Stepper* stArray[] = { new Stepper(1,2), new Stepper(3,4), newStepper(5,6)};
   controller.move(stArray); // returns after the motors reached their targets
```
```

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

### Move Motors Asynchronously (References)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Starts moving multiple stepper motors to their targets without blocking the program execution. All motors will reach their targets simultaneously.

```cpp
   StepControl controller;
   Stepper s1(1,2), s2(3,4);
   controller.moveAsync(s1,s2);

```

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

### Stepper Class Position Management

Source: https://luni64.github.io/TeensyStep/index

Explains how to get the current motor position and set new target positions, both absolutely and relatively.

```APIDOC
## Stepper Class Position Management

### Description
Manages the motor's current position and sets target positions for movement.

### Methods
- **getPosition()**: Returns the current position of the motor.
- **setTargetAbs(position)**: Sets the target position to an absolute value.
- **setTargetRel(steps)**: Sets the target position relative to the current position.
- **setPosition(position)**: Directly sets the internal step counter to a new value without moving the motor.

### Example
```cpp
unsigned pos = motor_1.getPosition(); // get current position of the motor
motor_1.setTargetAbs(pos + 100);      // sets the target position 100 steps ahead of the current position
motor_1.setTargetRel(100);            // does the same thing directly

// Advance internal step counter without movement
int current_pos = motor_1.getPosition();      // get the current value of the step counter (position)
current_pos += 1000;                         
motor_1.setPosition(current_pos);             // set a new value of the step counter (this does not move the motor)
```
```

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

### Rotating Motors

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Methods to start rotating stepper motors, either by passing individual Stepper references or an array of Stepper pointers.

```APIDOC
## void rotateAsync(Stepper& s1 [, ...Stepper& sN])

Accepts up to N=10 references to stepper objects and starts rotating them. The rotation speeds are defined by the Stepper::setMaxSpeed function.
```
   RotateControl controller;
   Stepper s1(1,2), s2(3,4);
   controller.rotateAsync(s1,s2);
```

## void rotateAsync(Stepper* stepperArray[N])

Accepts an array of up to N=10 pointers to stepper objects and starts rotating them. The rotation speeds are defined by the Stepper::setMaxSpeed function. The function returns immediately after starting the motors (non blocking).
```
   // allocated on the stack / globally:
   Stepper m1(0,1);
   Stepper m2(2,3);
   Stepper m3(4,5);
   Stepeper* stArray[] = {&m1, &m2, &m3};
   controller.rotateAsync(stArray);

   // or, allocated dynamically:
   Stepper* stArray[] = { new Stepper(1,2), new Stepper(3,4), newStepper(5,6)};
   controller.rotateAsync(stArray);
```
```

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

### Set Absolute and Relative Target Positions

Source: https://luni64.github.io/TeensyStep/index

Demonstrates how to get the current motor position and set new target positions either absolutely or relative to the current position.

```cpp
unsigned pos = motor_1.getPosition(); // get current position of the motor
motor_1.setTargetAbs(pos + 100);      // sets the target position 100 steps ahead of the current position
motor_1.setTargetRel(100);            // does the same thing directly
```

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

### Motor Positioning

Source: https://luni64.github.io/TeensyStep/documentation/stepper

Functions to set and get the motor's target and current position.

```APIDOC
## void setTargetAbs(int32_t position)

### Description
Sets the target position in steps. To actually move the motor, use one of the controller objects.

### Method
`setTargetAbs`

### Parameters
#### Path Parameters
- **position** (int32_t) - Required - The absolute target position in steps.
```

```APIDOC
## void setTargetRel(int32_t delta)

### Description
Sets the target position relative to the current position. To actually move the motor, use one of the controller objects.

### Method
`setTargetRel`

### Parameters
#### Path Parameters
- **delta** (int32_t) - Required - The relative change in position in steps.
```

```APIDOC
## void setPosition(int32_t counterValue)

### Description
Sets the internal step counter to the parameter `counterValue`. This function is NOT setting a new target position. Typically, you only use this function after homing to set the counter to zero or some offset value.

### Method
`setPosition`

### Parameters
#### Path Parameters
- **counterValue** (int32_t) - Required - The value to set the internal step counter to.
```

```APIDOC
## int32_t getPosition()

### Description
Returns the current position of the stepper.

### Method
`getPosition`

### Returns
- **position** (int32_t) - The current position of the stepper in steps.
```

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

### Move Motors Asynchronously (Pointers)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Starts moving multiple stepper motors to their targets using an array of pointers. The function returns immediately, allowing other operations to proceed.

```cpp
   StepControl controller;
   Stepper* stArray[] = { new Stepper(1,2), new Stepper(3,4), newStepper(5,6)};
   
   controller.moveAsync(stArray);

```

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

### Get Current Speed

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Retrieves the current speed of the controlled motors. If multiple motors are controlled, it returns the speed of the fastest motor.

```APIDOC
## int32_t getCurrentSpeed()

Returns the current speed of the controlled motor. If more than one motor is controlled by the controller it returns the current speed of the leading (fastest) motor. The speed of the other motors is always a fixed ratio to the speed of the leading motor.
```
   controller.rotateAsync(s1);
   while(controller.getCurrentSpeed() < 5000)
   {
      Serial.printf("pos: %d, speed: %d\n", s1.getPosition(), controller.getCurrentSpeed());
      delay(50);
   }
   controller.stop();
```
```

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

### Synchronized Stepper Motor Control for Winding

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

This snippet demonstrates how to synchronize two stepper motors, 'feeder' and 'spindle', for a string winding application. It sets maximum speeds based on desired linear feed and winding pitch, then starts them asynchronously. The TeensyStep controller ensures a constant winding pitch even during speed changes.

```cpp
constexpr unsigned speed = 5; // mm/s
constexpr float pitch = 0.2;  // mm/rev

feeder.setMaxSpeed(speed * fdrStpPerMM);        // set speed in steps/sec
spindle.setMaxSpeed(speed/pitch*spdlStpPerRev); // calculate from pitch
controller.rotateAsync(feeder, spindle);        // and start the motors

```

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

### Start Synchronous Rotation of Two Motors

Source: https://luni64.github.io/TeensyStep/index

Initiates a synchronous rotation for multiple motors, maintaining a constant speed ratio during acceleration and deceleration. Motors are stopped after a specified delay.

```cpp
Stepper motor_1(0,1) , motor_2(2,3);
RotateControl controller;

motor_1.setAcceleration(10000);
motor_1.setMaxSpeed(50000);
motor_2.setAcceleration(10000);
motor_2.setMaxSpeed(150000);

controller.rotateAsync(motor_1, motor_2);   // start synced rotation of both motors

delay(5000);                                // stop rotation after 5s
controller.stop()
```

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

### Asynchronous Motor Stop

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Initiates a deceleration sequence to stop the controlled motors. This function returns immediately after starting the stop sequence.

```cpp
void stopAsync()
```

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

### Get Current Motor Speed

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Returns the current speed of the leading (fastest) controlled motor. The speeds of other motors are always a fixed ratio to this leading motor.

```cpp
controller.rotateAsync(s1);
while(controller.getCurrentSpeed() < 5000)
{
   Serial.printf("pos: %d, speed: %d\n", s1.getPosition(), controller.getCurrentSpeed());
   delay(50);
}
controller.stop();
```

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

### Stop Motors Asynchronously

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Initiates a deceleration sequence for the controlled motors to bring them to a stop. This function is non-blocking and returns immediately after starting the deceleration.

```cpp
 controller.moveAsync(s1,s2);
 
 delay(1000);
 controller.stopAsync();     // starts deceleration

```

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

### Stepper Class Initialization and Configuration

Source: https://luni64.github.io/TeensyStep/index

Demonstrates how to initialize Stepper objects and configure their physical properties like speed, acceleration, and polarity.

```APIDOC
## Stepper Class Usage

### Description
Initializes and configures stepper motor properties.

### Methods
- **Stepper(step_pin, dir_pin)**: Constructor to define STEP and DIR pins.
- **setMaxSpeed(speed)**: Sets the maximum speed of the motor.
- **setAcceleration(acceleration)**: Sets the acceleration of the motor.
- **setPullInSpeed(speed)**: Sets the pull-in speed of the motor.
- **setStepPulsePolarity(polarity)**: Sets the polarity for step pulses (e.g., LOW for active low drivers).
- **setInverseRotation(inverse)**: Inverts the rotation direction.

### Example
```cpp
// define a few motors
Stepper motor_1(2,3); // STEP at pin 2, DIR at pin 3
Stepper motor_2(4,5); // STEP at pin 4, DIR at pin 5
Stepper motor_3(6,7); // STEP at pin 6, DIR at pin 7

void setup() {
    // Setup some motor properties
    motor_1.setMaxSpeed(64000);         // stp/s
    motor_1.setAcceleration(200000);    // stp/s^2
    
    // you can also use a 'fluent interface' to set the properties
    motor_2
        .setMaxSpeed(30000)             // stp/s
        .setPullInSpeed(800)            // stp/s
        .setAcceleration(150000);       // stp/s^2
    motor_3
        .setStepPulsePolarity(LOW)      //motor connected to an active low driver
        .setInverseRotation(true)
        .setMaxSpeed(45000)             // stp/s
        .setAcceleration(200000);       // stp/s^2              
}
```
```

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

### RotateControl Construction with Default Parameters

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Constructs a RotateControl object using default values for step pulse width (5µs) and speed update period (5ms).

```cpp
RotateControl controller;
```

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

### Initialize and Configure Stepper Motors

Source: https://luni64.github.io/TeensyStep/index

Defines stepper motor objects with their step and direction pins and configures their maximum speed, acceleration, and other properties. Supports a fluent interface for setting multiple properties.

```cpp
// define a few motors
Stepper motor_1(2,3); // STEP at pin 2, DIR at pin 3
Stepper motor_2(4,5); // STEP at pin 4, DIR at pin 5
Stepper motor_3(6,7); // STEP at pin 6, DIR at pin 7

void setup() {
    // Setup some motor properties
    motor_1.setMaxSpeed(64000);         // stp/s
    motor_1.setAcceleration(200000);    // stp/s^2
    
    // you can also use a 'fluent interface' to set the properties
    motor_2
        .setMaxSpeed(30000)             // stp/s
        .setPullInSpeed(800)            // stp/s
        .setAcceleration(150000);       // stp/s^2
    motor_3
        .setStepPulsePolarity(LOW)      //motor connected to an active low driver
        .setInverseRotation(true)
        .setMaxSpeed(45000)             // stp/s
        .setAcceleration(200000);       // stp/s^2              
}
```

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

### RotateControl Construction with Custom Parameters

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Constructs a RotateControl object with custom step pulse width and speed update period. Smaller speed update periods increase processor load but result in smoother acceleration.

```cpp
RotateControl controller(10, 10000);
```

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

### StepControl Construction

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Constructs a StepControl object with selectable or default parameters for step pulse width and speed update period.

```APIDOC
## StepControl(unsigned stepPulseWidth, unsigned speedUpdatePeriod)

Constructs a StepControl object with selectable values for the step pulse width (µs) and the speed update period (µs). During acceleration and deceleration, the controller updates the motor speed periodically. The period of this updates is set by the speedUpdatePeriod parameter (500µs to 20000µs). Smaller values increase the processor load but lead to a smoother acceleration. A value of 5000µs is sufficient for most of real life applications.

## StepControl()

Constructs a StepControl object with default parameters for stepPulseWidth (5µs) and speedUpdatePeriod (5ms)
```

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

### Asynchronous Motor Movement

Source: https://luni64.github.io/TeensyStep/index

Initiates motor movement asynchronously using `moveAsync` and provides a loop to perform other tasks while waiting for the movement to complete using `isRunning`.

```cpp
controller.moveAsync(motor_1, motor_2);     // This will start the movement and return immediately
doSomeWork();

while(controller.isRunning()){              // wait until the movement is finished
    delay(10);                     
}
```

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

### Stepper Constructor

Source: https://luni64.github.io/TeensyStep/documentation/stepper

Constructs a stepper object with the given pin numbers for STEP and DIR signals.

```APIDOC
## Stepper(unsigned stpPin, unsigned dirPin)

### Description
Constructs a stepper object with the given pin numbers for STEP and DIR signals.

### Parameters
#### Path Parameters
- **stpPin** (unsigned) - Required - The pin number for the STEP signal.
- **dirPin** (unsigned) - Required - The pin number for the DIR signal.
```

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

### Check StepControl Resource Availability

Source: https://luni64.github.io/TeensyStep/index

Verifies if StepControl objects can successfully reserve the required system resources (IntervalTimer and FTM channels). Panics if resources are insufficient.

```cpp
StepControl<> cnt1;
StepControl<> cnt2;
StepControl<> cnt3;

if(!(cnt1.isOk() && cnt2.isOk() && cnt3.isOk()))
{
    panic();
}
```

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

### Move Motors Synchronously (References)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Moves multiple stepper motors to their targets and blocks program execution until all motors have reached their destinations. Ensures synchronized arrival at target positions.

```cpp
   StepControl controller;
   Stepper s1(1,2), s2(3,4);
   controller.move(s1,s2);  // returns after the motors reached their targets

```

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

### StepControl Class Movement Execution

Source: https://luni64.github.io/TeensyStep/index

Details how to use the StepControl class to move one or multiple motors to their target positions.

```APIDOC
## StepControl Class Movement

### Description
Executes movements for one or more stepper motors to their set target positions.

### Methods
- **move(motor1, ...)**: Moves the specified motor(s) to their target position. This is a blocking call.
- **moveAsync(motor1, ...)**: Starts the movement for the specified motor(s) asynchronously and returns immediately.
- **isRunning()**: Returns true if any motor movement is currently in progress.
- **stop()**: Stops the movement of all motors with deceleration. This is a blocking call.
- **stopAsync()**: Initiates the stopping sequence for all motors asynchronously.
- **emergencyStop()**: Stops the movement of all motors immediately without deceleration.

### Example
```cpp
StepControl<> controller;                   // construct a controller object

// Blocking move
controller.move(motor_1);                   // this will move motor_1 to its target position
controller.move(motor_2, motor_3);          // moves motor_2 and motor_3 to their target positions

// Asynchronous move and wait
controller.moveAsync(motor_1, motor_2);     // This will start the movement and return immediately
doSomeWork();

while(controller.isRunning()){              // wait until the movement is finished
    delay(10);                     
}

// Stopping movements
controller.stop();      // stops the movement and waits until all motors stand still
controller.stopAsync(); // initiates the stopping sequence and returns immediately
controller.emergencyStop();  // stops the movement immediately
```
```

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

### RotateControl Construction

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Constructs a RotateControl object. You can either use default parameters or specify custom values for step pulse width and speed update period.

```APIDOC
## RotateControl(unsigned stepPulseWidth, unsigned speedUpdatePeriod)

Constructs a RotateControl object with selectable values for the step pulse width (µs) and the speed update period (µs). During acceleration and deceleration, the controller updates the motor speed periodically. The period of this updates is set by the speedUpdatePeriod parameter (500µs to 20000µs). Smaller values increase the processor load but lead to a smoother acceleration. A value of 5000µs is sufficient for most of real life applications.

## RotateControl()

Constructs a RotateControl object with default parameters for the step pulse width (5µs) and speed update period (5ms).
```

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

### Move Stepper Motors with StepControl

Source: https://luni64.github.io/TeensyStep/index

Constructs a StepControl object to manage motor movements. The `move` command executes a blocking movement to the target position for one or multiple motors.

```cpp
StepControl<> controller;                   // construct a controller object

controller.move(motor_1);                   // this will move motor_1 to its target position
controller.move(motor_2, motor_3);          // moves motor_2 and motor_3 to their target positions

motor_1.setTargetAbs(0);
motor_2.setTargetAbs(0);
motor_3.setTargetAbs(0);
controller.move(motor_1, motor_2, motor_3); // move all motors back to the starting position
```

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

### Move Motors Synchronously (Pointers)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Moves multiple stepper motors to their targets using an array of pointers. This is a blocking function that waits for all motors to complete their movement.

```cpp
   StepControl controller;
   Stepper* stArray[] = { new Stepper(1,2), new Stepper(3,4), newStepper(5,6)};
   
   controller.move(stArray); // returns after the motors reached their targets

```

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

### Print Winder Status Helper Function

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

A helper function to retrieve and print the current time, feeder speed, spindle speed, and pitch to the serial port. This is useful for monitoring and debugging the winder's state.

```cpp
void printCurrent()
{
  unsigned t = millis();
  unsigned feederSpeed = winder.getCurFeederSpeed();
  unsigned spindleSpeed = winder.getCurSpindleSpeed();
  float curPitch = winder.getCurPitch();

  if (spindleSpeed != 0 || feederSpeed != 0)
  {
    Serial.printf("%d\t%i\t%i\t%.3f\n", t, spindleSpeed, feederSpeed, curPitch);
  }
}
```

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

### Controlling the Winder

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Methods for controlling the winder's spindle speed and winding pitch. `setSpindleSpeed` and `setPitch` preset values, while `updateSpeeds` applies the changes.

```APIDOC
## Controlling the Winder

```cpp
// Set spindle speed to 1125 rpm
winder.setSpindleSpeed(1125.0f);
// Set pitch to 0.1mm/rev
winder.setPitch(0.1f);
// Apply the speed and pitch changes
winder.updateSpeeds();

// To stop the winder, set spindle speed to 0
// winder.setSpindleSpeed(0.0f);
// winder.updateSpeeds();
```
```

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

### Stop Motor Movement

Source: https://luni64.github.io/TeensyStep/index

Provides methods to stop motor movements with deceleration (`stop`) or immediately (`emergencyStop`). `stopAsync` initiates a stop sequence and returns immediately.

```cpp
controller.stop()      // stops the movement and waits until all motors stand still
controller.stopAsync() // initiates the stopping sequence and returns immediately

controller.emergencyStop()  // stops the movement immediately
```

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

### Stopping Motors (Async)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Initiates deceleration of the controlled motors to a stop without blocking program execution.

```APIDOC
## void stopAsync()

Decelerates the controlled motors to a stop. This function returns immediately after starting the stop sequence (non blocking).
```

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

### Sequential Motor Movement

Source: https://luni64.github.io/TeensyStep/index

Moves motors one after the other to their target absolute positions. Ensure motors are properly initialized and targets are set before calling move.

```cpp
StepControl<> controller;                

M1.setTargetAbs(targetY);
M2.setTargetAbs(targetX);

controller.move(M1);           // Move M1 to the target position (targetY)
controller.move(M2);           // Move M2_to the target position (targetX)
```

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

### Winder Class Interface Definition

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Defines the public interface of the Winder class, including constructors, parameter setters, and methods for controlling spindle speed and winding pitch. Requires Stepper objects for spindle and feeder.

```cpp
class Winder
{
public:
    Winder(Stepper &spindle, Stepper &feeder);

    Winder &setSpindleParams(unsigned stpPerRev, unsigned acceleration); // steps per spindle revolution & acceleration in stp/s^2
    Winder &setFeederParams(unsigned stpPerMM, unsigned acceleration);   // steps to move the feeder 1mm, acceleration for pitch trimming
    void begin();

    void setSpindleSpeed(float rpm);  // changes the spindle speed to the given rpm
    void setPitch(float pitch_in_mm); // changes the winder pitch to the given value
    void updateSpeeds();

    inline int getCurSpindleSpeed() { return spindleCtrl.isRunning() ? spindleCtrl.getCurrentSpeed() : 0; }
    inline int getCurFeederSpeed() { return feederCtrl.isRunning() ? feederCtrl.getCurrentSpeed() : 0; }
    inline float getCurPitch() { return (float)getCurFeederSpeed() / getCurSpindleSpeed() / pitchFactor; }

protected:
    Stepper &spindle;
    Stepper &feeder;

    unsigned spindleStpPerRev, spindleAcc, feederStpPerMM, feederAcc;
    float pitchFactor;

    float targetSpindleSpeed, targetPitch;
    float oldSpindleSpeed, oldPitch;

    RotateControl feederCtrl, spindleCtrl;
};

```

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

### Dynamic Pitch Adjustment for Winder

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Modifies the winder's pitch dynamically to simulate actions like trimming, followed by updating the speeds to apply the changes. This is useful for real-time adjustments during operation.

```cpp
// change pitch (simulate trimming)
  delay(3000);
  winder.setPitch(0.12);
  winder.updateSpeeds();

  // change pitch (simulate trimming)
  delay(500);
  winder.setPitch(0.08);
  winder.updateSpeeds();

  // change pitch (simulate trimming)
  delay(500);
  winder.setPitch(0.15);
  winder.updateSpeeds();
```

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

### emergencyStop

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Immediately stops all controlled motors without deceleration. Use with caution as it may lead to step losses.

```APIDOC
## void emergencyStop()

Immediately stops the controlled motors. Use this only in emergency since, depending on motor speed this will probably lead to step losses. A homing sequence is highly recommended after a call to emergencyStop().
```
 controller.moveAsync(s1,s2);
 delay(1000);
 controller.stopAsync();     // starts deceleration
 delay(50); 
 controller.emergencyStop(); // immediately stops the motor without decelleration
```
```

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

### Independent and Synchronous Movement

Source: https://luni64.github.io/TeensyStep/index

Manages independent and synchronous movements concurrently using separate StepControl objects. This allows one set of motors to move synchronously while another moves independently, with a mechanism to wait for both to complete.

```cpp
StepControl<> controller_1;
StepControl<> controller_2;

controller_1.moveAsync(M1, M2);   // synchronous movement of M1 and M2
// ... more controller_1 movements....

M3.setTargetAbs(transferAreaPos);
controller_2.moveAsync(motor_3);  // move M3 to the transfer station, independent of M1/M2 movements which run in parallel
...                                
while(controller_1.isRunning() || controller_2.isRunning()){  // wait until both controllers finished their movements
    delay(10);
}
// do the sample transfer...
```

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

### Manually Set Stepper Position

Source: https://luni64.github.io/TeensyStep/index

Allows direct manipulation of the internal step counter to a specific value without causing motor movement. Useful for synchronizing or resetting the position.

```cpp
int pos = motor_1.getPosition();      // get the current value of the step counter (position)
pos += 1000;                         
motor_1.setPosition(pos);             // set a new value of the step counter (this does not move the motor)
```

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

### Winder Class Interface

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

The Winder class interface defines methods for initializing and controlling a winding mechanism using two stepper motors.

```APIDOC
## Winder Class

```cpp
class Winder
{
public:
    Winder(Stepper &spindle, Stepper &feeder);

    Winder &setSpindleParams(unsigned stpPerRev, unsigned acceleration); // steps per spindle revolution & acceleration in stp/s^2
    Winder &setFeederParams(unsigned stpPerMM, unsigned acceleration);   // steps to move the feeder 1mm, acceleration for pitch trimming
    void begin();

    void setSpindleSpeed(float rpm);  // changes the spindle speed to the given rpm
    void setPitch(float pitch_in_mm); // changes the winder pitch to the given value
    void updateSpeeds();

    inline int getCurSpindleSpeed() { return spindleCtrl.isRunning() ? spindleCtrl.getCurrentSpeed() : 0; }
    inline int getCurFeederSpeed() { return feederCtrl.isRunning() ? feederCtrl.getCurrentSpeed() : 0; }
    inline float getCurPitch() { return (float)getCurFeederSpeed() / getCurSpindleSpeed() / pitchFactor; }

protected:
    Stepper &spindle;
    Stepper &feeder;

    unsigned spindleStpPerRev, spindleAcc, feederStpPerMM, feederAcc;
    float pitchFactor;

    float targetSpindleSpeed, targetPitch;
    float oldSpindleSpeed, oldPitch;

    RotateControl feederCtrl, spindleCtrl;
};
```
```

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

### Stopping Motors

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Provides methods to stop the controlled motors, including asynchronous, blocking, and emergency stop options.

```APIDOC
## void stopAsync()

Decelerates the controlled motors to a stop. This function returns immediately after starting the stop sequence (non blocking).

## void stop()

Decelerates the controlled motors to a stop and waits until the motors are stopped (blocking function).

## void emergencyStop()

Immediately stops the controlled motors. Use this only in emergency since, depending on motor speed this will probably lead to step losses. A homing sequence is highly recommended after a call to emergencyStop().
```

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

### Override Speed

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Allows overriding the current speed of all controlled motors on the fly by a given factor, maintaining synchronization.

```APIDOC
## void overrideSpeed(float factor)

This function is used to override the speed of all controlled motors on the fly. E.g. assume that the controller controls two motors m1, m2 with speeds of 20000 stp/s and 30000 respectively. A call to overrideSpeed(0.5f) would then decelerate m1 to 10000 stp/s and m2 to 15000 stp/s while keeping both motors in sync. Negative values will reverse the direction of the motors.
```
   controller.rotateAsync(s1,s2,s3);
   delay(1000);
   controller.overrideSpeed(0.5)  // reduce speed of all motors (s1, s2, s3) to 50%
```
```

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

### Synchronous Motor Movement

Source: https://luni64.github.io/TeensyStep/index

Moves multiple motors simultaneously along a straight line, adjusting step rates to maintain synchronization throughout acceleration and deceleration phases. Supports up to 10 motors.

```cpp
StepControl controller;               

M1.setTargetAbs(targetY);
M2.setTargetAbs(targetX);

controller.move(M1, M2);        // Move M1 _and_ M2 to the target position
```

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

### Stopping Motors (Blocking)

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Decelerates the controlled motors to a stop and waits until they have completely stopped.

```APIDOC
## void stop()

Decelerates the controlled motors to a stop and waits until the motors are stopped (blocking function).
```

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

### Winder Speed Reduction and Stop Sequence

Source: https://luni64.github.io/TeensyStep/applications2/010_winder/winder

Slows down the spindle speed and eventually stops the winder by setting the spindle speed to zero, followed by updating the speeds. Use this for controlled deceleration and halting the operation.

```cpp
// slow down spindle to 300 rpm, keep pitch
  delay(3000);
  winder.setSpindleSpeed(300);
  winder.updateSpeeds();

  // stop winder
  delay(2500);
  winder.setSpindleSpeed(0);
  winder.updateSpeeds();
```

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

### Override Rotation Speed

Source: https://luni64.github.io/TeensyStep/index

Allows changing the rotation speed of motors on-the-fly during an active rotation.

```cpp
controller.overrideSpeed(0.5);
```

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

### getCurrentSpeed

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Returns the current speed of the controlled motor. If multiple motors are controlled, it returns the speed of the fastest motor.

```APIDOC
## int32_t getCurrentSpeed()

Returns the current speed of the controlled motor. If more than one motor is controlled by the controller it returns the current speed of the leading (fastest) motor. The speed of the other motors is always a fixed ratio to the speed of the leading motor.
```

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

### Emergency Stop Motors

Source: https://luni64.github.io/TeensyStep/documentation/stepControl

Immediately halts all controlled motors without deceleration. Use with caution as it may lead to step losses, and a homing sequence is recommended afterward.

```cpp
 delay(50); 
 controller.emergencyStop(); // immediately stops the motor without decelleration

```

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

### Synchronous Motor Stop

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Decelerates the controlled motors to a complete stop and waits until all motors have stopped. This is a blocking function.

```cpp
void stop()
```

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

### Emergency Motor Stop

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Immediately halts all controlled motors without deceleration. Use with caution as this may cause step losses. A homing sequence is recommended after use.

```cpp
void emergencyStop()
```

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

### Override Motor Speed

Source: https://luni64.github.io/TeensyStep/documentation/rotateControl

Overrides the current speed of all controlled motors on the fly by a given factor, maintaining synchronization. Negative factors reverse direction.

```cpp
controller.rotateAsync(s1,s2,s3);
delay(1000);
controller.overrideSpeed(0.5)  // reduce speed of all motors (s1, s2, s3) to 50%
```
Tokens:
Raw