PID tuning algorithm for linear plant model
C = pidtune(sys,type)
C = pidtune(sys,C0)
C = pidtune(sys,type,wc)
C = pidtune(sys,C0,wc)
C = pidtune(sys,...,opts)
[C,info] = pidtune(...)
designs a PID controller of type
C = pidtune(
type for the plant
type specifies a one-degree-of-freedom
(1-DOF) PID controller, then the controller is designed for the unit feedback loop as
type specifies a two-degree-of-freedom (2-DOF) PID controller,
pidtune designs a 2-DOF controller as in the feedback loop of this
pidtune tunes the parameters of the PID controller
C to balance performance (response time) and robustness (stability
Single-input, single-output dynamic system
model of the plant for controller design.
If the plant has unstable poles, and
you must use
Controller type of the controller to design, specified as a character vector. The
term controller type refers to which terms are present in the
controller action. For example, a PI controller has only a proportional and an integral
term, while a PIDF controller contains proportional, integrator, and filtered derivative
For more information about 2-DOF PID controllers generally, see Two-Degree-of-Freedom PID Controllers.
2-DOF Controllers with Fixed Setpoint Weights
For more detailed information about fixed-setpoint-weight 2-DOF PID controllers, see PID Controller Types for Tuning.
For more information about PID controller forms and formulas, see:
Target value for the 0 dB gain crossover frequency of the tuned open-loop response.
Option set specifying additional tuning options for the
Controller designed for
In either case, however, where the algorithm can achieve adequate performance and
robustness using a lower-order controller than specified with
If you specify
Data structure containing information about performance and robustness of the tuned
PID loop. The fields of
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 a PID controller in standard form for the following plant.
To design a controller in standard form, use a standard-form controller as the
C0 argument to
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.57, Td = 0.642 Continuous-time PID controller in standard form
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
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.0658, Ki = 1.32, Ts = 0.1 Sample time: 0.1 seconds Discrete-time PI controller in parallel form.
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,C0_tr)
Ctr = Ts*(z+1) Ki * -------- 2*(z-1) with Ki = 1.32, Ts = 0.1 Sample time: 0.1 seconds Discrete-time I-only 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
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
c, to balance performance and robustness.
pidtune with the
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
pidstd reference pages.
For interactive PID tuning in the Live Editor, see the Tune PID Controller Live Editor task. This task lets you interactively design a PID controller and automatically generates MATLAB® code for your live script.
For information about the MathWorks® PID tuning algorithm, see PID Tuning Algorithm.
For interactive PID tuning in the Live Editor, see the Tune PID Controller Live Editor task. This task lets you interactively design a PID controller and automatically generates MATLAB code for your live script. For an example, see PID Controller Design in the Live Editor
Åström, K. J. and Hägglund, T. Advanced PID Control, Research Triangle Park, NC: Instrumentation, Systems, and Automation Society, 2006.