piddata

Access coefficients of parallel-form PID controller

Syntax

[Kp,Ki,Kd,Tf] = piddata(sys)
[Kp,Ki,Kd,Tf,Ts] = piddata(sys)
[Kp,Ki,Kd,Tf,Ts] = piddata(sys,J1,...,JN)


Description

[Kp,Ki,Kd,Tf] = piddata(sys) returns the PID gains Kp,Ki, Kd and the filter time constant Tf of the parallel-form controller represented by the dynamic system sys.

[Kp,Ki,Kd,Tf,Ts] = piddata(sys) also returns the sample time Ts.

[Kp,Ki,Kd,Tf,Ts] = piddata(sys,J1,...,JN) extracts the data for a subset of entries in sys, where sys is an N-dimensional array of dynamic systems. The indices J specify the array entry to extract.

Input Arguments

sys	SISO dynamic system or array of SISO dynamic systems. If sys is not a pid object, it must represent a valid PID controller that can be written in parallel PID form.
J	Integer indices of N entries in the array sys of dynamic systems. For example, suppose sys is a 4-by-5 (two-dimensional) array of pid controllers or dynamic system models that represent PID controllers. The following command extracts the data for entry (2,3) in the array. [Kp,Ki,Kd,Tf,Ts] = piddata(sys,2,3);

Output Arguments

Kp	Proportional gain of the parallel-form PID controller represented by dynamic system sys. If sys is a pid controller object, the output Kp is equal to the Kp value of sys. If sys is not a pid object, Kp is the proportional gain of a parallel PID controller equivalent to sys. If sys is an array of dynamic systems, Kp is an array of the same dimensions as sys.
Ki	Integral gain of the parallel-form PID controller represented by dynamic system sys. If sys is a pid controller object, then the output Ki is equal to the Ki value of sys. If sys is not a pid object, then Ki is the integral gain of a parallel PID controller equivalent to sys. If sys is an array of dynamic systems, then Ki is an array of the same dimensions as sys.
Kd	Derivative gain of the parallel-form PID controller represented by dynamic system sys. If sys is a pid controller object, then the output Kd is equal to the Kd value of sys. If sys is not a pid object, then Kd is the derivative gain of a parallel PID controller equivalent to sys. If sys is an array of dynamic systems, then Kd is an array of the same dimensions as sys.
Tf	Filter time constant of the parallel-form PID controller represented by dynamic system sys. If sys is a pid controller object, the output Tf is equal to the Tf value of sys. If sys is not a pid object, Tf is the filter time constant of a parallel PID controller equivalent to sys. If sys is an array of dynamic systems, Tf is an array of the same dimensions as sys.
Ts	Sample time of the dynamic system sys. Ts is always a scalar value.

Examples

Extract Coefficients From Parallel-Form PID Controller

Typically, you extract coefficients from a controller obtained from another function, such as pidtune or getBlockValue. For this example, create a PID controller that has random coefficients.

rng('default');    % for reproducibility
C = pid(rand,rand,rand,rand);

Extract the PID gains and filter time constant.

[Kp,Ki,Kd,Tf] = piddata(C)

Kp = 0.8147

Ki = 0.9058

Kd = 0.1270

Tf = 0.9134

Extract Parallel-Form Gains from Standard-Form PI Controller

Create a PI controller in standard form.

C = pidstd(2,3)

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

  with Kp = 2, Ti = 3
 
Continuous-time PI controller in standard form

Compute the gains of an equivalent parallel-form PID controller.

[Kp,Ki] = piddata(C)

Kp = 2

Ki = 0.6667

Extract PID Coefficients from Equivalent System

Extract coefficients from dynamic system that represents a valid discrete-time parallel-form PID controller with a derivate filter.

$$\mathit{H}\left(\mathit{z}\right)=\frac{\left(\mathit{z}-0.5\right)\left(\mathit{z}-0.6\right)}{\left(\mathit{z}-1\right)\left(\mathit{z}+0.8\right)}$$

H = zpk([0.5 0.6],[1,-0.8],1,0.1);

Extract the PID gains and filter time constant.

[Kp,Ki,Kd,Tf,Ts] = piddata(H)

Kp = 0.4383

Ki = 1.1111

Kd = 0.0312

Tf = 0.0556

Ts = 0.1000

For a discrete-time system, piddata calculates the coefficient values using the default ForwardEuler discrete integrator formula for both IFormula and DFormula.

Extract Coefficients from PI Controller Array

Typically, you obtain an array of controllers by using pidtune on an array of plant models. For this example, create a 2-by-3 array of PI controllers with random values of Kp, Ki.

rng('default');
C = pid(rand(2,3),rand(2,3));

Extract all the coefficients from the array.

[Kp,Ki] = piddata(C);

Each of the outputs is itself a 2-by-3 array. For example, examine Ki.

Ki

Ki = 2×3

    0.2785    0.9575    0.1576
    0.5469    0.9649    0.9706

Extract only the coefficients of entry (2,1) in the array.

[Kp,Ki] = piddata(C,2,1)

Kp = 0.9058

Ki = 0.5469

Tips

If sys is not a pid controller object, piddata returns the PID gains Kp, Ki, Kd and the filter time constant Tf of a parallel-form controller equivalent to sys.

For discrete-time sys, piddata returns the parameters of an equivalent parallel-form controller. This controller has discrete integrator formulas IFormula and DFormula set to ForwardEuler. See the pid reference page for more information about discrete integrator formulas.

Version History

Introduced in R2010b