Regulating drum boiler pressure

Regulating drum  boiler pressure
by

Regulating pressure in a drum boiler

The Simulink control design of a boiler drum is constructed. Using the operating point search function, we illustrate model linearization as well as subsequent state observer and LQR design.

In this drum-boiler model, the control problem is to regulate boiler pressure in the face of random heat fluctuations from the furnace by adjusting the feed water flow rate and the nominal heat applied. For this example, 95% of the random heat fluctuations are less than 50% of the nominal heating value(This is not unusual for a furnace-fired boiler).

Simulation with MATLAB code

First, initialize and open the model by typing Myboiler( Demo model is present in MATLAB as boiler_demo)

The boiler control model’s pre-load function initializes the controller sizes. This is necessary because to compute the operating point and linear model, the Simulink model must be executable. Note that u0, y0 are set after the operating point computation and are thus initially set to zero. The observer and regulator are computed during the controller design step and are also initially set to zero.

The Simulink model of a drum boiler is as shown below:

The components present inside the regulator block can be seen by Right click on model–>mask–>under the mask

Similarly, the components present inside an observer block can be seen below:

After initializing, find a nominal operating point and normalize it.

MATLAB code (Type scdboilerpad in command window for demo code)

First, we’ll create an operating point specification where the state values are known.

opspec = operspec(‘Myboiler’);
opspec.States(1).Known = 1;
opspec.States(2).Known = 1;
opspec.States(3).Known = [1;1];

Now, let’s adjust the operating point specification to indicate that the inputs must be computed and that they are lower bounded.

opspec.Inputs(1).Known = [0;0];       (Inputs unknown)
opspec.Inputs(1).Min = [0;0];            (Input minimum value)

Finally, we’ll add an output specification to the operating point specification; this is necessary to ensure that the output operating point is computed during the solution process.

opspec = addoutputspec(opspec,’Myboiler/Boiler’,1);
opspec.Outputs(1).Known = 0;    (Outputs unknown)
opspec.Outputs(1).Min = 0;         (Output minimum value)

Next, we compute the operating point and generate a report.

[opSS,opReport] = findop(‘Myboiler’,opspec);
Operating Point Search Report:
———————————
Operating Report for the Model Myboiler.
(Time-Varying Components Evaluated at time t=0)
Operating point specifications were successfully met.
States:
———-
(1.) Myboiler/Boiler/Steam volume
x:           5.6      dx:      7.85e-13 (0)
(2.) Myboiler/Boiler/Temperature
x:           180      dx:     -5.93e-14 (0)
(3.) Myboiler/Observer/Internal
x:             0      dx:             0 (0)
x:             0      dx:             0 (0)
Inputs:
———-
(1.) Myboiler/Input
u:      2.41e+05    [0 Inf]
u:           100    [0 Inf]
Outputs:
———-
(1.) Myboiler/Boiler
y:         1e+03    [0 Inf]

Before linearizing the model around this point, we’ll specify the input and

output signals for the linear model.

First, we specify the input points for linearization.

Boiler_io(1) = linio(‘Myboiler/Sum’,1,’input’);
Boiler_io(2) = linio(‘Myboiler/Demux’,2,’input’);

Now we specify the open loop output points for linearization.

Boiler_io(3) = linio(‘Myboiler/Boiler’,1,’openoutput’);
setlinio(‘Myboiler’,Boiler_io);





In this code, we find a linear model around the chosen operating point.

Lin_Boiler = linearize(‘Myboiler’,opSS,Boiler_io);

Finally, using the minreal function, make sure that the model is a

minimum realization, (e.g., there are no pole-zero cancellations).

Lin_Boiler = minreal(Lin_Boiler);
1 state removed.

Designing a regulator and state observer

Using this linear model, we will design an LQR regulator and Kalman filter state observer. First, find the controller offsets to make sure that the controller is operating around the chosen linearization point by retrieving the computed operating point.

u0 = opReport.Inputs.u;
y0 = opReport.Outputs.y;

Now design the regulator using the lqry function. Note that tight regulation of the output is required while input variation should be limited.

Q = diag(1e8);                    (Output regulation)
R = diag([1e2,1e6]);              (Input limitation)
[K,S,E] = lqry(Lin_Boiler,Q,R);
Design the Kalman state observer using the kalman function. Note that for this example the main noise source is process noise.  It enters the system only through one input, hence the form of G and H.
[A,B,C,D] = ssdata(Lin_Boiler);
G = [B(:,1)];
H = [0];
QN = 1e4;
RN = 1e-1;
NN = 0;
[Kobsv,L,P] = kalman(ss(A,[B G],C,[D H]),QN,RN);

 Simulate and Test

The output of the Simulink model of drum boiler is observed by simulating it.

For the designed controller the process inputs and outputs are shown below.

sim(‘Myboiler’)

The feed water flow rate is observed in figure 1:

Here is the feed water actuation signal in kg/s

figSize = [0 0 360 240];
h = figure(1); plot(FeedWater.time/60,FeedWater.signals.values)
h.Color = [1 1 1];
h.Position = figSize;
title(‘Feedwater flow rate [kg/s]’);
ylabel(‘Flow [kg/s]’)
xlabel(‘time [min]’)
grid on

The Applied heat rate can be observed in figure 2:

This illustrates the heat actuation signal in kJ:

h = figure(2); plot(Heat.time/60,Heat.signals.values/1000)
h.Color = [1 1 1];
h.Position = figSize;
title(‘Applied heat [kJ]’);
ylabel(‘Heat [kJ]’)
xlabel(‘time [min]’)
grid on

Heat disturbance rate can be observed in figure 3:

The figure shows the heat disturbance in kJ. Note that the disturbance varies by as much as 50% of the nominal heat value.

h = figure(3); plot(HeatDist.time/60,HeatDist.signals.values/1000)
h.Color = [1 1 1];
h.Position = figSize;
title(‘Heat disturbance [kJ]’);
ylabel(‘Heat [kJ]’)
xlabel(‘time [min]’)
grid on

Finally drum pressure rate can be observed for all the state input values in figure 4:

The figure below shows the corresponding drum pressure in kPa. Notice how the pressure varies by about 1% of the nominal value even though the disturbance is relatively large.

h =figure(4);
plot(DrumPressure.time/60,DrumPressure.signals.values)
h.Color = [1 1 1];
h.Position = figSize;
title(‘Drum pressure [kPa]’);
ylabel(‘Pressure [kPa]’)
xlabel(‘time [min]’)
grid on

Result and application:

The State observer and Kalman filter used in the Experiment observes/estimates the values of parameters which cannot be measured by physical sensors thus regulating a safe and stable processing of the system. The pressure, temperature, heat disturbance etc can be predicted correctly for smooth processing and for the safeguard of humans working around in the power plant or wherever boilers are used.

Knowledge about boilers is required for construction and observation.


Passion for robotics and always curious to learn more.

Leave a Reply