The layout in Figure 2 reflects the “classic” PID architecture, naming conventions, and software implementation, versus the primary reference article. Figure 2 shows the PID design by, where Kp, Ki, and Kd denote the time constants of the proportional, integral, and derivative terms respectively. Within the literature, the variable, block, and even layouts may change, while the fundamentals stay the same.

In this section, I am going to step through the blocks defined in Figure 2 “PID controller schematic” and look at how they have been translated into software.

• Error value
• Proportional term
• Integral term
• Differential term
• Summing junction

The software examples are from these PID controllers.

1. My Little PID Controller
2. Bare Bones (PID) Coffee Controller
3. AeroQuad

Error Value

The error value e(t) is defined as the difference between the desired setpoint r(t) and a measured process variable y(t). Here is the C++ statement used by the Bare Bones Coffee control software to implement this term.

  // determine how badly we are doing
  // error = setpoint - process value
  double error = sp - pv;

Proportional Term

The proportional term is only a function of the error. Here is the C++ statement used by the Bare Bones Coffee control software to implement this term.

  // the pTerm is the view from now, the pgain judges
  // how much we care about error we are at this instant.
   double pTerm = kp * error;

The proportional term (P) gives a system control input proportional to the error. Using only P control gives a stationary error in all cases except when the system control input is zero and the system process value y(t) equals the desired value.

In the figure below the stationary error e(t) in the system process value y(t) appears after a change in the desired value r(t). The response shown is that of a second-order transient system. Using a too large P term gives an unstable system.

Integral Term

You may remember the definition of integration, as shown in Figure 4, from your calculus class. If you have forgotten, the image below was originally presented in this review article.  To program the integral term we work backward from the definition by approximating the integral term by taking the area under the error(t) curve.

Here is the C++ statement used by My Little PID control software to implement this term.

 static double iTerm = 0;
 iTerm += ki * error;     // ki unit time (ki = Ki*dT)

Here is the C++ statement used by the AeroQuad PID control software to implement this term. Where the arrow operator -> is used to access the integratedError member of the PIDparameters data structure by reference.

PIDparameters->integratedError += error * G_Dt;

Where global variable for delta time [1] is defined as.

float G_Dt = 0.02;

[1] Of all the PID code examples reviewed for this article, this was the only one that included delta time (Dt). All other code examples combine delta time with the integral term (K_i).  This latter approach is computationally more efficient at the cost of clarity (see Computational Simplification).

The figure below shows the step responses to an I and PI controller. As seen the PI controller response has no stationary error and the I controller response is very slow.

Differential Term

Returning to your first course in calculus you hopefully also remember the definition of derivative as explained here. To program the differential term we again work backward from the definition by approximating the differential term by finding the slope of the error(t) curve at time t.

Here is a C++ statement for the My Simple PID control software to implement this term.

double dTerm = kd * (pv - last_value); // kd unit time (kd = Kd/dT)
last_value = pv;

Here is a C++ statement, written in the form of the AeroQuad PID control software to implement this term.

PIDparameters->differentialError = (currentPosition - PIDparameters->lastPosition) / G_Dt;

The figure below shows D and PD controller responses. The response of the PD controller gives a faster rising system process value.

The differential term essentially behaves as a high pass filter on the system error signal and may therefore increase the effect of noise on the system leading to system instability. To see if a differential term is the best choice for your application, I would recommend reading “The PID’s Derivative Term Can Improve Control Loop Performance, But Often at a Cost.”

Summing Junction

The summing junction u(t) adds the control inputs to be applied to the plant from the Proportional, Integral, and Differential blocks. Depending on the software implementation the gain factors  Kp, Ki, and Kd may be added here, or within each computational block. The summing junction is often included in the return statement.

The My Little PID controller takes the former approach as shown here.

  return pTerm + iTerm + dTerm; // process input

The Bare Bones Coffee controller takes the former approach as shown here.

  // the magic feedback bit
  return  pTerm + iTerm - dTerm;

The AeroQuad PID controller takes a hybrid approach with the gain factors P and I included at the summing junction, versus the differential block, where the term already includes gain factor D.

  return (PIDparameters->P * error) + (PIDparameters->I * (PIDparameters->integratedError)) + dTerm;

The figure below compares the P, PI, and PID controllers. PI improves the P by removing the stationary error, and the PID
improves the PI by the faster response and no overshoot.