After industrial robots proved their value in repeatable, structured tasks, researchers and companies pursued robots that could operate in human environments. Two major families emerged:

• Service robots: robots that assist humans in non-industrial settings (homes, offices, transport hubs, agriculture, logistics, etc.).
• Medical robots: robots that support diagnosis, surgery, rehabilitation, or hospital logistics—often involving direct physical contact with humans.

The key difference from industrial settings is uncertainty and human presence. From a control perspective, this required: (i) robust low-level stability, (ii) safe interaction characterized by compliant behavior, and (iii) high reliability in partially known environments.

flowchart TD
  I["Industrial robots (1970s-1980s)"] --> D["Drivers for expansion"]
  D --> U["Unstructured environments"]
  D --> H["Human-robot proximity"]
  D --> C["Cheaper sensors + computing"]
  U --> S["Service robots (1990s- )"]
  H --> M["Medical robots (1980s- )"]
  S --> Ex1["Home + public assistance"]
  M --> Ex2["Teleop + surgical + rehab"]
        

The rise of service and medical robots happened in overlapping waves:

1. Hospital logistics and assistance (late 1980s–1990s): early mobile robots delivered supplies or guided visitors.
2. Domestic service robots (mid-1990s–2000s): consumer robots such as autonomous vacuum cleaners gave robotics a mass-market footprint.
3. Robot-assisted surgery and intervention (mid-1980s–2000s): starting with experiments on industrial arms and culminating in commercial surgical teleoperation platforms.
4. Rehabilitation and assistive robots (1990s–present): robots for therapy, mobility support, and prosthetics.

A major intellectual shift was to view robots as cyber-physical systems embedded in human workflows, rather than isolated machines. This forced advances in safe control and human-in-the-loop design.

In unstructured settings, safety and performance are constrained by interaction forces and delay. We model a robot joint or actuator by a simplified LTI plant (students know this from Linear Control):

\[ G(s) = \frac{K}{(s + a)(s + b)}, \quad K > 0,\; a > 0,\; b > 0 \]

Stable tracking is necessary but not sufficient. For physical human interaction, we also require bounded contact forces, typically enforced by compliant or impedance-like behavior. A minimal interaction model is:

\[ F(t) = k_h\,(x(t) - x_h(t)) + d_h\,(\dot{x}(t) - \dot{x}_h(t)), \quad k_h > 0,\; d_h > 0 \]

Here \( x \) is robot position and \( x_h \) is human/environment position. Even without full robot kinematics, this 1-DOF abstraction already shows why stability + damping matter.

Many landmark medical robots were teleoperated: a surgeon (master) commands a robot (slave). A standard linear architecture is:

flowchart TD
  M["Master device"] --> C["Controller C(s)"]
  C --> D["Comm delay e^{-sT}"]
  D --> P["Slave robot G(s)"]
  P --> E["Environment/Human"]
  E -->|force feedback| P
  P -->|measured force| D
  D --> C
  C --> M
  Filt["Tremor filter H(s)"] --> C
        

Communication delay \( T \) threatens stability. A classical model uses a delayed feedback loop:

\[ u(s) = C(s)\left(x_m(s) - e^{-sT}x_s(s)\right) \]

where \( x_m \) is master motion and \( x_s \) slave motion. The closed-loop transfer is:

\[ \frac{x_s(s)}{x_m(s)} = \frac{e^{-sT} C(s)G(s)} {1 + e^{-sT} C(s)G(s)} \]

Stability depends on the Nyquist condition for the open-loop \( L(s)=e^{-sT}C(s)G(s) \). Because \( e^{-sT} \) adds phase lag, medical robots required careful controller design and, historically, motivated work on passivity-based teleoperation.

A system with input \( u(t) \) and output \( y(t) \) is passive if it cannot generate net energy:

\[ \int_{0}^{t} u(\tau)y(\tau)\,d\tau \ge -E_0 \quad \forall t \ge 0 \]

Teleoperation stability theorem (informal): If both the master-side controller and the slave-side robot/environment are passive, then their feedback interconnection is stable, even with bounded delays.

Proof idea:

1. Let master-side be passive with supply rate \( u_my_m \) and stored energy \( E_m \).
2. Let slave+environment be passive with supply rate \( u_sy_s \) and energy \( E_s \).
3. In interconnection, power into one side equals negative power out of the other, so total energy satisfies:

\[ E(t) = E_m(t) + E_s(t), \quad \dot{E}(t) \le u_my_m + u_sy_s = 0 \]

Hence \( E(t) \) is non-increasing and bounded below, implying bounded signals and Lyapunov stability of the interconnected system. This argument guided early surgical teleoperators toward passive filters and impedance-limited actuation.

A practical medical-robot advantage is filtering high-frequency hand tremor. A standard first-order low-pass filter:

\[ H(s) = \frac{1}{1 + s\tau}, \quad \tau > 0 \]

has frequency response magnitude \( |H(j\omega)| = \frac{1}{\sqrt{1+(\omega\tau)^2}} \). If tremor is concentrated around \( \omega_t \) and desired command bandwidth is \( \omega_c \ll \omega_t \), choose a cutoff \( \omega_f \) with \( \omega_c < \omega_f < \omega_t \).

Motion scaling (master motion amplified or reduced) is often modeled as:

\[ x_s(t) = \alpha\, (H * x_m)(t),\quad 0 < \alpha < 1 \]

where \( * \) denotes convolution. The scalar \( \alpha \) improves precision by shrinking movements, another hallmark of robot-assisted surgery.

This history lesson uses small control examples. Later chapters will introduce full robotics stacks (ROS/ROS2, Gazebo, sensor libraries). Relevant libraries you will see later include: Python: numpy, scipy, roboticstoolbox; C++: Eigen, Orocos/KDL; Java: EJML, ROS Java clients; MATLAB: Control System Toolbox, Robotics System Toolbox, Simulink.

7.1 Python: Fit a Logistic Adoption Curve + Tremor Filter

import numpy as np
from scipy.optimize import curve_fit
from scipy import signal
import matplotlib.pyplot as plt

# --- Logistic model for adoption of service robots (historical trend idea) ---
def logistic(t, K, r, t0):
    return K / (1 + np.exp(-r*(t - t0)))

# synthetic historical data (replace with real data if desired)
t = np.array([0, 5, 10, 15, 20, 25, 30])   # years since baseline
y = np.array([0.5, 1.2, 2.8, 6.0, 11.0, 17.5, 22.0])  # arbitrary units

popt, _ = curve_fit(logistic, t, y, p0=[25, 0.2, 15])
K_hat, r_hat, t0_hat = popt
print("Estimated K, r, t0:", popt)

tt = np.linspace(0, 30, 300)
plt.plot(t, y, 'o', label="data")
plt.plot(tt, logistic(tt, *popt), label="logistic fit")
plt.xlabel("years"); plt.ylabel("adoption (scaled)")
plt.legend(); plt.show()

# --- Tremor filtering example ---
fs = 200.0
t2 = np.arange(0, 2, 1/fs)
# intended slow motion + 10 Hz tremor
x_m = 0.5*np.sin(2*np.pi*0.5*t2) + 0.05*np.sin(2*np.pi*10*t2)

tau = 0.08  # time constant
b, a = signal.butter(1, 1/(2*np.pi*tau) / (fs/2))  # 1st-order low-pass
x_filt = signal.filtfilt(b, a, x_m)

plt.plot(t2, x_m, label="raw master")
plt.plot(t2, x_filt, label="filtered")
plt.legend(); plt.show()
      

7.2 C++: Discrete Low-Pass Filter for Master Commands

#include <iostream>
#include <vector>

class LowPassFilter {
public:
    LowPassFilter(double dt, double tau)
        : alpha(dt/(tau + dt)), y_prev(0.0) {}

    double step(double x) {
        double y = alpha * x + (1.0 - alpha) * y_prev;
        y_prev = y;
        return y;
    }
private:
    double alpha;
    double y_prev;
};

int main() {
    double dt = 0.005;   // 200 Hz
    double tau = 0.08;   // time constant
    LowPassFilter lpf(dt, tau);

    std::vector<double> x_m = {0.0, 0.1, 0.3, 0.2, 0.5, 0.4}; // example samples
    for (double x : x_m) {
        std::cout << lpf.step(x) << std::endl;
    }
    return 0;
}
      

7.3 Java: Same Filter Pattern

public class LowPassFilter {
    private final double alpha;
    private double yPrev = 0.0;

    public LowPassFilter(double dt, double tau) {
        this.alpha = dt / (tau + dt);
    }

    public double step(double x) {
        double y = alpha * x + (1.0 - alpha) * yPrev;
        yPrev = y;
        return y;
    }

    public static void main(String[] args) {
        LowPassFilter lpf = new LowPassFilter(0.005, 0.08);
        double[] samples = {0.0, 0.1, 0.3, 0.2, 0.5, 0.4};
        for (double s : samples) {
          System.out.println(lpf.step(s));
        }
    }
}
      

7.4 MATLAB / Simulink: Filter + Teleop Plant

% First-order low-pass for tremor suppression
dt = 0.005; tau = 0.08;
alpha = dt/(tau+dt);

x_m = [0 0.1 0.3 0.2 0.5 0.4];
y = zeros(size(x_m));
for k = 2:length(x_m)
    y(k) = alpha*x_m(k) + (1-alpha)*y(k-1);
end
disp(y);

% Continuous-time view
s = tf('s');
H = 1/(1 + s*tau);
G = 5/((s+2)*(s+8));  % example slave model
CL = feedback(H*G, 1); % filtered tracking
step(CL);
      

Simulink equivalent: use Transfer Fcn blocks for \( H(s) \) and \( G(s) \), a Transport Delay block for \( e^{-sT} \), and a Sum block for the error.

Problem 1 (Logistic Adoption): Service-robot adoption is often modeled by a logistic differential equation \( \dot{y} = r y \left(1 - \frac{y}{K}\right) \), with \( r > 0, K > 0 \). Derive the closed-form solution given initial condition \( y(0)=y_0 \).

Solution:

Separate variables:

\[ \frac{dy}{y(1-y/K)} = r\,dt \]

Use partial fractions: \( \frac{1}{y(1-y/K)} = \frac{1}{y} + \frac{1}{K-y} \). Then integrate:

\[ \int \left(\frac{1}{y} + \frac{1}{K-y}\right)dy = rt + c \;\Rightarrow\; \ln\frac{y}{K-y} = rt + c \]

Exponentiate and solve for \( y(t) \):

\[ \frac{y}{K-y} = A e^{rt} \;\Rightarrow\; y(t) = \frac{K}{1 + A^{-1}e^{-rt}} \]

Apply \( y(0)=y_0 \) gives \( A = \frac{y_0}{K-y_0} \), hence:

\[ y(t) = \frac{K}{1 + \left(\frac{K-y_0}{y_0}\right)e^{-rt}} \]

Problem 2 (Teleop Delay Margin): Let the open-loop teleoperation model be \( L(s)=e^{-sT}C(s)G(s) \). Show that if the non-delayed loop \( C(s)G(s) \) has phase margin \( \phi_m \), then delays satisfying \( T < \phi_m/\omega_{gc} \) preserve stability, where \( \omega_{gc} \) is the gain crossover frequency.

Solution:

At crossover, \( |C(j\omega_{gc})G(j\omega_{gc})|=1 \), and stability requires phase > \( -\pi \). Delay adds phase \( -\omega_{gc}T \). Thus stability holds if:

\[ -\pi + \phi_m - \omega_{gc}T > -\pi \;\Rightarrow\; \omega_{gc}T < \phi_m \;\Rightarrow\; T < \frac{\phi_m}{\omega_{gc}} \]

Problem 3 (Tremor Attenuation): A surgeon’s tremor is centered near \( f_t = 10\; \text{Hz} \). You design a first-order low-pass \( H(s)=1/(1+s\tau) \). Choose \( \tau \) so that tremor amplitude is reduced by at least a factor of 5 while keeping command bandwidth up to \( f_c = 1\; \text{Hz} \) almost unaffected (say <10% attenuation).

Solution:

Tremor attenuation requirement: \( |H(j\omega_t)| \le 1/5 \), so

\[ \frac{1}{\sqrt{1+(\omega_t\tau)^2}} \le \frac{1}{5} \;\Rightarrow\; 1+(\omega_t\tau)^2 \ge 25 \;\Rightarrow\; \tau \ge \frac{\sqrt{24}}{\omega_t} \]

With \( \omega_t = 2\pi f_t = 20\pi \) rad/s:

\[ \tau \ge \frac{\sqrt{24}}{20\pi} \approx 0.078\; \text{s} \]

Command-bandwidth condition at \( \omega_c=2\pi f_c = 2\pi \) rad/s: require \( |H(j\omega_c)| \ge 0.9 \):

\[ \frac{1}{\sqrt{1+(\omega_c\tau)^2}} \ge 0.9 \;\Rightarrow\; (\omega_c\tau)^2 \le \frac{1}{0.9^2}-1 \approx 0.234 \;\Rightarrow\; \tau \le \frac{\sqrt{0.234}}{\omega_c} \approx 0.077\; \text{s} \]

The bounds almost meet; a practical compromise is \( \tau \approx 0.078\; \text{s} \) and accepting slight command attenuation, or using a higher-order filter later.

Problem 4 (Energy Argument): Suppose a robot interacting with a human environment is modeled as a passive mechanical impedance \( Z(s) \). Show that adding a strictly proper stable low-pass filter \( H(s)=1/(1+s\tau) \) in series preserves passivity.

Solution:

A stable strictly proper transfer with nonnegative real part (positive real) preserves passivity under series connection of impedances. Since \( H(s) \) is stable and \( \Re(H(j\omega)) = \frac{1}{1+(\omega\tau)^2} \ge 0 \), it is positive real. Series of positive-real (passive) elements is positive real, hence passive. Therefore energy cannot increase, and safe interaction is preserved.

Service and medical robots emerged when robotics left structured factories. Key historical progress depended on control-theoretic advances: stability under delay, safe physical interaction, and tremor/precision enhancement via filtering and scaling. These ideas set the stage for later chapters on hardware, sensing, and software stacks.