Sampled Systems

1 Simple Periodic Sampler

The following model is a simple periodic sampler with a sampling period T that is constant and defined as a parameter that can be changed by the model user. This model has only one kind of event, the sampling event. We use the built-in function sample in the when-condition sample(0, T) to periodically generate the sampling events with a period time T. This is a simple model using the state space equations.

model SimplePeriodicSamplerUnclocked parameter Real T = 1 "Sample period"; input Real u "Input used at sample events"; discrete output Real y(fixed=true) "Output computed at sample events"; replaceable function f = Modelica.Math.atan2; replaceable function h = Modelica.Math.atan2; protected discrete Real x(fixed=true); // discrete state variable equation when sample(0, T) then x = f(pre(x), u); // state update expression y = h(pre(x), u); // output expression end when; end SimplePeriodicSamplerUnclocked;
loadModel(Modelica)
simulate(SimplePeriodicSamplerUnclocked,stopTime=1)
plot(y)

2 Simple Periodic Sampler Clocked

A clocked version of the same model appears as follows. A clocked output variable y1 had to be introduced since only equations for clocked variables are allowed inside a clocked when-equation. The equation for the unclocked variable y which is just a hold version of y1, had to be placed outside the clocked when-equation.

model SimplePeriodicSamplerClocked parameter Real T=1 "Clock period"; input Real u "Input used at sample events"; discrete output Real y1 "Output only defined at sample events"; output Real y "hold output y also defined between sample events"; protected discrete Real x "clocked discrete-time state variable"; equation when Clock(T) then x = f(previous(x),sample(u)); // state update expression y1 = h(previous(x),sample(u)); // output updated at clock events end when; y = hold(y1); // hold output y also defined between events end SimplePeriodicSamplerClocked;

We simplify even further by replacing the calls to the functions f and h by simple example expressions, removing the protected keyword to make the state variable x accessible for plotting, and setting u=time as an example instead of a real input signal:

model VerySimplePeriodicSamplerClocked parameter Real T=1 "Clock period"; Real u=time "Use time as input at sample events"; discrete output Real y1 "Output only defined at sample events"; output Real y "hold output y also defined between sample events"; discrete Real x(start=0) "clocked discrete-time state variable"; equation when Clock(T) then x = previous(x) + sample(u); // state update expression y1 = previous(x)+ 3*sample(u); // output updated at clock events end when; y = hold(y1); // hold output y also defined between events end VerySimplePeriodicSamplerClocked;

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

loadModel(Modelica)
setCommandLineOptions("+std=3.3")
simulate(VerySimplePeriodicSamplerClocked)

2.1 Unclocked version of VerySimplePeriodicSampler

model VerySimplePeriodicSamplerUnclocked parameter Real T=1 "Sample period"; Real u=time "Input used at sample events"; discrete output Real y "Output computed at sample events"; discrete Real x; // discrete-time state variable equation when sample(0,T) then x = pre(x) + u; // state update expression y = pre(x) + 3*u; // output y updated at sample events end when; end VerySimplePeriodicSamplerUnclocked;
simulate(VerySimplePeriodicSamplerUnclocked,stopTime=10)
plot({x,y,u})

3 Base Class for Sampling Models Unclocked

It is possible to formulate a base class for scalar sampling models using state-space equations.The class BaseSampler below can for example be specialized to either a periodic sampler or an aperiodic sampler.

loadModel(Modelica)
partial class BaseSamplerUnclocked input Real u; discrete output Real y(start=0, fixed=true); Boolean doSample; replaceable function f = Modelica.Math.atan2; replaceable function h = Modelica.Math.atan2; protected discrete Real x(start=0, fixed=true); equation when doSample then x = f(pre(x), u); // state update expression y = h(pre(x), u); // output expression end when; end BaseSamplerUnclocked;

We use two very simple example functions f2 and h2 for the redeclarations:

function f2 input Real u1; input Real u2; output Real y; algorithm y := u1+u2; end f2;
function h2 input Real u1; input Real u2; output Real y; algorithm y := u1 + 5*u2; end h2;

Below the base model is extended to a periodic sampling model PeriodicSampler with a fixed period time T.

model PeriodicSampler extends BaseSamplerUnclocked; parameter Real T = 1 "sample period"; equation doSample = sample(0, T); end PeriodicSampler;

In order to simulate the model it is instantiated below.

model TestPeriodicSampler protected function f1 input Real u1, u2; output Real y; algorithm y := u1 + u2; end f1; PeriodicSampler ps( redeclare function f=f1, redeclare function h=f1); equation ps.u = time; end TestPeriodicSampler;
simulate(TestPeriodicSampler, stopTime=3, simflags="-emit_protected")
plot({ps.u, ps.x})

4 Base Class for Sampling Models clocked

The clocked base sample model uses a clock variable doSample of built-in type Clock.

partial model BaseSamplerClocked Real u "Input used at clock events"; discrete output Real y1 "Output only defined at sample events"; output Real y "hold output y also defined between sample events"; Clock doSample; replaceable function f = Modelica.Math.atan2; // atan2 used as dummy replaceable function h = Modelica.Math.atan2; // default function discrete Real x(start=0) "clocked discrete-time state variable"; equation when doSample then x = f(previous(x),sample(u)); // state update expression y1 = h(previous(x),sample(u)); // output updated at clock events end when; y = hold(y1); // hold output y also defined between clock events end BaseSamplerClocked;
model PeriodicSamplerClocked extends BaseSamplerClocked(u=time,redeclare function f=f2, redeclare function h=h2); parameter Real T=1 "sample period"; equation doSample = Clock(T); end PeriodicSamplerClocked;

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

loadModel(Modelica)
setCommandLineOptions("+std=3.3")
simulate(PeriodicSamplerClocked)

5 Aperiodic Sampler Unclocked

Besides the above periodic sampler, an aperiodic sampling model with a time-varying sample period can be obtained by specializing the base class. A variable nextSampling is used for the next sampling time, which is current time + periodTime when the current time has reached the previous value of nextSampling. In this example we increase the period time by the logarithm of the current time just to have a time varying period time.

model APeriodicSamplerUnclocked extends BaseSamplerUnclocked(u=time,redeclare function f=f2, redeclare function h=h2); discrete Real nextSampling(start=0); discrete Real periodTime(start=2) "time-varying sample period"; equation doSample = time>pre(nextSampling); when doSample then nextSampling = pre(nextSampling) + periodTime; periodTime = pre(periodTime) + log(pre(periodTime)); // example end when; end APeriodicSamplerUnclocked;
simulate(APeriodicSamplerUnclocked,stopTime=10)
plot({nextSampling,periodTime,y})

6 Aperiodic Sampler Clocked

model APeriodicSamplerClocked extends BaseSamplerClocked(u=time,redeclare function f=f2, redeclare function h=h2); discrete Real nextSampling(start=0); discrete Real periodTime(start=2) "time-varying sample period"; equation doSample = Clock(time>hold(nextSampling)); when doSample then nextSampling = previous(nextSampling)+periodTime; periodTime = previous(periodTime) +log(previous(periodTime)); end when; end APeriodicSamplerClocked;

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(APeriodicSamplerClocked)

7 Discrete Scalar State Space Sampling Model

A discrete first order scalar state space model with periodic sampling can be formulated as follows, essentially being a special case of the above BaseSampler model even though we do not extend that class in this particular case.

model DiscreteScalarStateSpaceUnclocked parameter Real a, b, c, d; parameter Real T = 1; input Real u; discrete output Real y; protected discrete Real x; equation when sample(0, T) then x = a * pre(x) + b * u; y = c * pre(x) + d * u; end when; end DiscreteScalarStateSpaceUnclocked;
simulate(DiscreteScalarStateSpaceUnclocked,stopTime=5,simflags="-emit_protected")
plot({x,y,u})

Alternatively, the discrete scalar state space model can be expressed by extending the BaseSampler model for periodic sampling and redeclaring the functions f and g as below. However, in this case the result is not shorter or more readable since the syntax for expressing the local functions f1 and h1 is not very concise. On the other hand, if the functions f1 and h1 instead would be used in several places, the modeling style based on replaceable functions would be preferable.

model DiscreteScalarStateSpace2Unclocked extends BaseSamplerUnclocked(redeclare function f = f2, redeclare function h = h2); constant Real a=1, b=1, c=1, d=7; parameter Real T = 1 "sample period"; function f1 input Real x1; input Real x2; input Real y1; algorithm y1 := a * x1 + b * x2; end f1; function h1 input Real x1; input Real x2; input Real y1; algorithm y1 := c * x1 + d * x2; end h1; equation doSample = sample(0, T); end DiscreteScalarStateSpace2Unclocked;
simulate(DiscreteScalarStateSpace2Unclocked,stopTime=10,simflags="-emit_protected")
plot({x,y,u})

8 Discrete Vector State Space Sampling Model Clocked

model DiscreteScalarStateSpaceClocked parameter Real a=1, b=1, c=1, d=3; parameter Real T=1 "Clock period"; Real u=time "Use time as input at sample events"; discrete output Real y1 "Output only defined at sample events"; output Real y "hold output y also defined between sample events"; discrete Real x(start=0) "clocked discrete-time state variable"; equation when Clock(T) then x = a*previous(x) + b*sample(u); // state update expression y1 = b*previous(x) + d*sample(u); // output updated at clock events end when; y = hold(y1); // hold output y also defined between events end DiscreteScalarStateSpaceClocked;

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(DiscreteScalarStateSpaceClocked)

9 Discrete Vector State Space Sampling Model

Usually state space models are expressed using the more general vector form, as in the DiscreteVectorStateSpace periodic sampling model below:

model DiscreteVectorStateSpace parameter Integer n = 5, m = 4, p = 2; parameter Real A[n, n] = fill(1, n, n); parameter Real B[n, m] = fill(2, n, m); parameter Real C[p, n] = fill(3, p, n); parameter Real D[p, m] = fill(4, p, m); parameter Real T = 1; input Real u[m]; discrete output Real y[p] (each fixed=true); protected discrete Real x[n] (each fixed=true);// = fill(2, n); equation when sample(0, T) then x = A * pre(x) + B * u; y = C * pre(x) + D * u; end when; end DiscreteVectorStateSpace;
model DVSSTest DiscreteVectorStateSpace dvss; equation dvss.u= fill(time,dvss.m); end DVSSTest;

9.1 Simulation of DVSSTest

simulate( DVSSTest, stopTime=200 )
plot({dvss.m})

10 Two Rate Sampling Model Unclocked

In the TwoRateSampler model below the slow sampler is five times slower than the fast sampler, i.e. the slowSample when-equation is evaluated at every 5th activation of the fastSample when-equation. The two samplers are synchronized via equations involving the cyCounter variable.

model TwoRateSamplerUnclocked discrete Real x(fixed=true),y(fixed=true); Boolean fastSample; Boolean slowSample(fixed=true); Integer cyCounter(start=0,fixed=true); // Cyclic count 0,1,2,3,4, 0,1,2,3,4,... equation fastSample = sample(0,1); // Define the fast clock when fastSample then cyCounter = if pre(cyCounter) < 5 then pre(cyCounter)+1 else 0; slowSample = pre(cyCounter) == 0; // Define the slow clock end when; equation when fastSample then // fast sampling x = sin(time); end when; equation when slowSample then // slow sampling (5-times slower) y = log(1+time); end when; end TwoRateSamplerUnclocked;

10.1 Simulation of TwoRateSampler

simulate( TwoRateSamplerUnclocked, stopTime=100 )
plot( { x, y } )

11 Two Rate Sampling Model Clocked

model TwoRateSamplerClocked "Two clocked synchronized counters" Clock slowPulses; // Clock variable of type Clock Clock fastPulses; // Clock variable of type Clock discrete Real x,y; // Clocked variables for sampled values Real hx,hy; // Hold variables also defined between ticks Integer hcount, hslowCount; equation fastPulses = Clock(1); // Define the fast clock slowPulses = subSample(fastPulses,5); // Slow down clock by a factor 5 when fastPulses then // Sample sin every second x = sin(sample(time)+1); end when; when slowPulses then // Sample log every 5th second y = log(sample(time)+1); end when; hx = hold(x); // Hold variables are also defined between ticks hy = hold(y); end TwoRateSamplerClocked;

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(TwoRateSamplerClocked)