Embedded Systems · Control Theory · Tutorial

PID Control Explained: The Complete Guide to PID Implementation in C

PID is the workhorse of motor control — used to hold a speed, hit an exact position, or keep a robot balanced. This guide builds the intuition from the ground up, derives the math you actually need, gives you a clean, production-ready PID implementation in C, walks through running it on an STM32, and shows you how to tune it without the usual trial-and-error frustration. By the end, PID won't feel like a black box — it'll feel obvious.

What Is PID Control?

PID control — short for Proportional–Integral–Derivative — is a feedback control algorithm that automatically drives a system toward a desired target and keeps it there, even when the world pushes back. It is, by a wide margin, the most widely used control method in industry: an estimated 90%+ of all control loops in everything from cruise control and thermostats to drones, 3D printers, CNC machines, and industrial robots are some flavor of PID.

The reason for its dominance is simple: PID is model-free. You don't need a mathematical model of your motor, your heater, or your robot. You only need to measure the output and know the target. PID figures out the rest from three intuitive ideas — react to the error now, account for error that has built up over time, and respond to how fast the error is changing. That's it. Three numbers to tune, and a control loop that adapts to disturbances it was never explicitly told about.

A Everyday Analogy: Driving a Car

Before any math, let's ground PID in something you already do without thinking. Imagine you're driving and want to hold a steady 100 km/h. Your eyes read the speedometer (the measurement), your target is 100 km/h (the setpoint), and your foot on the throttle is the command. Watch how you naturally use all three PID terms:

A good driver blends all three automatically. A PID controller does exactly the same thing, just with arithmetic instead of intuition.

Open Loop vs. Closed Loop Control

Every control system answers one question: does it watch its own output and correct itself? That single difference splits all of control into two camps, and understanding it is the foundation everything else rests on.

An open-loop system fires off a command and hopes for the best. Tell a motor "apply 5 volts" and walk away — if the load gets heavier, the battery sags, or a bearing wears, the speed drifts and nothing notices. Its accuracy depends entirely on calibration and stable conditions. It's simple, cheap, and fast, but fundamentally blind. A microwave running for two minutes is open-loop: it never checks whether your food is actually hot.

A closed-loop system measures the real output with a sensor, compares it to the setpoint, and continuously nudges the command to close the gap. That feedback is what lets it shrug off disturbances it was never told to expect. A thermostat that turns the heater on and off to hold a room at 21 °C is closed-loop. PID lives here.

The Core Idea: One Number, Three Questions

PID works on a single value — the error, the difference between where you want to be (the setpoint) and where you actually are (the measurement):

From that one number, PID asks three different questions and blends the answers into a single command. This is the mental model to lock in — everything else is detail:

Present, past, future. That's the whole philosophy. Each term has a gain — Kp, Ki, Kd — that sets how loudly its answer counts. Now let's take each term apart, one at a time.

The Proportional Term (P): React to the Present

The proportional term is the engine of the controller. Its output is simply the error multiplied by a gain:

The logic is exactly what your intuition says: the further you are from the target, the harder you correct. A motor that's 500 RPM below setpoint gets a much stronger push than one that's only 10 RPM short. As the error shrinks, the correction automatically eases off, which is what lets the system settle smoothly instead of slamming into the target.

Raise Kp and the system responds faster and more aggressively. Raise it too far and it overshoots, then oscillates back and forth, and eventually becomes unstable — buzzing or hunting around the setpoint without ever settling.

The Integral Term (I): Erase the Past

The integral term watches the error over time. Every loop cycle, it adds the current error to a running total. As long as any error persists — even a tiny one — that accumulator keeps growing, steadily increasing the controller's output until the error is finally driven to zero.

This is the cure for steady-state error. Where the proportional term gives up once the error gets small, the integral term is relentless: a persistent 3 RPM shortfall might be invisible to P, but I will keep accumulating it cycle after cycle until that last little gap is closed. This is what lets a PID controller land exactly on the setpoint and stay there.

The trade-off is that the integral term is slow and can make the system sluggish or oscillatory if Ki is too high — it's reacting to history, so it lags. And it has one notorious failure mode you must guard against:

The Derivative Term (D): Predict the Future

The derivative term looks at how fast the error is changing — its slope — and pushes back against rapid change. If the error is closing quickly, D applies a braking action before the system overshoots, acting like a shock absorber that damps oscillation and lets you settle faster.

A well-chosen Kd lets you run a higher Kp for a snappy response while keeping overshoot under control — the best of both worlds. It's the term that makes a fast system feel smooth rather than twitchy.

The PID Equation

Put the three terms together and you get the classic continuous-time PID law:

Read it left to right and it's just the three questions again: K_p·e(t) is the present error, K_i·∫e(t)dt is the accumulated past error, and K_d·de(t)/dt is the rate of change. The output u(t) is the command you send to the motor — a PWM duty cycle, a voltage, a current setpoint, whatever your actuator takes.

From Math to Code: The Discrete PID

A microcontroller can't integrate or differentiate continuously — it runs your code at a fixed rate, say once every 1 millisecond. So we approximate the calculus with simple arithmetic on each loop tick, where dt is the time between ticks:

• The integral ∫e dt becomes a running sum: integral += error × dt
• The derivative de/dt becomes a difference: (error − prev_error) / dt

PID Implementation in C

Here's a compact, reusable controller. It's plain C — no STM32 dependencies — so you can drop it into any project and call pid_update() once per loop tick. It includes output clamping and anti-windup, the two things most tutorial implementations leave out.

typedef struct {
    float Kp, Ki, Kd;        // gains
    float integral;          // accumulated error
    float prev_error;        // for the derivative term
    float out_min, out_max;   // actuator limits
} PID;

void pid_init(PID *pid, float Kp, float Ki, float Kd,
              float out_min, float out_max)
{
    pid->Kp = Kp;  pid->Ki = Ki;  pid->Kd = Kd;
    pid->integral = 0.0f;
    pid->prev_error = 0.0f;
    pid->out_min = out_min;  pid->out_max = out_max;
}

float pid_update(PID *pid, float setpoint, float measurement, float dt)
{
    float error = setpoint - measurement;

    // Proportional — react to the error right now
    float P = pid->Kp * error;

    // Integral — accumulate to kill steady-state offset
    pid->integral += error * dt;
    float I = pid->Ki * pid->integral;

    // Derivative — respond to the rate of change
    float D = pid->Kd * (error - pid->prev_error) / dt;
    pid->prev_error = error;

    float output = P + I + D;

    // Clamp + anti-windup: stop integrating once saturated
    if (output > pid->out_max) {
        output = pid->out_max;
        pid->integral -= error * dt;   // undo this step's accumulation
    } else if (output < pid->out_min) {
        output = pid->out_min;
        pid->integral -= error * dt;
    }
    return output;
}

Motor Control on STM32

On an STM32, the pattern is always the same three steps, executed at a fixed rate from a timer interrupt: read the sensor → compute PID → drive the actuator.

Speed control (closed-loop RPM)

Read the motor speed from an encoder, run the PID, and write the result to a PWM channel driving the H-bridge:

PID motor_pid;
float target_rpm = 1500.0f;

void setup(void)
{
    // duty cycle clamped to 0..1000 (timer ARR)
    pid_init(&motor_pid, 0.8f, 12.0f, 0.01f, 0.0f, 1000.0f);
}

// Called from a 1 kHz timer interrupt (dt = 0.001 s)
void TIM2_IRQHandler(void)
{
    float rpm  = encoder_read_rpm();
    float duty = pid_update(&motor_pid, target_rpm, rpm, 0.001f);
    pwm_set_duty(TIM3, CH1, (uint16_t)duty);
}

Position control (closed-loop angle)

The exact same controller works for position — you just feed it the encoder count instead of speed, and a target angle as the setpoint. This is how servo positioning, robot joints, and gimbals work:

float target_deg = 90.0f;

void TIM2_IRQHandler(void)
{
    float angle = encoder_read_degrees();
    float cmd   = pid_update(&pos_pid, target_deg, angle, 0.001f);

    // signed command: sign picks direction, magnitude sets PWM
    motor_set_direction(cmd >= 0 ? FORWARD : REVERSE);
    pwm_set_duty(TIM3, CH1, (uint16_t)fabsf(cmd));
}

What Each Gain Does to the Response

The clearest way to see PID is the step response: command a sudden change and watch how the output chases the new setpoint over time. Each gain reshapes that curve in a characteristic way.

The tuning cheat sheet

Turning up a single gain has a predictable — but coupled — effect:

▾ = decreases / improves · ▴ = increases / worsens. These are general trends; because the terms interact, expect to iterate.

Try It Yourself: Interactive PID Simulator

Reading about gains is one thing — feeling them is another. Drag the sliders below to change Kp, Ki, and Kd and watch the step response redraw instantly. The simulated plant is a motor-like system with a little electrical and mechanical lag. With proportional-only control it settles short of the target (steady-state error); add the integral term and it lands exactly on the setpoint. Raise Kp and the response gets faster but overshoots more — exactly as the cheat sheet above predicts — and it stays stable across the whole slider range. Try the presets, then experiment.

How to Tune a PID Controller

Tuning is where most people get stuck, but a methodical approach beats random guessing every time. Here are the two most common methods.

Method 1 — Manual tuning (the practical recipe)

1. Start with Ki = 0 and Kd = 0.
2. Raise Kp until the system responds quickly and just begins to oscillate. Then back it off to about half that value.
3. Increase Ki until any steady-state error is driven to zero within an acceptable time. Too much Ki brings back oscillation and sluggishness.
4. If overshoot or ringing remains, add a small Kd to damp it. Keep it modest — too much amplifies noise.
5. Re-check under realistic disturbances (add load, change the setpoint) and fine-tune.

Method 2 — Ziegler–Nichols (a structured starting point)

A classic recipe that gives you ballpark gains. Set Ki = Kd = 0, then raise Kp until the output oscillates with a steady, constant amplitude. Call that gain the ultimate gain K_u and the oscillation period T_u. Then:

P, PI, PD, PID: Which One Do You Need?

You don't always need all three terms. Choosing the right combination keeps the controller simpler and often more robust.

Troubleshooting Common PID Problems

Real-World Applications

Once you start looking, PID is everywhere:

Frequently Asked Questions

Key Takeaways

• Closed-loop beats open-loop whenever accuracy or disturbances matter — feedback is the entire difference.
• P handles the present, I the past, D the future. That mental model explains every behavior you'll ever see.
• I eliminates steady-state error; D tames overshoot — but D amplifies noise, so use it sparingly (and often not at all).
• On a microcontroller, run the loop at a fixed rate from a timer interrupt, and always include anti-windup.
• Tune methodically: Kp first, then Ki, then a touch of Kd — and verify under real load.