Package with models for control set points
Information
This package contains component models to compute set points of control systems.
For additional models, see also
Modelica.Blocks.Continuous.
Extends from Modelica.Icons.VariantsPackage (Icon for package containing variants).
Package Content
Name |
Description |
HotWaterTemperatureReset
|
Block to compute the supply and return set point of heating systems |
OccupancySchedule
|
Occupancy schedule with look-ahead |
Table
|
Model for a set point that is interpolated based on a user-specified table |
Examples
|
Collection of models that illustrate model use and test models |
Validation
|
Collection of validation models |
Block to compute the supply and return set point of heating systems
Information
This block computes the set point temperatures for the
supply and return temperature of a heating system.
The set point for the room air temperature can either be specified
by a parameter, or it can be an input to the model. The latter allows
to use this model with systems that have night set back.
The parameter dTOutHeaBal
can be used to shift the heating curve
to take into account that heat gains from solar, equipment and people
make up for some of the transmission losses.
For example, in energy efficient houses, the heating may not be switched on if
the outside air temperature is greater than
12°C, even if a room temperature of 20°C is required.
In such a situation, set dTOutHeaBal=20-12=8
Kelvin to
shift the heating curve.
Extends from Modelica.Blocks.Icons.Block (Basic graphical layout of input/output block).
Parameters
Type | Name | Default | Description |
Real | m | 1.3 | Exponent for heat transfer |
Boolean | use_TRoo_in | false | Get the room temperature set point from the input connector |
Temperature | TRoo | 293.15 | Fixed value of room temperature set point [K] |
TemperatureDifference | dTOutHeaBal | 8 | Offset for heating curve [K] |
Nominal conditions |
Temperature | TSup_nominal | | Supply temperature [K] |
Temperature | TRet_nominal | | Return temperature [K] |
Temperature | TRoo_nominal | 293.15 | Room temperature [K] |
Temperature | TOut_nominal | | Outside temperature [K] |
Connectors
Type | Name | Description |
input RealInput | TRoo_in | Room air temperature set point [K] |
input RealInput | TOut | Outside temperature [K] |
output RealOutput | TSup | Setpoint for supply temperature [K] |
output RealOutput | TRet | Setpoint for return temperature [K] |
Modelica definition
block HotWaterTemperatureReset
extends Modelica.Blocks.Icons.Block;
parameter Real m = 1.3 ;
parameter Modelica.SIunits.Temperature TSup_nominal ;
parameter Modelica.SIunits.Temperature TRet_nominal ;
parameter Modelica.SIunits.Temperature TRoo_nominal = 293.15
;
parameter Modelica.SIunits.Temperature TOut_nominal ;
parameter Boolean use_TRoo_in = false
;
parameter Modelica.SIunits.Temperature TRoo = 293.15
;
parameter Modelica.SIunits.TemperatureDifference dTOutHeaBal(displayUnit="K") = 8
;
Modelica.Blocks.Interfaces.RealInput TRoo_in(
final quantity="ThermodynamicTemperature",
final unit = "K", displayUnit = "degC", min=0)
if
use_TRoo_in ;
Modelica.Blocks.Interfaces.RealInput TOut(
final quantity="ThermodynamicTemperature",
final unit = "K", displayUnit = "degC", min=0)
;
Modelica.Blocks.Interfaces.RealOutput TSup(
final quantity="ThermodynamicTemperature",
final unit = "K", displayUnit = "degC", min=0)
;
Modelica.Blocks.Interfaces.RealOutput TRet(
final quantity="ThermodynamicTemperature",
final unit = "K", displayUnit = "degC", min=0)
;
protected
Modelica.Blocks.Interfaces.RealInput TRoo_in_internal(
final quantity="ThermodynamicTemperature",
final unit = "K", displayUnit = "degC", min=0)
;
Real qRel ;
Modelica.SIunits.Temperature TOutOffSet
;
parameter Modelica.SIunits.Temperature TOutOffSet_nominal = TOut_nominal + dTOutHeaBal
;
equation
connect(TRoo_in, TRoo_in_internal);
if not use_TRoo_in
then
TRoo_in_internal = TRoo;
end if;
TOutOffSet = TOut + dTOutHeaBal;
qRel =
max(0, (TRoo_in_internal-TOutOffSet)/(TRoo_nominal-TOutOffSet_nominal));
TSup = TRoo_in_internal
+ ((TSup_nominal+TRet_nominal)/2-TRoo_nominal) * qRel^(1/m)
+ (TSup_nominal-TRet_nominal)/2 * qRel;
TRet = TSup - qRel * (TSup_nominal-TRet_nominal);
end HotWaterTemperatureReset;
Occupancy schedule with look-ahead
Information
This model outputs whether the building is currently occupied,
and how long it will take until the next time when the building
will be occupied or non-occupied.
The latter may be used, for example, to start a ventilation system
half an hour before occupancy starts in order to ventilate the room.
The occupancy is defined by a time schedule of the form
occupancy = 3600*{7, 12, 14, 19}
This indicates that the occupancy is from 7:00 until 12:00
and from 14:00 to 19:00. This will be repeated periodically.
The parameter periodicity
defines the periodicity.
The period always starts at t=0 seconds.
Extends from Modelica.Blocks.Icons.Block (Basic graphical layout of input/output block).
Parameters
Type | Name | Default | Description |
Real | occupancy[:] | 3600*{7,19} | Occupancy table, each entry switching occupancy on or off |
Boolean | firstEntryOccupied | true | Set to true if first entry in occupancy denotes a changed from unoccupied to occupied |
Time | period | 86400 | End time of periodicity [s] |
Connectors
Type | Name | Description |
output RealOutput | tNexNonOcc | Time until next non-occupancy |
output RealOutput | tNexOcc | Time until next occupancy |
output BooleanOutput | occupied | Outputs true if occupied at current time |
Modelica definition
block OccupancySchedule
extends Modelica.Blocks.Icons.Block;
parameter Real occupancy[:]=3600*{7, 19}
;
parameter Boolean firstEntryOccupied = true
;
parameter Modelica.SIunits.Time period = 86400 ;
Modelica.Blocks.Interfaces.RealOutput tNexNonOcc
;
Modelica.Blocks.Interfaces.RealOutput tNexOcc ;
Modelica.Blocks.Interfaces.BooleanOutput occupied
;
protected
final parameter Integer nRow =
size(occupancy,1)
;
output Modelica.SIunits.Time offSet=
integer(time/period)*period
;
output Integer nexStaInd ;
output Integer nexStoInd ;
output Integer iPerSta
;
output Integer iPerSto
;
output Modelica.SIunits.Time tOcc ;
output Modelica.SIunits.Time tNonOcc ;
encapsulated function switchInteger
import Modelica;
extends Modelica.Icons.Function;
input Integer x1;
input Integer x2;
output Integer y1;
output Integer y2;
algorithm
y1:=x2;
y2:=x1;
end switchInteger;
encapsulated function switchReal
import Modelica;
extends Modelica.Icons.Function;
input Real x1;
input Real x2;
output Real y1;
output Real y2;
algorithm
y1:=x2;
y2:=x1;
end switchReal;
initial algorithm
assert(
mod(nRow, 2) < 0.1,
"The parameter \"occupancy\" must have an even number of elements.\n");
assert(0 <= occupancy[1],
"The first element of \"occupancy\" must be bigger than or equal to zero."
+ "\n Received occupancy[1] = " +
String(occupancy[1]));
assert(period >= occupancy[nRow],
"The parameter \"period\" must be greater than or equal to the last element of \"occupancy\"."
+ "\n Received period = " +
String(period)
+ "\n occupancy[" +
String(nRow) +
"] = " +
String(occupancy[nRow]));
for i
in 1:nRow-1
loop
assert(occupancy[i] < occupancy[i+1],
"The elements of the parameter \"occupancy\" must be strictly increasing.");
end for;
iPerSta :=
integer(time/period);
iPerSto := iPerSta;
nexStaInd := 1;
nexStoInd := 2;
for i
in 1:2:nRow-1
loop
if time >= occupancy[i] + iPerSta*period
then
nexStaInd := i+2;
end if;
end for;
for i
in 2:2:nRow
loop
if time >= occupancy[i] + iPerSto*period
then
nexStoInd := i+2;
end if;
end for;
if nexStaInd > nRow
then
nexStaInd := 1;
iPerSta :=iPerSta + 1;
end if;
if nexStoInd > nRow
then
nexStoInd := 2;
iPerSto :=iPerSto + 1;
end if;
tOcc := occupancy[nexStaInd]+iPerSta*period;
tNonOcc := occupancy[nexStoInd]+iPerSto*period;
occupied := tNonOcc < tOcc;
if not firstEntryOccupied
then
(nexStaInd, nexStoInd) :=
switchInteger(nexStaInd, nexStoInd);
(iPerSta, iPerSto) :=
switchInteger(iPerSta, iPerSto);
(tOcc, tNonOcc) :=
switchReal(tOcc, tNonOcc);
occupied :=
not occupied;
end if;
equation
when time >=
pre(tOcc)
then
nexStaInd =
if pre(nexStaInd) + 2 <= nRow
then (
pre(nexStaInd) + 2)
else (
if firstEntryOccupied
then 1
else 2);
iPerSta =
if pre(nexStaInd) + 2 <= nRow
then pre(iPerSta)
else (
pre(iPerSta) + 1);
tOcc = occupancy[nexStaInd] + iPerSta*period;
occupied =
not pre(occupied);
nexStoInd =
pre(nexStoInd);
iPerSto =
pre(iPerSto);
tNonOcc =
pre(tNonOcc);
elsewhen time >=
pre(tNonOcc)
then
nexStoInd =
if pre(nexStoInd) + 2 <= nRow
then (
pre(nexStoInd) + 2)
else (
if firstEntryOccupied
then 2
else 1);
iPerSto =
if pre(nexStoInd) + 2 <= nRow
then pre(iPerSto)
else (
pre(iPerSto) + 1);
tNonOcc = occupancy[nexStoInd] + iPerSto*period;
occupied =
not pre(occupied);
nexStaInd =
pre(nexStaInd);
iPerSta =
pre(iPerSta);
tOcc =
pre(tOcc);
end when;
tNexOcc = tOcc-time;
tNexNonOcc = tNonOcc-time;
end OccupancySchedule;
Model for a set point that is interpolated based on a user-specified table
Information
This block can be used to schedule a set-point by using piecewise linear functions.
For example, the instances
Buildings.Controls.SetPoints.Table tabLinExt(constantExtrapolation=false,
table=[20, 0.0;
22, 0.5;
25, 0.5;
26, 1.0]);
Buildings.Controls.SetPoints.Table tabConExt(constantExtrapolation=true,
table=[20, 0.0;
22, 0.5;
25, 0.5;
26, 1.0]);
will cause the following output:
For the default setting constantExtrapolation=true
, the
block outputs
y=y1+offset
for u ≤ u1
, and
y=yMax+offset
for u ≥ uMax
.
Otherwise, the table is linearly extrapolated with a constant derivative.
Note that the first column must be strictly increasing.
Extends from Modelica.Blocks.Interfaces.SISO (Single Input Single Output continuous control block).
Parameters
Type | Name | Default | Description |
Real | table[:, 2] | fill(0.0, 1, 2) | Table matrix ( e.g., table=[u1, y1; u2, y2; u3, y3]) |
Real | offset | 0 | Offset of output signal |
Boolean | constantExtrapolation | true | If true, then y=y1 for u<u1, and y=yMax for u>uMax |
Connectors
Type | Name | Description |
input RealInput | u | Connector of Real input signal |
output RealOutput | y | Connector of Real output signal |
Modelica definition
model Table
extends Modelica.Blocks.Interfaces.SISO;
parameter Real table[:,2]=
fill(0.0, 1, 2)
;
parameter Real offset=0 ;
parameter Boolean constantExtrapolation = true
;
protected
final parameter Integer nRow =
if constantExtrapolation
then
size(table,1)+2
else
size(table,1) ;
final parameter Real[nRow,2] offsetVector = [
zeros(nRow), offset*
ones(nRow)]
;
Modelica.Blocks.Tables.CombiTable1D tab(
tableOnFile=false,
final table= (
if constantExtrapolation
then
cat(1, [table[1,1]-1, table[1,2]],
table,
[table[
end,1]+1, table[
end,2]])
else
table)
+offsetVector) ;
equation
connect(u, tab.u[1]);
connect(tab.y[1], y);
end Table;