← Foundations of Low-Level Robot Control

Admittance Control

Part 3 · Foundations of Low-Level Robot Control

The controllers in Part 2 require a sufficiently accurate and fast joint-torque interface. Many industrial robots instead accept only position or velocity commands through a stiff inner servo. Admittance control is well suited to these robots because it uses a wrist-mounted force/torque sensor to measure the external wrench and converts that measurement into position or velocity commands for the existing servo. Both impedance and admittance control aim to produce a prescribed relationship between force and displacement at the end-effector. Impedance control measures end-effector motion and commands joint torques, while admittance control measures the external wrench and commands end-effector motion.

Compliance through force and displacement

A position-controlled robot normally tries to remain exactly where it was commanded. If an external force displaces its end-effector, the position servo treats that displacement purely as tracking error and tries to eliminate it, rather than allowing a prescribed displacement under load.

A compliant robot is designed to yield to external forces in a controlled way. One common way to specify this behavior is with a spring law. If the end-effector is displaced by $\Delta x$ and the desired stiffness is $k$, then at equilibrium

$$F_\text{ext}=k\,\Delta x, \qquad \Delta x=\frac{F_\text{ext}}{k}.$$

The same equation can be read in either direction:

A high stiffness produces little displacement for a given force; a low stiffness produces more. Both impedance and admittance control aim to create this prescribed relationship at the end-effector. Impedance control maps displacement to force, while admittance control maps force to displacement.

Two ways to create compliant behavior

Impedance control: displacement determines force

Impedance control starts when an external force displaces the end-effector from its commanded position. The controller measures the resulting position error and calculates a restoring Cartesian force:

$$F_\text{cmd}=-k(x-x_d).$$

This Cartesian force is converted into joint torques with the Jacobian transpose:

$$\tau=J^\top F_\text{cmd}.$$

The target $x_d$ remains fixed. A larger displacement caused by the external force produces a larger restoring force. Because the controller realizes this restoring force through $J^\top F_\text{cmd}$, it requires an interface that accepts joint-torque commands.

Admittance control: force determines displacement

Admittance control begins with the measured external wrench and adjusts the commanded motion so the end-effector yields according to the desired compliance:

$$\Delta x=K_a^{-1}F_m, \qquad x_c=x_0+\Delta x.$$

Here $x_0$ is the position command with no external wrench, and $x_c$ is the command after the compliant displacement has been added. As the measured wrench changes, the controller updates $x_c$, and the robot's existing position servo follows it.

The spring law determines where the command eventually settles, but not how it moves there. To define how the command accelerates and settles, the controller uses a mass–damper–spring equation:

$$M_a\,\Delta\ddot x +D_a\,\Delta\dot x +K_a\,\Delta x =F_m.$$

The measured wrench drives the commanded displacement as though it were connected to a mass, damper, and spring with chosen parameters.

Summary

Impedance control Admittance control
Starts with Motion error $\delta x=x-x_d$ Measured external wrench $F_m$
Controller calculates ${F_\text{cmd} =\Lambda\ddot x_d-D_d\,\delta\dot x-K_d\,\delta x+\mu+p}$ ${\Delta\ddot x =M_a^{-1}(F_m-D_a\,\Delta\dot x-K_a\,\Delta x)}$
${x_c=x_0+\Delta x}$
Commands ${\tau=J^\top F_\text{cmd}}$
Joint torque $\tau$
${x_c\ \text{or}\ \dot x_c}$
End-effector position $x_c$ or velocity $\dot x_c$
Resulting relationship ${\Lambda(q)\,\delta\ddot x +D_d\,\delta\dot x+K_d\,\delta x=F_\text{ext}}$
The controller realizes the relationship by commanding joint torque.
${M_a\,\Delta\ddot x +D_a\,\Delta\dot x+K_a\,\Delta x=F_m}$
The controller uses the relationship to update the commanded motion.