A Hybrid Tank Model with a Discrete Controller

Now let us consider a hybrid Tank containing a Proportional-Integral (PI) controller.

Figure 1: A tank system with a tank, a source for liquid, and a controller.

1 Tank Model Componets

1.1 Connectors

connector ReadSignal Real val; end ReadSignal;
connector ActSignal Real act; end ActSignal;
connector LiquidFlow Real lflow; end LiquidFlow;
connector ActSignal "Signal to actuator for setting valve position" Real act; end ActSignal;
connector ReadSignal "Reading fluid level" Real val(unit = "m"); end ReadSignal;
connector LiquidFlow "Liquid flow at inlets or outlets" Real lflow(unit = "m3/s"); end LiquidFlow;

1.2 Functions

function LimitValue input Real pMin; input Real pMax; input Real p; output Real pLim; algorithm pLim := if p>pMax then pMax else if p<pMin then pMin else p; end LimitValue;
function limitValue input Real pMin; input Real pMax; input Real p; output Real pLim; algorithm pLim := if p>pMax then pMax else if p<pMin then pMin else p; end limitValue;

1.3 Components

1.3.1 PI Controllers

partial model PIcontroller parameter Real Ts = 0.1; // sampling time[s] parameter Real K = 2; // gain parameter Real T = 10; // time constant[s] parameter Real minV = 0, maxV = 1; // limits for output Real ref, error, outCtr; ReadSignal cInp; ActSignal cOut; equation error = ref - cInp.val; cOut.act = LimitValue(minV, maxV, outCtr); end PIcontroller;
partial model BaseController parameter Real Ts(unit = "s") = 0.1 "Time period between discrete samples"; parameter Real K = 2 "Gain"; parameter Real T(unit = "s") = 10 "Time constant"; ReadSignal cIn "Input sensor level, connector"; ActSignal cOut "Control to actuator, connector"; parameter Real ref "Reference level"; Real error "Deviation from reference level"; Real outCtr(fixed=true) "Output control signal"; equation error = ref - cIn.val; cOut.act = outCtr; end BaseController;

BaseControllerClocked

partial model BaseControllerClocked "Controller with clocked states" parameter Real Ts(unit="s")=0.1 "Time between samples"; parameter Real K=2 "Gain"; parameter Real T(unit="s")=10 "Time constant"; ReadSignal cIn "Input sensor level, connector"; ActSignal cOut "Control to actuator, connector"; parameter Real ref "Reference level"; discrete Real error "Deviation from reference level"; discrete Real outCtr "Output control signal"; discrete Real dCinval "Sampled sensor level"; equation dCinval = sample(cIn.val, Clock(Ts)); // sampling of sensor Cin.val error = ref - dCinval; cOut.act = hold(outCtr); // hold clocked output control signal end BaseControllerClocked;
model PIcontinuousController extends BaseController(K = 2, T = 10); Real x(fixed=true) "State variable of continuous PI controller"; equation der(x) = error/T; outCtr = K*(error + x); end PIcontinuousController;
model PIdiscreteControllerUnclocked extends BaseController(K = 2, T = 10); discrete Real x(fixed=true); // State variable of discrete controller equation when sample(0, Ts) then x = pre(x) + error * Ts / T; outCtr = K * (x + error); end when; end PIdiscreteControllerUnclocked;

PIdiscreteControllerClocked

model PIdiscreteControllerClocked "Pure clocked version of PI controller" extends BaseControllerClocked(K=2,T=10); discrete Real x; // State variable of discrete controller equation when Clock() then // clock frequency inferred from the variable error x = previous(x) + error*Ts/T; end when; outCtr = K*(x+error); end PIdiscreteControllerClocked;

1.3.2 PID Controlers

partial model PIDcontroller parameter Real Ts = 0.1; // sampling time[s] parameter Real K = 2; // gain parameter Real T = 10; // time constant[s] parameter Real minV = 0, maxV = 1; // limits for output Real ref, error, outCtr; ReadSignal cInp; ActSignal cOut; equation error = ref - cInp.val; cOut.act = LimitValue(minV, maxV, outCtr); end PIDcontroller;
model PIDcontinuousController extends PIDcontroller(K = 2, T = 10, maxV = 0.02); Real x(fixed=true); //state variable of continuous controller Real y(fixed=true); //state variable of continuous controller equation der(x) = error/T; y= T*der(error); outCtr = K * (x+error+y); end PIDcontinuousController;
model PIDdiscreteControllerUnclocked extends BaseController(K = 2, T = 10); discrete Real x(fixed=true); // State variable of discrete controller discrete Real y(fixed=true); // State variable of discrete controller equation when sample(0, Ts) then x = pre(x) + error * Ts / T; y = T*(error-pre(error)); outCtr = K * (x + error + y); end when; end PIDdiscreteControllerUnclocked;

PIDdiscreteControllerClocked Version

model PIDdiscreteControllerClocked "Clocked PID controller" extends BaseControllerClocked(K=2,T=10); discrete Real x; // Clocked state variable of discrete controller discrete Real y; // Clocked state variable of discrete controller equation when Clock() then x = previous(x)+error*Ts/T; y=T*(error-previous(error)); end when; outCtr = K*(x+error+y); end PIDdiscreteControllerClocked;

1.3.3 Tank

model Tank ReadSignal tSensor "Connector, sensor reading tank level (m)"; ActSignal tActuator "Connector, actuator controlling input flow"; LiquidFlow qIn "Connector, flow (m3/s) through input valve"; LiquidFlow qOut "Connector, flow (m3/s) through output valve"; parameter Real area(unit = "m2") = 0.5; parameter Real flowGain(unit = "m2/s") = 0.05; parameter Real minV= 0, maxV = 10; // Limits for output valve flow Real h(start = 0.0,fixed=true, unit = "m") "Tank level"; equation assert(minV>=0,"minV - minimum Valve level must be >= 0 "); der(h) = (qIn.lflow - qOut.lflow)/area; // Mass balance equation qOut.lflow = limitValue(minV, maxV, -flowGain*tActuator.act); tSensor.val = h; end Tank;
model LiquidSource LiquidFlow qOut; parameter Real flowLevel = 0.02; equation qOut.lflow = if time > 150 then 3*flowLevel else flowLevel; end LiquidSource;

2 TankHybridPI Model UnClocked

Finally we put together the hybrid tank system by simply replacing the continuous PI controller by the discrete one, called piDiscrete, as depicted in Figure 2.

Figure 2: A Hybrid Tank system consisting of a continuous tank model connected to a source for liquid and a discrete PI controller.

The TankHybridPI model connects a discrete PI controller to a liquid source and a tank, both defined by the models above.

model TankHybridPIUnclocked LiquidSource source(flowLevel=0.02); PIdiscreteControllerUnclocked piDiscrete(ref=0.25); Tank tank(area=1); equation connect(source.qOut, tank.qIn); connect(tank.tActuator, piDiscrete.cOut ); connect(tank.tSensor, piDiscrete.cIn ); end TankHybridPIUnclocked;

The hybrid tank system with a discrete PI controller is simulated, see Figure ??, obtaining essentially the same result as when using the continuous PI controller (compare to Figure ?? on page ??). The response shown in the curve is the reaction of the controller to an instantaneous increase in the input flow from the source at time t=150. The only difference compared to the continuous controller case is a few small squiggles in the curve probably caused by the discrete approximation.

2.1 Simulation of TankHybridPIUnclocked

simulate( TankHybridPIUnclocked, stopTime=250 )
plot( tank.h )

3 TankHybridPI Model Clocked

model TankHybridPIClocked LiquidSource source(flowLevel=0.02); PIdiscreteControllerClocked piDiscrete(ref=0.25); Tank tank(area=1); equation connect(source.qOut, tank.qIn); connect(tank.tActuator, piDiscrete.cOut); connect(tank.tSensor, piDiscrete.cIn); end TankHybridPIClocked;

This model contains clocked synchronous constructs that are not yet fully supported by OpenModelica as of October 2015, but may start working within the near future.Hence the Simulation of this models does not work

setCommandLineOptions("+std=3.3")
simulate(TankHybridPIClocked,stopTime=250)
plot( tank.h )

4 TankHybridPID Model Unclocked

model TankHybridPIDUnclocked LiquidSource source(flowLevel=0.02); PIDdiscreteControllerUnclocked pidDiscrete(ref=0.25); Tank tank(area=1); equation connect(source.qOut, tank.qIn); connect(tank.tActuator, pidDiscrete.cOut ); connect(tank.tSensor, pidDiscrete.cIn ); end TankHybridPIDUnclocked;

4.1 Simulation of TankHybridPI

simulate( TankHybridPIDUnclocked, stopTime=250 )
plot( tank.h )

4.2 TankHybridPID Model Clocked

model TankHybridPIDClocked LiquidSource source(flowLevel=0.02); PIDdiscreteControllerClocked pidDiscrete(ref=0.25); Tank tank(area=1); equation connect(source.qOut, tank.qIn); connect(tank.tActuator, pidDiscrete.cOut); connect(tank.tSensor, pidDiscrete.cIn); end TankHybridPIDClocked;

This model contains clocked synchronous constructs that are not yet supported by OpenModelica as of October 2015, but may start working within the near future.Hence the Simulation of this models does not work

setCommandLineOptions("+std=3.3")
simulate(TankHybridPIDClocked,stopTime=250)
plot( tank.h )