Any robot that moves in the physical world is built from:

• Links: rigid bodies that carry mass, inertia, and geometry.
• Joints: mechanical elements that connect links and allow relative motion.
• Base (ground link): a special link treated as immobile reference.

In this course we treat a robot mechanically as a mechanism: a collection of rigid links constrained by joints. The configuration of a robot is described by generalized coordinates \( \mathbf{q} \in \mathbb{R}^m \), where each coordinate corresponds to one independent joint motion.

flowchart LR
  B["Base / Ground link"] --> L1["Link 1 (rigid body)"]
  L1 --> J1["Joint 1 (constraints + allowed motion)"]
  J1 --> L2["Link 2"]
  L2 --> J2["Joint 2"]
  J2 --> EE["End-effector / Tool link"]
  subgraph "Mechanical chain"
    B --- L1 --- J1 --- L2 --- J2 --- EE
  end
        

A design question in robotics hardware is: how many independent motions does the structure permit? This is called the mobility or mechanical degree of freedom (DOF).

2.1 Links

A link is idealized as a rigid body. In 3D, a free rigid body has \(6\) instantaneous DOF: three translations and three rotations. We denote the number of links by \(N\), including the base.

Links are often categorized by how many joints connect to them:

• Binary link: connected to two joints.
• Ternary link: connected to three joints.
• n-ary link: connected to \(n\) joints.

2.2 Joints (Kinematic Pairs)

A joint connects two links and enforces constraints on their relative motion. If the relative motion has \(f\) DOF, then the joint applies \(c = 6 - f\) independent constraints (in spatial mechanisms).

Common 1-DOF joints (spatial) used in robots:

• Revolute (R): rotation about a fixed axis, coordinate \(q\).
• Prismatic (P): translation along a fixed axis, coordinate \(q\).
• Helical (H): coupled rotation/translation with pitch \(p\).

Multi-DOF joints exist (e.g., spherical, universal), but in robot arms we typically build mobility from many 1-DOF joints.

2.3 Constraint Viewpoint

Let all link poses be parameterized by a large coordinate vector \( \mathbf{x} \in \mathbb{R}^{6(N-1)} \) (each moving link contributes 6 coordinates). Joints impose algebraic constraints \( \boldsymbol{\phi}(\mathbf{x}) = \mathbf{0} \). If the Jacobian of constraints has rank \(r\), then locally

\[ M = 6(N-1) - r, \]

where \(M\) is the mobility (number of independent motions). This general rank formula leads to the counting rules derived next.

3.1 Spatial Mechanisms

Suppose a mechanism has: \(N\) links (including base), \(J\) joints, and the \(i\)-th joint allows \(f_i\) DOF.

Theorem (Spatial Grübler–Kutzbach): The mobility is \( M = 6(N-1-J) + \sum_{i=1}^{J} f_i \).

Proof:

Start with all moving links free in space. There are \(N-1\) moving links (excluding the base), each with 6 DOF, hence:

\[ M_0 = 6(N-1). \]

A spatial joint with \(f_i\) relative DOF removes \(c_i = 6 - f_i\) independent constraints. Assuming constraints are independent (no redundant constraints),

\[ M = M_0 - \sum_{i=1}^{J} c_i = 6(N-1) - \sum_{i=1}^{J} (6 - f_i) = 6(N-1) - 6J + \sum_{i=1}^{J} f_i = 6(N-1-J) + \sum_{i=1}^{J} f_i. \]

This completes the derivation. \(\square\)

Interpretation: each joint “spends” 6 DOF to connect two links, but “refunds” its allowed motion \(f_i\).

3.2 Planar Mechanisms

If motion is constrained to a plane, each free rigid body has only 3 DOF (two translations + one rotation). The planar form is:

\[ M = 3(N-1-J) + \sum_{i=1}^{J} f_i. \]

3.3 Serial Manipulators

A typical industrial arm is a serial chain (no closed loops), with \(J = N-1\) and almost always \(f_i=1\). Thus:

\[ M = 6(N-1-(N-1)) + \sum_{i=1}^{N-1} 1 = N-1 = J. \]

So a serial robot’s mobility equals its number of joints. This is why a “6-axis arm” has six revolute joints.

4.1 Payload, Gravity Loads, and Joint Torques

Even before full kinematic modeling, we can reason about loads. Consider a serial chain holding a payload of mass \(m_p\) at distance \(d\) from a given joint axis. The gravitational torque magnitude about that joint is approximately \( \tau_g \approx m_p g d \), where \(g \approx 9.81\,\mathrm{m/s^2}\).

4.2 Stiffness of Links and Chains

A link under axial load behaves like a spring with stiffness \(k = EA/L\), where \(E\) is Young’s modulus, \(A\) cross-sectional area, and \(L\) length.

\[ \delta = \frac{F}{k} = \frac{FL}{EA}, \]

with \(\delta\) axial deflection under force \(F\).

Proposition (Serial stiffness composes harmonically): If links/joints act like springs in series with stiffnesses \(k_1,\dots,k_J\), then the equivalent stiffness seen at the end is

\[ \frac{1}{k_{\mathrm{eq}}} = \sum_{i=1}^{J}\frac{1}{k_i}. \]

Proof:

A force \(F\) through series springs causes deflection \(\delta_i = F/k_i\) at each element, so total deflection

\[ \delta = \sum_{i=1}^{J} \delta_i = F\sum_{i=1}^{J} \frac{1}{k_i}. \]

Defining \(\delta = F/k_{\mathrm{eq}}\) yields the claim. \(\square\)

This explains a key design trade-off: long serial chains are flexible unless links and joints are made stiffer.

4.3 Mass Distribution and Inertia (Qualitative)

Mechanical architecture also shapes dynamic effort. If a link of mass \(m\) is approximated as concentrated at distance \(r\) from a joint axis, its rotational inertia about that joint scales like \(I \sim mr^2\). Hence long, heavy distal links sharply increase required joint effort.

A robot mechanism can be modeled as a labeled graph: nodes = links, edges = joints. A serial arm forms a tree; parallel robots introduce loops. This representation is useful for bookkeeping, mobility counting, and later kinematics.

flowchart TD
  subgraph "Serial chain (tree)"
    L0s["L0"] --> L1s["L1"] --> L2s["L2"] --> L3s["L3"]
  end
  subgraph "Parallel mechanism (loop)"
    L0p["L0"] --> A1["L1"]
    L0p --> A2["L2"]
    A1 --> A3["L3"]
    A2 --> A3
  end
        

5.1 Python: Graph + Mobility Counter

# Represent links and joints, compute mobility via Grübler–Kutzbach
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class Joint:
    parent: int
    child: int
    f: int  # allowed DOF of joint (1 for R/P, 2 for universal, etc.)

def spatial_mobility(N: int, joints: List[Joint]) -> int:
    J = len(joints)
    return 6*(N - 1 - J) + sum(j.f for j in joints)

# Example: 6R serial arm (N=7 including base, J=6, all f_i=1)
joints = [Joint(i, i+1, 1) for i in range(6)]
print("Mobility:", spatial_mobility(7, joints))

# Optionally build a link-joint graph
import networkx as nx
G = nx.Graph()
G.add_nodes_from(range(7))
G.add_edges_from((j.parent, j.child) for j in joints)
print("Is tree?", nx.is_tree(G))
      

Library note: networkx is a lightweight graph package convenient for representing mechanical connectivity. Later courses will use robotics-specific toolkits.

5.2 C++: Structure + Mobility

#include <iostream>
#include <vector>

struct Joint {
    int parent, child;
    int f; // DOF of joint
};

int spatialMobility(int N, const std::vector<Joint>& joints) {
    int J = static_cast<int>(joints.size());
    int sum_f = 0;
    for (const auto& j : joints) sum_f += j.f;
    return 6*(N - 1 - J) + sum_f;
}

int main() {
    // 3R planar arm is also spatially 3R with f=1 each
    int N = 4; // base + 3 links
    std::vector<Joint> joints = {
        {0,1,1}, {1,2,1}, {2,3,1}
    };
    std::cout << "Mobility = " << spatialMobility(N, joints) << std::endl;
    return 0;
}
      

Library note: in robotics C++ stacks, Eigen is the standard linear algebra library. We will start using it once kinematics/dynamics enter the course.

5.3 Java: Graph + Counting

import java.util.*;

class Joint {
    public int parent, child, f;
    public Joint(int p, int c, int f) { parent=p; child=c; this.f=f; }
}

public class MobilityCounter {
    public static int spatialMobility(int N, List<Joint> joints) {
        int J = joints.size();
        int sumF = 0;
        for (Joint j : joints) sumF += j.f;
        return 6*(N - 1 - J) + sumF;
    }

    public static void main(String[] args) {
        int N = 7; // base + 6 moving links
        List<Joint> joints = new ArrayList<>();
        for (int i=0; i<6; i++) joints.add(new Joint(i, i+1, 1));
        System.out.println("Mobility = " + spatialMobility(N, joints));
    }
}
      

Library note: for large projects, JGraphT provides robust graph data structures, useful for mechanisms with loops.

5.4 MATLAB / Simulink: Basic Mechanical Bookkeeping

% Mobility counting for a spatial mechanism
N = 7;                 % links including base
f = ones(1,6);         % 6 revolute joints
J = numel(f);
M = 6*(N-1-J) + sum(f);
disp("Mobility = " + M);

% MATLAB Robotics System Toolbox provides a 'rigidBodyTree'
robot = rigidBodyTree('DataFormat','row');
for i = 1:6
    body = rigidBody("link" + i);
    joint = rigidBodyJoint("joint" + i,'revolute');
    setFixedTransform(joint, eye(4));  % placeholder transform
    body.Joint = joint;
    if i==1
        addBody(robot, body, robot.BaseName);
    else
        addBody(robot, body, "link" + (i-1));
    end
end
showdetails(robot);
      

The rigidBodyTree object stores the mechanical connectivity. We are not using its kinematic functions yet; that comes in later courses.

Problem 1 (Serial-chain mobility): A robot arm consists of a base plus 5 moving links connected by 5 revolute joints. Compute its spatial mobility.

Solution:

Here \(N=6\) links (including base), \(J=5\), and each joint has \(f_i=1\). Thus

\[ M = 6(N-1-J) + \sum_{i=1}^J f_i = 6(6-1-5) + 5 = 0 + 5 = 5. \]

The arm has 5 independent joint motions.

Problem 2 (Planar vs spatial): A planar mechanism has 4 links (including ground) and 4 joints, each revolute. Compute planar mobility and explain the result.

Solution:

Planar DOF per free link is 3. With \(N=4\), \(J=4\), and \(f_i=1\):

\[ M = 3(N-1-J) + \sum f_i = 3(4-1-4) + 4 = 3(-1) + 4 = 1. \]

It is a 1-DOF planar linkage (like a 4-bar), even though it has 4 joints.

Problem 3 (Constraint redundancy): A spatial mechanism has \(N=5\) links and \(J=6\) joints, each with \(f_i=1\). The Grübler–Kutzbach formula yields \(M=0\). Yet the mechanism moves in practice. What does this imply?

Solution:

Plugging in:

\[ M = 6(5-1-6) + 6 = 6(-2) + 6 = -6. \]

A negative count indicates that the independence assumption fails: some constraints are redundant or dependent. Therefore the real mobility is higher. Such mechanisms require rank-based analysis \(M=6(N-1)-r\) or careful geometric reasoning.

Problem 4 (Series stiffness): A 3-joint arm has joint stiffnesses \(k_1=2000\,\mathrm{N/m}\), \(k_2=1000\,\mathrm{N/m}\), \(k_3=500\,\mathrm{N/m}\). Find \(k_{\mathrm{eq}}\).

Solution:

\[ \frac{1}{k_{\mathrm{eq}}} = \frac{1}{2000} + \frac{1}{1000} + \frac{1}{500} = 0.0005 + 0.001 + 0.002 = 0.0035. \]

\[ k_{\mathrm{eq}} = \frac{1}{0.0035} \approx 285.7\,\mathrm{N/m}. \]

The chain is far less stiff than its stiffest joint.

Problem 5 (Load torque estimate): A payload \(m_p=2\,\mathrm{kg}\) is held \(d=0.35\,\mathrm{m}\) from a revolute joint axis. Estimate gravity torque magnitude.

Solution:

\[ \tau_g \approx m_p g d = 2 \times 9.81 \times 0.35 \approx 6.867\,\mathrm{N\cdot m}. \]

The actuator at that joint must exceed this torque with margin.

We modeled robot hardware mechanically as rigid links connected by joints. From a constraint viewpoint we derived the Grübler–Kutzbach mobility formulas for spatial and planar mechanisms, showing why serial arms have mobility equal to their joint count. We linked architecture to performance via torque, stiffness, and inertia scaling arguments, and built simple graph-based representations with code. These ideas set the stage for deeper mechanism concepts in Chapter 5 and formal kinematics in Course 2.