Ph.D. - geht es zur Homepage der Informatik des Fachbereiches 3 ...

8.4. Behavioural Design
for the first six calculation steps (k = 0, 1, . . . , 5) is sketched in Figure 8.13.
Any execution is started by the external EVC actor via an asynchronous Start() message to
the “StateMachine” object. At first, “StateMachine” executes the initial CEVCState “Running”
(“Running” in Application Level 0) by a further Start() message. A running CEVCState object
always starts for each independent data flow object in m_CurrentDataFlow for the current active
Application Level an own thread [77] by a DataFlowThread() message to itself. In this example,
only one CDataFlow object is defined. “Running” handles the execution of the data flow by a
Execute() to the current CDataFlow object that is here “SDL0” at equidistant time points
(see Section 7.6). For each Execute() message from the related EVC state object, the data
flow object sends a Calculate() message to all CFunctionBlock objects in m_FunctionBlocks.
At the first execution step (k = 0), only the value of the counter storage “Value” in Figure 8.11
is increased by one. At the second step (k = 1), the CLevelCondition object “L1” is activated
by a Boolean true input. Therefore, it sends a m_CurrentApplicationLevel = "1" message
to the parent CEVCStateMachine object by its m_pParent aggregation. Furthermore, it
informs the parent CDataFlow object about an upcoming switch of the EVC state or/and the
ETCS Application Level by the m_bStateLevelSwitch = true message. As a consequence,
the execution of DataFlowThread(0) and Start() in “Running” is terminated and accordingly
returned to the “EVC” object execution. This then directly starts the execution of the current
active CEVCState object defined by m_pCurrentState, which is the same as before but now
with the new Application Level 1 (m_CurrentApplicationLevel).
Again, for each CDataFlow object (here only “SDL1”) in “Running” for the current Application
Level, a separated thread is started by the DataFlowThread() message that is for this example
only one. This thread executes the related CDataFlow object “SDL1” by the Execute()
message. For k = 2 and k = 3, only the value of “Value” is further increased. For k = 4,
the output of the CSum object is 5, which causes the activation of the CEVCCondition
“c1”. Thus, it places a reference of the corresponding CEVCTransition object “Tc1” of the
transition stack of “StateMachine” by the m_TransitionStack.push_back(&Tc1) message.
The m_bStateLevelSwitch = true is used to inform the “StateMachine” object about an
upcoming transition to a another CEVCState object. Like in Application Level 0 before, then
the execution of DataFlowThread() and Start() is terminated.
The “StateMachine” gets the target state of the “Tc1” object on the transition stack by the
GetTargetState() message that is here the only CEVCTransition object on the stack. In the
case of several objects, their priority property would be used to determine, which one is going
to be executed. The target state m_pTargetState of “Tc1” is “Running”, which reference is
then stored in m_pCurrentState.
Since “StateMachine” is still started by the EVC, it starts the new state “Running” by a
Start() message. As for “Running”, a thread for the only data flow object “RDL1” in “Running”
for Application Level 1 is started by Start(). This executes “RDL1” via the Execute()
messages (k = 6, 7, . . . ). Further execution steps are not explained in this example.
Finally, “StateMachine” is stopped by the EVC through a Stop() message.
139