A robot mechanism is a collection of rigid links connected by joints that constrain relative motions. In Chapter 5, Lesson 1, we introduced joint types and their motion capabilities. Here, we classify robots by how those joints are arranged.

Serial mechanism: a single kinematic chain from base to end-effector. Each joint motion is applied “in series.” If the chain has \( n \) joints, the configuration can be parameterized by generalized coordinates \( \mathbf{q} = [q_1,\dots,q_n]^T \).

Parallel mechanism: multiple chains connect the base to a common moving platform (end-effector). Motions are “in parallel,” and platform pose is determined by simultaneous constraints of all legs.

flowchart LR
  B["Base"] --> S1["Joint 1"] --> S2["Joint 2"] --> S3["..."] --> EE["End-effector"]
  subgraph Serial["Serial chain (one path)"]
    B
    S1
    S2
    S3
    EE
  end

  B2["Base"] --> L1["Leg 1"]
  B2 --> L2["Leg 2"]
  B2 --> L3["Leg 3"]
  L1 --> P["Moving platform"]
  L2 --> P
  L3 --> P
  subgraph Parallel["Parallel mechanism (many paths)"]
    B2
    L1
    L2
    L3
    P
  end
        

Intuitively: serial robots are like a human arm (one chain), while parallel robots are like a table supported by multiple legs.

The mobility (or degrees of freedom) of a mechanism is the dimension of its configuration space: how many independent coordinates are needed to specify its motion.

For a free rigid body in 3D, the motion space has dimension 6: 3 translations and 3 rotations. Hence a mechanism with links and joints reduces this freedom by imposing constraints.

A standard counting formula is the spatial Grübler–Kutzbach criterion:

\[ M = 6\,(L - 1 - J) + \sum_{i=1}^{J} f_i \]

where: \( M \) = mobility, \( L \) = number of links (including base), \( J \) = number of joints, and \( f_i \) = DOF allowed by joint \(i\) (e.g., revolute: \(f_i=1\), spherical: \(f_i=3\)).

Proof sketch (constraint count): Each moving link contributes 6 freedoms, so unconstrained freedom is \( 6(L-1) \). Each joint between two links removes \( 6-f_i \) freedoms (because it allows \(f_i\) motions). Total removed freedoms are \( \sum_{i=1}^{J}(6-f_i) = 6J - \sum f_i \). Therefore,

\[ M = 6(L-1) - \left(6J - \sum_{i=1}^{J} f_i\right) = 6(L-1-J) + \sum_{i=1}^{J} f_i. \]

This is a necessary count for generic mechanisms. Certain special geometries can create redundant or dependent constraints; those subtleties are studied in advanced kinematics courses.

2.1 Mobility of Serial Chains

A serial chain with \(n\) one-DOF joints has \(L=n+1\), \(J=n\), and \(f_i=1\) for all joints. Plugging in:

\[ M = 6\big((n+1)-1-n\big) + \sum_{i=1}^{n} 1 = 6(0) + n = n. \]

So serial mobility equals the number of joints. This matches your intuition from Lesson 1.

2.2 Mobility of Parallel Mechanisms

Parallel mechanisms often have many links/joints but fewer platform DOF because multiple chains impose constraints on the same moving platform. Consider a platform connected by \(m\) legs. Each leg contributes constraints; the net mobility is generally less than the sum of leg joints.

A simple conceptual way to see this is: if leg \(k\) allows the platform to move in a subspace of dimension \( d_k \), then the platform mobility is the intersection of these subspaces, so

\[ M \le \min_{k=1,\dots,m} d_k, \]

with equality only when leg constraints are mutually compatible. Parallel robots are thus good at constraining motion, not increasing it.

We compare mechanism families using quantities you can reason about before doing any detailed kinematics.

3.1 Workspace and Reach

For a serial robot, the end-effector can often reach a large region because each joint motion “adds” freedom along the chain. Conceptually, the reachable set is a nested union of joint sweeps.

Parallel robots have a moving platform tethered by multiple legs, so reach is limited by leg lengths and joint ranges. Large workspaces are harder to achieve.

3.2 Stiffness and Load Distribution

Stiffness is the relationship between a small applied force/torque (wrench) and the resulting small deflection: \( \mathbf{w} = \mathbf{K}\,\delta\mathbf{x} \), where \(\mathbf{K}\) is a stiffness matrix.

Serial chains behave like springs in series. If each joint/segment has compliance (inverse stiffness) \(\mathbf{C}_i\), then the total compliance along the chain adds approximately:

\[ \mathbf{C}_{serial} \approx \sum_{i=1}^{n} \mathbf{C}_i, \qquad \mathbf{K}_{serial} \approx \mathbf{C}_{serial}^{-1}. \]

Parallel robots distribute load through multiple legs. If leg compliances are \(\mathbf{C}_k\), their stiffnesses add (springs in parallel):

\[ \mathbf{K}_{parallel} \approx \sum_{k=1}^{m} \mathbf{K}_k, \qquad \mathbf{K}_k = \mathbf{C}_k^{-1}. \]

Consequence: for comparable components, \( \mathbf{K}_{parallel} \) is typically larger, so parallel manipulators are stiffer and better for precision and heavy payloads.

3.3 Error / Uncertainty Propagation (conceptual)

Suppose each joint has a small positioning error \(\delta q_i\). For a serial chain, errors accumulate along the chain. In a first-order linear approximation:

\[ \|\delta \mathbf{x}\| \le \sum_{i=1}^{n} a_i\,|\delta q_i|, \quad a_i \ge 0, \]

where the coefficients \(a_i\) depend on geometry (later in Course 2). The key point is the additive accumulation.

In parallel robots, multiple legs “average out” some errors because the platform pose must satisfy all legs simultaneously. The error is closer to a constrained least-squares compromise rather than a pure sum. Hence parallel robots can be more accurate in practice.

3.4 Actuator Placement and Moving Mass

Serial robots often carry actuators on moving links, increasing moving inertia. Parallel robots place many actuators on or near the base, reducing moving mass. This matters for speed and energy efficiency.

3.5 Singularities (high-level)

Both families have configurations where motion or force capabilities degrade (singularities). Serial singularities tend to occur at workspace boundaries; parallel singularities can also occur inside the workspace and may cause loss of control or stiffness. Detailed analysis is later.

flowchart TD
  T["Task requirements"] --> W["Need large workspace?"]
  W -->|yes| S["Prefer serial"]
  W -->|no| P1["Need high stiffness / precision?"]
  P1 -->|yes| P["Prefer parallel"]
  P1 -->|no| M1["Need high speed / low moving mass?"]
  M1 -->|yes| P
  M1 -->|no| C["Consider cost, control, safety"]
  C --> S
  C --> P
        

4.1 Serial Robots

• Industrial 6-DOF arms (e.g., elbow manipulators).
• SCARA robots (typically 4 DOF with planar focus).
• Humanoid arms and hands.

4.2 Parallel Robots

• Delta robots for high-speed pick-and-place (3 translational DOF).
• Stewart platforms / hexapods (typically 6 DOF, very stiff).
• Planar 5-bar linkages (2 DOF for planar positioning).

In every case, the mechanism family strongly shapes what the robot is “naturally good at,” before any controller is written.

Even in a conceptual chapter, it helps to automate mobility checks. We implement a simple Grübler–Kutzbach calculator. This is not a full kinematic solver; it only counts freedoms.

5.1 Python

from dataclasses import dataclass
from typing import List

@dataclass
class Joint:
    name: str
    fi: int  # DOF allowed by joint

def mobility_spatial(L: int, joints: List[Joint]) -> int:
    J = len(joints)
    sum_f = sum(j.fi for j in joints)
    M = 6 * (L - 1 - J) + sum_f
    return M

# Example 1: serial chain with 6 revolute joints
serial_joints = [Joint(f"R{i+1}", 1) for i in range(6)]
print("Serial M =", mobility_spatial(L=7, joints=serial_joints))

# Example 2: planar 5-bar (approx spatial count not ideal, but illustrative)
# Suppose L=5 links incl. base, J=5 revolute joints
fivebar_joints = [Joint(f"R{i+1}", 1) for i in range(5)]
print("Five-bar M (spatial formula) =", mobility_spatial(L=5, joints=fivebar_joints))
      

5.2 C++

#include <iostream>
#include <vector>
#include <numeric>

struct Joint {
    std::string name;
    int fi;
};

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

int main() {
    std::vector<Joint> serial;
    for (int i = 0; i < 6; ++i) serial.push_back({"R"+std::to_string(i+1), 1});
    std::cout << "Serial M = " << mobility_spatial(7, serial) << std::endl;

    std::vector<Joint> fivebar(5, {"R", 1});
    std::cout << "Five-bar M (spatial formula) = "
              << mobility_spatial(5, fivebar) << std::endl;
    return 0;
}
      

5.3 Java

import java.util.*;

class Joint {
    String name;
    int fi;
    Joint(String name, int fi) { this.name = name; this.fi = fi; }
}

public class MobilityGK {
    static int mobilitySpatial(int L, List<Joint> joints) {
        int J = joints.size();
        int sumF = 0;
        for (Joint j : joints) sumF += j.fi;
        return 6 * (L - 1 - J) + sumF;
    }
    public static void main(String[] args) {
        List<Joint> serial = new ArrayList<>();
        for (int i=0;i<6;i++) serial.add(new Joint("R"+(i+1), 1));
        System.out.println("Serial M = " + mobilitySpatial(7, serial));
    }
}
      

5.4 MATLAB / Simulink (script-level)

function M = mobility_spatial(L, fi)
% L: number of links including base
% fi: vector of joint DOF values, length J
J = length(fi);
M = 6*(L - 1 - J) + sum(fi);
end

% Serial example
fi_serial = ones(1,6);  % six revolute joints
M_serial = mobility_spatial(7, fi_serial)

% Stewart-platform-like count example (illustrative only)
% Suppose 13 links incl. base and platform, 18 one-DOF joints total
fi_stewart = ones(1,18);
M_stewart = mobility_spatial(13, fi_stewart)
      

In later courses, these counts become inputs to full kinematic models. For now, they provide a fast sanity check when you sketch mechanisms.

Problem 1 (Serial Mobility): A robot arm has 5 revolute joints and 1 prismatic joint, all arranged in a single chain. Using Grübler–Kutzbach counting, compute its mobility.

Solution: It is a serial chain with \(n=6\) one-DOF joints. From Section 2.1,

\[ M = n = 6. \]

The arm is a 6-DOF serial manipulator.

Problem 2 (Why Parallel Is Stiffer): Suppose a serial chain has two elastic stages with stiffness \(k_1, k_2\) along the same direction. A parallel mechanism has two legs of stiffness \(k_1, k_2\) supporting the platform in the same direction. Show that the parallel structure is stiffer.

Solution: For serial elastic stages, compliances add:

\[ \frac{1}{k_{serial}} = \frac{1}{k_1} + \frac{1}{k_2} \quad \Rightarrow \quad k_{serial} = \frac{k_1 k_2}{k_1 + k_2}. \]

For parallel legs, stiffnesses add:

\[ k_{parallel} = k_1 + k_2. \]

Since \(k_1+k_2 > \frac{k_1 k_2}{k_1+k_2}\) for any positive \(k_1, k_2\), parallel is stiffer.

Problem 3 (Counting Mobility of a Simple Parallel Mechanism): Consider a planar 5-bar linkage (two 2-link arms joined at a common end). Approximate mobility using a planar count: \(M = 3(L - 1 - J) + \sum f_i\), where planar links have 3 DOF. The mechanism has 5 links including base and 5 revolute joints. Find \(M\).

Solution: Here \(L=5\), \(J=5\), and all \(f_i=1\):

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

So the planar platform point has 2 DOF (x–y positioning).

Problem 4 (Workspace Intuition): A designer needs a robot that can reach widely around obstacles to perform maintenance. Should they start with a serial or parallel architecture? Give a mechanism-level justification.

Solution: Start with a serial chain. Serial mechanisms accumulate joint sweeps along one path, enabling large, “wrap-around” workspaces. Parallel platforms are constrained by multiple legs, typically yielding a smaller, more compact workspace.

Problem 5 (Choosing Architecture): A pick-and-place line demands extremely high speed and repeatability over a small region. Which family is more appropriate and why?

Solution: A parallel mechanism (e.g., delta-like). Base-mounted actuators lower moving inertia for speed, and parallel load sharing raises stiffness and repeatability in the required small workspace.

Serial mechanisms provide mobility equal to the number of joints, generally yielding large workspaces and high dexterity, but with compliance and error accumulation along a single chain. Parallel mechanisms use multiple legs to constrain a platform, giving smaller workspaces but higher stiffness, accuracy, and speed due to reduced moving mass. Mobility counting via Grübler–Kutzbach offers a first structural check before detailed kinematics (reserved for later).