Event Synchronization

1 Event Synchronization

Events often need to be synchronized and propagated. However, Modelica gives no guarantee that two different independent events occur at exactly the same time instant if they are not explicitly synchronized, e.g. via equations.

To achieve guaranteed synchronization between two events, we use the synchronous principle that computation at an event takes no time. An event can instantaneously, via one or more equations, change the values of certain discrete time variables used for the synchronization, typically Boolean or Integer variables. These changes may trigger other events without any elapsed time, which thereby are synchronized. For example, you can synchronize counters performing their counting behavior at different frequencies, e.g. as in the example below.

model SynchCountersUnclocked // Two synchronized counters Boolean slowPulses(fixed=true); Boolean fastPulses; Integer count(fixed=true); Integer slowCount(fixed=true); equation fastPulses = sample(0,1); when fastPulses then // Count every second count = pre(count)+1; slowPulses = mod(count,2)==0; // true when count=2,4,6,... end when; when slowPulses then // Count every 2nd second slowCount = pre(slowCount)+1; end when; end SynchCountersUnclocked;
simulate(SynchCountersUnclocked, stopTime=10)
plot({count, slowPulses, fastPulses, slowCount})

2 Event Synchronization Clocked

Below is a version of the previous model using clocked synchronous language primitives. The new model called SynchCountersClocked has a structure that is very similar to the previous model. The unclocked when-equations have been replaced by clocked when-equations. The pre() calls in the difference equations have been replaced by calls to previous(). The slowPulses and fastPulses variables have been changed from Boolean to the built-in Clock type. The clock constructor call Clock(1) now returns a clock with interval 1 second used for fastPulses. For slowPulses we use the built-in subSample() operator to obtain every second clock tick giving an interval of 2 seconds. Finally, we have introduced two unclocked hold variables hcount and hslowCount which are defined also between clock ticks, whereas the clocked variables count and slowCount are only defined at clock ticks.

model SynchCountersClocked "Two clocked synchronized counters" Clock slowPulses; // Clock variables Clock fastPulses; discrete Integer count, slowCount; // Clocked variables Integer hcount, hslowCount; equation fastPulses = Clock(1); when fastPulses then // Count every second count = previous(count)+1; end when; slowPulses = subSample(fastPulses,2); // Slow down clock by a factor 2 when slowPulses then // Count every 2nd second slowCount = previous(slowCount)+1; end when; hcount = hold(count); // Hold variables also defined between ticks hslowCount = hold(slowCount); end SynchCountersClocked;

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

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

There is an alternative way of writing this model without clocked when-equations if we make the difference equations clocked by other means, as shown in the shorter model SynchCounters-ClockedShort below

model SynchCountersClockedShort "Two clocked synchronized counters" Clock fastPulses = Clock(1) "Clock tick every second"; Clock slowPulses = Clock(2) "Clock tick every 2 seconds"; discrete Integer count, slowCount; Integer hcount, hslowCount; equation // Sample the constant value 1 at clock ticks of fastPulses or slowPulses // The count equation gets updated at every tick of fastPulses // Clock inference associates the fastPulses clock to count count = previous(count) + sample(1,fastPulses); slowCount = previous(slowCount) + sample(1,slowPulses); hcount = hold(count); // Hold variables also defined between ticks hslowCount = hold(slowCount); end SynchCountersClockedShort;

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

3 DeadLock

A kind of "deadlock" between different when-equations is present if there are mutual dependences, a so-called "algebraic loop", between the equations of the when-equations, as in the example below. This case should be detected by a Modelica compiler.

model DeadLock Boolean b1(fixed=true), b2(fixed=true); equation when pre(b1) then b2 = true; end when; when pre(b2) then b1 = true; end when; end DeadLock;

3.1 Simulation of DeadLock

simulate( DeadLock )
plot({b1, b2})