pidtune - PID tuning algorithm for linear plant model

Syntax

Description

C = pidtune(sys,type) designs a PID controller of type type for the plant sys in the unit feedback loop

pidtune tunes the parameters of the PID controller C to balance performance (response time) and robustness (stability margins).

C = pidtune(sys,C0) designs a controller of the same type and form as the controller C0. If sys and C0 are discrete-time models, C has the same discrete integrator formulas as C0.

C = pidtune(sys,type,wc) and C = pidtune(sys,C0,wc) specify a target value wc for the first 0 dB gain crossover frequency of the open-loop response L = sys*C.

C = pidtune(sys,...,opts) uses additional tuning options, such as the target phase margin. Use pidtuneOptions to specify the option set opts.

[C,info] = pidtune(...) returns the data structure info, which contains information about closed-loop stability, the selected open-loop gain crossover frequency, and the actual phase margin.

Tips

By default, pidtune with the type input returns a pid controller in parallel form. To design a controller in standard form, use a pidstd controller as input argument C0. For more information about parallel and standard controller forms, see the pid and pidstd reference pages.

Input Arguments

Output Arguments

Examples

Tune Parallel-Form PID Controller

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

As a first pass, design a simple PI controller:

sys = zpk([],[-1 -1 -1],1); % define the plant
[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 = 

                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 = 

                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('C\_pi','C\_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 = 1.03, Kd = 1.76, Tf = 0.00875
 
Continuous-time PIDF controller in parallel form.


info = 

                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('C\_pi\_fast','C\_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('C\_pi\_fast','C\_pidf\_fast'); 

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

Tune Standard-Form PID Controller

This example shows how to 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

This example shows how to 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.

Algorithms

Typical PID tuning objectives include:

• Closed-loop stability — The closed-loop system output remains bounded for bounded input.

• Adequate performance — The closed-loop system tracks reference changes and suppresses disturbances as rapidly as possible. The larger the loop bandwidth (the first frequency at which the open-loop gain is unity), the faster the controller responds to changes in the reference or disturbances in the loop.

• Adequate robustness — The loop design has enough phase margin and gain margin to allow for modeling errors or variations in system dynamics.

The MathWorks algorithm for tuning PID controllers helps you meet these objectives by automatically tuning the PID gains to balance performance (response time) and robustness (stability margins).

By default, the algorithm chooses a crossover frequency (loop bandwidth) based upon the plant dynamics, and designs for a target phase margin of 60°. If you specify the crossover frequency using wc or the phase margin using pidtuneOptions, the algorithm computes PID gains that best meet those targets.

References

Åström, K. J. and Hägglund, T. Advanced PID Control, Research Triangle Park, NC: Instrumentation, Systems, and Automation Society, 2006.

Alternatives

For interactive PID tuning, use the PID Tuner GUI (pidtool). See Designing PID Controllers for an example of designing a controller using the PID Tuner GUI.

The PID Tuner GUI cannot design controllers for multiple plants at once.

See Also

pid | pidstd | pidtool | pidtuneOptions

Tutorials

• Designing Cascade Control System with PI Controllers

Free Control Systems Interactive Kit

Learn more about resources for designing, testing, and implementing control systems.

Get free kit

Trials Available

Try the latest control systems products.

Get trial software