After the era of mechanical automata (Lesson 1), robotics entered factories because post-war manufacturing demanded repeatability, speed, and worker safety. The first industrial robots appeared in the late 1950s–1960s, with programmable manipulators for tasks like die casting and spot welding. Key drivers were:

• Mass production pressure: large-volume, standardized products (especially automobiles).
• Safety: robots operate in hot, toxic, or high-force environments.
• Control + actuation maturity: servomechanisms and feedback control became reliable and cheap.
• Digital computing: numerical control (NC) and early microprocessors enabled reprogrammability.

flowchart TD
  A["Mechanical automata era"] --> B["Servo and NC advances (1940s-50s)"]
  B --> C["First programmable manipulators (late 1950s)"]
  C --> D["Unimate installed in auto plants (1960s)"]
  D --> E["Rapid adoption: welding, painting, assembly (1970s-80s)"]
  E --> F["Standardization + safety norms"]
  F --> G["Flexible automation and modern industrial arms"]
        

The shift from fixed automation to programmable robots can be summarized by the idea of a reconfigurable mechanical plant governed by feedback. If a robot joint position is \( q(t) \): and the commanded setpoint is \( q_d(t) \): then industrial robotics is largely about making the tracking error \( e(t)=q_d(t)-q(t) \): small and repeatable across millions of cycles.

Early industrial manipulators were typically hydraulic or electric. For a single rotary joint, the simplified rigid-body dynamics are \( J \ddot{q} + B\dot{q} = \tau \): where \( J \) is inertia, \( B \) viscous friction, and \( \tau \) actuator torque. Taking Laplace transforms:

\[ (Js^2 + Bs)Q(s) = \tau(s) \quad\Rightarrow\quad G(s)=\frac{Q(s)}{\tau(s)}=\frac{1}{Js^2+Bs}. \]

A standard industrial servo uses a PD law (very common in early robots): \( \tau = K_p e + K_d \dot{e} \): giving closed-loop error dynamics:

\[ J\ddot{e} + (B+K_d)\dot{e} + K_p e = 0. \]

Stability proof (energy/Lyapunov argument). Consider the Lyapunov function \( V(e,\dot{e})=\tfrac12 J\dot{e}^2 + \tfrac12 K_p e^2 \): which is positive definite for \( J>0, K_p>0 \): Its derivative along trajectories is

\[ \dot{V} = J\dot{e}\ddot{e} + K_p e\dot{e} = \dot{e}\big(J\ddot{e}+K_p e\big) = -(B+K_d)\dot{e}^2 \le 0, \]

since \( B+K_d>0 \): Therefore the equilibrium \( (e,\dot{e})=(0,0) \): is stable, and with standard invariance arguments, \( e(t)\to 0 \): as \( t\to\infty \): This simple servo analysis explains why industrial robots could reliably repeat taught motions.

Takeaway: the industrial revolution in robotics occurred not because kinematics were new, but because feedback actuation made complex linkages behave like accurate programmable machines.

Industrial adoption depends on measurable performance. Let the end-effector reach a target pose with actual position vectors \( \mathbf{x}_1,\dots,\mathbf{x}_N \):

Accuracy is the bias to the desired target \( \mathbf{x}_d \):

\[ \mathbf{b} = \frac{1}{N}\sum_{k=1}^N \mathbf{x}_k - \mathbf{x}_d, \quad \text{Accuracy} = \|\mathbf{b}\|. \]

Repeatability measures spread around the mean:

\[ \sigma_r^2 = \frac{1}{N-1}\sum_{k=1}^N \|\mathbf{x}_k-\bar{\mathbf{x}}\|^2, \quad \bar{\mathbf{x}}=\frac{1}{N}\sum_{k=1}^N \mathbf{x}_k. \]

Early robots often had modest accuracy but high repeatability; this matched tasks like spot welding where performing the same motion precisely mattered more than absolute geometric perfection.

Cycle time and throughput. If a task requires a motion of duration \( T_m \): and a dwell/processing time \( T_p \): then the cycle time is \( T_c=T_m+T_p \): and throughput is \( \lambda = 1/T_c \): parts per second. Industrial lines compare robots to humans via \( \lambda \) and variability.

Factory managers cared about uptime. Define mean time between failures \( \text{MTBF} \): and mean time to repair \( \text{MTTR} \): Then the steady-state availability is

\[ A = \frac{\text{MTBF}}{\text{MTBF}+\text{MTTR}}. \]

Derivation. In a renewal view, each operating-repair cycle has expected length \( \text{MTBF}+\text{MTTR} \): and expected operating time \( \text{MTBF} \): so the long-run fraction of time operating is their ratio, giving the formula above.

With multiple robots in series, line availability approximately multiplies: if robots have availabilities \( A_1,\dots,A_M \):

\[ A_{\text{line}} \approx \prod_{i=1}^{M} A_i, \]

explaining why even small reliability gains strongly affected adoption in high-volume factories.

Let the robot cell cost be \( C_0 \): (purchase + integration), annual maintenance cost \( C_m \): and annual labor savings \( S \): relative to manual operation. With discount rate \( r \): and lifetime \( n \): years, the net present value is

\[ \text{NPV} = -C_0 + \sum_{k=1}^{n}\frac{S-C_m}{(1+r)^k}. \]

The break-even horizon \( k^\star \): is the earliest integer such that \( \text{NPV}(k^\star)\ge 0 \):

\[ C_0 \le (S-C_m)\sum_{k=1}^{k^\star}(1+r)^{-k} = (S-C_m)\frac{1-(1+r)^{-k^\star}}{r}. \]

In the 1960s–1980s, rising wages and improved robot reliability pushed \( S \) up and \( C_m \) down, shrinking \( k^\star \) to 1–3 years for many tasks, triggering rapid adoption.

Early industrial robots were programmed by demonstration: an operator guided the arm through key poses, stored them, and the robot replayed them under servo control. A common primitive is point-to-point (PTP) motion: for joint coordinate \( q(t) \): moving from \( q_0 \) to \( q_f \) over duration \( T \): a cubic polynomial ensures zero start/end velocity:

\[ q(t)=a_0+a_1 t+a_2 t^2+a_3 t^3,\quad 0\le t\le T, \]

Boundary conditions:

\[ q(0)=q_0,\;\dot{q}(0)=0,\; q(T)=q_f,\;\dot{q}(T)=0. \]

Solving gives \( a_0=q_0,\; a_1=0,\; a_2=3(q_f-q_0)/T^2,\; a_3=-2(q_f-q_0)/T^3 \): so

\[ q(t)=q_0 + 3\Delta\left(\frac{t}{T}\right)^2 - 2\Delta\left(\frac{t}{T}\right)^3, \quad \Delta=q_f-q_0. \]

This “smooth PTP” curve is historically important because it matches how first-generation robots executed taught paths: store points, interpolate, and servo-track.

flowchart TD
  S["Operator teaches key points q0, qf"] --> M["Store points in controller memory"]
  M --> I["Interpolate smooth PTP trajectory"]
  I --> C["Servo tracking (PD/PID loops)"]
  C --> R["Repeat cycle for production"]
        

The following snippets compute \( q(t) \) for a single joint using the cubic PTP formula. (Industrial robots apply this per joint, then track each trajectory with servo control.)

7.1 Python (NumPy)

import numpy as np

def cubic_ptp(q0, qf, T, t):
    """Cubic point-to-point joint interpolation."""
    t = np.clip(t, 0.0, T)
    Delta = qf - q0
    s = t / T
    return q0 + 3*Delta*s**2 - 2*Delta*s**3

# Example usage
q0, qf, T = 0.2, 1.0, 2.0
ts = np.linspace(0, T, 50)
qs = cubic_ptp(q0, qf, T, ts)
print(qs[:5])
      

7.2 C++ (Eigen optional)

#include <iostream>
#include <vector>
#include <algorithm>

double cubic_ptp(double q0, double qf, double T, double t){
    t = std::max(0.0, std::min(t, T));
    double Delta = qf - q0;
    double s = t / T;
    return q0 + 3.0*Delta*s*s - 2.0*Delta*s*s*s;
}

int main(){
    double q0=0.2, qf=1.0, T=2.0;
    for(int i=0;i<5;i++){
        double t = i*(T/4.0);
        std::cout << cubic_ptp(q0,qf,T,t) << std::endl;
    }
    return 0;
}
      

7.3 Java

public class CubicPTP {
    public static double cubicPTP(double q0, double qf, double T, double t){
        t = Math.max(0.0, Math.min(t, T));
        double Delta = qf - q0;
        double s = t / T;
        return q0 + 3.0*Delta*s*s - 2.0*Delta*s*s*s;
    }

    public static void main(String[] args){
        double q0=0.2, qf=1.0, T=2.0;
        for(int i=0;i<5;i++){
            double t = i*(T/4.0);
            System.out.println(cubicPTP(q0,qf,T,t));
        }
    }
}
      

7.4 MATLAB / Simulink Script

function q = cubic_ptp(q0, qf, T, t)
    % Cubic point-to-point joint interpolation
    t = min(max(t,0),T);
    Delta = qf - q0;
    s = t / T;
    q = q0 + 3*Delta*s.^2 - 2*Delta*s.^3;
end

% Example usage
q0 = 0.2; qf = 1.0; T = 2.0;
ts = linspace(0,T,50);
qs = arrayfun(@(tt)cubic_ptp(q0,qf,T,tt), ts);
disp(qs(1:5));
      

Note: In historical controllers, these trajectories were executed by embedded servo loops. Modern toolchains (e.g., ROS2, vendor SDKs) automate interpolation, but the core idea remains unchanged.

Problem 1 (Servo Stability): A single robot joint is modeled by \( J\ddot{q}+B\dot{q}=\tau \): and controlled by \( \tau=K_p(q_d-q)+K_d(\dot{q}_d-\dot{q}) \): with constant setpoint \( q_d \): Show that tracking is asymptotically stable if \( K_p>0 \) and \( K_d>-B \):

Solution: Let \( e=q_d-q \): then \( \dot{e}=-\dot{q} \) and the closed-loop error dynamics are

\[ J\ddot{e} + (B+K_d)\dot{e} + K_p e = 0. \]

With Lyapunov function \( V=\tfrac12 J\dot{e}^2+\tfrac12 K_p e^2 \): we get

\[ \dot{V}=-(B+K_d)\dot{e}^2. \]

If \( K_p>0 \) and \( B+K_d>0 \), then \( V \) is positive definite and \( \dot{V}\le 0 \): the only invariant set where \( \dot{V}=0 \) is \( \dot{e}=0 \), which implies \( e=0 \): hence \( e(t)\to 0 \):

Problem 2 (Availability Calculation): A robot has \( \text{MTBF}=2000\text{ hr} \): and \( \text{MTTR}=10\text{ hr} \): (a) compute availability; (b) compute approximate line availability for three identical robots in series.

Solution:

\[ A=\frac{2000}{2000+10}=\frac{2000}{2010}\approx 0.9950. \]

For three in series:

\[ A_{\text{line}}\approx A^3 \approx 0.9950^3 \approx 0.9851. \]

Problem 3 (Break-Even Time): A robot cell costs \( C_0=250{,}000 \) euros. Annual savings are \( S=110{,}000 \) euros and maintenance \( C_m=20{,}000 \) euros. With discount rate \( r=0.05 \): estimate the smallest \( k^\star \) such that NPV is nonnegative.

Solution: Net annual benefit is \( S-C_m=90{,}000 \): We need

\[ 250000 \le 90000\frac{1-(1.05)^{-k^\star}}{0.05} = 1{,}800{,}000\big(1-(1.05)^{-k^\star}\big). \]

Divide both sides: \( 250000/1{,}800{,}000 \approx 0.1389 \): so \( 1-(1.05)^{-k^\star} \ge 0.1389 \Rightarrow (1.05)^{-k^\star}\le 0.8611 \):

\[ k^\star \ge \frac{\ln(0.8611)}{\ln(1/1.05)} \approx \frac{-0.1495}{-0.0488} \approx 3.06. \]

Thus break-even occurs just after year 3, so \( k^\star=4 \) years.

Problem 4 (Cubic PTP Verification): Verify that \( q(t)=q_0 + 3\Delta(t/T)^2 - 2\Delta(t/T)^3 \): satisfies the four boundary conditions in Section 6.

Solution: At \( t=0 \): \( q(0)=q_0 \): since the polynomial terms vanish. Its derivative is \( \dot{q}(t)= 6\Delta t/T^2 - 6\Delta t^2/T^3 \): so \( \dot{q}(0)=0 \): At \( t=T \):

\[ q(T)=q_0+3\Delta-2\Delta=q_0+\Delta=q_f, \quad \dot{q}(T)=6\Delta/T-6\Delta/T=0. \]

The industrial robotics revolution was driven by manufacturing needs and enabled by reliable servomechanisms, digital control, and teach-and-playback programming. We modeled a joint servo, proved PD stability, and connected adoption to metrics like repeatability, availability, and ROI. These ideas set up Lesson 3, where robotics expands beyond factories toward service and medical settings.