Arduino PID Control Tutorial

Updated: October 28, 2025

In control systems, a controller corrects the output of a particular system to a target in the presence of errors and disturbances. The most popular type of controller is PID which is an acronym for Proportional, Integral, and Derivative. In this Arduino PID control tutorial, I will show you how you can employ such a controller in your project.

What is PID?

As mentioned, PID is short for proportional, integral, and derivative. The name comes from the methods of how such controllers deal with disturbances in the system. However, such a controller is only in feedback systems. I suggest reading material specifically written for such a topic, but I’ll do my best to explain it here as simply as I can.

A feedback system is one wherein part of the output is “fed back” to the input. For example, you could have a project that controls the fire in the furnace. Below is a simple illustration:

You want to maintain the temperature in the furnace to a certain set point.  A temperature sensor in the furnace determines the temperature at any time. This sensor, in this case, provides the feedback as a reference on the required temperature increase or decrease. The difference between the feedback sensor value and a temperature set point is the error.

In this Arduino PID tutorial, we’ll learn how to build a feedback control system that automatically adjusts an actuator such as a motor or heater.

Proportional Control

Proportional control refers to an adjustment that is proportional to how much the error is. Let’s say the controller in our example is an electronic valve for controlling the fuel to the furnace. If the error is small, the valve will release a small amount of fuel so that the set point and the feedback match. If the error is large, the valve must release more fuel.

Integral Control

Proportional control produces offset in its correction due to disturbances. The Integral controller can remove this offset and bring back the error to zero. Such a controller produces an adjustment that is based on the accumulated error over time. Without integral control, the system can’t deal with trends on errors.

Using our previous example, an offset may be present when the fuel valve doesn’t return to its original position when it increases and then decreases its fuel output. The integral controller will detect this and will turn the fuel valve to its original position.

Derivative Control

Finally, Derivative control deals with the rate of change of the error. If integral control looks at the history of the error, derivative control predicts the error. Basically, the amount of correction will be based on how fast the error is changing. This type of controller works best with dynamic errors which both proportional and integral controllers can’t deal with.

Let’s say the temperature in the furnace goes from 130 °C to 140 °C against a 120 °C set point in 2 seconds. The proportional and integral controllers will respond to the magnitude of the error, but they will have a hard time catching up to how fast the error occurred.. The derivative controller can deal with such because it has been looking at the rate of change of the error from the beginning.

A feedback system with a PID controller:

$r(t) = K_{p}e(t) + K_{i} \int e(t)dt + K_{d}\frac{de(t)}{dt}$

Here the input variable or set point is r(t), the output variable is y(t), the controlled variable is u(t) and the error is e(t). Continuing with our furnace example, r(t) would be the desired temperature and y(t) is the actual temperature; e(t) is the difference between the desired temperature and actual temperature; u(t) is the sum of the corrections from the P, I and D controllers which are fed to the plant which is the fuel valve.

Note that a PID controller is not usable out of the box. Tuning must be done to ensure that the desired performance is achieved. This is done by carefully changing K constants as shown on the diagram above. These constants must be determined beforehand and changed according to the actual response of the system until the optimum values are achieved.

PID Term Effects Overview

This table shows how each PID term typically affects system behavior.

Implementing PID in Code

To implement a PID controller in an Arduino sketch, we need to calculate the three control terms — Proportional (P), Integral (I), and Derivative (D) — during each loop cycle, based on the error between the setpoint and the actual measured value.

Required Parameters

Before coding, identify these five parameters:

Step 1: Measure Time Elapsed

PID calculations depend on how much time has passed since the last update.
In Arduino, we can use millis() to get the current runtime in milliseconds.

currentTime = millis();
elapsedTime = currentTime - previousTime;

Step 2: Compute the Error

The error is simply the difference between the target value and the measured value.

error = setPoint - input;

Step 3: Compute the Integral and Derivative

The integral accumulates the total error over time.

The derivative looks at how quickly the error is changing.

cumError += error * elapsedTime;                // Integral term
rateError = (error - lastError) / elapsedTime;  // Derivative term

Tip: Limiting the cumulative error prevents "integral wind-up". You can use constrain(cumError, -maxIntegral, maxIntegral);

Step 4: Combine the Terms to Compute Output

Multiply each term by its constant and sum them to produce the final control output:

output = Kp * error + Ki * cumError + Kd * rateError;

This output can be sent to an actuator (e.g., motor PWM signal, heater power, servo position).

Step 5: Store Current Values for Next Cycle

Before ending the loop, save the latest error and timestamp for the next iteration.

lastError = error;
previousTime = currentTime;

Full Example Code

Below is a simple Arduino PID control loop example for a motor positioning system using a rotary encoder:

// --- PID constants (tune these for your system) ---
double Kp = 2.0;
double Ki = 5.0;
double Kd = 1.0;

// --- PID variables ---
unsigned long currentTime, previousTime;
double elapsedTime;
double error, lastError;
double input, output, setPoint;
double cumError, rateError;

void setup() {
  setPoint = 0; // Target position = 0 degrees
  pinMode(3, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  input = analogRead(A0);        // Read sensor or encoder input
  output = computePID(input);    // Get PID output
  analogWrite(3, output);        // Drive motor (PWM output)
  delay(50);                     // Adjust delay for your system
}

double computePID(double inp) {
  currentTime = millis();
  elapsedTime = (double)(currentTime - previousTime);

  error = setPoint - inp;
  cumError += error * elapsedTime;
  rateError = (error - lastError) / elapsedTime;

  double out = Kp * error + Ki * cumError + Kd * rateError;

  // --- Prevent integral wind-up ---
  out = constrain(out, 0, 255);  

  lastError = error;
  previousTime = currentTime;

  return out;
}

Understanding the Output

• Increasing Kp makes the system respond faster but can cause oscillation.
• Increasing Ki helps reach the target value by removing steady-state error.
• Increasing Kd reduces overshoot and stabilizes the response.

Try printing the values to the Serial Monitor:

Serial.print("Error: "); Serial.print(error);
Serial.print("\tOutput: "); Serial.println(output);

This helps you visualize the controller’s performance while tuning.

If you prefer not to write your own PID logic, you can use Brett Beauregard’s PID_v1 library — which includes automatic handling of timing, limits, and modes. Let’s explore that next.

Using the Arduino PID Library

Manually coding a PID loop is a great learning exercise, but for most projects it’s easier and safer to use the Arduino PID Library written by Brett Beauregard.
This library (known as PID_v1) takes care of timing, output limits, and direction — letting you focus on tuning and testing instead of math.

Installing the Library

1. In the Arduino IDE, go to Sketch → Include Library → Manage Libraries…
2. Search for “PID”
3. Install “PID by Brett Beauregard”
4. Once installed, include it in your sketch:

 #include <PID_v1.h>

How It Works

You define:

• Input — the process variable (e.g., temperature, position)
• Setpoint — the target value
• Output — the control signal sent to the actuator (PWM, valve, etc.)
• Tunings — constants Kp, Ki, Kd

The library continuously computes:

Output = Kp * error + Ki * integral + Kd * derivative

at a set sample rate (default: 100ms).

Basic Example

Below is the classic PID_Basic.ino example that ships with the library. This sketch controls an analog input (like a temperature or position sensor) and writes the PID output to a PWM pin.

#include <PID_v1.h>

#define PIN_INPUT  A0
#define PIN_OUTPUT 3

// --- Define Variables we’ll be connecting to ---
double Setpoint, Input, Output;

// --- Specify initial tuning parameters ---
double Kp = 2, Ki = 5, Kd = 1;

// Create PID object: (Input, Output, Setpoint, Kp, Ki, Kd, Direction)
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

void setup() {
  Serial.begin(9600);
  Setpoint = 100;              // Target value
  Input = analogRead(PIN_INPUT);
  myPID.SetMode(AUTOMATIC);    // Enable PID
  myPID.SetOutputLimits(0, 255); // Limit PWM output range
}

void loop() {
  Input = analogRead(PIN_INPUT);  // Read process variable
  myPID.Compute();                // Calculate PID output
  analogWrite(PIN_OUTPUT, Output); // Drive actuator

  Serial.print("Input: "); Serial.print(Input);
  Serial.print("\tOutput: "); Serial.println(Output);
  delay(100);
}

Key Library Functions

Manual vs. Library Approach

Tuning with the Library

Start with:

double Kp = 2, Ki = 5, Kd = 1;

Then:

1. Increase Kp until the output starts oscillating.
2. Slowly increase Ki to eliminate steady-state error.
3. Add Kd to smooth the response.

Optional:

myPID.SetSampleTime(50); // faster updates (50 ms)
myPID.SetOutputLimits(0, 255); // match your actuator range

Tip: For slow systems like temperature control, use a longer sample time (500–1000 ms).
For fast systems (motor speed), shorter intervals (20–100 ms) work better.

Advanced: Auto-Tuning PID

You can add the PID_AutoTune library by the same author to find near-optimal constants automatically.
It works by oscillating the system and calculating Kp, Ki, and Kd based on response data.
Once tuned, hardcode those values for stable operation.

• The PID library simplifies everything — you just define input, output, setpoint, and constants.
• Use SetOutputLimits() and SetMode() to prevent overshoot and actuator strain.
• Combine this with real sensor feedback (e.g., temperature, distance, position) for stable closed-loop control.

Next: Try combining this with the PID Tuning Example section to visualize how each constant affects your Arduino project.

PID Tuning Example

To see PID control in action, let’s apply it to a simple temperature control system.

Hardware Setup

• Arduino Uno or compatible board
• LM35 or TMP36 temperature sensor
• MOSFET or relay to switch a heating element (small lamp or resistor)
• 5V power supply
• Serial Monitor to observe temperature readings

The goal is to maintain the temperature at 40 °C using PID.

Step-by-Step

1. Start with Kp only (Ki = 0, Kd = 0).
   Increase Kp gradually until the temperature oscillates around the setpoint.
   This finds the “critical” proportional gain.
2. Add Ki slowly to remove steady-state error.
   If the system overshoots or reacts sluggishly, reduce Ki.
3. Add Kd to dampen overshoot and make the response smoother.
   Kd predicts rapid changes in error.

Example parameter set (your results will vary):

Observing the Response

Below is a sample plot of the system’s step response while tuning:

You should see:

• Faster rise time with increasing Kp
• Reduced offset with Ki
• Minimal overshoot with correct Kd

Code Snippet

You can adapt your earlier sketch by printing values to the Serial Monitor:

Serial.print("Temp: ");
Serial.print(Input);
Serial.print("  Output: ");
Serial.println(Output);

Then log these readings into Excel or Plotter to visualize PID performance.

Tip: For slower systems (like temperature), choose a longer sample time (e.g., 1 second). For faster systems (motors), use shorter intervals (10–100 ms).

Troubleshooting and FAQs

Even with correct formulas, PID tuning can be tricky.
Here are some common issues and fixes you can try:

Q: My output oscillates rapidly.

A: Your Kp is too high or loop interval is too short.
→ Reduce Kp gradually or add a small Kd term to stabilize.

Q: The system reacts slowly and never reaches the setpoint.

A: Increase Kp slightly or raise Ki to remove the steady-state error.
Make sure your actuator (motor, heater, etc.) is powerful enough.

Q: My integral term keeps increasing (system overshoots badly).

A: This is integral wind-up.
Use the PID library’s SetOutputLimits() function to restrict the output range, or reset the integral when output saturates.

Q: The derivative term makes my output noisy.

A: Add a small delay or filter your input sensor value.
Derivative amplifies noise, so a simple moving average helps.

Q: Can I use this PID library on an ESP32 or STM32 board?

A: Yes. The PID_v1 library is platform-independent.
Just adjust PWM resolution and output limits for your microcontroller.

Q: How do I choose the right sample time?

A: As a rule of thumb, pick a loop interval 5–10 × faster than your system’s expected response time.
For motors: 50–100 ms; for temperature control: 1–2 s.

Summary and Closing

When tuning:

1. Start with Kp only → find a stable oscillation.
2. Add Ki to remove offset.
3. Add Kd to smooth response.
4. Use small incremental adjustments and record your results.

Tip: Patience matters — even small parameter changes can have a big effect on control stability

Hopefully, you have a slight grasp of how to implement PID control in this article. It is a powerful controller that will reduce manual correction for your systems. If you have any questions about implementing Arduino PID, kindly drop a comment below!