# 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

collapse all

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 ```

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 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`.

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