The Proportional Statement

The P in PID is a proportional statement of the error, or the difference between the input and the setpoint value. Kp is the gain value and determines how the P statement reacts to change in error; the lower the gain, the less the system reacts to an error. Kp is what tunes the proportional part of the equation. All gain values are set by the programmer or dynamically via a user input. The proportional statement aids in the steady-state error control by always trying to keep the error minimal. The steady state describes when a system has reached the desired setpoint. The first part of the proportional code will calculate the amount of error and will appear something like this:

error = setpoint – input ;

The second part of the code multiplies the error by the gain variable:

Pout = Kp * error;

The proportional statement attempts to lower the error by calculating the error to zero where input = setpoint. A pure proportional controller, with this equation and code, will not settle at the setpoint, but usually somewhere below the setpoint. The reason the proportional statement settles below the setpoint is because the proportional control always tries to reach a value of zero, and the settling is a balance between the input and the feedback. The integral statement is responsible for achieving the desired setpoint.

The Integral Statement

The I in PID is for an integral; this is a major concept in calculus, but integrals are not scary. Put simply, integration is the calculation of the area under a curve. This is accomplished by constantly adding a very small area to an accumulated total. For a refresher of some calculus, the area is calculated by length × width; to find the area under a curve, the length is determined by the function’s value and a small difference that then is added to all other function values. For reference, the integral in this type of setup is similar to a Riemann sum.

The PID algorithm does not have a specific function; the length is determined by the error, and the width of the rectangle is the change in time. The program constantly adds this area up based on the error. The code for the integral is

errorsum = (errorsum + currenterror) * timechange;
Iout = Ki * errorsum ;

The integral reacts to the amount of error and duration of the error. The errorsum value increases when the input value is below the setpoint, and decreases when the input is above the setpoint. The integral will hold at the setpoint when the error becomes zero and there is nothing to subtract or add. When the integral is added to proportional statement, the integral corrects for the offset to the error caused by the proportional statement’s settling. The integral will control how fast the algorithm attempts to reach the setpoint: lower gain values approach at a slower rate; higher values approach the setpoint quicker, but have the tendency to overshoot and can cause ringing by constantly overshooting above and below the setpoint and never settling. Some systems, like ovens, have problems returning from overshoots, where the controller does not have the ability to apply a negative power. It’s perfectly fine to use just the PI part of a PID equation for control, and sometimes a PI controller is satisfactory.

The Derivative Statement

The D in PID is the derivative, another calculus concept, which is just a snapshot of the slope of an equation. The slope is calculated as rise over run—the rise comes from the change in the error, or the current error subtracted from the last error; the run is the change in time. When the rise is divided by the time change, the rate at which the input is changing is known. Code for the derivative component is

Derror = (Error – lasterror) / timechange ;
Dout = Kd * Derror ;

or

Derror = (Input – lastinput) / timechange ;
Dout = Kd * Derror ;

The derivative aids in the control of overshooting and controls the ringing that can occur from the integral. High gain values in the derivative can have a tendency to cause an unstable system that will never reach a stable state. The two versions of code both work, and mostly serve the same function. The code that uses the slope of the input reduces the derivative kick caused when the setpoint is changed; this is good for systems in which the setpoint changes regularly. By using the input instead of the calculated error, we get a better calculation on how the system is changing; the code that is based on the error will have a greater perceived change, and thus a higher slope will be added to the final output of the PID controller.

Adding It All Up

With the individual parts calculated, the proportion, integral, and the derivative have to be added together to achieve a usable output. One line of code is used to produce the output:

Output = Pout + Iout + Dout ;

The output might need to be normalized for the input when the output equates to power. Some systems need the output to be zero when the setpoint is achieved (e.g., ovens) so that no more heat will be added; and for motor controls, the output might have to go negative to reverse the motor.

Time

PID controllers use the change in time to work out the order that data is entered and relates to when the PID is calculated and how much time has passed since the last time the program calculated the PID. The individual system’s implementation determines the required time necessary for calculation. Fast systems like radio-controlled aircraft may require time in milliseconds, ovens or refrigerators may have their time differences calculated in seconds, and chemical and HVAC systems may require minutes. This is all based on the system’s ability to change; just as in physics, larger objects will move slower to a given force than a smaller ones at the same force.

There are two ways to set up time calculation. The first takes the current time and subtracts that from the last time and uses the resulting change in the PID calculation. The other waits for a set amount of time to pass before calculating the next iteration. The code to calculate based on time is as follows and would be in a loop:

// loop
now = millis() ;
timechage = (now – lasttime);
// pid caculations
lasttime = now;

This method is good for fast systems like servo controllers where the change in time is based on how fast the code runs through a loop. Sometimes it is necessary to sample at a greater time interval than that at which the code runs or have more consistency between the time the PID calculates. For these instances, the time change can be assumed to be 1 and can be dropped out of the calculation for the I and D components, saving the continual multiplication and division from the code. To speed up the PID calculation, the change in time can be calculated against the gains instead of being calculated within the PID. The transformation of the calculation is Ki * settime and Kd / settime. The code then looks like this, with gains of .5 picked as a general untuned starting point:

// setup
settime = 1000 ; // 1000 milliseconds is 1 second
Kp = .5;
Ki = .5 * settime;
Kd = .5 / settime;
// loop
now = millis() ;
timechage = (now – lasttime);
if (timechange >= time change){
   error = Setpoint – Input;
   errorsum = errorsum + error;
   Derror = (Input – lastinput);
   Pout = Kp * error;
   Iout = Ki * errorsum ;
   Dout = Kd * Derror ;
   Output = Pout + Iout + Dout ;
}

Wiring the Hardware

Set up an Arduino as per Figure 7-1. After the Arduino is set up with the components, upload the code in Listing 7-1.

Listing 7-1.  Basic PID Arduino Sketch

float Kp = .5 , Ki = .5, Kd = .5 ; // PID gain values
float Pout , Iout , Dout , Output; // PID final ouput variables
float now , lasttime = 0 , timechange; // important time
float Input , lastinput , Setpoint = 127.0; // input-based variables
float error , errorsum = 0, Derror; // output of the PID components
int settime = 1000; // this = 1 second, so Ki and Kd do not need modification
void setup (){
   Serial.begin(9600); // serial setup for verification
} // end void setup (){

void loop (){
   now = millis() ; // get current milliseconds
   timechange = (now – lasttime); // calculate difference
   if (timechange >= settime) { // run PID when the time is at the set time
      Input = (analogRead(0)/4.0); // read Input and normalize to output range
      error = Setpoint – Input; // calculate error
      errorsum = errorsum + error; // add curent error to running total of error
      Derror = (Input – lastinput); // calculate slope of the input
      Pout = Kp * error;  // calculate PID gains
      Iout = Ki * errorsum ;
      Dout = Kd * Derror ;
      if (Iout > 255)        // check for integral windup and correct
          Iout = 255;
      if (Iout < 0)
         Iout = 0;
      Output = Pout + Iout + Dout ; // prep the output variable
      if (Output > 255)  // sanity check of the output, keeping it within the
           Output = 255; // available output range
      if (Output < 0)
           Output = 0;
      lastinput = Input; // save the input and time for the next loop
      lasttime = now;
      analogWrite (3, Output); // write the output to PWM pin 3
      Serial.print (Setpoint); // print some information to the serial monitor
      Serial.print (" : ");
      Serial.print (Input);
      Serial.print (" : ");
      Serial.println (Output);
   } // end if (timechange >= settime)
}  // end void loop ()

Verifying the Code

Run the code uploaded to the Arduino and start the serial monitor. The code will print one line containing the Setpoint : Input : Output values, and print one line per iteration of the running PID about every second. The system will stabilize around a value of the setpoint—the first value of every printed line in the serial monitor. However, because of the inherent noise in the RC filter, it will never settle directly at the setpoint. Using an RC circuit is one of the easier ways to demonstrate a PID controller in action, along with the noise simulating a possible jitter in the system. The potentiometer is used to simulate a negative external disturbance; if the resistance on potentiometer is increased, the controller will increase the output to keep the input at the setpoint.

Tuning

The tuning of a PID can be where most of the setup time is spent; entire semesters can be spent in classes on how to tune and set up PID controllers. There are many methods and mathematical models for achieving a tune that will work. In short, there is no absolute correct tuning, and what works for one implementation may not work for another. How a particular setup works and reacts to changes will differ from one system to another, and the desired reactions of the controller changes how everything is tuned. Once the output is controllable with the loopback and the algorithm, there are three parameters that tune the controller: the gains of Kp, Ki, and Kd. Figures 7-5 through 7-7 show the differences between low gain and high gain using the same setup from earlier in the chapter.

The proportional control gains control how aggressively the system reacts to error and the distance from the setpoint at which the proportional component will settle. On the left of Figure 7-5, using a gain of 1, the system stabilizes at about 50 percent of the setpoint value. At a gain of 7 (the right side of Figure 7-5), the system becomes unstable. To tune a decent gain for a fast-reacting system, start with the proportion, set the integral and the derivative to zero, and increase the Kp value until the system becomes unstable; then back off a bit until it becomes stable again. This particular system becomes stable around a Kp value of 2.27. For a slower system or one that needs a slower reaction to error, a lower gain will be required. After the proportional component is set, move on to the integral.

Figure 7-6 demonstrates the addition of the integral component, making a PI controller. The left side of the figure shows that a lower Ki gain produces a slower controller that approaches the setpoint without overshoot. The right side of the figure, with a gain of 2, shows a graph with a faster rise, followed by overshoot and a ringing before settling at the setpoint. Setting a proper gain for this part is dependent on the needs of the system and the ability to react to overshoot. A temperature system may need a lower gain than a system that controls positing; it is about finding a good balance.

The derivative value is a bit more difficult to tune because of the interaction of the other two components. The derivative is similar to a damper attempting to limit the overshoot. It is perfectly fine omit the derivate portion and simply use a PI controller. To tune the derivative, the balance of the PI portions should be as close as possible to the reaction required for the setup. Once you’ve achieved this, then you can slowly change the gain in the derivative to provide some extra dampening. Figure 7-7 demonstrates a fully functional PID with the PID Tuner program. In this graph, there is a small amount of overshoot, but the derivate function corrects and allows the setpoint to be reached quickly.

PID Library

There is a user-made library available from Arduino Playground that implements all the math and control for setting up a PID controller on an Arduino (see www.arduino.cc/playground/Code/PIDLibrary/). The library makes it simple to have multiple PID controllers running on a single Arduino.

After downloading the library, set it up by unzipping the file into the Arduino libraries folder. To use a PID controller in Arduino code, add #include <PID_v1.h> before declaring variables Setpoint, Input, and Output. After the library and variables are set up, you need to create a PID object, which is accomplished by the following line of code:

PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

This informs the new PID object about the variables used for Setpoint, Input, and Output, as well as the gains Kp, Ki, and Kd. The final parameter is the direction: use DIRECT unless the system needs to drop to a setpoint.

After all of this is coded, read the input before calling the myPID.Compute() function.

PID Library Functions

Following is a list of the important basic functions for the PID library:

• PID(&Input, &Output, &Setpoint, Kp, Ki, Kd, Direction): This is the constructer function, which takes the address of the Input, Output, and Setpoint variables, and the gain values.
• Compute(): Calling Compute() after the input is read will perform the math required to produce an output value.
• SetOutputLimits(min ,max): This sets the values that the output should not exceed.
• SetTunings(Kp,Ki,Kd): This is used to change the gains dynamically after the PID has been initialized.
• SetSampleTime(milliseconds): This sets the amount of time that must pass before the Compute() function will execute the PID calculation again. If the set time has not passed when Compute() is called, the function returns back to the calling code without calculating the PID.
• SetControllerDirection(direction): This sets the controller direction. Use DIRECT for positive movements, such as in motor control or ovens; use REVERSE for systems like refrigerators.

Listing 7-2 is a modified version of the basic PID example using the PID library given at the library’s Arduino Playground web page (www.arduino.cc/playground/Code/PIDLibrary/). The modifications to the sketch include a serial output to display what is going on. There is a loss in performance when using the library compared to the direct implementation of Listing 7-1, and the gains had to be turned down in comparison while using the same hardware configuration as in Figure 7-1. The library can easily handle slower-reacting systems; to simulate this. a lager capacitor can be used in the RC circuit.

Listing 7-2.  PID Impemented with the PID Library

#include <PID_v1.h>

double Setpoint, Input, Output;
float Kp = .09;
float Ki = .1;
float Kd = .07;

// set up the PID's gains and link to variables
PID myPID(&Input, &Output, &Setpoint,Kp,Ki,Kd, DIRECT);

void setup(){

  Serial.begin(9600);
  // variable setup
  Input = analogRead(0) / 4; // calculate input to match output values
  Setpoint = 100  ;
  // turn the PID on
  myPID.SetMode(AUTOMATIC);
  // myPID.SetSampleTime(100);
}

void loop(){

  // read input and calculate PID
  Input = analogRead(0) / 4;
  myPID.Compute();
  analogWrite(3,Output);
   
 // print value to serial monitor
  Serial.print(Setpoint);
  Serial.print(" : ");
  Serial.print(Output);
  Serial.print(" : ");
  Serial.println(Input);
}