Motion Profile Simulator: Trapezoidal and S-Curve

Controls

Distance and top speed describe the move you want. Acceleration and jerk limit describe what the machine can actually do. The lab re-plans on every drag — there is nothing to press before the curves respond.

Show switches between both profiles and either one alone. Play runs a playhead across the plots in real time, which is the quickest way to feel that the S-curve finishes later.

The note under the limits tells you when a limit stops being reachable, which is the whole reason the sliders are worth dragging.

Theory

Four plots, stacked, each the derivative of the one above it. That stacking is the argument: a corner in velocity is a step in acceleration, and a step in acceleration is an impulse in jerk. The discontinuity never disappears as you differentiate — it moves down until it becomes unbounded.

A trapezoidal profile accelerates at a constant rate, cruises, then decelerates. Velocity is a trapezoid, acceleration is a square wave, and jerk is a set of impulses at the corners. Those impulses are what a machine hears as a knock and what a compliant drivetrain answers with ringing.

An S-curve profile limits jerk as well. Acceleration ramps in over t_j = a_max / j_max, holds, and ramps out, so velocity gains rounded corners. It costs exactly one jerk time and buys bounded shock.

Neither profile can always honour every limit. A move shorter than v²/a never reaches the top speed. An S-curve whose top speed is below a²/j never reaches the acceleration limit. Both are ordinary and both are visible here.

Algorithm

The lab solves the profile rather than integrating it. Each segment has a constant jerk, so within one segment:

a(τ) = a₀ + j·τ
v(τ) = v₀ + a₀·τ + j·τ²/2
x(τ) = x₀ + v₀·τ + a₀·τ²/2 + j·τ³/6

Those are exact, which is why the move lands on the target instead of near it, and why dragging a slider re-plans instantly.

Picking the peak velocity uses one identity: a velocity ramp is odd-symmetric about its midpoint, so it always covers exactly v_peak/2 × duration whatever shape it has. That turns “is there a cruise phase?” into a single comparison, and makes the distance-limited peak solvable in closed form — a quadratic while acceleration still saturates, a cube root once it does not.

Source code

A trapezoidal generator small enough to paste into a sketch. It returns the position your control loop should be chasing at time t:

// Target position t seconds into a trapezoidal move of `d` mm.
float profilePosition(float t, float d, float vMax, float a) {
  float tAcc = vMax / a;
  float dAcc = vMax * vMax / (2 * a);

  if (2 * dAcc > d) {                      // too short to reach vMax
    float tPeak = sqrtf(d / a);            // triangular profile
    if (t >= 2 * tPeak) return d;
    if (t < tPeak) return 0.5f * a * t * t;
    float left = 2 * tPeak - t;
    return d - 0.5f * a * left * left;
  }

  float tCruise = (d - 2 * dAcc) / vMax;
  float tTotal  = 2 * tAcc + tCruise;
  if (t >= tTotal) return d;
  if (t < tAcc)           return 0.5f * a * t * t;
  if (t < tAcc + tCruise) return dAcc + vMax * (t - tAcc);

  float left = tTotal - t;
  return d - 0.5f * a * left * left;
}

Call it once per control period and feed the result to whatever closes the loop. AccelStepper does the equivalent internally for steppers; there is no S-curve option, so a jerk-limited profile is one you generate yourself.

Circuit diagram

There is no circuit unique to this lab — the profile is a layer of arithmetic, not a part. It sits between your command source and the loop you already have:

target position  →  PROFILE  →  setpoint  →  controller  →  driver  →  motor
                                                 ↑                        │
                                                 └────── encoder ─────────┘

The wiring is whatever your motor already needs: a driver sized for the peak current the ramp demands, and encoder feedback if you want the loop closed. What changes is only what the controller is asked to follow.

The full derivation, the Marlin “jerk” confusion, and the reason profiling often fixes a PID that looked badly tuned are in motion profiles: trapezoidal and S-curve acceleration.