If you’ve ever wondered how your robotic vacuum cleaner doesn’t slam into walls every time or how a self-driving car hugs curves without spinning out like a confused Beyblade, allow me to introduce the unsung hero behind the scenes: the PID controller.
PID stands for Proportional-Integral-Derivative. Sounds fancy, I know—but don’t panic. It’s just a control algorithm that helps a system reach a desired goal smoothly and efficiently. Think of it like that one friend who’s great at keeping you on track without overreacting or being annoyingly slow about it.
In this post, we’ll break down the intuition behind PID control, give you a taste of the math, show you how to code it in Python and C++, and explain how it’s used in robotics and self-driving vehicles. And yes, there’s a bonus at the end that segues into Robot Operating Systems (ROS) because why stop at just one piece of the automation puzzle?
Table of Contents
Why Do We Need a Controller in the First Place?
Let’s say you want your robot to reach a target position or speed. You could just keep pushing it until it gets there… but it’ll probably overshoot, oscillate like crazy, or just freeze in indecision. That’s where a controller comes in.
A PID controller takes the difference between what you want (the setpoint) and what you currently have (the process variable), and decides how much correction to apply.
The Intuition Behind PID
Let’s break it down like it’s 2 AM and you’re debugging a robot that just yeeted itself off a table.
- Proportional (P) – “How far off am I?”
- This part reacts to the current error.
- Bigger error? Bigger correction.
- But only using P can lead to overshooting and never fully settling.
- Integral (I) – “How long have I been off?”
- This sums up past errors.
- Helps eliminate bias or small consistent errors.
- But too much I? Hello, overshoot and instability.
- Derivative (D) – “How fast is the error changing?”
- Predicts future error based on rate of change.
- Smooths the response, prevents overshoot.
Put them together, and you get a controller that’s reactive, adaptive, and not a complete drama queen.
The Equation
The PID formula looks like this:
\(\text{output} = \text{Kp} * \text{error} + \text{Ki} * \text{integral} + \text{Kd} * \text{derivative}\)
where,
\(\text{error} = \text{setpoint} – \text{current_value}\\
\text{integral} \mathrel{+}=\text{error} * \text{dt}\\
\text{derivative} = (\text{error} – \text{previous_error}) / \text{dt}\)
The constants Kp, Ki, and Kd are the tuning parameters. You’ll spend a lot of time fiddling with these in real life.
PID controller in Python: Quick Example
import matplotlib.pyplot as plt
class PIDController:
def __init__(self, Kp, Ki, Kd):
self.Kp = Kp
self.Ki = Ki
self.Kd = Kd
self.integral = 0
self.previous_error = 0
def update(self, setpoint, current_value, dt):
error = setpoint - current_value
self.integral += error * dt
derivative = (error - self.previous_error) / dt
output = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
self.previous_error = error
return output
# Simulation parameters
pid = PIDController(1.2, 0.01, 0.4)
setpoint = 10
current_value = 0
dt = 0.1
time = [0]
values = [current_value]
outputs = [0]
# Run the PID simulation
for i in range(1, 100):
control_signal = pid.update(setpoint, current_value, dt)
current_value += control_signal * dt # Simulating system response
outputs.append(control_signal)
values.append(current_value)
time.append(i * dt)
# Plotting the result
plt.figure(figsize=(10, 5))
plt.plot(time, values, label='System Output')
plt.axhline(setpoint, color='r', linestyle='--', label='Setpoint')
plt.title('PID Controller Response Over Time')
plt.xlabel('Time (s)')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()Here is the output of the controller:
Breaking Down the PID Controller in Python (With a Plot to Prove It Works)
Let’s walk through the code above.
In this example, we define a class called PIDController with three parameters: Kp, Ki, and Kd, representing the proportional, integral, and derivative gains, respectively. These gains are what control the aggressiveness of each term in the feedback loop. We also initialize an integral accumulator and a variable to store the previous error so we can calculate how fast the error is changing.
The controller has an update() method, which takes in the desired target value (the setpoint), the current system state, and the time step dt. It computes the error (difference between setpoint and actual value), adds it to the integral term (to track accumulation over time), and calculates the derivative (how fast the error is changing). It then combines all three terms using the PID formula to generate a control output.
We simulate a basic system starting at zero and trying to reach a setpoint of 10. On each loop iteration (we do 100 steps), we apply the PID output to the system, allowing it to evolve over time. This models how a motor or steering system might behave under control—slowly moving toward the target value.
To make this even more visual (because data without a graph is just numbers yelling at you), we plot the results using Matplotlib. The output graph shows the system value over time approaching the red dashed line, which represents the setpoint. A well-tuned controller will get close quickly and settle smoothly without oscillating wildly or dragging forever like a Windows XP shutdown.
This kind of simulation is a great way to get an intuitive feel for how the three PID terms interact—P helps you move fast, I helps you eliminate bias or drift, and D stops you from overshooting like a caffeinated RC car.
Now that you’ve seen it work in Python, and you’ve got a plot to prove it, you’re already ahead of half the internet tutorials out there. Ready to try it on an actual robot or vehicle system? Keep reading.
PID in C++
In real-life applications, the system in which PID controllers are implemented demand high speed. Now don’t blow your brains out but in such cases, C++ has proven to be faster than Python (You can take a break here to calm yourself down!)
So below is the implementation of PID-controller in C++:
#include <iostream>
#include <fstream>
#include <vector>
class PIDController {
public:
PIDController(double kp, double ki, double kd)
: Kp(kp), Ki(ki), Kd(kd), prev_error(0), integral(0) {}
double update(double setpoint, double current_value, double dt) {
double error = setpoint - current_value;
integral += error * dt;
double derivative = (error - prev_error) / dt;
prev_error = error;
return Kp * error + Ki * integral + Kd * derivative;
}
private:
double Kp, Ki, Kd;
double prev_error, integral;
};
int main() {
PIDController pid(1.2, 0.01, 0.4);
double setpoint = 10.0;
double current_value = 0.0;
double dt = 0.1;
std::vector<double> time, output, values;
std::ofstream file("pid_output.csv");
file << "Time,Output,SystemValue\n";
for (int i = 0; i < 100; ++i) {
double t = i * dt;
double control = pid.update(setpoint, current_value, dt);
current_value += control * dt;
time.push_back(t);
output.push_back(control);
values.push_back(current_value);
file << t << "," << control << "," << current_value << "\n";
}
file.close();
std::cout << "Simulation complete. Data saved to pid_output.csv\n";
return 0;
}Tuning the Beast: Finding the Optimal P, I, and D
If PID gains were people, P would be the reactive overachiever, I the long-term planner, and D the overly cautious friend. Getting the perfect trio to vibe together? That’s where tuning comes in.
Let’s break it down.
1. The Good Ol’ Manual Tuning Method
This one’s for the hands-on folks who love trial and (a lot of) error.
- Step 1: Set I = 0 and D = 0, and increase P until the system starts oscillating (like it’s had too much coffee).
- Step 2: Dial P back just enough to stop the oscillation.
- Step 3: Now introduce a bit of I to eliminate any steady-state error.
- Step 4: Sprinkle in some D to reduce overshoot and stabilize the response.
It’s kind of like seasoning food—too much of anything and it’s a disaster, but just enough and it’s chef’s kiss.
2. Ziegler-Nichols Method (For the Fancy Ones)
For when you’re feeling more academic:
- Set I = 0, D = 0.
- Increase P until you reach the ultimate gain (Ku), where the system oscillates with a constant amplitude.
- Measure the oscillation period (Pu).
- Use these classic formulas:
| Controller | Kp | Ki | Kd |
|---|---|---|---|
| P | 0.5Ku | 0 | 0 |
| PI | 0.45Ku | 1.2Kp/Pu | 0 |
| PID | 0.6Ku | 2Kp/Pu | Kp*Pu/8 |
3. Software-Based Tuning
If you’re using a simulation platform or a robot middleware like ROS, some frameworks (like Gazebo + ROS2) offer auto-tuning plugins or adaptive controllers that can do the hard work for you. You still need to know what’s happening under the hood—but hey, who doesn’t love a bit of automation?
Pro Tips While Tuning:
- High P = Fast response but more overshoot.
- High I = Removes steady-state error but can destabilize.
- High D = Reduces overshoot but can cause noise sensitivity.
Tune smart. Or prepare to chase your robot as it launches into the neighbor’s bushes.
Real-World Use Cases of PID Controllers
1. Robots
Robots need to control their motors, joints, and sensors in a reliable, smooth way. Whether it’s moving an arm to a certain angle or maintaining speed on a mobile base, PID controller helps prevent jerky movement and laggy response.
2. Self-Driving Cars
- Throttle control: Adjust speed based on road and traffic conditions.
- Steering control: Follow lanes and curves precisely.
- Brake control: Slow down smoothly when needed, not just slam to a halt.
And all this happens in real-time, which is why well-tuned PID controllers are critical for safety and performance.
Summary
- A PID controller continuously adjusts system output based on current, past, and predicted errors.
- It helps systems reach and maintain target values smoothly—no guesswork or overshoot parties.
- You saw how to implement one in both Python and C++.
- Robots and autonomous vehicles use PID controller to manage everything from motion to steering, keeping things responsive and stable.
Want to Level Up? Time to Talk ROS
If PID controller is the brain behind smooth control, ROS (Robot Operating System) is the entire nervous system that makes it all work together. Controllers, sensors, data pipelines—ROS is how modern robots communicate, plan, and execute.
So if you’re ready to go from “I can make a robot move” to “I can make an intelligent robot ecosystem,” check out my next blog:
An Intuitive Guide to Robot Operating System (ROS)
And hey, if you’re enjoying these tutorials, don’t forget to follow me on Instagram @machinelearningsite where I post demos, quick code tips, and the occasional AI meme roast.
Let the robots roll.