Generating Repeated Events Using Sample

1 SamplingClock

The function sample(first,interval) returns true and can be used to trigger events at time instants first + i*interval (i=0,1,...), where first is the time of the first event and interval is the time interval between the periodic events. It is typically used in models of periodically sampled systems.

sample acts as a kind of clock that returns true at periodically occurring time instants. We can use this behavior in combination with a when-equation to periodically trigger events, e.g. as below:

class Squarewave parameter Modelica.SIunits.Time first = 0; parameter Modelica.SIunits.Time interval = 1; Boolean clock; Real x(start=1,fixed=true); equation clock = sample(first,interval); when clock then x=-pre(x); end when; end Squarewave;

1.1 Simulation of SamplingClock

loadModel(Modelica)
simulate( Squarewave, stopTime=10 )
plot(x)

2 Sampling Values at Clock Ticks Using Clocked sample()

The clocked version of sample( ) is quite different from the unclocked version generating events, which was described in the previous section. The clocked version of the operator samples a continuous-time expression at the ticks of a clock and returns a clocked expression. Below a very simple example model using sample is given where the variable x is sampled at 5 Hz.

class SampleTime parameter Modelica.SIunits.Time interval=1; Clock clk; // A clock variable discrete Real stime(start=1); // A clocked variable for the sample result Real x=time; equation clk = Clock(1,5); // Clocked equation, interval=1/5 s, freq 5Hz stime = sample(x, clk); // Clocked equation to perform the sampling end SampleTime;
loadModel(Modelica)
setCommandLineOptions("+std=3.3")
simulate(SampleTime)
plot(x)

3 Accessing Clocked Values Between Clocked Events Using hold()

Unclocked discrete-time variables are piece-wise constant, may change at events, and have defined values also between events. This is however not the case for clocked variables which are only defined and may only change at clock ticks for their associated clock. The hold() operator makes clocked values available also in unclocked equations and expressions. The operator effectively converts a clocked discrete-time expression into an unclocked discrete-time expression which is piece-wise constant and accessible between clock tick events.

In the SquareWaveClocked model we instead use Modelica synchronous clocks where the clock variable clk is declared using the builtin Clock type, the clock interval is specified using the Clock constructor, and we have introduced a synchronous clocked discrete-time variable xclocked which is only defined at clock ticks.

class SquareWaveClocked parameter Modelica.SIunits.Time interval=1; Clock clk; // A clock variable discrete Real xclocked(start=1); // A clocked variable Real x; equation clk = Clock(interval); // Clocked equation when clk then xclocked = -previous(xclocked); // Clocked equation end when; x = hold(xclocked); // Unclocked equation end SquareWaveClocked;

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 Simulation of this model does not work

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

4 Preventing Events Using smooth () for Continuous Expressions

The function smooth(p,expr) evaluates and returns the value of the expression expr in a way that can avoid event generation. This is similar to noEvent(), but with the difference that smooth() does not guarantee preventing events- it lets the Modelica environment decide what is appropriate. By placing a call to smooth() around expr, we state that expr is continuous and its derivates up to order p are continuous. This information can be used by the Modelica environment to avoid event generation and thus increase performance.

model SmoothAndEvents Real x,y,z; parameter Real p; equation x = if time<1 then 2 else time-2; // time<1 generates events y = smooth(0, if time<0 then 0 else time); // may avoid events z = smooth(1,noEvent(if x<0 then 0 else sqrt(x)*x)); // noEvent is necessary end SmoothAndEvents;
simulate(SmoothAndEvents)
plot({x,y,z})