Skip to content
LumenaryAcademy
Control 75 min

Force, impedance and compliant control

When a robot touches the world, controlling position is not enough — control how it pushes back, and build actuators that can give way.

Code tested · 5AI-draftedAwaiting review by a roboticist

Your guides: Chloe · The Builder, Margaret · The Experimenter, Gideon · The Safety Engineer

MotivationH

When the robot touches the world

Every lesson so far has been about putting a robot where it should be. That is the right goal in free space. But much of what we want robots to do happens in contact: wiping a table, sanding a car door, plugging in a charger, inserting a shaft into a bearing, opening a drawer, handing a cup to a person, or simply walking, since every step is a collision with the ground.

In contact, position control is the wrong tool. Suppose a camera locates a whiteboard to within 5 mm and an arm is told to press its sponge to the board's surface. If the board is really 5 mm closer than the camera thought, a stiff position controller will try to drive the sponge 5 mm through it, and the force it generates in trying could be tens or hundreds of newtons. If the board is 5 mm farther away, the sponge never touches. Either way, the task fails, and in the first case something may break.

The answer, developed in the 1980s and now built into every collaborative robot, is to control not position alone or force alone but the relationship between them: how hard the robot pushes back when it is pushed, as a function of how far it is displaced. This lesson shows why stiff position control fails in contact, how impedance, admittance and hybrid force–position control work, how the design of the actuator itself changes what any controller can achieve, and why that matters for robots that work beside people.

IntuitionH

Two springs in series

A position-controlled joint behaves like a very stiff spring: displace the tool from its set-point and the controller pushes back in proportion, with a stiffness set by the gains. The environment is a spring too: a steel table is very stiff, a sponge or a person's arm much softer. When the tool touches something, the two springs are in series, and if the set-point lies a distance δ\delta beyond the surface, the steady contact force is

F=Krobot KenvKrobot+Kenv δ.F = \frac{K_{\text{robot}}\,K_{\text{env}}}{K_{\text{robot}} + K_{\text{env}}}\,\delta .

When both are stiff, a millimetre of error makes a large force. When the robot is soft, the force is small and forgiving, whatever the environment: the soft spring takes up the error.

Analogy, not a formal construction

Shake hands with someone whose arm is locked rigid and the handshake hurts, and any mismatch in where you each expected the hands to meet becomes a jolt. A good handshake is firm but compliant: each arm gives a little, and the hands meet where they meet. Neville Hogan, who formalised impedance control at MIT, also studied how people tune the stiffness of their own arms.

The idea in one sentence: a robot cannot choose both the position and the force at a point of contact; the environment decides one of them. Against a rigid wall, the wall decides the position along its normal, and the robot can only choose the force. In free space, nothing resists, so the force is zero and the robot chooses the position. The controller should be designed for the relationship between the two.

DefinitionsH

Definitions

Definition— mechanical impedance

The mechanical impedance of a system at a port is the map from the motion imposed on it to the force it returns; its admittance is the inverse map, from applied force to resulting motion. A mass–spring–damper with displacement ee has impedance F=Me¨+De˙+KeF = M\ddot e + D\dot e + K e.

Definition— impedance control

Impedance control makes the robot's tool behave like a chosen mass–spring–damper attached to a moving set-point xdx_d: with e=x−xde = x - x_d, the target behaviour is Mde¨+Dde˙+Kde=FextM_d\ddot e + D_d\dot e + K_d e = F_{\text{ext}}. On a torque-controlled arm it is commonly implemented without changing the apparent mass, as

τ=J(q)⊤(Kd(xd−x)+Dd(x˙d−x˙))+g(q),\tau = J(q)^\top \big( K_d (x_d - x) + D_d (\dot x_d - \dot x) \big) + g(q),

which needs joint torque control but no force sensor.

Definition— admittance control

Admittance control measures the external force (typically with a six-axis force–torque sensor at the wrist), integrates the chosen virtual dynamics Max¨r+Dax˙r+Ka(xr−xd)=FextM_a \ddot x_r + D_a \dot x_r + K_a (x_r - x_d) = F_{\text{ext}} to get a reference xrx_r, and sends xrx_r to a stiff position controller.

Definition— hybrid position/force control

Hybrid position/force control splits the task directions, in a frame attached to the contact, into those where the robot regulates force (where the environment constrains motion) and those where it regulates position (where the environment constrains force). A diagonal selection matrix SS of ones and zeros picks them.

Worked examplesH

An end effector meets a wall

Let us make the intuition quantitative. A tool of effective mass 2 kg moves along a line towards a wall at 0.30 m. The wall is modelled as a stiff spring–damper (50 kN/m) that can push but not pull. The controller is the impedance law above, in one dimension: u=K(xd−x)+D(x˙d−x˙)u = K(x_d - x) + D(\dot x_d - \dot x), with the damping chosen for a critically damped response in free space. The set-point approaches at 0.1 m/s and stops 5 mm beyond the wall's surface, the size of a typical error in a camera's estimate of where a surface is. We vary KK from the stiffness of an industrial position loop down to a gentle 300 N/m. A second run, in free space, asks the tool to stop at 0.28 m against 3 N of friction, the kind of drag a cable or an unmodelled gearbox adds.

python
import numpy as np

# A 1-D end effector of mass m driven by a force u, moving towards a wall at x = 0.30 m.
m = 2.0                                   # effective mass of the arm at the tool (kg)
X_WALL, K_WALL, B_WALL = 0.30, 50_000.0, 50.0   # wall position, stiffness (N/m), damping (N s/m)
DT = 0.0005                               # 2 kHz control loop

def wall_force(x, v):
    """Force the wall pushes back with (>= 0, it can push but not pull)."""
    if x <= X_WALL:
        return 0.0
    return max(0.0, K_WALL * (x - X_WALL) + B_WALL * v)

def run(K, D, x_goal, speed=0.1, friction=0.0, seconds=1.5):
    """Impedance control u = K (x_d - x) + D (v_d - v); x_d moves to x_goal at a constant speed."""
    x, v, peak = 0.25, 0.0, 0.0
    for k in range(int(seconds / DT)):
        t = k * DT
        x_d = min(0.25 + speed * t, x_goal)
        v_d = speed if x_d < x_goal else 0.0
        u = K * (x_d - x) + D * (v_d - v)
        f_wall = wall_force(x, v)
        f_fric = -friction * np.tanh(v / 0.001)           # smoothed Coulomb friction
        for _ in range(5):                                # finer steps for the stiff contact
            a = (u - f_wall + f_fric) / m
            v += a * DT / 5
            x += v * DT / 5
            f_wall = wall_force(x, v)
        peak = max(peak, f_wall)
    return x, f_wall, peak

print("commanded 5 mm into the wall, approaching at 0.1 m/s")
print(f"{'controller stiffness':>21} {'steady force':>13} {'peak force':>11} {'free space, 3 N friction':>25}")
for K in [1_000_000.0, 20_000.0, 5_000.0, 300.0]:
    D = 2 * np.sqrt(K * m)                                # critically damped in free space
    x, f, peak = run(K, D, X_WALL + 0.005)
    x_free, _, _ = run(K, D, 0.28, friction=3.0)          # stop short of the wall, against friction
    print(f"{K:17,.0f} N/m {f:11.1f} N {peak:9.1f} N   stops {abs(x_free - 0.28) * 1000:5.2f} mm short"
          f" (could be up to {3.0 / K * 1000:.3f} mm)")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Read the table row by row. The stiff position loop presses with 238 N to correct a 5 mm error, enough to crack a panel or a gearbox. At 300 N/m the same error makes 1.5 N. That is the case for compliance. The last column is the price: with only 300 N/m of stiffness, 3 N of friction can hold the tool anywhere within 10 mm of where it was sent. Accuracy in free space and gentleness in contact pull in opposite directions, and the stiffness KK sets the balance. Many robots therefore change KK during a task: stiff while moving through free space, soft just before and during contact.

ExplanationH

Impedance and admittance: two ways to be compliant

set-pointKDtoolx_dwallK (x_d − x)
Impedance control in one picture. The controller makes the tool behave as if a virtual spring K and damper D connected it to a set-point carriage. The set-point x_d lies beyond the wall, so the spring is stretched and the tool presses on the wall with force K(x_d − x); the wall's own stiffness decides how far the tool actually penetrates.

There are two ways to build this behaviour, mirror images of each other.

Impedance control reads motion and commands force. The controller measures where the tool is and how fast it moves, and computes the force the virtual spring and damper would exert; the Jacobian transpose turns that force into joint torques, τ=J⊤F\tau = J^\top F, because a force FF at the tool and torques τ\tau at the joints do the same work through any small motion: τ⊤δq=F⊤δx=F⊤J δq\tau^\top \delta q = F^\top \delta x = F^\top J\,\delta q (the Jacobians lesson derives this duality). It needs joints that can produce a commanded torque accurately and, ideally, that can be backdriven, moved by an external push without fighting it. Torque-controlled arms with joint torque sensors and the low-friction actuators of legged robots are built for this.

Admittance control reads force and commands motion. Most industrial arms have high-ratio gearboxes with so much friction that they cannot be backdriven, and their drives accept only position commands. Bolt a force–torque sensor to the wrist, and the controller can compute how a virtual mass–damper–spring would move under the measured force and send that motion to the stiff position loop. This is how many industrial robots are hand-guided and how they perform force-controlled polishing and assembly.

The two have complementary strengths. Impedance control is inherently stable against stiff environments (the robot is a spring, and pressing a spring into a wall is benign) but its free-space accuracy suffers from friction and model errors, as the table showed. Admittance control is accurate in free space, because the stiff inner position loop rejects friction, but it can become unstable against a stiff environment: the force loop's gain is roughly the environment stiffness divided by the virtual mass, so a stiff wall and a light virtual mass make a loop that, with the inner loop's lag and the sensor's delay, oscillates. Admittance controllers therefore use large virtual damping in contact, and some systems switch between the two schemes.

ExplanationH

Force control and hybrid position/force control

Sometimes the task really is about force: press a sanding disc with 20 N, insert a connector until the force reaches 15 N, polish with a constant pressure. Explicit force control measures the contact force and corrects the command to make it equal a target, usually with integral action, since the steady force must be exact. It has one awkward property: the force loop's gain is proportional to the stiffness of whatever the tool touches. A gain tuned on a soft foam block may be violently unstable on steel. Practical force controllers therefore add damping on the tool's motion along the force direction, which keeps the loop well behaved over a wide range of stiffnesses, and they treat the moment of first contact carefully, approaching slowly with a "guarded move" that stops on a force threshold.

Most contact tasks need force control in some directions and position control in others. Matthew Mason described each task by its natural constraints, what the environment fixes, and artificial constraints, what the task asks of the remaining directions. For wiping a whiteboard: the board fixes motion along its normal, so control the normal force; it fixes nothing along its surface, so control position there. Marc Raibert and John Craig's hybrid controller (1981) implements exactly this, with a selection matrix.

Below, the two-link arm of the trajectories lesson, now lying in a horizontal plane, wipes along a wall: PI force control with damping along the wall's normal (xx), PD position control along it (yy), and the commanded tool force mapped to joint torques by J⊤J^\top. The robot believes the wall is the line x=0.60x = 0.60 m, but it is tilted by 2°, so its true position varies by ±5 mm over the stroke. For comparison, the second run replaces force control along xx with position control aimed 2 mm into the wall the robot believes in.

python
import numpy as np

# The two-link arm of the trajectories lesson, now lying in a horizontal plane (no gravity),
# wiping along a wall: press with 10 N along x, slide along y. The robot believes the wall is
# the line x = 0.60 m, but it is tilted by 2 degrees: x = 0.60 + 0.035 y.
L1, L2, M1, M2 = 0.5, 0.4, 2.0, 1.0
K_WALL, B_WALL, MU = 20_000.0, 30.0, 0.3
DT = 0.001                                          # 1 kHz

def fk(q):
    return np.array([L1 * np.cos(q[0]) + L2 * np.cos(q[0] + q[1]),
                     L1 * np.sin(q[0]) + L2 * np.sin(q[0] + q[1])])

def jacobian(q):
    s1, c1 = np.sin(q[0]), np.cos(q[0])
    s12, c12 = np.sin(q[0] + q[1]), np.cos(q[0] + q[1])
    return np.array([[-L1 * s1 - L2 * s12, -L2 * s12], [L1 * c1 + L2 * c12, L2 * c12]])

def arm_accel(q, dq, tau):
    c2, s2 = np.cos(q[1]), np.sin(q[1])
    M = np.array([[M1 * L1**2 + M2 * (L1**2 + L2**2 + 2 * L1 * L2 * c2), M2 * (L2**2 + L1 * L2 * c2)],
                  [M2 * (L2**2 + L1 * L2 * c2), M2 * L2**2]])
    h = M2 * L1 * L2 * s2
    c = np.array([-h * (2 * dq[0] * dq[1] + dq[1]**2), h * dq[0]**2])
    return np.linalg.solve(M, tau - c)

def contact(p, v):
    """Force of the wall on the tool: a stiff spring-damper along -x, friction along y."""
    pen = p[0] - (0.60 + 0.035 * p[1])
    if pen <= 0:
        return np.zeros(2)
    fn = max(0.0, K_WALL * pen + B_WALL * v[0])
    return np.array([-fn, -MU * fn * np.tanh(v[1] / 0.002)])

def ik(p, elbow=-1):
    c2 = (p @ p - L1**2 - L2**2) / (2 * L1 * L2)
    q2 = elbow * np.arccos(c2)
    return np.array([np.arctan2(p[1], p[0]) - np.arctan2(L2 * np.sin(q2), L1 + L2 * np.cos(q2)), q2])

def y_ref(t):
    """Wipe from y = -0.15 to +0.15 m and back, each way a 2 s quintic, after 1 s of settling."""
    tt = t - 1.0
    if tt <= 0: return -0.15, 0.0
    up = tt <= 2.0
    s = (tt if up else tt - 2.0) / 2.0
    s = min(s, 1.0)
    a, b = (-0.15, 0.15) if up else (0.15, -0.15)
    return a + (b - a) * (10*s**3 - 15*s**4 + 6*s**5), (b - a) * (30*s**2 - 60*s**3 + 30*s**4) / 2.0


def wipe(force_control):
    F_D, KI_F, D_X = 10.0, 20.0, 40.0               # force target (N), integral gain, damping
    K_X = 5000.0                                     # for comparison: position control along x
    KP_Y, KD_Y = 2000.0, 80.0                        # position gains along the wall
    q, dq, force_int = ik(np.array([0.58, -0.15])), np.zeros(2), 0.0
    forces, y_err = [], []
    for k in range(int(5.0 / DT)):
        t = k * DT
        p, v = fk(q), jacobian(q) @ dq
        f_meas = -contact(p, v)[0]                   # the wrist sensor reads the normal force
        yd, vyd = y_ref(t)
        if force_control:                            # x: regulate the force, damp the motion
            force_int += (F_D - f_meas) * DT
            fx = F_D + KI_F * force_int - D_X * v[0]
        else:                                        # x: aim 2 mm into the believed wall
            fx = K_X * (0.602 - p[0]) - D_X * v[0]
        fy = KP_Y * (yd - p[1]) + KD_Y * (vyd - v[1])
        tau = jacobian(q).T @ np.array([fx, fy])     # wanted tool force -> joint torques
        for _ in range(5):
            f_c = contact(fk(q), jacobian(q) @ dq)
            dq = dq + arm_accel(q, dq, tau + jacobian(q).T @ f_c) * DT / 5
            q = q + dq * DT / 5
        if t >= 1.0:
            forces.append(f_meas); y_err.append(abs(yd - p[1]))
    return min(forces), max(forces), max(y_err)

print(f"{'along the normal':18} {'normal force while wiping':>26} {'worst y error':>14}")
for name, fc in [("force control", True), ("position control", False)]:
    lo, hi, ey = wipe(fc)
    print(f"{name:18} {round(lo, 1) + 0.0:10.1f} N to {hi:5.1f} N {ey * 1000:15.1f} mm")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

With force control, the normal force stays within 0.6 N of its 10 N target over the whole stroke, although the wall's position changes by 10 mm and the friction force flips direction at each end. With position control, the same 2° tilt makes the force swing from 29 N at one end to zero, the sponge lifting off the board, at the other. That is the whole argument for force control in one comparison.

ExplanationH

Compliance you can build: series elastic and quasi-direct-drive actuators

Return to the impact peak that no controller could remove. During the first few milliseconds of a collision, the force is set by how much mass hits, how fast and how stiffly, not by the controller. And the mass that hits is not only the link: through a gearbox of ratio NN, a motor rotor of inertia JrJ_r appears at the joint as an inertia N2JrN^2 J_r, the reflected inertia. With N=160N = 160, a rotor of only 2×10−52 \times 10^{-5} kg·m² (a small brushless motor) reflects 0.510.51 kg·m², ten times more than the 0.5 m link it drives.

Two families of actuators attack this directly.

high-ratioseries elasticquasi-directmotorgearboxN ≈ 100–160linkmotorgearboxlinkτ = k · deflectionlarge motorgearsN ≈ 6–10link
Three ways to drive a joint. A high-ratio gearbox makes the small, fast rotor feel heavy at the output. A series elastic actuator puts a spring between gearbox and link, so the link is briefly decoupled from the rotor during an impact, and measuring the spring's deflection measures the torque. A quasi-direct-drive actuator uses a large-diameter motor with a low ratio, so little inertia is reflected and the motor current itself indicates the torque.
  • A series elastic actuator (SEA), introduced by Gill Pratt and Matthew Williamson at MIT in 1995, puts a deliberately compliant spring between the gearbox and the load. Measuring the spring's deflection with two encoders gives the torque by Hooke's law, turning force control into the much easier problem of position control of the spring. During an impact the spring decouples the heavy reflected rotor from the link for the first moments. The costs are a lower force-control bandwidth and a spring resonance to manage. SEAs have been used in humanoids, exoskeletons, collaborative arms and the drives of some quadrupeds.
  • A quasi-direct-drive (QDD) actuator, championed by the MIT Cheetah team, uses a large-diameter, high-torque motor with a low gear ratio, typically 6 to 10. Reflected inertia (which grows with N2N^2) and gear friction are small, so the joint is easily backdriven, absorbs impacts, and can estimate its output torque from the motor current alone: "proprioceptive" force sensing. Many of today's quadrupeds and humanoids use actuators of this kind.

Here is the difference in a collision: the 0.5 m link swinging its tip into a padded obstacle (10 kN/m) at 1 m/s, driven through each kind of actuator.

python
import numpy as np

# One joint swinging a 0.5 m link (its own inertia 0.05 kg m^2 about the joint) into a padded
# obstacle (10 kN/m) at the tip, at 1 m/s. What does the motor behind the gearbox add?
R, I_LINK, K_OBST, V_TIP = 0.5, 0.05, 10_000.0, 1.0

def impact(I_rotor_side, k_spring=None, dt=1e-5, seconds=0.06):
    """Peak tip force. The rotor side has inertia I_rotor_side (as seen at the joint, N^2 J).
    Without a spring it is rigidly attached; with one (N m/rad) it sits behind it."""
    w0 = V_TIP / R
    th_l, w_l, th_r, w_r, peak = 0.0, w0, 0.0, w0, 0.0
    for _ in range(int(seconds / dt)):
        f = max(0.0, K_OBST * R * th_l)                   # obstacle force at the tip
        tau_c = f * R                                    # its torque on the joint
        if k_spring is None:
            w_l -= tau_c / (I_LINK + I_rotor_side) * dt
            th_l += w_l * dt
        else:
            tau_s = k_spring * (th_r - th_l)             # the spring pushes the link
            w_l += (tau_s - tau_c) / I_LINK * dt
            w_r -= tau_s / I_rotor_side * dt
            th_l += w_l * dt
            th_r += w_r * dt
        peak = max(peak, f)
    return peak

J_ROTOR = 2e-5                                           # a small brushless motor's rotor, kg m^2
print(f"{'actuator':38} {'reflected inertia':>17} {'peak force':>11}")
for name, N, k in [("high-ratio gearbox, N = 160", 160, None),
                   ("quasi-direct drive, N = 9", 9, None),
                   ("series elastic, N = 160, 300 N m/rad", 160, 300.0),
                   ("link alone (motor disconnected)", 0, None)]:
    I_r = N**2 * J_ROTOR
    peak = impact(I_r, k) if N else impact(0.0)
    print(f"{name:38} {I_r:13.3f} kg m^2 {peak:9.1f} N")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The rigid high-ratio drive more than triples the peak force compared with the bare link, because the tip effectively weighs 2.25 kg instead of 0.2 kg. The SEA, with the same gearbox, halves it; the QDD actuator nearly matches the bare link. And all of this happens within the first 25 ms of the collision, in which a 1 kHz controller completes only a couple of dozen cycles and a person's reaction has not even begun: compliance and low inertia work instantly, because they are physics, not software.

ExplanationH

Compliance as a safety feature

A robot that works near people must make any unintended contact survivable and, ideally, harmless. Fences and light curtains do this for traditional industrial robots by keeping people out. Collaborative robots, designed to share a workspace, rely instead on limiting what a collision can do, and the methods are the subject of this lesson: low moving mass and speed, compliant or backdrivable joints, torque sensing that detects a collision within milliseconds and stops or reverses the arm, and soft, rounded surfaces.

The international standards for this are ISO 10218 (safety of industrial robots and robot systems, revised in 2025) and ISO/TS 15066 (collaborative operation), published by the International Organization for Standardization. They describe several collaborative modes: a safety-rated monitored stop, hand guiding, speed and separation monitoring (slow down and stop as a person approaches), and power and force limiting, which sets permissible contact forces and pressures for different regions of the body, with the lowest limits, or no permitted contact at all, for the most sensitive areas such as the face. Meeting them is a property of the whole application, not of the robot alone: a collaborative arm carrying a sharp tool or a heavy part can be dangerous, and every installation needs a risk assessment.

Note

If you experiment with contact control, do it in simulation first and then on a small, slow, low-power arm whose maximum force you know is harmless, with an emergency stop within reach. Never test impact behaviour on yourself or another person, and never defeat the guarding or speed limits of an industrial robot: those machines can move fast enough and push hard enough to cause serious injury.

ExplanationH

Contact control in practice

  • Torque-controlled arms, such as research and collaborative arms with torque sensors in every joint, expose a 1 kHz torque interface on which users run impedance controllers, often a Cartesian version of the law above with null-space control for a seventh joint. Khatib's operational space formulation extends it to include the arm's task-space inertia.
  • Industrial arms offer force-control options built on a wrist force–torque sensor and admittance control, used for polishing, deburring, assembly and hand guiding. In ROS 2, ros2_control includes an admittance controller.
  • Legged robots are contact machines: every footstep is an impact, and their QDD or SEA actuators run joint-level impedance control (a PD law with torque feedforward, exactly the "position, velocity, torque" commands met in the PID lesson), with stiffness and damping often chosen by a higher-level controller or a learned policy.
  • Learned manipulation. As of 2026, many learning-based manipulation systems output set-points (and sometimes stiffness) at 10 to 50 Hz and rely on a 1 kHz impedance controller underneath to make contact gentle and robust; dexterous manipulation at the Frontier level returns to this.
Common misconceptionsH

Common misconceptions

Misconception

"A stiffer robot is a more accurate robot, so stiffer is better." In free space, yes. In contact, stiffness turns every millimetre of uncertainty about where the world is into force. The right stiffness depends on the task and the phase of the task.

Misconception

"Force control means controlling force in every direction." You cannot command force along a direction in which nothing resists (the tool would just accelerate), nor position along a direction in which the environment does not let you move. Hybrid control chooses force or position per direction, according to the contact.

Misconception

"Software can make any robot safe to touch." Software can limit speeds and forces and stop quickly after a collision is detected, and that matters. But the first milliseconds of an impact are governed by the moving mass, the speed and the stiffness, which only hardware design and speed limits change.

Misconception

"Admittance control and impedance control are the same thing with different names." Both aim at the same mass–spring–damper behaviour, but one commands force from measured motion and the other commands motion from measured force. They fail in opposite situations: impedance control loses accuracy in free space, admittance control can chatter against stiff surfaces.

Exercises

Exercises

1. Force, impedance and compliant control

Warm-upHuman

A robot's position loop behaves like a spring of 20 00020\,000 N/m. It is told to put its tool 33 mm beyond the surface of a block whose stiffness is 80 00080\,000 N/m. What steady contact force, in newtons, results?

2. Force, impedance and compliant control

CoreHuman

A tool whose effective mass is 44 kg strikes a padded surface of stiffness 25 00025\,000 N/m at 0.250.25 m/s. Treat the contact as an undamped spring and ignore the controller (it is too slow to matter in the first milliseconds). What is the peak contact force, to the nearest newton?

3. Force, impedance and compliant control

CoreHuman

A factory wants to hand-guide a large industrial arm (high-ratio gearboxes that cannot be backdriven, drives that accept only position commands) by pushing on a handle with a six-axis force–torque sensor behind it. Which scheme fits the hardware?

Choose one

4. Force, impedance and compliant control

CoreHuman

A robot sands a flat vertical panel with a disc held flat against it. Using natural and artificial constraints, which assignment of the three translational directions is right?

Choose one

5. Force, impedance and compliant control

CoreComputational

Write joint_torques(q, F, l1, l2) for the planar two-link arm: the joint torques that make its tip push on the world with force F=(Fx,Fy)F = (F_x, F_y), ignoring gravity and motion. Use τ=J(q)⊤F\tau = J(q)^\top F, with the arm's Jacobian

J=[−l1sin⁡q1−l2sin⁡(q1+q2)−l2sin⁡(q1+q2)l1cos⁡q1+l2cos⁡(q1+q2)l2cos⁡(q1+q2)].J = \begin{bmatrix} -l_1\sin q_1 - l_2\sin(q_1 + q_2) & -l_2\sin(q_1+q_2) \\ l_1\cos q_1 + l_2\cos(q_1+q_2) & l_2\cos(q_1+q_2) \end{bmatrix}.

The tests check a hand-computed case and the principle of virtual work at several configurations.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

6. Force, impedance and compliant control

StretchComputational

Implement the heart of an admittance controller: a virtual mass–damper–spring Mx¨+Dx˙+Kx=fM\ddot x + D\dot x + Kx = f driven by the measured force ff. update(f) is called every dt seconds and must advance the state by one step with semi-implicit Euler (update the velocity from the acceleration, then the position from the new velocity) and return the new position offset xx, which the robot's position loop will track.

The tests push with a steady force on a critically damped admittance (it should settle at f/Kf/K without overshoot), try K=0K = 0 (hand guiding: a steady push gives a steady velocity f/Df/D), and check that nothing moves without a force.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

7. Force, impedance and compliant control

CoreHuman

A collaborative arm's collision detection stops its motors within 10 ms of an unexpected contact. Engineers want to reduce the peak force of an unexpected collision of the moving arm with an obstacle. Which change helps most?

Choose one

8. Force, impedance and compliant control

Warm-upHuman

What is the name of an actuator that deliberately places a spring between its gearbox and its load, and measures the spring's deflection to know the force? (Three words.)

Further reading and resources

  • Impedance Control: An Approach to Manipulation (Parts I–III) · Neville Hogan · 1985The papers that framed manipulation as controlling the dynamic relation between motion and force. Journal of Dynamic Systems, Measurement, and Control 107(1).
  • Hybrid position/force control of manipulators · Marc H. Raibert and John J. Craig · 1981Force control along some task directions and position control along the others, chosen by a selection matrix. Journal of Dynamic Systems, Measurement, and Control 103(2).
  • Compliance and force control for computer controlled manipulators · Matthew T. Mason · 1981Natural and artificial constraints, the language for deciding which directions to control in force. IEEE Transactions on Systems, Man, and Cybernetics 11(6).
  • A unified approach for motion and force control of robot manipulators: the operational space formulation · Oussama Khatib · 1987Dynamics and control written directly in task space, the basis of much modern whole-body control. IEEE Journal of Robotics and Automation 3(1).
  • Series elastic actuators · Gill A. Pratt and Matthew M. Williamson · 1995Putting a spring between gearbox and load on purpose, to measure and control force through its deflection. IEEE/RSJ IROS 1995.
  • Proprioceptive actuator design in the MIT Cheetah · Patrick M. Wensing, Albert Wang, Sangok Seok, David Otten, Jeffrey Lang and Sangbae Kim · 2017The case for low-ratio, high-torque-density motors that sense force through their own current. IEEE Transactions on Robotics 33(3).
  • Unified impedance and admittance control · Christian Ott, Ranjan Mukherjee and Yoshihiko Nakamura · 2010Why impedance control suits stiff environments and admittance control soft ones, and how to switch between them. IEEE ICRA 2010.
  • Modern Robotics: Mechanics, Planning, and Control · Kevin M. Lynch and Frank C. Park · 2017Chapter 11 covers force control, hybrid motion–force control and impedance control; free preprint and videos.
  • International Organization for Standardization (ISO)Publisher of ISO 10218 (safety of industrial robots) and ISO/TS 15066 (collaborative robots, including power and force limiting).
  • ros2_controlThe ROS 2 controller framework; its controller collection includes an admittance controller.