A guide on how to tune a PID controller

[maxeitelwein]

Description: This post aims to help users understand how to tune their thermostat controller with a simulation.

To get a first impression of how your room's temperature reacts to a heater, I wrote a small simulation of a room climate system, which can be found at the bottom of this post. To run it just copy it to your PC, input your room's parameters and run it with python. It will show you in a graph how the temperature of a room will react to a heater that is controlled by a PID controller.

Understand the important parameters

1. Heat Capacity (C)

The heat capacity of a room is a measure of how much heat is required to change the room's temperature by 1°C.

2. Thermal Resistance (R)

The thermal resistance (R) of the room walls determines how effectively the walls prevent heat from escaping. Typically around 0.5-1 W/m·K for badly isolated houses and 3-5 for new and better isolated houses.

3. Maximum Heating Power (Q)

The maximum heating power (Q) refers to the maximum output of the heating system, typically provided by the manufacturer. It is usually given in Watts (W).

How to tune the PID controller

1. Start by setting the P value to e.g 10 and I and D to 0. Run the simulation. If the room temperature takes a long time to increase, increase the P value until you are either happy with the time it takes for the temperature to rise or you are overshooting your set target.
2. Set an I value to e.g 0.001. It has to be very small, because for a heating system a P-controller often suffices to control it. The I value only makes sure, that the set-point is definitely reached. Setting it to high makes the controller too aggressive and the temperature will overshoot by a lot.
3. In my opinion the D value is unnecessary. The D value has to be used with a lot of caution since it makes the system unstable (not good). In most cases it is enough to just leave it at 0. You can play with it a bit by setting it to e.g 1
4. If you are happy with your simulation results implement your found P, I, D values into the real smart_thermostat and test them. There you probably have to tweak them a little bit because the simulation is very rudimentary. However it gives a good starting point.

Code

To get a understanding to what I assumed is a "good tuning", just run the code with the set parameters.

import numpy as np
import matplotlib.pyplot as plt

# Simulation parameters
dt = 60.0                 # Time step (seconds) (input how often your sensor reports its temperature)
simulation_time = 3600   # Total simulation time (seconds)
steps = int(simulation_time / dt)

# System parameters
# Heat capacity (C) calculation:
# C = m * c
# Where m is the mass of the room air (kg), and c is the specific heat capacity of air (J/kg·K).
room_volume = 65         # Room volume in cubic meters (m^3)
air_density = 1.225      # Air density (kg/m^3)
specific_heat_air = 1005 # Specific heat capacity of air (J/kg·K)
m = room_volume * air_density  # Mass of the air in the room (kg)
C = m * specific_heat_air  # Heat capacity of the room (J/K)

# R depends on your house's isolation: Bad isolation: 0.5-1, good isolation: 3-5
R = 1                    # Thermal resistance (K/W)

# Time it takes from turning on the heater to any temperature change in the room
tau_d = 60               # Dead time (seconds)

Q_max = 3200             # Maximum heating power (W)

T_out = 10               # Outside temperature (°C)

# PID parameters
Kp = 14
Ki = 0.001
Kd = 0

# Target temperature
T_target = 21            # Desired room temperature (°C)

# Initializations
T_room = [18]            # Room temperature
Q_heating = [0]          # Heating power
error_sum = 0            # Error integration
previous_error = 0

# Lists to store PID components
P, I, D = [0], [0], [0]

# Dead time memory
delayed_heating = [0] * int(tau_d / dt)

# Simulation loop
for t in range(steps):
    # --- PID controller ---
    error = T_target - T_room[-1]  # Error calculation
    error_sum += error * dt  # Error accumulation (I-component)
    error_rate = (error - previous_error) / dt  # Error rate (D-component)
    previous_error = error  # Update previous error

    # PID control output
    control = Kp * error + Ki * error_sum + Kd * error_rate
    control = max(0, min(control, 100))  # Limit to 0-100%
    Q = (control / 100) * Q_max  # Heating power in Watts

    # Store PID components
    P.append(Kp * error)
    I.append(Ki * error_sum)
    D.append(Kd * error_rate)

    # Account for dead time
    delayed_heating.append(Q)
    delayed_Q = delayed_heating.pop(0)

    # System dynamics (temperature update)
    T_new = T_room[-1] + dt / C * (delayed_Q - (T_room[-1] - T_out) / R)

    # Store new room temperature
    T_room.append(T_new)

# Time vector for plotting
time = np.arange(0, simulation_time + dt, dt)

# Plot results
plt.figure(figsize=(12, 12))

# Temperature evolution
plt.subplot(3, 1, 1)
plt.plot(time, T_room, label="Room Temperature")
plt.axhline(T_target, color="red", linestyle=":", label="Target Temperature")
plt.xlabel("Time (s)")
plt.ylabel("Temperature (°C)")
plt.legend()
plt.grid()
plt.title("Room Temperature Evolution")

# Heating power (0-100%)
plt.subplot(3, 1, 2)
plt.plot(time, np.array([min(100, max(0, Kp * (T_target - T) + Ki * (T_target - T) * dt + Kd * (T_target - T))) for T in T_room]), label="Heating Power")
plt.xlabel("Time (s)")
plt.ylabel("Heating Power (%)")
plt.legend()
plt.grid()

# PID components (P, I, D)
plt.subplot(3, 1, 3)
plt.plot(time, P, label="P-component")
plt.plot(time, I, label="I-component")
plt.plot(time, D, label="D-component")

plt.xlabel("Time (s)")
plt.ylabel("PID Components")
plt.legend()
plt.grid()

plt.tight_layout()
plt.show()

Have fun with it.