By the end of this lesson you should be able to:

• Recognize standard industrial arm families from their joint sequences.
• Compute mobility (degrees of freedom) using constraint counting.
• Predict qualitative workspace shapes and approximate workspace volumes.
• Explain why a structure is preferred for certain tasks (assembly, welding, pick-place, etc.).

We will describe a manipulator as an ordered sequence of joint types. Let each joint be either revolute \( R \) or prismatic \( P \). For an \( n \)-joint serial arm, define the joint-type sequence \( \mathbf{s} = (s_1,\dots,s_n), \; s_i \in \{R,P\} \).

Examples: \( (P,P,P) \) denotes a Cartesian gantry; \( (R,P,P) \) denotes a cylindrical arm.

Industrial arms are usually open-chain serial mechanisms. For conceptual analysis, we use the Grübler–Kutzbach mobility formula.

Consider a mechanism with: \( L \) links (including ground), \( J \) joints, each joint \( j \) allowing \( f_j \) relative DOF in 3D space. The mobility \( M \) is

\[ M = 6(L-1-J) + \sum_{j=1}^{J} f_j. \]

Proof sketch (constraint counting):

A free rigid body in 3D has 6 DOF. Thus \( L-1 \) moving links give \( 6(L-1) \) unconstrained DOF. Each joint between two links imposes constraints. A joint with allowance \( f_j \) removes \( 6 - f_j \) DOF. Total constraints: \( \sum_j (6-f_j) = 6J - \sum_j f_j \). Subtracting constraints from unconstrained DOF yields

\[ M = 6(L-1) - (6J - \sum_j f_j) = 6(L-1-J) + \sum_{j=1}^J f_j. \]

For a serial manipulator, the graph is a tree. Hence \( J=L-1 \), and every joint is 1-DOF (\( f_j=1 \)), so:

\[ M = 6(L-1-(L-1)) + \sum_{j=1}^{L-1} 1 = n. \]

Therefore, a serial arm with \( n \) single-DOF joints has mobility \( M=n \). Industrial arms are often \( n=4,5,6 \).

flowchart LR
  S["Joint sequence s = (s1,...,sn)"] --> A["PPP"]
  S --> B["RPP"]
  S --> C["RRP"]
  S --> D["RRP with elbow + vertical P"]
  S --> E["RRR + RRR wrist"]
  A --> A1["Cartesian / Gantry"]
  B --> B1["Cylindrical"]
  C --> C1["Spherical (Polar)"]
  D --> D1["SCARA (RR-P)"]
  E --> E1["Articulated / Anthropomorphic"]
        

3.1 Cartesian (Gantry) Arms — \( (P,P,P) \)

Three mutually orthogonal prismatic axes produce pure translation. Let axis strokes be \( L_x, L_y, L_z \). The reachable workspace is a rectangular box:

\[ \mathcal{W}_{\text{car}} = \{(x,y,z)\;|\; 0 <= x <= L_x,\; 0 <= y <= L_y,\; 0 <= z <= L_z\}. \]

Approximate workspace volume: \( V_{\text{car}} = L_x L_y L_z \). Gantries excel at high stiffness and accuracy because loads align with linear guides.

3.2 Cylindrical Arms — \( (R,P,P) \)

A base rotation sweeps a radial prismatic slide; a vertical prismatic axis provides height. With radial range \( r \in [r_{\min}, r_{\max}] \) and height \( z \in [0, L_z] \), the workspace is a cylindrical shell:

\[ \mathcal{W}_{\text{cyl}} = \{(r,\theta,z)\;|\; r_{\min} <= r <= r_{\max},\; 0 <= \theta < 2\pi,\; 0 <= z <= L_z\}. \]

Volume: \( V_{\text{cyl}} = \pi (r_{\max}^2 - r_{\min}^2) L_z \). Cylindrical arms are simple and good for machine tending and palletizing.

3.3 Spherical / Polar Arms — \( (R,R,P) \) or \( (R,R,P,P) \)

Two revolute joints orient a telescoping prismatic radius. The workspace is a spherical sector. Let radius \( r \in [r_{\min}, r_{\max}] \), elevation \( \phi \in [\phi_{\min},\phi_{\max}] \), azimuth \( \theta \in [0,2\pi) \).

\[ V_{\text{sph}} = \int_{r_{\min}}^{r_{\max}} \int_{\phi_{\min}}^{\phi_{\max}} \int_{0}^{2\pi} r^2 \sin\phi \; d\theta \, d\phi \, dr = 2\pi \left(\cos\phi_{\min} - \cos\phi_{\max}\right)\frac{r_{\max}^3-r_{\min}^3}{3}. \]

Polar arms historically served spraying and casting tasks, but are less common today due to lower stiffness near extended reaches.

3.4 SCARA — \( (R,R,P) \) with two coplanar \( R \) joints

Selective Compliance Assembly Robot Arm (SCARA) uses two horizontal revolute joints for planar motion and a vertical prismatic joint for insertion. If planar link lengths are \( l_1, l_2 \), the planar reachable set is an annulus (no IK needed to state this):

\[ \mathcal{W}_{\text{scara,xy}} = \{(x,y)\;|\; |l_1-l_2| <= \sqrt{x^2+y^2} <= l_1+l_2\}. \]

Planar area: \( A_{\text{scara}} = \pi\left((l_1+l_2)^2-(|l_1-l_2|)^2\right) \). Full volume with vertical stroke \( L_z \): \( V_{\text{scara}} = A_{\text{scara}} L_z \). SCARAs are dominant in high-speed assembly.

3.5 Articulated / Anthropomorphic Arms — \( (R,R,R) \) + wrist

The most common industrial robot is a 6-DOF articulated arm: three revolute joints for gross positioning, plus a 3-DOF wrist for tool orientation. Joint sequence is typically \( (R,R,R,R,R,R) \), yielding \( M=6 \).

Their workspace is roughly a thick spherical shell, with occlusions due to self-collision. Articulated arms provide the best generality for welding, painting, and handling.

3.6 Brief note on parallel industrial arms

From Lesson 2 you saw that parallel mechanisms close kinematic loops. Industrial examples include Delta robots (high-speed pick-place) and Stewart platforms (precision). Mobility is again computed with Grübler–Kutzbach, but now \( J \neq L-1 \), so loop constraints reduce \( M \) below the number of actuators.

A simple quantitative descriptor is the workspace compactness ratio \( \rho \):

\[ \rho = \frac{V_{\mathcal{W}}}{V_{\text{bbox}}}, \]

where \( V_{\mathcal{W}} \) is reachable workspace volume and \( V_{\text{bbox}} \) is the volume of the smallest axis-aligned bounding box. Roughly:

• Cartesian: \( \rho \approx 1 \) (workspace is already a box).
• Cylindrical: \( \rho \approx \pi/4 \) when \( r_{\min}\approx 0 \) (cylinder inside a box).
• Spherical sector: \( \rho \ll 1 \) for narrow angular ranges.
• SCARA: moderate \( \rho \) because annulus wastes box corners.

flowchart LR
  T["Task requirements"] --> W["Workspace needed?"]
  W -->|large rectangular| CAR["Choose Cartesian"]
  W -->|cylindrical reach around base| CYL["Choose Cylindrical"]
  W -->|sector / radial reach| SPH["Choose Spherical"]
  W -->|fast planar + vertical insertion| SCA["Choose SCARA"]
  W -->|general 3D dexterity| ART["Choose Articulated"]
  T --> P["Payload / stiffness priority?"]
  P -->|very high stiffness| CAR
  P -->|moderate, high speed| SCA
  P -->|general payload| ART
        

Conceptually, you can interpret arm choice as a trade among reachable shapes, structural stiffness, achievable speed, and cost.

5.1 Python: classify structure and estimate workspace

from dataclasses import dataclass
from math import pi, cos, sin

@dataclass
class ArmStructure:
    joint_sequence: str   # e.g., "PPP", "RPP", "RRP", "RRP", "RRPR" etc.
    params: dict          # geometric strokes / lengths

    def dof(self):
        # Each character denotes a 1-DOF joint
        return len(self.joint_sequence)

    def workspace_volume(self):
        s = self.joint_sequence.upper()
        p = self.params

        if s == "PPP":  # Cartesian
            return p["Lx"] * p["Ly"] * p["Lz"]

        if s == "RPP":  # Cylindrical
            rmin, rmax, Lz = p["rmin"], p["rmax"], p["Lz"]
            return pi * (rmax**2 - rmin**2) * Lz

        if s == "RRP":  # Spherical/polar
            rmin, rmax = p["rmin"], p["rmax"]
            phimin, phimax = p["phimin"], p["phimax"]
            return 2*pi*(cos(phimin) - cos(phimax))*(rmax**3 - rmin**3)/3

        if s == "RRP_SCARA":  # tag for SCARA planar R,R plus vertical P
            l1, l2, Lz = p["l1"], p["l2"], p["Lz"]
            A = pi*((l1+l2)**2 - abs(l1-l2)**2)
            return A * Lz

        return None

# Example usage
gantry = ArmStructure("PPP", {"Lx":1.5, "Ly":1.0, "Lz":0.8})
print("Cartesian DOF, volume:", gantry.dof(), gantry.workspace_volume())

scara = ArmStructure("RRP_SCARA", {"l1":0.45, "l2":0.35, "Lz":0.2})
print("SCARA DOF, volume:", scara.dof(), scara.workspace_volume())
      

5.2 C++: same idea with a small struct

#include <iostream>
#include <string>
#include <cmath>
#include <unordered_map>

struct ArmStructure {
    std::string seq; // "PPP", "RPP", "RRP", "RRP_SCARA"
    std::unordered_map<std::string,double> p;

    int dof() const { return (int)seq.size(); }

    double workspaceVolume() const {
        const double PI = 3.141592653589793;
        if (seq == "PPP") {
            return p.at("Lx") * p.at("Ly") * p.at("Lz");
        }
        if (seq == "RPP") {
            double rmin = p.at("rmin"), rmax = p.at("rmax"), Lz = p.at("Lz");
            return PI * (rmax*rmax - rmin*rmin) * Lz;
        }
        if (seq == "RRP") {
            double rmin = p.at("rmin"), rmax = p.at("rmax");
            double phimin = p.at("phimin"), phimax = p.at("phimax");
            return 2*PI*(std::cos(phimin) - std::cos(phimax))*(std::pow(rmax,3)-std::pow(rmin,3))/3.0;
        }
        if (seq == "RRP_SCARA") {
            double l1 = p.at("l1"), l2 = p.at("l2"), Lz = p.at("Lz");
            double A = PI * ((l1+l2)*(l1+l2) - std::abs(l1-l2)*std::abs(l1-l2));
            return A * Lz;
        }
        return NAN;
    }
};

int main() {
    ArmStructure gantry{"PPP", {
      {"Lx",1.5},
      {"Ly",1.0},
      {"Lz",0.8}
    }
  };
    std::cout << "Gantry DOF=" << gantry.dof()
              << ", V=" << gantry.workspaceVolume() << std::endl;
    return 0;
}
      

5.3 Java: encode joint sequences and basic metrics

import java.util.Map;

public class ArmStructure {
    private final String seq;
    private final Map<String, Double> p;
    private static final double PI = Math.PI;

    public ArmStructure(String seq, Map<String, Double> params) {
        this.seq = seq.toUpperCase();
        this.p = params;
    }

    public int dof() { return seq.length(); }

    public double workspaceVolume() {
        switch (seq) {
            case "PPP":
                return p.get("Lx") * p.get("Ly") * p.get("Lz");
            case "RPP":
                double rmin = p.get("rmin"), rmax = p.get("rmax"), Lz = p.get("Lz");
                return PI * (rmax*rmax - rmin*rmin) * Lz;
            case "RRP":
                double phimin = p.get("phimin"), phimax = p.get("phimax");
                rmin = p.get("rmin"); rmax = p.get("rmax");
                return 2*PI*(Math.cos(phimin) - Math.cos(phimax))*(Math.pow(rmax,3)-Math.pow(rmin,3))/3.0;
            case "RRP_SCARA":
                double l1 = p.get("l1"), l2 = p.get("l2");
                Lz = p.get("Lz");
                double A = PI * ((l1+l2)*(l1+l2) - Math.abs(l1-l2)*Math.abs(l1-l2));
                return A * Lz;
            default:
                return Double.NaN;
        }
    }
}
      

5.4 MATLAB / Simulink-ready formulas

A MATLAB function (droppable into a MATLAB Function block in Simulink) for DOF and volume:

function [M, V] = arm_metrics(seq, params)
% seq: 'PPP','RPP','RRP','RRP_SCARA'
% params: struct with required fields

seq = upper(seq);
M = length(seq);

switch seq
    case 'PPP'
        V = params.Lx * params.Ly * params.Lz;

    case 'RPP'
        V = pi * (params.rmax^2 - params.rmin^2) * params.Lz;

    case 'RRP'
        V = 2*pi*(cos(params.phimin) - cos(params.phimax)) * ...
            (params.rmax^3 - params.rmin^3)/3;

    case 'RRP_SCARA'
        A = pi*((params.l1 + params.l2)^2 - abs(params.l1 - params.l2)^2);
        V = A * params.Lz;

    otherwise
        V = NaN;
end
end
      

These representations let you reason about structure choices in software without any forward/inverse kinematics machinery.

Problem 1 (Classify the arm): A manipulator has joint sequence \( (R,P,P) \). Identify its family and describe the workspace shape.

Solution: \( (R,P,P) \) is a cylindrical arm: base rotation sweeps a radial slide and a vertical slide. The workspace is a cylindrical shell:

\[ \mathcal{W} = \{(r,\theta,z)\;|\; r_{\min} <= r <= r_{\max},\; 0 <= \theta < 2\pi,\; 0 <= z <= L_z\}. \]

Problem 2 (Mobility check): A serial industrial arm has 5 revolute joints. Using mobility arguments, compute its DOF.

Solution: Serial chain with \( n=5 \) single-DOF joints has \( M=n=5 \) by Section 2.

Problem 3 (SCARA area): A SCARA has planar link lengths \( l_1=0.5 \) m and \( l_2=0.3 \) m. Compute the planar workspace area.

Solution: Planar region is an annulus with radii \( r_{\max}=l_1+l_2=0.8 \), \( r_{\min}=|l_1-l_2|=0.2 \).

\[ A = \pi(r_{\max}^2 - r_{\min}^2) = \pi(0.8^2 - 0.2^2) = \pi(0.64 - 0.04) = 0.60\pi \approx 1.885\;\text{m}^2. \]

Problem 4 (Compactness ratio): For a cylindrical arm with \( r_{\min}=0 \), \( r_{\max}=1 \), \( L_z=1 \), compute the compactness ratio \( \rho = V_{\mathcal{W}}/V_{\text{bbox}} \).

Solution: Cylindrical volume: \( V_{\mathcal{W}} = \pi r_{\max}^2 L_z = \pi \). The tight bounding box has side lengths \( 2r_{\max} \times 2r_{\max} \times L_z \), so \( V_{\text{bbox}} = 4r_{\max}^2 L_z = 4 \).

\[ \rho = \frac{\pi}{4} \approx 0.785. \]

We classified common industrial arm structures by their joint sequences, proved how mobility follows from constraint counting, and derived simple workspace descriptions and volumes for Cartesian, cylindrical, spherical, SCARA, and articulated arms. These conceptual tools let you reason about what an industrial robot can do mechanically before learning the full kinematic mathematics in the next course.