Jacobians in Robotic Arms

What Is the Jacobian?

The Jacobian is the matrix that relates joint-space velocities $\dot{\mathbf{q}}$ to the end-effector's Cartesian velocity (its twist) $\mathbf{v}$ ^[1]:

For an $n$-DOF arm with a 6-D task space, $J \in \mathbb{R}^{6 \times n}$. For planar arms, the twist reduces to $[\dot{x},, \dot{y},, \dot{\phi}]^\top$ and $J \in \mathbb{R}^{3 \times n}$. Because $J$ depends on $\mathbf{q}$, the mapping changes as the robot moves — which is what makes Jacobian-based control non-trivial.

A 2-DOF Planar Arm

Consider the simplest non-trivial case: two revolute joints in the plane. The kinematic chain below shows the two links $l_1$, $l_2$ and the joint angles $\theta_1$, $\theta_2$.

DH Parameters

The Denavit–Hartenberg convention ^[2] parameterises each joint with four numbers. For a planar arm all link offsets and twist angles are zero:

Forward Kinematics

Composing the two joint transforms gives the end-effector position:

At $\theta_1 = 0.4,\text{rad}$, $\theta_2 = 0.2,\text{rad}$ with $l_1 = l_2 = 1,\text{m}$, the homogeneous transform $T_0^2$ is:

Deriving the Jacobian

Differentiating $p_x$ and $p_y$ with respect to $\theta_1$ and $\theta_2$, and stacking the orientation row $\dot{\phi} = \dot{\theta}_1 + \dot{\theta}_2$, yields the $3 \times 2$ geometric Jacobian:

where $s_1 = \sin\theta_1$, $c_1 = \cos\theta_1$, $s_{12} = \sin(\theta_1 + \theta_2)$, $c_{12} = \cos(\theta_1 + \theta_2)$.

Singularities

The arm loses a degree of freedom when $\det(J J^\top) = 0$. For the position rows (dropping orientation), $\det J_{2\times2} = l_1 l_2 \sin\theta_2$. This is zero when $\theta_2 = 0$ or $\pi$ — the arm is fully extended or fully folded. Near these configurations the inverse Jacobian blows up and joint velocities become unbounded for any Cartesian motion.

Velocity Mapping

The plot below shows simulated joint velocities $\dot{\theta}_1$, $\dot{\theta}_2$ fed through $J(\mathbf{q})$ to produce end-effector velocities $\dot{x}$, $\dot{y}$ over time. Note how the Cartesian speed oscillates with the arm configuration even when joint speeds are smooth.

Jacobian Transpose Control

The Jacobian transpose $J^\top$ lets you convert a desired end-effector force $\mathbf{f}$ into joint torques $\boldsymbol{\tau}$ without inverting $J$. This is used in impedance control and gravity compensation:

For resolved-rate motion control — driving the arm to a goal in Cartesian space — the damped least-squares pseudo-inverse avoids singularity blow-up:

Implementation

import numpy as np

def jacobian(q: np.ndarray, l: np.ndarray) -> np.ndarray:
    """Geometric Jacobian for an n-DOF planar revolute arm."""
    n = len(q)
    J = np.zeros((3, n))
    cum = np.cumsum(q)
    for i in range(n):
        suffix_cos = sum(l[j] * np.cos(cum[j]) for j in range(i, n))
        suffix_sin = sum(l[j] * np.sin(cum[j]) for j in range(i, n))
        J[0, i] = -suffix_sin
        J[1, i] = suffix_cos
        J[2, i] = 1.0
    return J

def damped_pinv(J: np.ndarray, lam: float = 0.01) -> np.ndarray:
    JJT = J @ J.T
    return J.T @ np.linalg.inv(JJT + lam**2 * np.eye(JJT.shape[0]))

Null Space and Redundancy

When $n > 6$ the arm is redundant: there is a whole family of joint configurations that achieve the same end-effector pose. The null space of $J$ spans the self-motions that leave the end-effector stationary. These extra degrees of freedom can be used to avoid joint limits or obstacles:

where $(I - J^\dagger J)$ projects any vector $\mathbf{z}$ onto the null space of $J$. Choosing $\mathbf{z} = -\nabla H(\mathbf{q})$ for some penalty function $H$ (joint-limit proximity, manipulability measure) exploits redundancy without disturbing the primary task.