Trajectory Generation

In robotics, trajectory generation refers to creating a smooth, time-dependent sequence of motions for a robot’s joints. Unlike a path, which only specifies the geometric curve between two points in space, a trajectory also defines the timing—how fast or slow the robot should move along that path. At every instant of time, the trajectory provides the desired position, velocity, and often acceleration for each joint.

Why smoothness is essential
Robots are physical systems with actuators and motors that cannot respond to sudden changes. If a trajectory has discontinuities:

A jump in position is impossible because it would require infinite velocity.
A sudden change in velocity demands infinite acceleration, which motors cannot deliver.
An abrupt change in acceleration produces high jerk (the derivative of acceleration), leading to vibrations, mechanical stress, and reduced accuracy.
Therefore, a valid trajectory must ensure continuity of position, velocity, and often acceleration to achieve realistic and stable motion.

Feasibility and actuator limits
Beyond smoothness, trajectories must be feasible given the robot’s physical constraints. Each actuator has:

Maximum displacement or joint limits
Maximum velocity
Maximum acceleration
If a trajectory exceeds any of these, the robot cannot execute it safely. For example, moving too fast during a welding operation would result in poor weld quality, while excessive acceleration during pick-and-place could cause the robot to drop its payload.

Applications
Trajectory generation is fundamental to nearly every robotic task:

Welding requires the torch to move smoothly along a precise curve at constant speed.
Painting demands even coverage, which depends on maintaining steady velocity.
Pick-and-place involves accelerating and decelerating smoothly to protect fragile objects.
Assembly relies on precise, controlled motions to align components correctly.

In practice, trajectory generation acts as the bridge between high-level motion planning (deciding where the robot should go) and low-level control (sending commands to motors). By providing smooth and feasible joint commands, it ensures that the robot not only reaches its goal but does so in a safe, efficient, and reliable way.

Refresher

Position

In robotics, the position of a joint describes where it is at a given instant.

For a revolute joint, position is an angle (in radians or degrees).
For a prismatic joint, position is a displacement (in meters).

So is our fundamental variable — the trajectory function.

Velocity

Velocity is the rate of change of position with respect to time:

It tells us how fast and in which direction* the joint is moving.

Units:
Revolute joint → rad/s
Prismatic joint → m/s
A positive velocity means motion in the “positive” joint direction; a negative velocity means motion in the opposite direction.

In trajectory planning, we want velocity to be continuous (no sudden jumps).

Speed

Speed is simply the magnitude of velocity:

Speed ignores direction.
For example, a joint rotating at has the same speed as one rotating at .
In applications like welding or painting, constant speed* along the end-effector path is critical for quality.

Acceleration

Acceleration is the rate of change of velocity with respect to time:

Units:
Revolute joint → rad/s²
Prismatic joint → m/s²
Acceleration tells us how “hard” the motor must push to speed up or slow down.

Discontinuous accelerations cause jerk, which leads to vibrations, noise, and mechanical wear.

Jerk (extra refresher)

Jerk is the derivative of acceleration:

While often ignored in beginner treatments, in practice it matters a lot: payloads, delicate tools, or high-speed robots suffer if jerk is too high.
Quintic polynomials are popular because they control acceleration smoothness, reducing jerk at boundaries.
So in short:
→ Position (rad or m)
→ Velocity (rad/s or m/s)
→ Acceleration (rad/s² or m/s²)
→ Jerk (rad/s³ or m/s³)

Interpolation with Polynomials

Why polynomials for trajectory generation?

When we want a robot joint (say an R joint) to move smoothly from a start configuration to a final configuration, we need a continuous mathematical function describing how the joint angle evolves with time. Polynomials are commonly chosen because:

They are smooth (infinitely differentiable).
They are simple to compute (no exponentials or trigonometric functions).
They can satisfy a required number of boundary conditions exactly, since the number of coefficients increases with polynomial order.

General concept

Suppose a robot joint starts at angle at time , ends at angle at time , and we may also specify desired velocities and (and possibly accelerations).

We seek a function:

The number of coefficients equals the number of conditions we want to enforce:

2 conditions (start & final positions) → need at least quadratic.
4 conditions (positions + velocities at start & end) → cubic.

6 conditions (positions + velocities + accelerations at start & end) → quintic.

So the order of the polynomial is directly determined by how smooth we want the trajectory.

Case 1: Cubic Polynomial (positions + velocities specified)

Let’s assume:

We assume:

Velocity is:

Now apply boundary conditions:

At :

At :

At :

At :

This gives 4 linear equations with 4 unknowns .

In matrix form:

When we solve this system, we obtain explicit formulas for .

For simplicity, take . Then the equations reduce to:

So the cubic polynomial is fully determined.

Special case: start & final velocities = 0

This is very common in robotics because a robot often starts and ends at rest. Substituting :

Thus:

This function guarantees:

Starts at , ends at .
Starts and ends with zero velocity.

Has continuous velocity profile (but acceleration jumps at start/end → jerk issue).

Case 2: Quintic Polynomial (positions, velocities, accelerations specified)

Why Quintic?

A cubic polynomial can enforce position and velocity constraints at the start and end.
However, the acceleration at boundaries may still be nonzero, which leads to discontinuous acceleration profiles and high jerk.
To also enforce zero (or specified) acceleration at the start and end, we need 6 conditions in total.
A quintic polynomial has 6 coefficients → perfect fit.

So quintics are the go-to for smooth trajectories when both and must vanish at start/end.

Sometimes, we want not only and to be smooth, but also (acceleration). For example, moving a fragile payload requires avoiding jerk.

General polynomial form

We assume:

Then:

We want:

That’s 6 equations for 6 unknowns

Step 1: Boundary conditions at t=0t = 0

At t = 0:

So first three coefficients are immediately fixed:

This leaves only to solve.

Step 2: Boundary conditions at

At

Position:

Velocity:

Acceleration:

Step 3: Write in matrix form

We now have 3 linear equations in unknowns :

Call this:

Step 4: Solve system

Divide each row by appropriate powers of to simplify. Let’s normalize time by . Then the system becomes:

Define:

So:

Step 5: Solve the 3×3 system

Equation set:

From (2) and (3):

Divide (3) by 2 →
Subtract from (2):

So:

Substitute into (2):

Now substitute into (1):

Find common denominator 6:

Then:

Step 6: Convert back to coefficients

Recall definitions:

So:

Final Quintic Trajectory Equation

This function:

Starts at , ends at
Has zero velocity and acceleration at start and end
Smooth velocity and acceleration profiles (jerk finite, no jumps).

Limits of High-Order Polynomials

In theory, any number of boundary conditions (positions, velocities, accelerations, etc.) can be satisfied if we choose a polynomial of high enough order. For example:

A cubic (3rd order) handles 4 conditions.
A quintic (5th order) handles 6 conditions.
A 9th order could handle 10 conditions, and so on.

However, in practice, high-order polynomials behave badly:

They tend to oscillate between points (Runge’s phenomenon).
They may create large peaks in velocity and acceleration that were not intended.
They are globally sensitive: changing one condition at a single point changes the shape everywhere else.

Because of this, robotics rarely uses single polynomials beyond quintic. Instead, we break the trajectory into segments, each represented by a low-order polynomial (usually cubic).

Via Points

In many real tasks, the robot’s path must not only start at and end at , but also pass through intermediate positions (called via points).

Examples:

A welding torch must pass through certain weld spots.
A pick-and-place arm must move through a “safe waypoint” above an obstacle.
An inspection robot must visit multiple measurement locations.

So the problem becomes:

Start at at time .
Pass through via point qvq_v at time .
End at at time .

One polynomial is not enough, because that would require too many constraints. Instead, we use piecewise cubics.

Piecewise Cubics (Splines)

The idea is to divide the total trajectory into segments, each fitted with its own cubic polynomial:

Segment 1: on
Segment 2: on

At the connection point TvT_v, we must ensure:

Position continuity:
Velocity continuity:
(Often) acceleration continuity:

This guarantees the robot passes smoothly through the via point without stopping or jerking.

Why Cubics Are Preferred

Simplicity: 4 parameters → exactly enough to satisfy start/end position + velocity.
Stability: Local behavior — changing one segment doesn’t distort the entire trajectory.
Practicality: Most industrial robots do not require constraints beyond velocity continuity at waypoints, so cubic splines are sufficient.

Interpolation with Linear and Parabolic Functions (LSPB)

Linear Segments with Parabolic Blends (LSPB) is a common trajectory generation method in robotics.
The motion is built from straight-line segments (constant velocity) connected by short parabolic arcs (constant acceleration).
At the start, a parabolic ramp-up smoothly accelerates the joint from rest.
At each via point, a parabolic blend adjusts velocity gradually between incoming and outgoing slopes.
At the end, a parabolic ramp-down decelerates the joint smoothly to rest.
This ensures position and velocity are continuous, while acceleration is piecewise constant.

Setup and notation

We’re given a time-stamped sequence of points a single actuator must pass through:

If we connect points with straight lines in qq-vs-tt, velocity q˙\dot q (the slope) will jump at each waypoint—i.e., infinite acceleration. LSPB fixes this by keeping the motion linear “in the large” but inserting a short parabolic segment (constant acceleration) around each join to ramp velocity from the old slope to the new one.

Define the local linear slopes (the “would-be” velocities) on each raw interval:

The parabolic blend at a waypoint (core idea + derivation)

Consider a single waypoint with neighbors and
Without blending, the velocity would jump from to .
We introduce a constant acceleration for a short time centered on so that:

at the start of the blend (time ), velocity is ;
at the end of the blend (time ), velocity is .

Since velocity changes linearly under constant acceleration,

We typically choose the magnitude and set the signed acceleration

so the duration becomes the clean, magnitude-only formula

Parabola equation through the blend window

Let the linear motion before the blend keep slope q˙i−1\dot q_{i-1} until ti−t_i^-.
Its value there is

From to we apply constant acceleration . With
, the blend is

Its velocity and acceleration across the blend are

At we get by design, so the profile is continuous (position and velocity continuous). Acceleration is piecewise-constant; the jerk is impulsive only at switch times.

Linear spans between blends

Outside the blend windows, motion is linear with the corresponding slope:

After the blend around tit_i ends,

Smooth start from rest (derivation of )

Common requirement: start at rest at
Let the start blend use constant acceleration of magnitude for duration , with sign

During the parabolic start ():

We want to match into a constant-velocity line that reaches the first waypoint.
A neat way to preserve area (and therefore position) is to make that line pass through the offset point
and . Its slope is

Velocity continuity at t0+Tst_0+T_s requires

This is a quadratic in TsT_s. Solving,

We take the minus root to ensure . The discriminant must be non-negative; if not, the chosen asa_s is too small for the allotted time.

The start linear segment (constant velocity) then runs on
with slope vsv_s.

Smooth finish to rest (derivation of )

Similarly, to end at rest at (tf,qf)(t_f,q_f), pick a deceleration magnitude af>0a_f>0 (direction handled by sign). Let the final blend duration be TfT_f. The constant-velocity line before the final parabola should pass through the offset point
and , so its slope magnitude is

Constant deceleration over TfT_f must reduce that speed to zero, hence

Again a quadratic in TfT_f; solving gives

(Choose the minus root; the discriminant must be non-negative.)

The final linear segment runs on .

Full piecewise definition (putting it all together)

Given , choose magnitudes , for each internal waypoint, and . Then:

Start parabola :
Start linear :
For each internal waypoint i=1,…,ni=1,\dots,n:
- Duration: , with as above.
- Window: .
- Parabola
- Linears between blends:
Final linear
Final parabola

This construction guarantees position and velocity continuity at every join, with explicit control of peak acceleration (via your chosen aa magnitudes).

Feasibility & edge cases

The square-root discriminants must be non-negative:
If not, increase the corresponding aa or the time gap.
For an internal waypoint ii, the blend window must fit:
If a chosen aia_i makes TiT_i too large to fit, increase aia_i (sharper ramp) or give more time between waypoints. If still tight, you’ll converge to a triangular velocity change (no constant-velocity span near that join).
Acceleration is piecewise constant; jerk is impulsive at switch times. If jerk limits matter, move to S-curve profiles (jerk-limited blends).

Trajectory in Joint Space

In joint space, the trajectory is defined as a sequence of positions (angles for revolute joints, displacements for prismatic joints) over time for each joint independently.
Each joint is planned separately using LSPB, cubic, or quintic polynomials.
The final robot motion is then obtained by synchronizing all the joints so they start and finish at the correct times.

Mathematically, for an nn-DOF robot:

Each is generated by the trajectory planner (cubic, quintic, or LSPB).

Synchronization

Each joint may have different travel distances and constraints.
To ensure the end effector reaches the target pose at the same time across all joints:
- Compute the minimum required time for each joint based on its motion limits.
- The largest of these times is chosen as the common trajectory duration.
- The other joints’ trajectories are stretched in time (slower) to match.

Example:

Joint 1 must rotate with → needs 1.5 s.
Joint 2 must rotate with → needs 0.75 s.
Synchronization: choose T=1.5 s, stretch Joint 2’s profile to finish in 1.5 s as well.

Pros and cons

Simple to compute; each joint treated separately.
Always respects individual joint limits.
End-effector path in Cartesian space is not guaranteed to be straight or smooth → it may “swing” through intermediate configurations.

Trajectory in Task Space

In task space (also called Cartesian space), the trajectory is specified for the robot end effector (e.g., a tool tip moving along a straight line in XYZ).
The planner defines a desired path:
where position + orientation are specified over time.
Then, at each time instant, inverse kinematics is solved to compute the joint angles:

Implementation

Choose the path in Cartesian space (e.g., straight line from point A to B).
Assign timing law for progress along the path (e.g., trapezoidal velocity profile in arc length).
At each time step, compute desired Cartesian point x(t)\mathbf{x}(t).
Apply inverse kinematics to get the corresponding joint angles q(t)\mathbf{q}(t).
Ensure the result respects joint/velocity/acceleration limits → if not, adjust timing.

Example:

End effector must move in a straight line from to in 2 s.
Task-space planner generates:
Each time step, inverse kinematics maps to joint coordinates
This guarantees the end effector really follows the straight line.

Pros and cons

End effector follows the desired geometric path (important for machining, welding, painting).
Intuitive for human operators/programmers.
Requires inverse kinematics at each step (can be expensive or have multiple solutions).
Must carefully check joint limits and avoid singularities.

Conclusion

Trajectory generation ensures smooth, feasible motion for robots.
Joint space trajectories are simple and safe but don’t guarantee a Cartesian path.
Task space trajectories guarantee geometric path following but are more complex (IK required).
In practice:
- Pick joint space planning for pick-and-place or when path shape is not critical.
- Pick task space planning when path accuracy matters (e.g., welding along a seam).
Advanced systems often combine both: task-space goals + joint-space optimization under limits.

Welcome to Robotics