Forward Kinematics (DH Parameters)

From joint angles to a pose

A robot arm is a chain of rigid links connected by joints. Each joint adds one degree of freedom — typically a rotation angle (revolute) or a sliding distance (prismatic). Given the current value of every joint, what's the position and orientation of the gripper at the end of the chain? That's the forward kinematics problem.

The brute-force answer is "compose the geometric transformations from base to end effector". A rotation here, a translation there, repeat for every link. Done by hand for a 6-joint arm, this is bookkeeping hell — every author chooses different axes, and signs flip in places nobody can audit. The DH convention is a discipline that fixes this: it forces you to lay out the link frames in a specific way, so the transform between consecutive frames always takes the same parameterized form. Then forward kinematics is "fill in the table, multiply the matrices".

The DH rules in plain language

Pick a coordinate frame at every joint (standard DH):

1. z-axis at joint i is the axis of motion (rotation axis for revolute, translation axis for prismatic).
2. x-axis at joint i points along the common perpendicular from z_i−1 to z_i.
3. y-axis follows from the right-hand rule.

Four parameters describe how to get from frame i−1 to frame i:

• θ_i — rotate around z_i−1 (joint variable for revolute).
• d_i — translate along z_i−1 (joint variable for prismatic).
• a_i — translate along the new x_i axis (link length).
• α_i — rotate around the new x_i axis (link twist).

Two of these vary with the joint state; the other two are fixed by the geometry of the robot.

The DH transform matrix

The transform from frame i−1 to frame i, given the four DH parameters, is:

          | cos θ      -sin θ cos α      sin θ sin α      a cos θ |
T(i-1, i) = | sin θ       cos θ cos α     -cos θ sin α      a sin θ |
          | 0           sin α             cos α            d       |
          | 0           0                 0                1       |

Forward kinematics for an n-joint arm is the chain product:

T_0,n = T_0,1 · T_1,2 · T_2,3 · ... · T_n−1,n

The result is a 4×4 matrix whose upper-left 3×3 block is the orientation of the end effector and whose upper-right 3×1 column is its position, all expressed in the base frame.

DH and competing parametrizations

Parametrization	Year	Params/joint	Strength	Weakness
Standard DH (Denavit-Hartenberg)	1955	4	Most compact, ubiquitous in textbooks	Frames not at the joint physically; non-unique parametrization
Modified DH (Craig)	1986	4	Frame i at proximal end of link i; cleaner for branch chains	Different matrix form than standard; mixing conventions silently breaks code
Hayati parametrization	1985	5 (per joint when needed)	Adds a fifth param to handle parallel consecutive joint axes	More complex; only needed when standard DH degenerates
Zero-reference / POE	1994	6 (twist coords)	Singularity-free, no per-joint frame placement	Larger memory footprint; requires Lie-algebra background
URDF (XML link tree)	2009	6 (xyz, rpy)	Tool-friendly, used by ROS; trivial to author	Bulkier than DH; ambiguous if not paired with joint axis convention
Raw 4×4 per link	—	16 (6 independent)	No conventions to memorize	No structure to exploit; can't tell rotation from translation in the data

Worked example: 2-link planar arm

A planar arm with two revolute joints, link lengths a₁ = 0.5 m and a₂ = 0.3 m, joint angles θ₁ and θ₂. The DH table:

i	αi	ai	θi	di
1	0	0.5	θ1	0
2	0	0.3	θ2	0

With α_i = 0, each transform is a rotation about z by θ followed by translation along x by a. The chain product with θ₁ = 30°, θ₂ = 45° gives:

x_tip = a₁cos(θ₁) + a₂cos(θ₁+θ₂) = 0.5·cos(30°) + 0.3·cos(75°) = 0.511 m
y_tip = a₁sin(θ₁) + a₂sin(θ₁+θ₂) = 0.5·sin(30°) + 0.3·sin(75°) = 0.540 m

End-effector orientation (z-rotation only for a planar arm) is θ₁ + θ₂ = 75°. The full 4×4 result encodes all three numbers in standard form.

DH product loop in code

import numpy as np

def dh_transform(alpha, a, theta, d):
    """Return the 4x4 standard-DH transform for one joint."""
    ct, st = np.cos(theta), np.sin(theta)
    ca, sa = np.cos(alpha), np.sin(alpha)
    return np.array([
        [ct,  -st * ca,   st * sa,   a * ct],
        [st,   ct * ca,  -ct * sa,   a * st],
        [0,        sa,         ca,        d],
        [0,         0,          0,        1],
    ])

def forward_kinematics(dh_table, joint_values):
    """dh_table: list of (alpha, a, theta_offset, d_offset, joint_type).
       joint_values: list of theta (revolute) or d (prismatic) values."""
    T = np.eye(4)
    for params, q in zip(dh_table, joint_values):
        alpha, a, theta_off, d_off, kind = params
        theta = theta_off + (q if kind == 'R' else 0.0)
        d     = d_off     + (q if kind == 'P' else 0.0)
        T = T @ dh_transform(alpha, a, theta, d)
    return T

# UR5 (Universal Robots) standard-DH parameters from manufacturer datasheet:
# (alpha,           a,        theta_off, d_off,    kind)
ur5 = [
    ( np.pi/2,  0.0,      0.0,  0.089159, 'R'),
    ( 0.0,     -0.425,    0.0,  0.0,      'R'),
    ( 0.0,     -0.39225,  0.0,  0.0,      'R'),
    ( np.pi/2,  0.0,      0.0,  0.10915,  'R'),
    (-np.pi/2,  0.0,      0.0,  0.09465,  'R'),
    ( 0.0,      0.0,      0.0,  0.0823,   'R'),
]

# Home pose: all joints at zero
T_end = forward_kinematics(ur5, [0, 0, 0, 0, 0, 0])
print(T_end[:3, 3])  # end-effector position in meters

The loop is twelve lines and runs in microseconds even with NumPy's overhead. Production robot controllers compute the same thing in C with hand-unrolled trigonometric calls, hitting tens of nanoseconds per call.

Real-world specs

• Universal Robots UR5 — 6-DOF collaborative arm, 5 kg payload, ±360° on every joint, ±0.03 mm repeatability, 850 mm reach. Public DH table widely cited in academic papers.
• ABB IRB 6700 — heavy industrial 6-DOF, 235 kg payload, 3.2 m reach, ±0.05 mm repeatability. Uses modified DH internally.
• Franka Emika Panda — 7-DOF research arm, redundant joint configuration enables null-space motion (the 7th joint allows changing arm posture without moving the end effector).

Common failure modes

• Mixing standard and modified DH conventions. A datasheet using Craig's modified DH plugged into code that expects standard DH gives wrong end-effector poses with no error message — you discover the bug only when the gripper smashes into a workpiece.
• Singularities at full extension. When a 6-DOF arm reaches near its kinematic limit, multiple joint configurations produce the same Cartesian motion and the inverse Jacobian becomes ill-conditioned. Forward kinematics works fine here; only the inverse problem fails.
• Joint backlash compounding. Each gearbox has a few arc-minutes of backlash. In a 6-DOF chain, the lever-arm-amplified end-effector error can reach millimeters even with sub-arc-minute joint encoders. Calibration measures and compensates this.
• Ambiguous zero positions. Two different "θ = 0" conventions can produce DH parameters that look different but describe the same arm. When porting parameters between codebases, always verify the home pose visually before commanding any motion.
• Frame numbering off-by-one. Some sources number frames 1..n, others 0..n with the base as frame 0. A loop that multiplies T_1,2 through T_n,n+1 instead of T_0,1 through T_n−1,n drops the base transform and gives a relative pose.

Variants

• Modified DH (Craig 1986) — frame i at proximal end of link i; dominant in modern textbooks and ROS-based libraries.
• Hayati parametrization — adds a fifth parameter to handle consecutive parallel joint axes, where standard DH becomes singular in parameter space.
• Product of Exponentials (POE) — built on screw theory and Lie groups; avoids per-joint frame placement. Each joint contributes a constant twist vector; the forward map is a product of matrix exponentials.
• Closed-form vs iterative inverse — arms with three intersecting wrist axes (Pieper's criterion) have closed-form 8-solution Pieper inverse. Otherwise, numerical methods (Jacobian-pseudoinverse, Levenberg-Marquardt, FABRIK) solve iteratively.