The PID Algorithm

Learning Goals 5 min

Bang-bang control overshoots and oscillates. PID — Proportional + Integral + Derivative — is the smoother controller used in cruise control, drones, 3D printer heaters, balancing robots, industrial process control. The same three-term formula has been industry standard for over a century. By the end of this lesson you will:

1. Explain what each of the three terms (P, I, D) contributes intuitively.
2. Implement a basic PID controller in Arduino C, with non-blocking sample timing.
3. Tune the three gains (K_p, K_i, K_d) using the "manual" method — and know when to reach for the PID_v1 / QuickPID libraries.

Warm-Up 10 min

No hardware. We'll think through the algorithm conceptually, then code it.

The intuition

PID looks at three things:

• P (proportional): how big is the error now? Bigger error → bigger reaction.
• I (integral): how much error has accumulated over time? Persistent small offsets eventually trigger a response.
• D (derivative): how fast is the error changing? Damps overshoot — if you're approaching the target fast, ease off.

Output = K_p·P + K_i·I + K_d·D, where each K is a tunable gain.

New Concept · PID in code 25 min

The minimal PID class

class PID {
public:
  PID(float kp, float ki, float kd)
    : kp_(kp), ki_(ki), kd_(kd),
      integral_(0), lastError_(0), lastTime_(0) {}

  float update(float setpoint, float measurement) {
    unsigned long now = millis();
    if (lastTime_ == 0) { lastTime_ = now; return 0; }
    float dt = (now - lastTime_) / 1000.0;
    if (dt <= 0) return 0;
    lastTime_ = now;

    float error = setpoint - measurement;
    integral_ += error * dt;
    float derivative = (error - lastError_) / dt;
    lastError_ = error;

    return kp_ * error + ki_ * integral_ + kd_ * derivative;
  }

  void setGains(float kp, float ki, float kd) { kp_ = kp; ki_ = ki; kd_ = kd; }
  void reset() { integral_ = 0; lastError_ = 0; lastTime_ = 0; }

private:
  float kp_, ki_, kd_;
  float integral_, lastError_;
  unsigned long lastTime_;
};

One update(setpoint, measurement) call per loop iteration. Returns a control output number.

Using it for a temperature controller

PID tempPID(2.0, 0.5, 1.0);   // initial gains

void loop() {
  float t = readTemp();
  float u = tempPID.update(80.0, t);   // setpoint 80 °C
  int duty = constrain((int)u, 0, 255);
  analogWrite(HEATER_PIN, duty);
  delay(100);
}

The output u can be any number — clamp to your actuator's range. For a heater (PWM 0..255), use constrain. For a bidirectional motor, the sign of u = direction.

Tuning method 1 — manual

Standard practice:

1. Start with K_p small, K_i = 0, K_d = 0.
2. Increase K_p until the system oscillates. Halve.
3. Add a little K_d to dampen overshoot.
4. Add K_i if there's persistent steady-state error.

Tuning method 2 — Ziegler-Nichols

Engineering classic. Set K_i = K_d = 0. Increase K_p until you get sustained oscillation. Note the gain (K_u) and period (T_u). Then:

• P only: K_p = 0.5 K_u.
• PI: K_p = 0.45 K_u, K_i = 1.2 K_p / T_u.
• PID: K_p = 0.6 K_u, K_i = 2 K_p / T_u, K_d = K_p T_u / 8.

Heuristic, not optimal, but a fast first cut. Tune up from there.

Anti-windup

If the actuator is saturated (e.g. motor at 100% duty but still not reaching setpoint), the integral keeps growing indefinitely. When the error finally drops, the accumulated integral causes a long overshoot. The fix is "anti-windup": stop accumulating integral while the actuator is saturated.

if (output > MAX_OUT) { output = MAX_OUT; /* don't grow integral */ }
else if (output < MIN_OUT) { output = MIN_OUT; }
else { integral_ += error * dt; }

Real libraries (PID_v1, QuickPID) handle anti-windup, output limits, and derivative-on-measurement (a refinement that ignores setpoint changes in the D term) for you.

Worked Example · PID-controlled fan speed 25 min

You want to hold a fan at a target speed (in RPM) regardless of how dusty it is. Open-loop: analogWrite a duty cycle. Closed-loop: read a tachometer pulse from the fan, measure RPM, PID controls duty.

Pseudo-build

• Fan with 4-wire connector (PWM + tach input).
• PWM out from Arduino → fan's PWM pin.
• Tach pulse counted via interrupt on D2.
• PID at 10 Hz.

Sketch outline

#include "PID.h"

const int PWM_PIN = 9;
const int TACH_PIN = 2;
volatile unsigned int pulses = 0;

PID pid(0.5, 0.2, 0.05);

void onPulse() { pulses++; }

void setup() {
  Serial.begin(115200);
  pinMode(PWM_PIN, OUTPUT);
  pinMode(TACH_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(TACH_PIN), onPulse, RISING);
}

void loop() {
  static unsigned long lastSample = 0;
  unsigned long now = millis();
  if (now - lastSample < 100) return;
  float dt = (now - lastSample) / 1000.0;
  lastSample = now;

  noInterrupts();
  unsigned int p = pulses;
  pulses = 0;
  interrupts();

  // 4-wire PC fans give 2 pulses per revolution
  float rpm = (p / dt) * 60.0 / 2.0;
  float u = pid.update(2000.0, rpm);
  int duty = constrain((int)u, 0, 255);
  analogWrite(PWM_PIN, duty);

  Serial.print("rpm=");  Serial.print(rpm);
  Serial.print(" duty="); Serial.println(duty);
}

Tuning the fan

1. Run with K_i = K_d = 0. Increase K_p: 0.2 → 0.5 → 1.0. Watch for the moment it oscillates around 2000 RPM.
2. Halve K_p. Now smooth but probably 50 RPM off setpoint.
3. Add K_i = 0.1. Steady-state error should slowly fade.
4. Add K_d = 0.05. Tames overshoot when setpoint changes quickly.

Final tuning depends on the fan + sensor + sample rate. Plot the RPM vs setpoint over a few minutes to see the response.

Try It Yourself 15 min

Mini-Challenge · Identify P / I / D contributions 10 min

For each scenario, name which term is most responsible:

1. System overshoots target by 20 % then settles.
2. System never quite reaches target — sits at 95 % of setpoint forever.
3. System oscillates rapidly around target.
4. System reacts sluggishly to a sudden setpoint change.

Recap 5 min

PID = three terms acting on the error and its derivatives. Tune in this order: K_p, K_d, K_i. Anti-windup the integral. Smooth noisy measurements before computing D. For production, use PID_v1 / QuickPID library. PID lives in cruise control, drones, 3D printer heaters, factory floor regulators. Tomorrow we apply PID to a real moving target — line-following.

PID

Proportional + Integral + Derivative controller. The most widely-used closed-loop control algorithm.

Proportional (P)

Output proportional to current error. Gain K_p. Bigger gain = faster but more overshoot.

Integral (I)

Accumulates error over time. Eliminates steady-state offset. Gain K_i.

Derivative (D)

Reacts to how fast error is changing. Damps overshoot. Gain K_d. Amplifies sensor noise.

Setpoint, error, output

Setpoint = target; error = setpoint − measurement; output = controller's action signal.

Anti-windup

Preventing the integral term from growing while the actuator is saturated. Avoids long overshoots after disturbances.

Ziegler-Nichols tuning

Classic heuristic for setting K_p/K_i/K_d from an oscillation test.

Sample period

How often the controller runs. Should be much faster than the system's natural time constant.

PID_v1 library

Brett Beauregard's industry-standard Arduino PID library. Handles dt, anti-windup, modes.

Homework 5 min

1. Code the §3 PID class. Save in your reusable library folder.
2. If you have a fan with tachometer, build the §4 controller. Otherwise simulate with two pots: one as "measurement", one as "setpoint", output to an LED's brightness. Tune the gains.
3. Read ahead to ARD-L04-25 (Line-Following Sensors). Bring IR reflectance sensors (TCRT5000 × 3 or a QTR sensor array).