## Documentation Center |

This example shows how to use Robust Control Toolbox™ to decouple the two main feedback loops in a distillation column.

On this page… |
---|

This example uses a simple model of the distillation column shown below.

**Figure 1: Distillation Column**

In the so-called LV configuration, the controlled variables are the concentrations `yD` and `yB` of the chemicals `D` (tops) and `B` (bottoms), and the manipulated variables are the reflux `L` and boilup `V`. This process exhibits strong coupling and large variations in steady-state gain for some combinations of L and V. For more details, see Skogestad and Postlethwaite, *Multivariable Feedback Control*.

The plant is modeled as a first-order transfer function with inputs `L,V` and outputs `yD,yB`:

s = tf('s','TimeUnit','minutes'); G = [87.8 -86.4 ; 108.2 -109.6]/(75*s+1); G.InputName = {'L','V'}; G.OutputName = {'yD','yB'};

The control objectives are as follows:

Independent control of the tops and bottoms concentrations by ensuring that a change in the tops setpoint

`Dsp`has little impact on the bottoms concentration`B`and vice versaResponse time of about 15 minutes

Fast rejection of input disturbances affecting the effective reflux

`L`and boilup`V`

To achieve these objectives we use the control architecture shown below. This architecture consists of a static decoupling matrix `DM` in series with two PI controllers for the reflux `L` and boilup `V`.

```
open_system('rct_distillation')
```

**Controller Tuning in Simulink with LOOPTUNE**

The `looptune` command provides a quick way to tune MIMO feedback loops. When the control system is modeled in Simulink, you just specify the tuned blocks, the control and measurement signals, and the desired bandwidth, and `looptune` automatically sets up the problem and tunes the controller parameters. `looptune` shapes the open-loop response to provide integral action, roll-off, and adequate MIMO stability margins.

Use the `slTuner` interface to specify the tuned blocks, the controller I/Os, and signals of interest for closed-loop validation.

ST0 = slTuner('rct_distillation',{'PI_L','PI_V','DM'}); % Signals of interest addPoint(ST0,{'r','dL','dV','L','V','y'})

Use `TuningGoal` objects to express the design requirements. Specify that each loop should respond to a step command in about 15 minutes with minimum cross-coupling.

TR = TuningGoal.Tracking('r','y',15);

Set the control bandwidth by using [0.1,0.5] as gain crossover band for the open-loop response.

wc = [0.1,0.5];

To enforce fast disturbance rejection, specify that the disturbance attenuation factor should be at least 20 dB at 0.1 rad/s, increasing to infinity at 0 rad/s since the controller has integral action.

DR = TuningGoal.Rejection({'L','V'},1/s); DR.Focus = [0 0.1]; % enforced between 0 and 0.1 rad/s viewSpec(DR)

Next use `looptune` to tune the controller blocks `PI_L`, `PI_V`, and `DM` subject to these requirements.

Controls = {'L','V'}; Measurements = 'y'; [ST,gam,Info] = looptune(ST0,Controls,Measurements,wc,TR,DR);

Final: Peak gain = 1, Iterations = 67 Achieved target gain value TargetGain=1.

The final value is near 1 which indicates that all requirements were met. Use `loopview` to check the resulting design. The responses should stay outside the shaded areas.

loopview(ST,Info)

Use `getIOTransfer` to access and plot the closed-loop responses from reference and disturbance to the tops and bottoms concentrations. The tuned responses show a good compromise between tracking and disturbance rejection.

clf Ttrack = getIOTransfer(ST,'r','y'); step(Ttrack,40), grid, title('Setpoint tracking')

Treject = getIOTransfer(ST,{'dV','dL'},'y'); step(Treject,40), grid, title('Disturbance rejection')

If you do not have a Simulink model of the control system, you can use LTI objects and Control Design blocks to create a MATLAB representation of the following block diagram.

**Figure 2: Block Diagram of Control System**

First parameterize the tunable elements using Control Design blocks. Use the `ltiblock.gain` block to parameterize `DM`:

```
DM = ltiblock.gain('Decoupler',eye(2));
```

This creates a 2x2 static gain with four tunable parameters. Similarly, use the `ltiblock.pid` block to parameterize the two PI controllers:

PI_L = ltiblock.pid('PI_L','pi'); PI_L.TimeUnit = 'minutes'; PI_V = ltiblock.pid('PI_V','pi'); PI_V.TimeUnit = 'minutes';

At this point, the tunable elements are over-parameterized because multiplying `DM` by two and dividing the PI coefficients by two does not change the overall controller. To eliminate redundant parameters, normalize the PI controllers by fixing their proportional gain `Kp` to 1:

PI_L.Kp.Value = 1; PI_L.Kp.Free = false; PI_V.Kp.Value = 1; PI_V.Kp.Free = false;

Next construct a model `C0` of the controller
in Figure 2.

C0 = blkdiag(PI_L,PI_V) * DM * [eye(2) -eye(2)]; % Note: I/O names should be consistent with those of G C0.InputName = {'Dsp','Bsp','yD','yB'}; C0.OutputName = {'L','V'};

Now tune the controller parameters with `looptune` as done previously.

% Tracking requirement TR = TuningGoal.Tracking({'Dsp','Bsp'},{'yD','yB'},15); % Disturbance rejection requirement DR = TuningGoal.Rejection({'L','V'},1/s); DR.Focus = [0 0.1]; % Crossover band wc = [0.1,0.5]; [~,C] = looptune(G,C0,wc,TR,DR);

Final: Peak gain = 1, Iterations = 78 Achieved target gain value TargetGain=1.

To validate the design, close the loop with the tuned compensator `C` and simulate the step responses for setpoint tracking and disturbance rejection. Also compare the open- and closed-loop disturbance rejection characteristics in the frequency domain.

Tcl = connect(G,C,{'Dsp','Bsp','L','V'},{'yD','yB'}); Ttrack = Tcl(:,[1 2]); step(Ttrack,40), grid, title('Setpoint tracking')

Treject = Tcl(:,[3 4]); Treject.InputName = {'dL','dV'}; step(Treject,40), grid, title('Disturbance rejection')

clf, sigma(G,Treject), grid title('Rejection of input disturbances') legend('Open-loop','Closed-loop')

The results are similar to those obtained in Simulink.

Was this topic helpful?