# ltiblock.pid

Tunable PID controller

## Syntax

`blk = ltiblock.pid(name,type)blk = ltiblock.pid(name,type,Ts)blk = ltiblock.pid(name,sys)`

## Description

Model object for creating tunable one-degree-of-freedom PID controllers. `ltiblock.pid` lets you parametrize a tunable SISO PID controller for parameter studies or for automatic tuning with requires Robust Control Toolbox™ tuning commands such as `systune`, `looptune`, or `hinfstruct`.

`ltiblock.pid2` is part of the family of parametric Control Design Blocks. Other parametric Control Design Blocks include `ltiblock.gain`, `ltiblock.ss`, and `ltiblock.tf`.

## Construction

`blk = ltiblock.pid(name,type)` creates the one-degree-of-freedom continuous-time PID controller:

$blk={K}_{p}+\frac{{K}_{i}}{s}+\frac{{K}_{d}s}{1+{T}_{f}s},$

with tunable parameters `Kp`, `Ki`, `Kd`, and `Tf`. The string `type` sets the controller type by fixing some of these values to zero (see Input Arguments).

`blk = ltiblock.pid(name,type,Ts)` creates a discrete-time PID controller with sample time `Ts`:

$blk={K}_{p}+{K}_{i}IF\left(z\right)+\frac{{K}_{d}}{{T}_{f}+DF\left(z\right)},$

where IF(z) and DF(z) are the discrete integrator formulas for the integral and derivative terms, respectively. The values of the `IFormula` and `DFormula` properties set the discrete integrator formulas (see Properties).

`blk = ltiblock.pid(name,sys)` uses the dynamic system model, `sys`, to set the sample time, `Ts`, and the initial values of the parameters `Kp`, `Ki`, `Kd`, and `Tf`.

### Input Arguments

`name`

PID controller `Name`, specified as a string. (See Properties.)

`type`

String specifying controller type. Specifying a controller type fixes up to three of the PID controller parameters. `type` can take the following values:

StringController TypeEffect on PID Parameters
`'P'`Proportional only`Ki` and `Kd` are fixed to zero; `Tf` is fixed to 1; `Kp` is free
`'PI'`Proportional-integral`Kd` is fixed to zero; `Tf` is fixed to 1; `Kp` and `Ki` are free
`'PD'`Proportional-derivative with first-order filter on derivative action`Ki` is fixed to zero; `Kp`, `Kd`, and `Tf` are free
`'PID'`Proportional-integral-derivative with first-order filter on derivative action`Kp`, `Ki`, `Kd`, and `Tf` are free

`Ts`

Sample time, specified as a scalar.

`sys`

Dynamic system model representing a PID controller.

## Properties

`Kp, Ki, Kd, Tf`

Parametrization of the PID gains `Kp`, `Ki`, `Kd`, and filter time constant `Tf` of the tunable PID controller `blk`.

The following fields of `blk.Kp`, `blk.Ki`, `blk.Kd`, and `blk.Tf` are used when you tune `blk` using a tuning command such as `systune`:

FieldDescription
`Value`Current value of the parameter.
`Free`Logical value determining whether the parameter is fixed or tunable. For example,
• If `blk.Kp.Free = 1`, then `blk.Kp.Value` is tunable.

• If `blk.Kp.Free = 0`, then `blk.Kp.Value` is fixed.

`Minimum`Minimum value of the parameter. This property places a lower bound on the tuned value of the parameter. For example, setting ```blk.Kp.Minimum = 0``` ensures that `Kp` remains positive.
`blk.Tf.Minimum` must always be positive.
`Maximum`Maximum value of the parameter. This property places an upper bound on the tuned value of the parameter. For example, setting ```blk.Tf.Maximum = 100``` ensures that the filter time constant does not exceed 100.

`blk.Kp`, `blk.Ki`, `blk.Kd`, and `blk.Tf` are `param.Continuous` objects. For general information about the properties of these `param.Continuous` objects, see the `param.Continuous` object reference page.

`IFormula, DFormula`

Strings setting the discrete integrator formulas IF(z) and DF(z) for the integral and derivative terms, respectively. `IFormula` and `DFormula` can have the following values:

StringIF(z) or DF(z) Formula
`'ForwardEuler'`

$\frac{{T}_{s}}{z-1}$

`'BackwardEuler'`

$\frac{{T}_{s}z}{z-1}$

`'Trapezoidal'`

$\frac{{T}_{s}}{2}\frac{z+1}{z-1}$

Default: `'ForwardEuler'`

`Ts`

Sample time. For continuous-time models, `Ts = 0`. For discrete-time models, `Ts` is a positive scalar representing the sampling period. This value is expressed in the unit specified by the `TimeUnit` property of the model. To denote a discrete-time model with unspecified sample time, set ```Ts = -1```.

Changing this property does not discretize or resample the model. Use `c2d` and `d2c` to convert between continuous- and discrete-time representations. Use `d2d` to change the sample time of a discrete-time system.

Default: `0` (continuous time)

`TimeUnit`

String representing the unit of the time variable. This property specifies the units for the time variable, the sample time `Ts`, and any time delays in the model. Use any of the following values:

• `'nanoseconds'`

• `'microseconds'`

• `'milliseconds'`

• `'seconds'`

• `'minutes'`

• `'hours'`

• `'days'`

• `'weeks'`

• `'months'`

• `'years'`

Changing this property has no effect on other properties, and therefore changes the overall system behavior. Use `chgTimeUnit` to convert between time units without modifying system behavior.

Default: `'seconds'`

`InputName`

Input channel names. Set `InputName` to a string for single-input model. For a multi-input model, set `InputName` to a cell array of strings.

Alternatively, use automatic vector expansion to assign input names for multi-input models. For example, if `sys` is a two-input model, enter:

`sys.InputName = 'controls';`

The input names automatically expand to `{'controls(1)';'controls(2)'}`.

You can use the shorthand notation `u` to refer to the `InputName` property. For example, `sys.u` is equivalent to `sys.InputName`.

Input channel names have several uses, including:

• Identifying channels on model display and plots

• Extracting subsystems of MIMO systems

• Specifying connection points when interconnecting models

Default: Empty string `''` for all input channels

`InputUnit`

Input channel units. Use `InputUnit` to keep track of input signal units. For a single-input model, set `InputUnit` to a string. For a multi-input model, set `InputUnit` to a cell array of strings. `InputUnit` has no effect on system behavior.

Default: Empty string `''` for all input channels

`InputGroup`

Input channel groups. The `InputGroup` property lets you assign the input channels of MIMO systems into groups and refer to each group by name. Specify input groups as a structure. In this structure, field names are the group names, and field values are the input channels belonging to each group. For example:

```sys.InputGroup.controls = [1 2]; sys.InputGroup.noise = [3 5];```

creates input groups named `controls` and `noise` that include input channels 1, 2 and 3, 5, respectively. You can then extract the subsystem from the `controls` inputs to all outputs using:

`sys(:,'controls')`

Default: Struct with no fields

`OutputName`

Output channel names. Set `OutputName` to a string for single-output model. For a multi-output model, set `OutputName` to a cell array of strings.

Alternatively, use automatic vector expansion to assign output names for multi-output models. For example, if `sys` is a two-output model, enter:

`sys.OutputName = 'measurements';`

The output names automatically expand to `{'measurements(1)';'measurements(2)'}`.

You can use the shorthand notation `y` to refer to the `OutputName` property. For example, `sys.y` is equivalent to `sys.OutputName`.

Output channel names have several uses, including:

• Identifying channels on model display and plots

• Extracting subsystems of MIMO systems

• Specifying connection points when interconnecting models

Default: Empty string `''` for all output channels

`OutputUnit`

Output channel units. Use `OutputUnit` to keep track of output signal units. For a single-output model, set `OutputUnit` to a string. For a multi-output model, set `OutputUnit` to a cell array of strings. `OutputUnit` has no effect on system behavior.

Default: Empty string `''` for all output channels

`OutputGroup`

Output channel groups. The `OutputGroup` property lets you assign the output channels of MIMO systems into groups and refer to each group by name. Specify output groups as a structure. In this structure, field names are the group names, and field values are the output channels belonging to each group. For example:

```sys.OutputGroup.temperature = [1]; sys.InputGroup.measurement = [3 5];```

creates output groups named `temperature` and `measurement` that include output channels 1, and 3, 5, respectively. You can then extract the subsystem from all inputs to the `measurement` outputs using:

`sys('measurement',:)`

Default: Struct with no fields

`Name`

System name. Set `Name` to a string to label the system.

Default: `''`

`Notes`

Any text that you want to associate with the system. Set `Notes` to a string or a cell array of strings.

Default: `{}`

`UserData`

Any type of data you wish to associate with system. Set `UserData` to any MATLAB® data type.

Default: `[]`

## Examples

Tunable Controller with a Fixed Parameter

Create a tunable PD controller. Then, initialize the parameter values, and fix the filter time constant.

```blk = ltiblock.pid('pdblock','PD'); blk.Kp.Value = 4; % initialize Kp to 4 blk.Kd.Value = 0.7; % initialize Kd to 0.7 blk.Tf.Value = 0.01; % set parameter Tf to 0.01 blk.Tf.Free = false; % fix parameter Tf to this value blk```
```blk = Parametric continuous-time PID controller "pdblock" with formula: s Kp + Kd * -------- Tf*s+1 and tunable parameters Kp, Kd. Type "pid(blk)" to see the current value and "get(blk)" to see all properties. ```

Controller Initialized by Dynamic System Model

Create a tunable discrete-time PI controller. Use a `pid` object to initialize the parameters and other properties.

```C = pid(5,2.2,'Ts',0.1,'IFormula','BackwardEuler'); blk = ltiblock.pid('piblock',C)```
```blk = Parametric discrete-time PID controller "piblock" with formula: Ts*z Kp + Ki * ------ z-1 and tunable parameters Kp, Ki. Type "pid(blk)" to see the current value and "get(blk)" to see all properties. ```

`blk` takes the value of properties, such as `Ts` and `IFormula`, from `C`.

Controller with Named Input and Output

Create a tunable PID controller, and assign names to the input and output.

```blk = ltiblock.pid('pidblock','pid') blk.InputName = {'error'} % assign input name blk.OutputName = {'control'} % assign output name```

collapse all

### Tips

• You can modify the PID structure by fixing or freeing any of the parameters `Kp`, `Ki`, `Kd`, and `Tf`. For example, `blk.Tf.Free = false` fixes `Tf` to its current value.

• To convert an `ltiblock.pid` parametric model to a numeric (nontunable) model object, use model commands such as `pid`, `pidstd`, `tf`, or `ss`. You can also use `getValue` to obtain the current value of a tunable model.