Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English version of the page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

# make2DOF

Convert 1-DOF PID controller to 2-DOF controller

## Syntax

``C2 = make2DOF(C1)``
``C2 = make2DOF(C1,b)``
``C2 = make2DOF(C1,b,c)``

## Description

example

````C2 = make2DOF(C1)` converts the one-degree-of-freedom PID controller `C1` to two degrees of freedom. The setpoint weights b and c of the 2-DOF controller are 1, and the remaining PID coefficients do not change. ```
````C2 = make2DOF(C1,b)` specifies the setpoint weight for the proportional term. ```

example

````C2 = make2DOF(C1,b,c)` specifies the setpoint weights for both the proportional and derivative terms. ```

## Examples

collapse all

Design a 1-DOF PID controller for a plant.

```G = tf(1,[1 0.5 0.1]); C1 = pidtune(G,'pidf',1.5)```
```C1 = 1 s Kp + Ki * --- + Kd * -------- s Tf*s+1 with Kp = 1.12, Ki = 0.23, Kd = 1.3, Tf = 0.122 Continuous-time PIDF controller in parallel form. ```

Convert the controller to two degrees of freedom.

`C2 = make2DOF(C1)`
```C2 = 1 s u = Kp (b*r-y) + Ki --- (r-y) + Kd -------- (c*r-y) s Tf*s+1 with Kp = 1.12, Ki = 0.23, Kd = 1.3, Tf = 0.122, b = 1, c = 1 Continuous-time 2-DOF PIDF controller in parallel form. ```

The new controller has the same PID gains and filter constant. It also contains new terms involving the setpoint weights `b` and `c`. By default, `b` = `c` = 1. Therefore, in a closed loop with the plant `G`, the 2-DOF controller `C2` yields the same response as `C1`.

```T1 = feedback(G*C1,1); CM = tf(C2); T2 = CM(1)*feedback(G,-CM(2)); stepplot(T1,T2,'r--')```

Convert `C1` to a 2-DOF controller with different `b` and `c` values.

`C2_2 = make2DOF(C1,0.5,0.75)`
```C2_2 = 1 s u = Kp (b*r-y) + Ki --- (r-y) + Kd -------- (c*r-y) s Tf*s+1 with Kp = 1.12, Ki = 0.23, Kd = 1.3, Tf = 0.122, b = 0.5, c = 0.75 Continuous-time 2-DOF PIDF controller in parallel form. ```

The PID gains and filter constant are still unchanged, but the setpoint weights now change the closed-loop response.

```CM_2 = tf(C2_2); T2_2 = CM_2(1)*feedback(G,-CM_2(2)); stepplot(T1,T2_2,'r--')```

## Input Arguments

collapse all

1-DOF PID controller, specified as a `pid` object or a `pidstd` object.

Setpoint weight on proportional term, specified as a real, nonnegative, finite value. If you do not specify `b`, then `C2` has `b` = 1.

Setpoint weight on derivative term, specified as a real, nonnegative, finite value. If you do not specify `c`, then `C2` has `c` = 1.

## Output Arguments

collapse all

2-DOF PID controller, returned as a `pid2` object or `pidstd2` object. `C2` is in parallel form if `C1` is in parallel form, and standard form if `C1` is in standard form.

For example, suppose `C1` is a continuous-time, parallel-form `pid` controller of the form:

`${C}_{1}={K}_{p}+\frac{{K}_{i}}{s}+\frac{{K}_{d}s}{{T}_{f}s+1}.$`

Then `C2` is a parallel-form 2-DOF `pid2` controller, which has two inputs and one output. The relationship between the inputs, r and y, and the output u of `C2` is given by:

`$u={K}_{p}\left(br-y\right)+\frac{{K}_{i}}{s}\left(r-y\right)+\frac{{K}_{d}s}{{T}_{f}s+1}\left(cr-y\right).$`

The PID gains Kp, Ki, and Kd, and the filter time constant Tf are unchanged. The setpoint weights b and c are specified by the input arguments `b` and `c`, or 1 by default. For more information about 2-DOF PID controllers, see Two-Degree-of-Freedom PID Controllers.

The conversion also preserves the values of the properties `Ts`, `TimeUnit`, ```Sampling Grid```, `IFormula`, and `DFormula`.