In physical human–robot or robot–environment interaction, we are not only interested in tracking a trajectory, but also in how forces and motions relate at the contact. Two dual viewpoints are standard:

• Impedance control: The robot is commanded to behave like a target mechanical impedance. Conceptually, motion deviations generate forces according to a desired law (e.g., mass–spring–damper).
• Admittance control: The robot is commanded to behave like a target mechanical admittance, i.e. the inverse of impedance. Conceptually, sensed forces generate motion commands.

Let \( F(t) \) be the interaction force and \( v(t) = \dot{x}(t) \) the contact-point velocity. The mechanical impedance and admittance in the Laplace domain are defined as

\[ Z(s) = \frac{F(s)}{V(s)}, \qquad Y(s) = \frac{V(s)}{F(s)} = \frac{1}{Z(s)}. \]

An impedance controller aims to render a desired mapping \( Z_d(s) \) at the end-effector; an admittance controller aims to render \( Y_d(s) = Z_d(s)^{-1} \). In a 1-DOF translational mass–spring–damper,

\[ F(t) = M \ddot{x}(t) + D \dot{x}(t) + K x(t) \]

and in the Laplace domain (with zero initial conditions),

\[ Z(s) = \frac{F(s)}{V(s)} = \frac{M s^2 X(s) + D s X(s) + K X(s)}{s X(s)} = M s + D + \frac{K}{s}. \]

In both impedance and admittance control we typically choose a target triplet \( (M_d, D_d, K_d) \) and design the controller such that the robot as seen from the environment approximates this behavior. The crucial difference lies in:

• What we measure: motion vs force,
• What we command: force/torque vs position/velocity,
• Where we place high-gain loops: torque loop vs position loop.

Consider a 1-DOF translational end-effector interacting along coordinate \( x \) with an environment modeled as a linear impedance. The robot endpoint has equivalent mass \( M_r \), viscous damping \( D_r \), and (possibly small) structural stiffness \( K_r \). The environment has stiffness \( K_e \) and damping \( D_e \). The interaction force is

\[ F(t) = K_e \bigl(x(t) - x_e\bigr) + D_e \bigl(\dot{x}(t) - \dot{x}_e\bigr), \]

where \( x_e \) is the environment rest position (often constant) and \( \dot{x}_e = 0 \). The robot's joint-space dynamics projected to the task coordinate (assuming previous lessons' derivations) can be written as

\[ M_r \ddot{x}(t) + D_r \dot{x}(t) + K_r x(t) = F_u(t) + F(t), \]

where \( F_u(t) \) is the control-generated generalized force at the task coordinate (coming from joint torques \( \tau \) via Jacobian transpose).

The desired interaction behavior w.r.t. a reference trajectory \( x_d(t) \) is typically specified as

\[ F(t) = M_d \bigl(\ddot{x}(t) - \ddot{x}_d(t)\bigr) + D_d \bigl(\dot{x}(t) - \dot{x}_d(t)\bigr) + K_d \bigl(x(t) - x_d(t)\bigr), \]

which corresponds to the target impedance

\[ Z_d(s) = M_d s + D_d + \frac{K_d}{s}. \]

Realizing this target mapping can be approached in two dual ways:

• Impedance control: compute \( F_u \) so that the force–motion relation of the closed-loop robot approximates \( Z_d \).
• Admittance control: compute a motion command (e.g., virtual position) from the measured force according to the inverse relation \( Y_d = Z_d^{-1} \), and rely on a stiff inner position servo.

A typical 1-DOF impedance controller (in task space) computes a commanded interaction force

\[ F_c(t) = M_d \bigl(\ddot{x}_d(t) - \ddot{x}(t)\bigr) + D_d \bigl(\dot{x}_d(t) - \dot{x}(t)\bigr) + K_d \bigl(x_d(t) - x(t)\bigr). \]

The joint torques are then

\[ \tau = J(q)^{\top} F_c + \tau_{\text{comp}}, \]

where \( \tau_{\text{comp}} \) denotes gravity and dynamics compensation terms derived previously. Assuming ideal inner torque tracking (high bandwidth), we can approximate \( F_u \approx F_c \) in the task dynamics:

\[ M_r \ddot{x} + D_r \dot{x} + K_r x = F_c + F. \]

Substituting the expression of \( F_c \) and rearranging yields the closed-loop relation between \( F \) and \( (x - x_d) \). For example, in the simple case \( x_d \) constant and negligible structural stiffness \( K_r \approx 0 \), one obtains, after algebra,

\[ F(s) \approx \bigl(M_d s + D_d + \tfrac{K_d}{s}\bigr)\bigl(X(s) - X_d(s)\bigr) = Z_d(s)\bigl(X(s) - X_d(s)\bigr), \]

provided that the physical robot dynamics \( M_r, D_r \) are dominated by the control action (i.e., sufficiently high bandwidth). Thus, from the environment viewpoint, the robot behaves approximately as the target impedance \( Z_d(s) \).

Key features of impedance control:

• It primarily relies on motion sensing (encoders) and torque actuation.
• It remains conceptually well-defined without force sensing (though force feedback improves performance).
• If \( Z_d(s) \) is passive, the closed-loop interaction with any passive environment is stable in the ideal continuous-time limit.

An admittance controller uses the measured interaction force \( F(t) \) as input and produces a commanded motion \( x_c(t) \) to a lower-level position servo. A standard form is

\[ M_d \ddot{x}_c(t) + D_d \dot{x}_c(t) + K_d \bigl(x_c(t) - x_d(t)\bigr) = F(t), \]

where \( x_d(t) \) is a nominal reference (e.g., free-space trajectory) and \( x_c(t) \) is the modified command. The inner position loop tries to enforce

\[ x(t) \approx x_c(t). \]

Assuming ideal position tracking (high-gain inner loop), the actual motion satisfies the same differential equation as \( x_c(t) \), so in the Laplace domain

\[ X(s) \approx X_c(s), \qquad \bigl(M_d s^2 + D_d s + K_d\bigr)\bigl(X(s) - X_d(s)\bigr) = F(s). \]

Hence, the realized admittance between force input and motion deviation is

\[ Y_d(s) = \frac{X(s) - X_d(s)}{F(s)} = \frac{1}{M_d s^2 + D_d s + K_d}. \]

In terms of velocity,

\[ \frac{V(s)}{F(s)} = s Y_d(s) = \frac{s}{M_d s^2 + D_d s + K_d}, \]

which is the inverse of the target impedance \( Z_d(s) \) (up to reference-shift details).

Key features of admittance control:

• It requires force sensing with sufficient bandwidth and low noise.
• It uses a stiff inner position servo (common in industrial robots).
• Discrete-time implementation can reduce passivity margins; stability depends on the sampling and on the chosen \( M_d, D_d, K_d \).

Consider the environment impedance in Laplace domain:

\[ Z_e(s) = D_e + \frac{K_e}{s}. \]

In impedance control, the robot behaves approximately as \( Z_d(s) \) in series with the environment. The overall interaction between the relative motion \( x - x_e \) and the force \( F \) is

\[ Z_{\text{tot}}(s) = Z_d(s) + Z_e(s). \]

For a passive environment (e.g., physical spring–damper with \( D_e > 0, K_e \ge 0 \)) and a passive target impedance (\( M_d > 0, D_d > 0, K_d \ge 0 \)), \( Z_{\text{tot}}(s) \) remains passive, and the interaction is stable in the ideal continuous-time limit.

In admittance control, the situation is slightly more subtle. The environment still supplies \( F = Z_e(s) V(s) \), but the robot's realized admittance is \( Y_d(s) \). Combining the two gives

\[ V(s) = Y_d(s) F(s), \qquad F(s) = Z_e(s) V(s), \]

so that the closed-loop characteristic is determined by

\[ V(s) = Y_d(s) Z_e(s) V(s) \quad \Rightarrow \quad \bigl(1 - Y_d(s) Z_e(s)\bigr)V(s) = 0. \]

Non-trivial solutions require

\[ 1 - Y_d(s) Z_e(s) = 0, \]

so the closed-loop poles are roots of \( 1 - Y_d(s) Z_e(s) \). Even if \( Y_d \) and \( Z_e \) are individually passive, the discretization of \( Y_d \) and inner-loop dynamics can lead to loss of passivity and instabilities in practice. This is one of the reasons why admittance control is more sensitive to sampling, delays, and force sensor noise.

The choice between impedance and admittance therefore depends on:

• Hardware type (torque-controlled vs position-controlled robot).
• Quality and location of force sensing.
• Environment stiffness and inertia.
• Desired interaction type (e.g., compliant surface following vs hand-guiding a heavy robot).

A linear time-invariant system with transfer function \( Z(s) \) is (strictly) passive if it is positive real: all poles lie in the closed left half-plane, and

\[ \Re\bigl\{Z(j\omega)\bigr\} \ge 0 \quad \text{for all } \omega \in \mathbb{R}. \]

For the mass–spring–damper impedance

\[ Z_d(s) = M_d s + D_d + \frac{K_d}{s}, \]

the passivity conditions in continuous time reduce to

\[ M_d > 0,\quad D_d > 0,\quad K_d \ge 0. \]

Under ideal torque control, these conditions guarantee stable interaction with any passive environment (also modeled by a positive-real impedance).

In admittance control, positive-realness of \( Y_d(s) \) (inverse of \( Z_d(s) \)) is more delicate, especially after discretization. A common tuning guideline (in 1-DOF) is:

• Choose \( M_d \) not too small, so that the virtual inertia filters high-frequency force sensor noise.
• Choose \( D_d \) sufficiently large such that the continuous-time damping ratio

  \[ \zeta = \frac{D_d}{2\sqrt{M_d K_d}} \]

  satisfies \( \zeta \ge 1 \) (overdamped or critically damped).
• Ensure that the closed-loop poles of the discrete-time implementation are well inside the unit circle by relating the sampling period to the natural frequency

  \[ \omega_n = \sqrt{\frac{K_d}{M_d}} \]

  and maintaining \( \omega_n T_s \ll 1 \).

These guidelines motivate the design heuristics discussed next.

The following decision flow summarizes typical guidelines. It assumes you already know how to implement both impedance and admittance structures from previous lessons; here we focus on architectural choice.

flowchart TD
  START["Start: Need compliant interaction"] --> LOOP["Inner actuation type?"]
  LOOP -->|Torque or current control available| TORQUE["Robot behaves like force source"]
  LOOP -->|Only stiff position control| POS["Robot behaves like motion source"]

  TORQUE --> ENV1["Environment mainly passive, \nunknown stiffness"]
  POS --> ENV2["Environment mainly stiff \nand well known?"]

  ENV1 --> IMP1["Prefer impedance control with passive Z_d"]
  ENV2 -->|yes| ADM1["Prefer admittance \ncontrol with \nforce sensor"]
  ENV2 -->|no| MIX["Consider impedance \nor hybrid with \nlimited admittance"]

  IMP1 --> TUNE1["Tune Md, Dd, Kd \nfor stability \nand performance"]
  ADM1 --> TUNE2["Tune Md, Dd, Kd \nand sampling for \ndiscrete time"]
  MIX --> TUNE3["Analyze hardware \nlimits and possibly \nreduce bandwidth"]
        

Rule-of-thumb summary:

• If you have torque-controlled joints and possibly no high-quality force sensor, impedance control is often the primary choice.
• If you have a stiff industrial arm with an excellent force/torque sensor mounted at the wrist, and the inner loop is position-controlled, admittance control is often more practical.
• For uncertain or varying environments, passivity arguments favor impedance control with conservative \( M_d, D_d, K_d \).
• For hand-guiding or cooperative manipulation of a heavy robot, admittance control is convenient: human forces become motion commands.

A high-level block representation of both architectures highlights the structural difference in signal flow.

flowchart LR
  subgraph IMP["Impedance architecture"]
    Xd["Desired motion x_d"] --> IMP_CTRL["Impedance law (uses x, xdot)"]
    X_MEAS["Measured motion x"] --> IMP_CTRL
    IMP_CTRL --> TAU_CMD["Joint torques"]
    TAU_CMD --> ROBOT1["Robot mechanics"]
    ROBOT1 --> ENV1["Environment"]
    ENV1 --> F_INT1["Interaction force F"]
    F_INT1 --> ROBOT1
  end

  subgraph ADM["Admittance architecture"]
    Xd2["Desired motion x_d"] --> SUMREF["Sum with virtual motion"]
    F_INT2["Interaction force F"] --> ADM_CTRL["Admittance law"]
    ADM_CTRL --> SUMREF
    SUMREF --> X_CMD["Position command x_c"]
    X_CMD --> POS_SERVO["Inner position loop"]
    POS_SERVO --> ROBOT2["Robot mechanics"]
    ROBOT2 --> ENV2["Environment"]
    ENV2 --> F_INT2
  end
        

In impedance control the outer loop modulates torques, in admittance control it modulates motion commands. This has strong implications for numerical conditioning and saturation:

• In impedance control, torque saturation limits the maximum force that can be exerted for a given motion deviation.
• In admittance control, position and velocity limits constrain the motion generated by a given sensed force.

We now implement a simple discrete-time simulation of a 1-DOF robot endpoint in contact with a spring–damper environment, using both impedance and admittance control. We focus on the main loops; complete robot dynamics were discussed in earlier chapters.

9.1 Python Implementation (NumPy, basic integration)

Python is well-suited for prototyping. Here we use numpy as a numerical backbone; in a real setup, this would be embedded in a ROS or simulation framework.

import numpy as np

# Simulation parameters
dt = 0.001
T  = 5.0
N  = int(T / dt)

# Robot and environment
M_r = 5.0   # robot reflected mass
D_r = 2.0   # robot structural damping

K_e = 500.0  # environment stiffness
D_e = 10.0   # environment damping

# Desired impedance parameters
M_d = 2.0
D_d = 30.0
K_d = 200.0

# Reference motion: constant position
x_d = 0.05  # 5 cm into the environment

# Data arrays
t  = np.linspace(0.0, T, N)
x  = np.zeros(N)
v  = np.zeros(N)
F  = np.zeros(N)     # interaction force
x_c = np.zeros(N)    # for admittance
mode = "impedance"   # or "admittance"

def environment_force(xi, vi):
    # xi: end-effector position, vi: velocity
    return K_e * xi + D_e * vi

for k in range(N - 1):
    # Interaction force from environment
    F[k] = environment_force(x[k], v[k])

    if mode == "impedance":
        # Impedance control: compute control force F_u
        e  = x_d - x[k]
        ed = 0.0 - v[k]  # desired velocity = 0
        # Discrete approximation of acceleration error is omitted; we use PD + stiffness
        F_u = K_d * e + D_d * ed

        # Robot dynamics: M_r * a = F_u + F
        a = (F_u + F[k] - D_r * v[k]) / M_r

        # Euler integration
        v[k+1] = v[k] + dt * a
        x[k+1] = x[k] + dt * v[k]

    elif mode == "admittance":
        # Admittance control: map force to virtual position x_c
        if k == 0:
            x_c[k] = 0.0
            v_c = 0.0
        else:
            v_c = (x_c[k] - x_c[k-1]) / dt

        # Admittance dynamics in discrete time (explicit Euler)
        # M_d * a_c + D_d * v_c + K_d * (x_c - x_d) = F
        a_c = (F[k] - D_d * v_c - K_d * (x_c[k] - x_d)) / M_d
        v_c_new = v_c + dt * a_c
        x_c[k+1] = x_c[k] + dt * v_c_new

        # Inner position loop (very stiff)
        # Robot tries to track x_c
        e_pos = x_c[k] - x[k]
        F_u = 1000.0 * e_pos  # large proportional gain on position

        a = (F_u + F[k] - D_r * v[k]) / M_r
        v[k+1] = v[k] + dt * a
        x[k+1] = x[k] + dt * v[k+1]

# After simulation, t, x, F can be plotted using matplotlib
      

9.2 C++ Implementation (Eigen, low-level loop)

In C++ one would typically integrate this into a real-time control loop (e.g., in a ROS control node). Here is a simplified snippet that shows one time-step update in both modes. Note the use of Eigen for linear algebra.

#include <iostream>
#include <cmath>

enum class Mode { Impedance, Admittance };

struct InteractionState {
    double x;    // position
    double v;    // velocity
    double x_c;  // commanded position (admittance)
};

void stepInteraction(InteractionState& s,
                     double x_d,
                     double dt,
                     Mode mode)
{
    // Robot and environment parameters
    const double M_r = 5.0;
    const double D_r = 2.0;
    const double K_e = 500.0;
    const double D_e = 10.0;

    const double M_d = 2.0;
    const double D_d = 30.0;
    const double K_d = 200.0;

    // Environment force
    double F_env = K_e * s.x + D_e * s.v;

    double F_u = 0.0;

    if (mode == Mode::Impedance) {
        double e  = x_d - s.x;
        double ed = 0.0 - s.v;

        F_u = K_d * e + D_d * ed;

        double a = (F_u + F_env - D_r * s.v) / M_r;
        s.v += dt * a;
        s.x += dt * s.v;

    } else { // Admittance
        static double v_c = 0.0;  // virtual velocity
        double a_c = (F_env - D_d * v_c - K_d * (s.x_c - x_d)) / M_d;
        v_c += dt * a_c;
        s.x_c += dt * v_c;

        // Inner position servo
        double e_pos = s.x_c - s.x;
        F_u = 1000.0 * e_pos;

        double a = (F_u + F_env - D_r * s.v) / M_r;
        s.v += dt * a;
        s.x += dt * s.v;
    }
}
      

9.3 Java Implementation (Plain OOP, for simulation or middleware)

Java is less common for low-level control but appears in higher-level middleware (e.g., ROSJava). The following is a minimal simulation step similar to the C++ version.

public class Interaction1DOF {

    public enum Mode { IMPEDANCE, ADMITTANCE }

    public static class State {
        public double x;
        public double v;
        public double xCommand;
        public double vVirtual;
    }

    // Parameters
    private final double Mr = 5.0;
    private final double Dr = 2.0;
    private final double Ke = 500.0;
    private final double De = 10.0;

    private final double Md = 2.0;
    private final double Dd = 30.0;
    private final double Kd = 200.0;

    public void step(State s, double xRef, double dt, Mode mode) {
        double Fenv = Ke * s.x + De * s.v;
        double Fu;

        if (mode == Mode.IMPEDANCE) {
            double e  = xRef - s.x;
            double ed = 0.0 - s.v;
            Fu = Kd * e + Dd * ed;

            double a = (Fu + Fenv - Dr * s.v) / Mr;
            s.v += dt * a;
            s.x += dt * s.v;

        } else {
            // Admittance
            double ac = (Fenv - Dd * s.vVirtual - Kd * (s.xCommand - xRef)) / Md;
            s.vVirtual += dt * ac;
            s.xCommand += dt * s.vVirtual;

            double ePos = s.xCommand - s.x;
            Fu = 1000.0 * ePos; // inner position loop

            double a = (Fu + Fenv - Dr * s.v) / Mr;
            s.v += dt * a;
            s.x += dt * s.v;
        }
    }
}
      

9.4 MATLAB/Simulink Implementation

In MATLAB, we can implement the dynamics via ODE integration. The same equations can be realized in Simulink using Integrator and Gain blocks connected according to the differential equations.

function interaction_simulation
  % Parameters
  Mr = 5.0;  Dr = 2.0;
  Ke = 500.0; De = 10.0;
  Md = 2.0;  Dd = 30.0; Kd = 200.0;
  x_d = 0.05;
  mode = "impedance";  % or "admittance"

  tspan = [0 5];
  x0 = [0; 0; 0; 0];   % [x; v; x_c; v_c]
  [t, x] = ode45(@(t, x) dyn(t, x, x_d, mode, Mr, Dr, Ke, De, Md, Dd, Kd), tspan, x0);

  figure; 
  subplot(2,1,1); plot(t, x(:,1)); xlabel('t'); ylabel('x');
  subplot(2,1,2); plot(t, x(:,3)); xlabel('t'); ylabel('x_c');
end

function dx = dyn(~, x, x_d, mode, Mr, Dr, Ke, De, Md, Dd, Kd)
  % x = [x; v; x_c; v_c]
  pos   = x(1);
  vel   = x(2);
  x_c   = x(3);
  v_c   = x(4);

  F_env = Ke * pos + De * vel;
  dx    = zeros(4,1);

  if mode == "impedance"
      e  = x_d - pos;
      ed = 0.0 - vel;
      F_u = Kd * e + Dd * ed;

      a  = (F_u + F_env - Dr * vel) / Mr;
      dx(1) = vel;
      dx(2) = a;
      dx(3) = 0.0;
      dx(4) = 0.0;

  else
      % Admittance
      a_c = (F_env - Dd * v_c - Kd * (x_c - x_d)) / Md;
      dx(3) = v_c;
      dx(4) = a_c;

      e_pos = x_c - pos;
      F_u = 1000.0 * e_pos;

      a  = (F_u + F_env - Dr * vel) / Mr;
      dx(1) = vel;
      dx(2) = a;
  end
end
      

In Simulink, one may create two subsystems: one encoding the M_r, D_r plant, and one encoding either the impedance or admittance law, with appropriate summing junctions for forces and positions as in the block diagram.

9.5 Wolfram Mathematica Implementation

Mathematica is convenient for symbolic analysis of closed-loop poles and numerical simulation.

(* Parameters *)
Mr = 5.0; Dr = 2.0;
Ke = 500.0; De = 10.0;
Md = 2.0; Dd = 30.0; Kd = 200.0;
xD[t_] := 0.05;

(* Impedance control differential equations *)
impedanceEqns = {
  x'[t] == v[t],
  Mr v'[t] == Fu[t] + Ke x[t] + De v[t] - Dr v[t],
  Fu[t] == Kd (xD[t] - x[t]) + Dd (0 - v[t])
};

(* Admittance control differential equations *)
admittanceEqns = {
  x'[t] == v[t],
  xc'[t] == vc[t],
  Md vc'[t] == Ke x[t] + De v[t] - Dd vc[t] - Kd (xc[t] - xD[t]),
  Mr v'[t] == 1000.0 (xc[t] - x[t]) + Ke x[t] + De v[t] - Dr v[t]
};

(* Solve numerically *)
solImp = NDSolve[
  Join[impedanceEqns, {x[0] == 0, v[0] == 0}],
  {x, v, Fu}, {t, 0, 5}
];

solAdm = NDSolve[
  Join[admittanceEqns, {x[0] == 0, v[0] == 0, xc[0] == 0, vc[0] == 0}],
  {x, v, xc, vc}, {t, 0, 5}
];

Plot[{x[t] /. solImp[[1]], x[t] /. solAdm[[1]]}, {t, 0, 5},
  PlotLegends -> {"Impedance", "Admittance"},
  AxesLabel -> {"t", "x(t)"}
]
      

Symbolic tools can also be used to compute eigenvalues of the linearized closed-loop systems and to verify passivity constraints.

In this lesson we compared impedance and admittance control as dual ways of shaping robot–environment interaction. Starting from 1-DOF mass–spring–damper models, we defined mechanical impedance and admittance, derived how each architecture renders a desired interaction law, and analyzed resulting stability and passivity conditions.

Impedance control is most natural for torque-controlled robots and leverages motion sensing to generate torques that realize a target impedance. When the desired impedance is passive, interaction with any passive environment is stable in the ideal continuous-time limit. Admittance control, by contrast, is most appropriate for stiff position-controlled robots with high-quality force sensing; forces are mapped to virtual motions, which are then tracked by the inner servo. Its performance and stability are highly sensitive to sampling, inner-loop dynamics, and parameter choices.

We concluded with concrete, implementable examples in Python, C++, Java, MATLAB/Simulink, and Mathematica, and we solved representative analytical problems showing how environment stiffness, virtual impedance parameters, and control architecture jointly determine the closed-loop behavior. These insights will be crucial when designing contact-rich tasks and labs in subsequent lessons.