PID Controller Design at the Command Line

This example shows how to design a PID controller for the plant given by:

As a first pass, create a model of the plant and design a simple PI controller for it.

sys = zpk([],[-1 -1 -1],1); 
[C_pi,info] = pidtune(sys,'PI')

C_pi =
 
             1 
  Kp + Ki * ---
             s 

  with Kp = 1.14, Ki = 0.454
 
Continuous-time PI controller in parallel form.

info = struct with fields:
                Stable: 1
    CrossoverFrequency: 0.5205
           PhaseMargin: 60.0000

C_pi is a pid controller object that represents a PI controller. The fields of info show that the tuning algorithm chooses an open-loop crossover frequency of about 0.52 rad/s.

Examine the closed-loop step response (reference tracking) of the controlled system.

T_pi = feedback(C_pi*sys, 1);
step(T_pi)

To improve the response time, you can set a higher target crossover frequency than the result that pidtune automatically selects, 0.52. Increase the crossover frequency to 1.0.

[C_pi_fast,info] = pidtune(sys,'PI',1.0)

C_pi_fast =
 
             1 
  Kp + Ki * ---
             s 

  with Kp = 2.83, Ki = 0.0495
 
Continuous-time PI controller in parallel form.

info = struct with fields:
                Stable: 1
    CrossoverFrequency: 1
           PhaseMargin: 43.9973

The new controller achieves the higher crossover frequency, but at the cost of a reduced phase margin.

Compare the closed-loop step response with the two controllers.

T_pi_fast = feedback(C_pi_fast*sys,1);
step(T_pi,T_pi_fast)
axis([0 30 0 1.4])
legend('PI','PI,fast')

This reduction in performance results because the PI controller does not have enough degrees of freedom to achieve a good phase margin at a crossover frequency of 1.0 rad/s. Adding a derivative action improves the response.

Design a PIDF controller for Gc with the target crossover frequency of 1.0 rad/s.

[C_pidf_fast,info] = pidtune(sys,'PIDF',1.0)

C_pidf_fast =
 
             1            s    
  Kp + Ki * --- + Kd * --------
             s          Tf*s+1 

  with Kp = 2.72, Ki = 0.985, Kd = 1.72, Tf = 0.00875
 
Continuous-time PIDF controller in parallel form.

info = struct with fields:
                Stable: 1
    CrossoverFrequency: 1
           PhaseMargin: 60.0000

The fields of info show that the derivative action in the controller allows the tuning algorithm to design a more aggressive controller that achieves the target crossover frequency with a good phase margin.

Compare the closed-loop step response and disturbance rejection for the fast PI and PIDF controllers.

T_pidf_fast =  feedback(C_pidf_fast*sys,1);
step(T_pi_fast, T_pidf_fast);
axis([0 30 0 1.4]);
legend('PI,fast','PIDF,fast');

You can compare the input (load) disturbance rejection of the controlled system with the fast PI and PIDF controllers. To do so, plot the response of the closed-loop transfer function from the plant input to the plant output.

S_pi_fast = feedback(sys,C_pi_fast);
S_pidf_fast = feedback(sys,C_pidf_fast);
step(S_pi_fast,S_pidf_fast);
axis([0 50 0 0.4]);
legend('PI,fast','PIDF,fast');

This plot shows that the PIDF controller also provides faster disturbance rejection.

Design Standard-Form PID Controller

Design a PID controller in standard form for the plant defined by

To design a controller in standard form, use a standard-form controller as the C0 argument to pidtune.

sys = zpk([],[-1 -1 -1],1);
C0 = pidstd(1,1,1); 
C = pidtune(sys,C0)

C =
 
             1      1          
  Kp * (1 + ---- * --- + Td * s)
             Ti     s          

  with Kp = 2.18, Ti = 2.36, Td = 0.591
 
Continuous-time PID controller in standard form

Specify Integrator Discretization Method

Design a discrete-time PI controller using a specified method to discretize the integrator.

If your plant is in discrete time, pidtune automatically returns a discrete-time controller using the default Forward Euler integration method. To specify a different integration method, use pid or pidstd to create a discrete-time controller having the desired integration method.

sys = c2d(tf([1 1],[1 5 6]),0.1);
C0 = pid(1,1,'Ts',0.1,'IFormula','BackwardEuler');  
C = pidtune(sys,C0)

C =
 
             Ts*z 
  Kp + Ki * ------
              z-1 

  with Kp = -0.518, Ki = 10.4, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time PI controller in parallel form.

Using C0 as an input causes pidtune to design a controller C of the same form, type, and discretization method as C0. The display shows that the integral term of C uses the Backward Euler integration method.

Specify a Trapezoidal integrator and compare the resulting controller.

C0_tr = pid(1,1,'Ts',0.1,'IFormula','Trapezoidal');
Ctr = pidtune(sys,C_tr)

Ctr =
 
       Ts*(z+1)
  Ki * --------
       2*(z-1) 

  with Ki = 10.4, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time I-only controller.

Design 2-DOF PID Controller

Design a 2-DOF PID Controller for the plant given by the transfer function:

Use a target bandwidth of 1.5 rad/s.

wc = 1.5;
G = tf(1,[1 0.5 0.1]);
C2 = pidtune(G,'PID2',wc)

C2 =
 
                       1              
  u = Kp (b*r-y) + Ki --- (r-y) + Kd*s (c*r-y)
                       s              

  with Kp = 1.26, Ki = 0.255, Kd = 1.38, b = 0.665, c = 0
 
Continuous-time 2-DOF PID controller in parallel form.

Using the type 'PID2' causes pidtune to generate a 2-DOF controller, represented as a pid2 object. The display confirms this result. The display also shows that pidtune tunes all controller coefficients, including the setpoint weights b and c, to balance performance and robustness.