Impedance Control vs Admittance Control: Compliant Manipulation in Contact

A position-controlled robot is a very stubborn employee. Tell it to move to a pose and it will get there, whatever stands in the way. That is wonderful in free space and a disaster the moment the tool touches something. A millimetre of error between where the robot believes a part is and where it really is can produce hundreds of newtons of contact force, because the controller treats the error as something to be eliminated at any cost.

Impedance control is the standard answer: instead of commanding where the robot is, you command how it should react when pushed. Its dual, admittance control, reaches the same behaviour from the opposite direction and runs on the position-controlled arms that dominate factory floors. Choosing between them is the most consequential architecture decision in compliant manipulation, and it is usually decided by your hardware rather than by taste.

This article is a working engineer’s comparison. You will leave with the shared mass-spring-damper model, a clear rule for when each causality fits, stability arguments backed by a runnable one-degree-of-freedom simulation with real numbers, gain selection guidance, a ROS 2 configuration, and the safety limits that bound everything.

What this covers: why position control fails in contact, target dynamics, impedance versus admittance, hybrid force/position control, passivity and contact instability, gain tuning, ros2_control in practice, learned contact-rich policies, and collaborative safety.

Context and Background

Industrial robots were designed to repeat. Their joints are driven through high-ratio gearboxes, wrapped in fast position loops, and tuned so that a payload and a trajectory result in the same tool pose every cycle. That design philosophy delivers sub-millimetre repeatability, and it also makes the arm an almost perfect position source: its apparent stiffness at the tool is enormous, and it responds to a disturbance by pushing back harder rather than yielding.

Contact tasks expose the problem. Inserting a peg into a hole with 0.1 mm clearance, polishing a curved panel, tightening a screw, wiping a table, or handing an object to a person all involve a robot whose end effector must exchange energy with an environment it cannot model exactly. The environment is itself a dynamic system, and a stiff robot coupled to a stiff environment is a recipe for large forces, chatter, or a protective stop.

The theoretical foundation is Neville Hogan’s 1985 three-part paper series, “Impedance Control: An Approach to Manipulation,” published in the ASME Journal of Dynamic Systems, Measurement, and Control. Hogan’s insight was that a manipulator interacting with an environment should not be controlled to a trajectory or to a force alone. The controller should shape the dynamic relationship between the end-effector motion and the interaction force, and that relationship is the mechanical impedance (or its inverse, the admittance). The classic papers are hosted by the MIT Newman Lab (Hogan 1985, Part I: Theory).

Four decades later, the hardware landscape splits into two camps. Torque-controlled arms such as the Franka Research series, the KUKA LBR iiwa and various research and cobot platforms expose joint torque as a command interface and run internal torque loops at around a kilohertz. Position-controlled arms, including most of the industrial fleet from Universal Robots, FANUC, ABB, KUKA and Yaskawa, expose positions or velocities and sometimes a limited force mode. The first camp makes impedance control natural. The second camp makes admittance control the practical option, typically with a six-axis force/torque (F/T) sensor mounted between flange and tool.

Meanwhile, learning-based manipulation has made the topic urgent again. Imitation-learning policies such as the ones we covered in our diffusion policy for robot manipulation article output pose targets, not forces. Whatever sits between those targets and the motors decides whether the policy survives contact. In practice, that layer is an impedance or admittance controller.

The vocabulary matters, so define it precisely. Impedance maps motion to force: given a displacement or velocity, how much force does the system produce? Admittance is the inverse map, from force to motion: given a force, how much does the system move? A spring is an impedance (force proportional to displacement) and its inverse, a compliance, is an admittance. Control engineers say a system has impedance causality if it reads motion and writes force, and admittance causality if it reads force and writes motion.

The Core Argument: One Target Dynamic, Two Causalities

Impedance control and admittance control both make the end effector behave like a virtual mass-spring-damper attached to a desired pose. They differ in which side of the equation is measured and which is commanded. Impedance control measures motion and outputs force or torque; admittance control measures force and outputs motion. The choice is dictated by whether your joints accept torque commands.

Figure 1: Both schemes enforce the same target dynamics; impedance control reads motion and commands force, admittance control reads force and commands motion.

The diagram shows that the decision node is causality, not physics. The upstream target, a desired pose plus three tunable matrices, is identical. What changes is what the software reads from the robot and what it writes back, and with it which physical effects the control law must fight.

The target dynamics

Let x be the Cartesian pose error of the tool relative to a desired pose x_d, so x = x_actual − x_d. The behaviour we want when an external wrench F_ext pushes on the tool is

M·ẍ + D·ẋ + K·x = F_ext

where M is the virtual inertia, D the virtual damping and K the virtual stiffness. For a six-degree-of-freedom tool these are 6×6 matrices, usually diagonal in a task frame. A stiffness of K = 500 N/m in a given axis means that a 5 N push moves the tool 10 mm from its desired position at steady state. That one equation specifies how compliant the robot appears, how fast it reacts, and how much it oscillates.

Three consequences are worth internalising. First, in the quasi-static limit the equation reduces to Hooke’s law, F = K·x, so you can program the contact force by choosing where the desired pose sits relative to the surface. Putting x_d 5 mm inside a wall with K = 800 N/m yields roughly 4 N of contact force without any force feedback at all. Second, damping sets the character of transients: the damping ratio ζ = D / (2·√(M·K)) tells you whether the response overshoots (ζ below 1), is critically damped (ζ = 1), or is sluggish (ζ above 1). Third, the virtual inertia M is a design choice only for admittance control. In impedance control, shaping the apparent inertia requires acceleration feedback or force feedback, both of which are noisy and fragile, so most practical impedance controllers leave the natural inertia of the arm in place.

Impedance control: motion in, force out

An impedance controller measures joint positions and velocities, computes the Cartesian error, and outputs a force through the Jacobian transpose. The standard Cartesian law for a torque-controlled manipulator is

τ = Jᵀ(q)·[K·(x_d − x) − D·ẋ] + g(q) + (optional Coriolis and friction terms)

The term g(q) cancels gravity, so the arm floats; the Jacobian transpose maps the Cartesian spring-damper force into joint torques. If you are fuzzy on the Jacobian, our walk-through of inverse kinematics, the Jacobian and damped least squares explains the object this equation is built on.

Notice what is absent: there is no force sensor in the loop. The compliance emerges from the torque interface itself. Contact force is felt only through the resulting motion, which means the controller reacts in a single servo cycle, typically 1 ms. This is why impedance control is the method of choice for fast, light interaction: catching an object, teaching by hand guidance, or sliding along a surface. The price is that it demands accurate modelling of gravity and, to a lesser degree, friction, since uncompensated friction behaves like an unmodelled force that shifts the equilibrium.

Hardware requirements follow. You need a joint-level torque command interface, low reflected inertia (so that the physical robot does not mask the programmed behaviour), and low joint friction or a joint torque sensor to measure and compensate it. That describes a small family of lightweight, torque-sensing arms. It does not describe a standard industrial robot with a 100:1 harmonic drive and a closed controller.

Admittance control: force in, motion out

Admittance control inverts the loop. A force/torque sensor measures the contact wrench; the controller feeds it into the target dynamics, integrates the equation to obtain a displacement, and adds that displacement to the nominal reference. The result goes to a stiff, fast inner position controller. Solving for acceleration gives

ẍ_c = M⁻¹·(F_ext − D·ẋ_c − K·(x_c − x_d))

and a numerical integrator advances x_c each cycle. Think of it as simulating a small virtual mass-spring-damper in software and asking the real robot to follow its motion.

The strength of this approach is that it works on almost any position-controlled arm. The inner loop is already tuned and rejects friction and gearbox nonlinearities, so you inherit that precision for free. The F/T sensor also provides a direct, bandwidth-limited measurement of the contact force, which makes the controller insensitive to the arm’s internal friction. Admittance control can even emulate large virtual inertia, which is handy for smooth hand guidance of a heavy payload.

The weakness is physical. The inner position loop is stiff, so the arm stays rigid to forces that the outer loop has not yet processed. There is a sensor filter, a sampling period, an integration step and a command latency between a contact event and the arm’s response. If the environment is stiff, the net loop gain at contact can exceed what the delayed loop can tolerate, and the result is chatter or bouncing. The simulation later in this article quantifies this.

A direct comparison

The table below summarises the differences that matter in practice. Scores are qualitative engineering judgement, not measurements.

Dimension	Impedance control	Admittance control
Reads	Joint position and velocity	Wrench from F/T sensor
Commands	Joint torque	Position or velocity
Typical hardware	Torque-controlled cobot or research arm	Position-controlled industrial arm plus F/T sensor
Free-space accuracy	Limited by friction and model error	Excellent (stiff inner loop)
Soft environments	Excellent	Good
Stiff environments	Good, naturally passive	Prone to bounce unless damped
Reaction time	One servo cycle	Sensor, filter and loop latency
Virtual inertia	Hard to change	Free design parameter
Setup cost	Model identification, gravity and friction	Sensor calibration, payload and bias

A useful mnemonic: impedance control makes the robot behave like a spring in hardware, so it is intrinsically a low-impedance device that you make stiffer. Admittance control makes the robot behave like a spring in software, so it is intrinsically a high-impedance device that you make softer. Making something softer than it is, and doing so quickly, is the harder direction.

Where force control and hybrid control fit

Plain force control closes a loop on a measured force and drives the error to zero. Raibert and Craig’s hybrid position/force control (1981) splits the task space with a selection matrix: along surface-normal directions you control force, along tangential directions you control position. Polishing a flat table is the textbook case: hold 10 N normal, follow a path tangentially.

Pure force control has a known pathology. It is unstable when the robot is in free space (no force to regulate), and it struggles at the instant of impact. Impedance and admittance schemes behave better because they remain meaningful in free space (they are just a spring pulling the tool to x_d) and they pass smoothly through contact. Many modern implementations therefore use the selection-matrix idea inside an impedance or admittance framework: stiff along directions where position matters, soft (or with a feed-forward force) along directions where force matters. The ros2_control admittance controller discussed later exposes exactly this through a per-axis selected_axes switch.

Deeper Analysis: Stability, Gains and the Numbers

The two schemes are not equally forgiving of stiff contact, and the reason is a mixture of passivity and delay. Passivity means a system cannot generate energy on its own; a passive robot touching a passive environment cannot go unstable. Sampling, latency and filtering break passivity, and the stiffer the environment, the less time you have to be wrong.

Why position control fails in contact

Consider a robot with a PD position loop of stiffness K_p = 40,000 N/m in the contact direction touching a wall with stiffness k_e = 20,000 N/m. Plug in a 1 mm planning error. The two springs are in series, and the contact force is the series combination times the error: roughly 40,000 × 20,000 / 60,000 × 0.001 ≈ 13 N for every millimetre. A 5 mm error is about 67 N. The robot cannot tell that the error is a modelling issue; it simply pushes. Compliant control lowers the effective K from 40,000 to a programmed value of a few hundred N/m, which cuts the same 1 mm error to under 1 N. That is the whole reason this topic exists. Note that those figures are first-principles arithmetic on assumed stiffnesses, not measurements from a specific robot.

An admittance-friendly control architecture

Figure 2: An admittance control loop wraps a stiff position controller; the F/T sensor passes through gravity and bias compensation before entering the virtual mass-spring-damper.

Figure 2 shows the signal chain you will actually build. The F/T sensor reading is not the contact force. It also contains the weight of the tool, the sensor bias, and inertial forces during motion. If you skip gravity compensation, the controller will interpret the weight of the gripper as a push and drift slowly in the direction of gravity. Every admittance deployment needs payload mass, centre of gravity and sensor bias identified before tuning anything else. The next piece is the inner loop: it must be stiff and fast relative to the outer one, otherwise the two loops interact. A common rule of thumb is a bandwidth ratio of about five to ten between inner and outer loops, which is a design heuristic rather than a theorem.

Cartesian impedance on a torque-controlled arm

Figure 3: Impedance control computes a Cartesian spring-damper force, maps it through the Jacobian transpose, and adds gravity and Coriolis compensation before the torque interface.

The impedance architecture is shorter, and that is both its virtue and its constraint. There is no outer sensor loop; everything runs in the joint torque servo at around 1 kHz. Quality depends on the dynamic model. If the gravity vector is off by 5 percent, the equilibrium shifts; if friction is high, small contact forces are masked until they exceed it. Because the inner loop is the torque interface itself, bandwidth is not a bottleneck, which is why impedance control is stable against environments that would cause an admittance loop to bounce.

A one-degree-of-freedom simulation

Theory is easier to trust after you have broken it. The following script simulates a 5 kg effective mass moving at 50 mm/s toward a wall at x = 100 mm. The reference pose goes 5 mm past the wall surface, so the programmed steady-state contact force is K × 5 mm. The wall is a unilateral spring-damper (it pushes only when penetrated). Impedance control applies a spring-damper torque directly to the mass. Admittance control integrates the virtual mass-spring-damper from the measured force, sampled at 1 kHz, and feeds the result to a stiff PD loop (K_p = 40,000 N/m, K_v = 400 N·s/m). It uses plain NumPy and runs in seconds.

import numpy as np

def env(x, v, xw=0.10, ke=20000.0, de=40.0):
    """Unilateral wall: force on the robot, zero if not penetrating."""
    return -(ke * (x - xw) + de * v) if x > xw else 0.0

def impedance(M=5.0, K=800.0, D=60.0, xd_end=0.105, T=8.0, dt=1e-4, ke=20000.0):
    x = v = xd = 0.0; vd = 0.05; out = []
    for i in range(int(T / dt)):
        xd = min(xd + vd * dt, xd_end)
        f_ext = env(x, v, ke=ke)
        u = K * (xd - x) - D * v           # torque-level spring-damper
        v += (u + f_ext) / M * dt
        x += v * dt
        out.append((i * dt, x, -f_ext))    # contact force magnitude
    return np.array(out)

def admittance(Md=5.0, Dd=60.0, Kd=800.0, xd_end=0.105, T=8.0, dt=1e-4,
               ke=20000.0, Kp=40000.0, Kv=400.0, mr=5.0, ts=1e-3):
    x = v = xd = xc = vc = 0.0; vd = 0.05; out = []
    n = int(round(ts / dt))
    for i in range(int(T / dt)):
        xd = min(xd + vd * dt, xd_end)
        f_ext = env(x, v, ke=ke)
        if i % n == 0:                      # outer loop at the sensor rate
            ac = (f_ext - Dd * vc - Kd * (xc - xd)) / Md
            vc += ac * ts
            xc += vc * ts
        u = Kp * (xc - x) - Kv * v          # stiff inner position loop
        v += (u + f_ext) / mr * dt
        x += v * dt
        out.append((i * dt, x, -f_ext))
    return np.array(out)

The full script, including the reporting function, lives alongside this post as sim.py. All results below come from running it; the model is illustrative, with a 5 kg effective mass and round-number stiffnesses, so treat the absolute values as properties of this toy and the patterns as the lesson.

Case (target M, D, K = 5 kg, 60, 800)	Wall k_e	Peak force	Contact lost after first touch	Force, final second
Impedance	20 kN/m	15.2 N	0.8% of time	3.85 N steady
Admittance, D = 60	20 kN/m	18.3 N	55.7% of time	3.6 N mean, 5.0 N std
Admittance, D = 150	20 kN/m	11.0 N	0.6% of time	3.77 N steady
Impedance	200 kN/m	49.1 N	3.9% of time	3.98 N steady
Admittance, D = 60	200 kN/m	52.9 N	80.1% of time	4.05 N mean, 9.5 N std
Admittance, D = 150	200 kN/m	33.9 N	1.9% of time	3.91 N steady
Admittance, M = 0.5, D = 15	either	diverges	not applicable	numerical blow-up

Several things stand out. First, all converge on roughly K × 5 mm = 4 N when they settle, confirming that the programmed stiffness sets the contact force. Second, with identical M, D and K the impedance controller touches down and stays down, while the admittance version with a damping ratio of about 0.47 repeatedly bounces off the wall, losing contact for most of the run. Third, raising the admittance damping to 150 (ζ ≈ 1.2) fixes it and even lowers the peak below the impedance case, because overdamped virtual dynamics absorb the impact. Fourth, shrinking the virtual mass to 0.5 kg with light damping makes the loop numerically unstable against both walls. A small virtual mass means a very high gain from force to acceleration; combined with one sample of delay and a stiff environment, the discrete loop amplifies instead of attenuates.

Passivity, contact instability and the delay budget

The robot-environment loop can be analysed as two interconnected two-port systems. If both are passive, the interconnection is stable (the passivity theorem); this is the foundation of the work by Colgate and Hogan on coupled stability. Impedance control, when implemented with a torque interface, a continuous-time spring-damper and nonnegative K and D, is passive with respect to the pair (velocity, force), so it is a safe partner for unknown passive environments.

Discretisation destroys this. Zero-order-hold sampling at period T injects an effective negative damping of about K·T/2 into a virtual spring of stiffness K. To remain passive, the physical or virtual damping must exceed that amount. For K = 800 N/m and T = 1 ms, K·T/2 = 0.4 N·s/m, which is trivial against D = 60; for K = 20,000 N/m and T = 4 ms it is 40 N·s/m, which is not. This is a standard result in haptics (the Colgate-Schenkel condition, which bounds stiffness by roughly 2b/T for physical damping b), and it explains why stiff virtual walls need fast loops. The condition is an approximation for a simple model; check your own setup in simulation.

Admittance control has an additional hazard. The loop includes the measured force as an input and the environment stiffness as a feedback path, so a stiff wall is an additional gain. As a heuristic (my own reasoning, not a published bound), a stiffer wall and a smaller virtual mass raise the effective force-to-motion gain at contact, and the inner loop’s phase lag adds to the problem. A larger virtual mass or heavier damping lowers that gain. This matches the table: M = 5 with ζ ≈ 1.2 is stable and soft; M = 0.5 with ζ < 1 is not.

Gain selection: a practical order of operations

Pick the stiffness first. Decide the force you want per millimetre of error. If a 1 mm error should yield no more than 2 N, K cannot exceed 2,000 N/m. Then select the damping ratio, and bias toward overdamped (ζ between 1 and 1.5) for admittance on stiff parts, near 0.7 to 1 for impedance. For admittance, finally choose M_d large enough that the force-to-acceleration gain is tolerable; as a start, aim for a natural frequency √(K/M) of 1 to 3 Hz, which for K = 800 N/m means M of roughly 2 to 20 kg. Those frequency targets are a starting heuristic from practice, not a published standard. Then increase bandwidth until chatter appears and back off by 30 to 50 percent.

Two further knobs deserve respect. Variable impedance, scheduling K down as the tool approaches an unknown surface and up during free motion, usually beats any fixed setting. And asymmetric damping, with extra damping only during approach, tames the bounce seen in Figure 4 without making hand guidance sluggish.

Figure 4: The contact sequence for a compliant controller, from free-space approach to settling near K times the offset; bounce is where delay and a stiff wall interact.

Figure 4 maps the table above onto time. The danger zone is the note between first contact and settling: a stiff wall plus loop delay can turn the yield into a rebound. The impedance controller experiences this as a short blip; the poorly damped admittance controller turns it into a limit cycle, shown by the 55 to 80 percent lost-contact figures.

Compliant Control in ROS 2 and on Real Arms

Theory meets software at the ros2_control layer. The framework separates controllers from hardware interfaces, which is exactly the seam where impedance and admittance part ways. If you need a refresher on that layer, our ros2_control hardware interface tutorial covers how command and state interfaces are declared.

The admittance_controller package

The admittance_controller in ros2_controllers implements the admittance scheme on top of position-controlled hardware. According to its documentation (written for the Iron release, which has since reached end of life, so check the page for your distribution), it is a chainable controller: it takes position and velocity references per joint, reads joint state plus a wrench from a force/torque sensor semantic component, and writes position, velocity or acceleration commands. It needs a kinematics plugin from the kinematics_interface package to move between joint and Cartesian space.

The parameters map one-to-one onto the theory above. Six values each for mass, stiffness and damping_ratio cover x, y, z, rx, ry, rz; selected_axes switches individual degrees of freedom on or off, which is the selection matrix of hybrid control. The documentation defines damping_ratio as D / (2·√(M·S)), the same ζ used earlier in this article, and also allows damping to be specified directly. A gravity_compensation block takes the tool’s weight and centre of gravity, and an ft_sensor block defines the sensor frame and an exponential filter coefficient (the documented default is 0.05). Separate frames define where the admittance is computed (control.frame) and in which frame gravity points down (fixed_world_frame).

PickNik’s admittance configuration guide shows a realistic chain on a UR-class arm: a force_torque_sensor_broadcaster publishing the wrench, a joint_trajectory_controller in chained mode producing the nominal motion, and the admittance_controller modifying those commands. Their example uses 10 kg and 5 kg virtual mass for translation and rotation, stiffness of 500 and 100, and a damping ratio of 5.0, i.e. heavily overdamped. That choice is consistent with the lesson from the simulation: on a position-controlled arm, start overdamped and soft, then tighten. Note the side effect they point out as well: because the arm now deviates from its plan, the trajectory and goal tolerances must be relaxed.

A skeleton configuration illustrates the shape. Names and values are placeholders to adapt, not a tested setup.

controller_manager:
  ros__parameters:
    update_rate: 500
    force_torque_sensor_broadcaster:
      type: force_torque_sensor_broadcaster/ForceTorqueSensorBroadcaster
    admittance_controller:
      type: admittance_controller/AdmittanceController

admittance_controller:
  ros__parameters:
    joints: [shoulder_pan_joint, shoulder_lift_joint, elbow_joint,
             wrist_1_joint, wrist_2_joint, wrist_3_joint]
    command_interfaces: [position]
    state_interfaces: [position, velocity]
    chainable_command_interfaces: [position, velocity]
    ft_sensor:
      name: tcp_fts_sensor
      frame: {id: wrist_3_link, external: false}
      filter_coefficient: 0.05
    control:
      frame: {id: tool0, external: false}
    fixed_world_frame:
      frame: {id: base_link, external: false}
    gravity_compensation:
      frame: {id: tool0, external: false}
      CoG: {pos: [0.0, 0.0, 0.05], force: 14.7}   # measured payload, 1.5 kg here
    admittance:
      selected_axes: [true, true, true, false, false, false]
      mass:          [8.0, 8.0, 8.0, 1.0, 1.0, 1.0]
      stiffness:     [300.0, 300.0, 300.0, 50.0, 50.0, 50.0]
      damping_ratio: [1.2, 1.2, 1.2, 1.0, 1.0, 1.0]

The parameter layout above follows the structure in the documentation; the exact key spellings differ between releases, so validate against the schema of the version you install.

Cartesian impedance on torque-controlled arms

On a torque-controlled robot like the Franka arm, the vendor’s interface exposes joint torque commands at 1 kHz, and Cartesian impedance controllers are shipped as example controllers in the Franka ROS stack. I could not confirm the current layout of the franka_ros2 repository from primary documentation during this research, so check Franka’s own documentation for controller names and the supported command interfaces before relying on any example. The same caution applies to Universal Robots: its drivers provide position and velocity control plus a vendor-defined force mode, and the most common route to compliant behaviour on a UR is the admittance chain above. Details of the UR force-mode API should be read from the manufacturer’s documentation for your software version.

A reasonable decision rule: if the arm accepts torque commands and you can identify its dynamics, implement Cartesian impedance, because it reacts within one servo cycle and is naturally passive. If it only accepts positions, buy a well-calibrated F/T sensor and use admittance. If you have both, use impedance for fast phases such as insertion and admittance for slow, large-inertia phases such as hand guidance.

Calibrating the sensor chain

The F/T path is where most admittance deployments quietly fail. Before tuning any gain, identify three things: the sensor bias at several tool orientations, the payload mass and centre of gravity, and the sensor-to-tool transform. A simple procedure is to hold the tool still in six orientations (±x, ±y, ±z pointing up), record the wrench, and fit mass, centre of gravity and bias by least squares. A wrong centre of gravity by even a few centimetres yields orientation-dependent torque errors that look exactly like the operator pushing. Also account for cable drag and temperature drift; a slow drift of the zero will move the arm by itself, which is why many controllers add a small deadband or re-zero on demand.

Contact-Rich Tasks and Learned Policies

Compliant control provides the low-level reflex; higher-level behaviours are increasingly learned. Contact-rich manipulation, such as peg-in-hole assembly, connector mating, wiping and wire insertion, is a regime where precise geometric models are hard to build and sensor noise is the norm. Classical approaches handle it with search strategies, spiral motions and force thresholds, all built on top of a compliant controller.

Learned policies change the interface between planner and controller. A diffusion or behaviour-cloning policy typically predicts a short chunk of future end-effector poses at 5 to 30 Hz. Feeding those directly to a position-controlled arm is brittle in contact: small prediction errors become large forces. A common remedy is to treat the predicted pose as the reference x_d of an impedance or admittance controller running at a much higher rate, so the policy chooses where to go and the compliant layer decides how hard to push. Some work goes further and has the policy output stiffness parameters as well as poses, giving it variable impedance as an action; a recent example in this direction is the arXiv paper on robust peg-in-hole assembly via compliant and interactive contact-rich manipulation, which I list as a pointer rather than an endorsement of its specific results.

Safety: Collaborative Force Limits

Compliance is not the same as safety, but the two interact. A compliant arm that can be pushed aside is gentler on a person, yet the force it can apply is set by gains, velocity and mass, not by good intentions.

The relevant standards are ISO 10218 (industrial robot safety) and ISO/TS 15066 (collaborative robots). According to an A3 (Association for Advancing Automation) FAQ, ISO 10218-1 and -2 were revised and published in 2025; the terms “collaborative robot” and “collaborative operation” were replaced by “collaborative application”, and the content formerly in ISO/TS 15066 was incorporated into Part 2. That is a secondary source, so confirm clause numbers against the purchased standard before certifying anything.

ISO/TS 15066 defined four collaborative modes, one of which is power and force limiting (PFL), where contact with a human is permitted as long as force and pressure stay below body-region thresholds. Published analyses of the technical specification describe a table giving, per body region, a maximum permissible force, an effective spring constant and an effective mass, plus the biomechanical speed limit v_rel,max = F_max / √(μ·k), where μ = (1/m_H + 1/m_R)⁻¹ is the reduced mass of the human segment and robot (Safe Physical Human-Robot Interaction through Variable Impedance Control based on ISO/TS 15066). That paper reproduces, for example, 140 N for the hand and fingers with a spring constant of 75 N/mm and 0.6 kg effective mass. I have not checked those entries against the standard itself, and the standard distinguishes quasi-static from transient contact with different allowances, so use the document, not a blog post, for any real risk assessment.

The engineering implication is clear. Reduced mass and low speed raise the allowable speed, and a compliant controller does not by itself change either. What impedance control adds is the ability to cap the force: the contact force is roughly K times penetration, so a limited K and a bounded deviation bound the force. Variable-impedance schemes that lower stiffness when a person is near are an active research direction, including the cited paper. A certified safety function still has to enforce the limits independently of the compliant controller, because a software gain is not a safety-rated limit.

Trade-offs, Gotchas, and What Goes Wrong

Stiff environments punish admittance. The simulation showed it: a modest damping ratio produced bouncing for most of the run, and a small virtual mass diverged. In production, symptoms are audible buzzing, protective stops on force spikes, and a tool that “chatters” on a hard fixture. The fix is more virtual mass, more damping or a lower F/T filter cutoff, in that order of preference, though a lower cutoff adds phase lag.

Soft control does not mean accurate positioning. With K = 300 N/m, 3 N of unexpected force moves the tool 10 mm. If a task needs both millimetre accuracy and low contact force, a single fixed impedance is the wrong tool; use hybrid control with stiff axes in free directions and a force feed-forward along the contact normal.

Gravity and payload errors masquerade as contact. In admittance control, an incorrect payload estimate causes drift that grows with orientation. Re-identify the payload whenever the tool changes, and monitor the force reading when the arm is stationary in free space as a health check.

Latency budget is a first-class parameter. Sensor communication, filtering, controller period and the vendor’s internal command interpolation all add delay. Measure end-to-end latency from a force step to the first motion response; if it is more than a few ticks of your loop, reduce gains accordingly. Real-time scheduling matters too; a jittery loop violates the passivity assumptions above.

Practical Recommendations

Start from the hardware, because it constrains the causality: torque interface means impedance, position interface plus F/T sensor means admittance. Do not attempt to retrofit true impedance control onto a closed position-controlled industrial arm, and do not buy a torque-controlled arm if what you need is ten-micron repeatability in free space.

Then work in a fixed order. Fix the physical prerequisites first (payload, bias, tool centre point, latency measurement). Choose stiffness from the force you can afford per millimetre of error. Choose damping so the response is near critically damped for impedance and overdamped for admittance on stiff parts. Choose virtual mass last and as large as your task tolerates. Commission at 10 percent speed with force limits enforced by an independent safety function, and increase only when the contact force trace looks clean.

When you add learning, let the policy emit pose references (and, if you can, stiffness) at a low rate and let the compliant controller absorb the contact at a high rate. Log wrench alongside actions from the first demonstration, since you will want it later.

[ ] Payload mass, centre of gravity and F/T bias identified at several orientations
[ ] End-to-end latency from force step to motion response measured
[ ] Stiffness set from an explicit force-per-millimetre budget
[ ] Damping ratio at or above 1 for admittance on stiff contact
[ ] Trajectory and goal tolerances relaxed to match the allowed deviation
[ ] Independent, safety-rated force or speed limits in place
[ ] Behaviour validated against a stiff wall, a soft pad and free-space swing
[ ] Wrench logged with every recorded demonstration

Frequently Asked Questions

What is the difference between impedance control and admittance control?

Both make a robot behave like a virtual mass-spring-damper, but the causality is inverted. Impedance control measures motion (position and velocity) and commands force or torque, so it needs torque-controlled joints. Admittance control measures force with a sensor and commands motion, so it runs on position-controlled arms. Because they enforce the same target dynamics, the end behaviour can be similar, but their robustness to stiff contact and their hardware requirements differ.

When should I use admittance control instead of impedance control?

Use admittance control when your arm exposes only position or velocity commands, which describes most industrial robots, and you can add a six-axis force/torque sensor at the wrist. It also suits tasks where you want large virtual inertia, such as hand guiding a heavy payload, and where free-space accuracy matters. Use impedance control when you have a torque interface and need fast reaction to contact or stable interaction with stiff surfaces.

Is impedance control the same as force control?

No. Pure force control regulates a contact force to a setpoint, which works only while the robot is in contact and can be unstable at impact. Impedance control regulates the dynamic relationship between motion and force, so it stays well defined in free space and through the transition into contact. You can still obtain a desired force indirectly by placing the reference pose inside the surface by an amount equal to force divided by stiffness.

How do I pick stiffness, damping and mass?

Choose stiffness from the force you can accept per millimetre of position error, for example 2,000 N/m gives 2 N per millimetre. Set the damping ratio near 1 for impedance and at or above 1 for admittance on stiff parts. For admittance, then raise the virtual mass until the loop is stable against the stiffest expected surface. Validate in simulation and commission slowly. These are starting heuristics, not universal values.

Does the ROS 2 admittance controller work with any robot?

It works with robots whose hardware interface accepts the command types it outputs (position, velocity or acceleration) and that supply joint state plus a force/torque sensor interface. It also needs a kinematics plugin. Because it is chainable, it typically sits behind a joint trajectory controller. It does not turn a position-controlled arm into a torque-controlled one; it adds software compliance on top of the position loop, so the latency limits described above still apply.

Does a compliant controller make a robot safe around people?

Not by itself. Compliance limits contact force by bounding stiffness and deviation, but safety requires a risk assessment under ISO 10218 and, for collaborative applications, the force, pressure and speed limits derived from ISO/TS 15066 content, which the 2025 revision of ISO 10218 reportedly folded into Part 2. Safety-rated monitoring should enforce those limits independently of the control gains.

Impedance vs Admittance Control: Compliant Robot Manipulation, Force Control and Contact-Rich Tasks (2026)