Robot Kinematics

What is Kinematics?

Kinematics is the branch of mechanics that studies the motion of bodies without considering the forces that cause the motion. In robotics, kinematics focuses on the geometric relationship between the links and joints of a robot and the resulting position, velocity, and acceleration of the end-effector (the tool or gripper at the tip of the arm).

Why It Matters

Every robot controller needs kinematics. When you command a robot arm to move its gripper to a specific location in space, the controller must solve an inverse kinematics problem: determine what joint angles produce the desired end-effector pose. When the robot reports its current joint angles, forward kinematics computes where the end-effector actually is. Without kinematics, you cannot plan paths, avoid obstacles, or coordinate multiple robots.

Two Central Problems

• Forward Kinematics (FK) — Given joint variables (angles for revolute joints, displacements for prismatic joints), compute the position and orientation of the end-effector. This is always solvable and has a unique solution.
• Inverse Kinematics (IK) — Given a desired end-effector pose, find the joint variables that achieve it. This may have zero, one, or multiple solutions, and is generally much harder than FK.

Types of Joints

• Revolute (R) — rotational joint, 1 DOF. Most common in robot arms. Variable: angle theta.
• Prismatic (P) — linear sliding joint, 1 DOF. Variable: displacement d.
• Spherical (S) — ball-and-socket, 3 DOF. Equivalent to three revolute joints with intersecting axes.
• Cylindrical (C) — rotation + translation along the same axis, 2 DOF.
• Universal (U) — two perpendicular revolute joints, 2 DOF. Common in drive shafts.

An n-DOF serial robot chain has n joints and n+1 links. The total degrees of freedom determine the dimension of the configuration space (C-space), which is the space of all possible joint configurations.

Spatial Representations

Before diving into kinematics equations, we need tools to represent position and orientation in 3D space.

Rotation Matrices

A 3x3 rotation matrix R belongs to the Special Orthogonal group SO(3). It satisfies R^T R = I and det(R) = 1. Rotation matrices are used to describe the orientation of one coordinate frame relative to another.

Elementary rotations about the x, y, z axes can be composed to represent any orientation. The order of multiplication matters because rotations are not commutative.

Euler Angles

Three angles that parameterize a rotation. Common conventions include ZYZ (used in many industrial robots), ZYX (roll-pitch-yaw, used in aerospace), and XYZ. Euler angles are intuitive but suffer from gimbal lock: when two rotation axes align, one degree of freedom is lost.

Quaternions

Unit quaternions q = (w, x, y, z) with |q| = 1 provide a singularity-free representation of rotations. They are compact (4 numbers vs 9 for a matrix), and interpolation between orientations (SLERP) is smooth and efficient. Widely used in game engines and modern robotics software.

Homogeneous Transformation Matrices

A 4x4 matrix T in SE(3) combines rotation and translation into a single compact representation:

Composing transformations is simple matrix multiplication: T_02 = T_01 * T_12 gives the pose of frame 2 relative to frame 0. This is the foundation of forward kinematics.

Axis-Angle Representation

Any rotation can be described by an axis (unit vector omega) and an angle theta. Related to rotation matrices via Rodrigues' formula: R = I + sin(theta) [omega]_x + (1 - cos(theta)) [omega]_x^2, where [omega]_x is the 3x3 skew-symmetric matrix of omega. The axis-angle form connects naturally to the product of exponentials formulation.

Forward Kinematics

Forward kinematics maps joint variables to the end-effector pose. For a serial chain of n joints, the end-effector pose is computed by multiplying the transformation matrices of each link:

Each T_{i-1,i} depends on the joint variable q_i (an angle for revolute joints, a displacement for prismatic joints) and the fixed geometric parameters of the link.

Procedure

• Step 1: Assign coordinate frames to each joint using a systematic convention (DH or PoE).
• Step 2: Determine the transformation matrix for each link as a function of the joint variable.
• Step 3: Multiply the chain of transformations to get T_0n.
• Step 4: Extract position (the last column of T_0n) and orientation (the upper-left 3x3 submatrix).

Important Properties

• Forward kinematics always has a unique solution — given a set of joint values, there is exactly one end-effector pose.
• The computation is O(n) in the number of joints — just n matrix multiplications.
• The result is exact (no iteration needed), unlike inverse kinematics.
• FK is used in simulation, visualization, collision checking, and as a subroutine in IK solvers.

Denavit-Hartenberg Parameters

The Denavit-Hartenberg (DH) convention, introduced by Jacques Denavit and Richard Hartenberg in 1955, provides a systematic method for assigning coordinate frames to robot links. It reduces the description of each link to exactly four parameters.

The Four DH Parameters

For a revolute joint, theta_i is the joint variable (varies during motion); the other three are fixed geometric constants. For a prismatic joint, d_i is the joint variable.

DH Transformation Matrix

Each link's transformation is computed as:

T_{i-1,i} = [ cos(theta)  -sin(theta)*cos(alpha)   sin(theta)*sin(alpha)  a*cos(theta) ]
            [ sin(theta)   cos(theta)*cos(alpha)  -cos(theta)*sin(alpha)  a*sin(theta) ]
            [     0             sin(alpha)              cos(alpha)              d        ]
            [     0                 0                       0                   1        ]

Modified DH (Craig's Convention)

An alternative convention by John Craig places the coordinate frame at the proximal end of the link rather than the distal end. The transformation order becomes Rot_x(alpha_{i-1}) * Trans_x(a_{i-1}) * Rot_z(theta_i) * Trans_z(d_i). Both conventions are widely used; consistency is what matters. Industrial robots from ABB, KUKA, and FANUC typically use the standard (distal) convention in their documentation.

Example: 2-Link Planar Arm DH Table

The forward kinematics gives: x = L1*cos(theta_1) + L2*cos(theta_1 + theta_2), y = L1*sin(theta_1) + L2*sin(theta_1 + theta_2). This is the simplest non-trivial example and is a standard homework problem in every robotics course.

Product of Exponentials (PoE)

An alternative to DH parameters, the Product of Exponentials formulation is based on Lie group theory and the exponential map from se(3) to SE(3). Popularized by Murray, Li, and Sastry (1994) and the Modern Robotics textbook by Lynch and Park.

Core Idea

Each joint is described by a screw axis S_i = (omega_i, v_i) in the home (zero) configuration. The forward kinematics is:

where M is the end-effector pose at the home configuration (all joints at zero), and e^{[S_i]*q_i} is the matrix exponential of the 4x4 twist matrix [S_i] scaled by the joint variable q_i.

Advantages over DH

• No frame assignment ambiguity — DH parameters are not unique when consecutive joint axes are parallel or intersecting. PoE avoids this entirely.
• Geometric intuition — each exponential represents a screw motion (rotation + translation along a screw axis).
• Clean Jacobian — the space Jacobian has a natural recursive formula.
• Works for any joint type — revolute (omega != 0, ||omega|| = 1) and prismatic (omega = 0, ||v|| = 1) are handled uniformly.

Matrix Exponential

For a revolute joint with screw axis S = (omega, v) and joint angle theta:

where e^{[omega]*theta} is computed by Rodrigues' formula. This formulation is used in Drake, Pinocchio, and other modern robotics libraries.

Inverse Kinematics

Inverse kinematics (IK) is the problem of finding joint variables q = (q_1, ..., q_n) such that FK(q) = T_desired. This is fundamentally harder than forward kinematics because the mapping is generally many-to-one (multiple joint configurations can produce the same end-effector pose), and solutions may not exist if the desired pose is outside the workspace.

Analytical (Closed-Form) Solutions

For robots with specific geometric structures, IK can be solved in closed form using trigonometric identities. This is fast, exact, and enumerates all solutions. Pieper's theorem (1968) states that a 6-DOF robot with three consecutive revolute joint axes intersecting at a point (a spherical wrist) always admits a closed-form IK solution.

Common Analytical Techniques

• Geometric approach — project the problem into 2D planes and use the law of cosines. Works well for planar arms and SCARA robots.
• Algebraic approach — write out the FK equations explicitly and solve the system of transcendental equations using substitutions like the half-angle tangent (Weierstrass substitution).
• Decoupling — separate position (first 3 joints) and orientation (last 3 joints, spherical wrist). Solve position IK first, then orientation IK with known wrist center.
• Subproblem decomposition (Paden-Kahan) — decompose the IK problem into canonical subproblems: rotation about a single axis, rotation about two axes, and rotation to a specified distance. Used with the PoE formulation.

Numerical Methods

When closed-form solutions are not available (redundant robots, non-standard geometries), numerical methods iteratively converge to a solution.

• Newton-Raphson — linearize FK around current q, solve J * delta_q = delta_x, update q. Quadratic convergence near a solution, but may diverge if the initial guess is poor.
• Jacobian Pseudoinverse — q_new = q + J^+ * (x_desired - FK(q)). For redundant robots (more joints than task DOFs), J^+ = J^T * (J * J^T)^{-1} gives the minimum-norm solution.
• Damped Least Squares (Levenberg-Marquardt) — q_new = q + J^T * (J*J^T + lambda^2*I)^{-1} * e. The damping factor lambda prevents instability near singularities. This is the workhorse of practical IK solvers.
• Cyclic Coordinate Descent (CCD) — optimize one joint at a time, cycling through all joints. Simple to implement, works well for animation but can be slow for precision robotics.
• FABRIK (Forward and Backward Reaching IK) — heuristic method that alternately adjusts joint positions from the end-effector backward and from the base forward. Fast and intuitive for chains.
• Optimization-based — formulate IK as a constrained optimization: minimize ||FK(q) - T_desired||^2 subject to joint limits and collision constraints. Libraries like IPOPT, NLopt, or CasADi can solve this.

Number of Solutions

A 6-DOF robot can have up to 16 IK solutions for a given end-effector pose. In practice, elbow-up/elbow-down and wrist-flip configurations are the main solution branches. Redundant robots (7+ DOF) have infinitely many solutions, forming a self-motion manifold.

The Jacobian

The Jacobian matrix J(q) maps joint velocities to end-effector velocities. It is the fundamental tool for differential kinematics, force analysis, singularity detection, and numerical IK.

Computing the Jacobian

For a serial chain, each column J_i of the Jacobian corresponds to joint i:

• Revolute joint: J_i = [z_{i-1} x (o_n - o_{i-1}) ; z_{i-1}] where z_{i-1} is the joint axis and o_{i-1} is the joint origin, both expressed in the base frame.
• Prismatic joint: J_i = [z_{i-1} ; 0] — pure translation along the joint axis.

These quantities are extracted directly from the intermediate transformation matrices T_0i computed during forward kinematics.

Analytical vs Geometric Jacobian

• The geometric Jacobian maps joint velocities to the spatial twist (linear + angular velocity of the end-effector). This is what we described above.
• The analytical Jacobian maps joint velocities to the time derivative of a minimal representation of pose (e.g., x, y, z, roll, pitch, yaw). It requires a transformation matrix T_a that depends on the orientation representation: J_a = T_a^{-1} * J.
• The analytical Jacobian has singularities from the orientation representation (gimbal lock) in addition to kinematic singularities.

Force/Torque Relationship

By the principle of virtual work, the Jacobian transpose maps end-effector forces/torques to joint torques:

This is used in force control, impedance control, and computing the load a robot can support at a given configuration.

Manipulability

Yoshikawa's manipulability measure w = sqrt(det(J * J^T)) quantifies how well the robot can move in all directions at a given configuration. When w = 0, the robot is at a singularity. The manipulability ellipsoid (eigenvalues/eigenvectors of J * J^T) visualizes directional dexterity.

Workspace Analysis

The workspace is the set of all positions (and orientations) the end-effector can reach. Understanding workspace geometry is essential for robot design and task planning.

Types of Workspace

• Reachable workspace — the set of all points the end-effector can reach with at least one orientation. It is the union of all reachable positions.
• Dexterous workspace — the set of points reachable with any arbitrary orientation. This is a subset of the reachable workspace and is typically much smaller.
• Cross-section workspace — a 2D slice through the 3D workspace, useful for visualization.

Workspace Geometry

For a 2-link planar arm with link lengths L1 and L2 (L1 > L2), the reachable workspace is an annulus (ring) with inner radius |L1 - L2| and outer radius L1 + L2. For a 6-DOF anthropomorphic arm (like the PUMA 560 or KUKA KR series), the workspace is roughly a hollow sphere, with exclusion zones caused by joint limits, self-collisions, and singularity surfaces.

Factors Affecting Workspace

• Link lengths — directly determine reach
• Joint limits — restrict the workspace from the theoretical maximum
• Joint types — prismatic joints create different workspace shapes than revolute joints (SCARA robots have a cylindrical workspace)
• Self-collision — some configurations are unreachable because links would intersect
• Mounting — floor-mounted, ceiling-mounted, and wall-mounted robots have different effective workspaces

Singularities

A singularity is a configuration where the robot loses one or more degrees of freedom of motion. Mathematically, it occurs when the Jacobian loses rank: rank(J(q)) < min(m, n), where m is the task dimension (typically 6) and n is the number of joints.

Types of Singularities

• Boundary singularities — at the edge of the workspace, when the arm is fully extended or fully folded. Example: a 2-link arm with theta_2 = 0 (fully extended) or theta_2 = pi (folded back).
• Interior singularities — inside the workspace, typically when two or more joint axes align. Example: in a 6-DOF arm with a spherical wrist, if joints 4 and 6 axes align (joint 5 = 0), the robot loses one rotational DOF.
• Wrist singularities — specific to robots with spherical wrists. Occur when joint 5 passes through zero.
• Shoulder singularities — when the wrist center intersects joint 1 axis.
• Elbow singularities — when the arm is fully stretched or folded (joints 2 and 3 configuration).

Consequences of Singularities

• Near a singularity, small end-effector velocities require very large joint velocities — the robot cannot physically achieve the commanded motion.
• Inverse kinematics becomes ill-conditioned; the pseudoinverse amplifies noise.
• Joint torques may saturate even for small end-effector forces.
• Some directions of motion become impossible (the robot "locks up").

Dealing with Singularities

• Damped least squares (DLS) — adds regularization to the Jacobian inverse, sacrificing tracking accuracy near singularities in exchange for bounded joint velocities.
• Singularity-robust task priority — decompose the task into primary and secondary objectives; degrade gracefully near singularities.
• Path planning around singularities — detect singular configurations in advance and plan trajectories that avoid them.
• Redundancy resolution — robots with 7+ DOF can use null-space motion to move away from singularities while maintaining the end-effector trajectory.

Worked Examples

1. Two-Link Planar Arm (2-DOF)

The simplest non-trivial robot arm. Two revolute joints, both in the xy-plane.

Forward Kinematics:

Inverse Kinematics (geometric): Using the law of cosines:

Jacobian:

J = [ -L1*sin(q1) - L2*sin(q1+q2)    -L2*sin(q1+q2) ]
    [  L1*cos(q1) + L2*cos(q1+q2)     L2*cos(q1+q2) ]

The determinant det(J) = L1*L2*sin(q2). Singularity occurs at q2 = 0 (arm fully extended) or q2 = pi (arm folded back).

2. SCARA Robot (4-DOF)

The Selective Compliance Assembly Robot Arm has 2 revolute joints for planar positioning, 1 prismatic joint for vertical motion, and 1 revolute joint for orientation. Popular for pick-and-place and PCB assembly.

The SCARA's workspace is a cylindrical shell. IK decouples cleanly: q1 and q2 determine xy position (same as 2-link planar), q3 determines z height, q4 determines end-effector rotation.

3. Six-DOF Industrial Arm (PUMA 560)

The Unimation PUMA 560 is one of the most studied robots in history. It has 6 revolute joints with a spherical wrist (joints 4, 5, 6 axes intersect). DH parameters (standard convention):

IK is solved by position-orientation decoupling: joints 1-3 position the wrist center, joints 4-6 orient the end-effector. The PUMA 560 has up to 8 IK solutions (2 shoulder x 2 elbow x 2 wrist configurations). Paul, Shimano, and Mayer published the complete closed-form solution in 1981.

4. Redundant 7-DOF Arm (KUKA LBR iiwa)

The KUKA LBR iiwa has 7 revolute joints, making it kinematically redundant (7 joints for a 6-DOF task). The extra DOF enables null-space motion: the robot can change its elbow position without moving the end-effector. This is exploited for obstacle avoidance, singularity avoidance, joint limit avoidance, and optimizing manipulability during task execution.

Real-World Applications

References & Further Reading