PID control of a robot joint

Most robot joints in the world are controlled by some form of PID: proportional, integral and derivative feedback on the joint position error. Industrial arms, collaborative robots, legged robots and drones all run PID or close relatives in their inner loops, often alongside the model-based terms of later lessons. PID is popular because it needs only a rough plant model, can be tuned on the machine, and in its derivative and integral terms already provides damping and the rejection of constant disturbances such as gravity. It also has well-known failure modes: integrator windup when the actuator saturates, noise amplification by the derivative, and limit cycles with friction. This lesson designs PID controllers for the joint model of lesson 3 by pole placement, compares this with classical tuning rules, and covers the practical details that turn a textbook PID into one that works on a robot.

The plant: independent joint control

Lesson 3 reduced each joint to an effective inertia J and viscous damping b driven by torque, with gravity, friction and coupling from other joints lumped into a disturbance torque d:

Controlling each joint separately with this simple model is called independent joint control. It works well when the gear ratio is high, because the disturbance is small compared with the motor torque and the inertia varies little. The controller sees a position error \( e = q_d - q \) and computes a torque. The plant has a pole at the origin, a pure integrator from speed to position, and a pole at \( -b/J \). Our job is to place the closed-loop poles where we want them.

Proportional control

With \( \tau = K_pe \), the closed loop from desired to actual position is

a second-order system with \( \omega_n = \sqrt{K_p/J} \) and \( \zeta = b/(2\sqrt{K_pJ}) \). Raising \( K_p \) speeds the response but lowers the damping, and since b is usually small, a fast P controller oscillates badly. Its other weakness appears with a constant disturbance such as gravity: at steady state \( K_pe_{ss} = d \), so the joint sags by \( e_{ss} = d/K_p \).

PD control and pole placement

Adding derivative action, \( \tau = K_pe + K_d\dot{e} \), and taking \( \dot{q}_d = 0 \) for a set-point, gives the characteristic polynomial

Now the two closed-loop poles can be placed independently: \( K_p \) sets the natural frequency and \( K_d \) sets the damping. A common choice for robot joints is critical damping, ζ = 1, the fastest response without overshoot, because overshoot means the robot moves past its target and may hit something. The gains follow directly:

Physically, a PD controller is a virtual spring and damper connecting the joint to its target. The derivative should be taken of the measured position, \( -K_d\dot{q} \), rather than of the error when the set-point jumps, to avoid a huge torque spike at each step change (derivative kick). PD control still sags under gravity by \( d/K_p \), but with damping the gain can be raised until the sag is acceptably small.

PID control

Integral action accumulates the error so that any steady error causes a steadily growing torque until the error is gone:

The closed loop is now third order. By the final value theorem of ROB-230, a constant disturbance produces zero steady error, because the integrator places a zero at s = 0 in the transfer function from disturbance to error. A convenient pole-placement choice is a triple pole at \( s = -\omega \), which gives a critically damped, overshoot-free disturbance response. Matching \( J(s + \omega)^3 = Js^3 + 3J\omega s^2 + 3J\omega^2s + J\omega^3 \) term by term:

Other placements trade speed against overshoot; the Routh–Hurwitz test of lesson 5 shows that stability requires \( (b + K_d)K_p > JK_i \), so too much integral gain destabilizes the loop.

Classical tuning rules

When a model is not available, PID gains can be found by experiment. The Ziegler–Nichols ultimate-gain method, published in 1942, is the best known: with integral and derivative action off, raise the proportional gain until the loop oscillates steadily; record that ultimate gain \( K_u \) and the oscillation period \( T_u \); then set

These settings give fast but oscillatory responses, about a quarter-amplitude decay per cycle, which is usually too aggressive for robots. They are a starting point to be softened. Driving a robot joint into sustained oscillation is also risky, so relay auto-tuning, which induces a small controlled oscillation with an on–off torque, or model-based tuning from a measured step response, is safer in practice. For a pure double-integrator joint with little damping, P control is already marginally stable, so the ultimate-gain experiment does not apply directly; it suits joints with an extra lag such as a filter or delay.

Saturation and integrator windup

Every actuator has a torque limit. When a large step command saturates the motor, the error stays large for longer than the linear design assumed, and the integrator keeps accumulating it. When the joint finally reaches the target, the integrator holds a large stored value that drives the joint well past the target, producing a big overshoot and slow recovery. This is integrator windup. Two standard fixes are:

• Clamping (conditional integration): stop integrating while the output is saturated and the error would push it further into saturation.
• Back-calculation: feed the difference between the saturated and unsaturated commands back into the integrator through a gain \( 1/T_t \), bleeding off the excess. A tracking time \( T_t \) between \( T_d \) and \( T_i \) is a common choice.

Robot controllers also clamp the integrator to a maximum torque contribution and often reset or freeze it during large motions, enabling it only near the target where its job, removing small steady errors, is done. With static friction, an integrator can still cause the stick-slip limit cycle of lesson 3; remedies include friction feedforward, a small dead zone on the integrator, or integral action only on the velocity loop.

import numpy as np
J, b, tmax = 1.5, 0.5, 40.0                 # joint, torque limit 40 N m
Kp, Ki, Kd = 1012.5, 5062.5, 67.0
def run(antiwindup, T=1.5, h=1e-4):
    q = qd = integ = 0.0; peak = 0.0; target = 1.0
    for k in range(int(T/h)):
        e = target - q
        u = Kp*e + Ki*integ - Kd*qd
        tau = np.clip(u, -tmax, tmax)
        if antiwindup:
            integ += h*(e + (tau - u)/(Ki*0.05))      # back-calculation, Tt = 0.05 s
        else:
            integ += h*e
        qdd = (tau - b*qd)/J
        q += h*qd; qd += h*qdd
        peak = max(peak, q)
    return peak, q
for aw in (False, True):
    peak, qend = run(aw)
    print(f"anti-windup={aw!s:5}: overshoot {max(0.0, 100*(peak-1)):6.1f} %, q(1.5 s) = {qend:.3f} rad")

anti-windup=False: overshoot  152.6 %, q(1.5 s) = -2.686 rad
anti-windup=True : overshoot    0.0 %, q(1.5 s) = 1.000 rad

Without anti-windup the saturated step overshoots by more than 150 % and is still swinging wildly 1.5 s later, because the integrator stores the error accumulated during the long saturated climb and the saturated loop cannot unload it quickly; with back-calculation the joint arrives without overshoot and settles cleanly on the target. The torque limit makes this step far slower than the linear design predicted, a reminder that trajectory planning (lesson 8) should keep commands within the actuator's capability in the first place.

Practical PID details

Several further details separate a working joint controller from a textbook one:

• Derivative filtering: the derivative of a quantized encoder signal is noisy (ROB-230). Use a filtered velocity, for example a first-order low-pass with a cutoff a few times the loop bandwidth, or a velocity estimate from an observer (lesson 6).
• Velocity feedforward: when following a moving target, add \( K_d\dot{q}_d \) or better a model-based feedforward, so that the controller does not rely on error to generate the torque needed for motion.
• Gain scheduling: when inertia varies with configuration or payload, scale the gains with the estimated inertia, \( K_p = \hat{J}(\mathbf{q})\omega_n^2 \), so the loop keeps its intended speed and damping.
• Sample rate: a digital PID should run at least 10 to 20 times faster than the closed-loop bandwidth; lesson 11 covers discretization and delay.
• Bumpless transfer: when switching from manual to automatic mode or between gain sets, initialize the integrator so the commanded torque does not jump.