Stateflow®

Connective Junction Examples

Label Format for Transition Segments Example

The general label format for a transition segment entering a junction is the same as for transitions entering states, as shown in the following example.

Execution of a transition in this example occurs as follows:

1. When an event occurs, state S1 is checked for an outgoing transition with a matching event specified.

2. If a transition with a matching event is found, the transition condition for that transition (in brackets) is evaluated.

3. If condition_1 evaluates to true, the condition action condition_action (in braces) is executed.

4. The outgoing transitions from the junction are checked for a valid transition. Since condition_2 is true, a valid state-to-state transition (S1 to S2) is found.

5. State S1 is exited (including execution of S1's exit action).

6. The transition action transition_action is executed.

7. The completed state-to-state transition (S1 to S2) is taken.

8. State S2 is entered (including execution of S2's entry action).

Back to Top

If-Then-Else Decision Construct Example

This example shows the behavior of an if-then-else decision construct.

Initially, the Stateflow^® chart is asleep. State A is active. Event E_one occurs and awakens the chart. Condition [C_two] is true. Event E_one is processed from the root of the chart down through the hierarchy of the chart:

1. The Stateflow chart root checks to see if there is a valid transition as a result of E_one.

   There is a valid transition segment from state A to the connective junction. The transition segments beginning from a 12 o'clock position on the connective junction are evaluated for validity. The first transition segment, labeled with condition [C_one], is not valid. The next transition segment, labeled with the condition [C_two], is valid. The complete transition from state A to state C is valid.

2. State A exit actions (exitA()) execute and complete.

3. State A is marked inactive.

4. State C is marked active.

5. State C entry actions (entC()) execute and complete.

6. The chart goes back to sleep.

This sequence completes the execution of this Stateflow chart associated with event E_one.

Back to Top

Self-Loop Transition Example

This example shows the behavior of a self-loop transition using a connective junction.

Initially, the Stateflow chart is asleep. State A is active. Event E_one occurs and awakens the chart. Condition [C_one] is false. Event E_one is processed from the root of the chart down through the hierarchy of the chart:

1. The Stateflow chart root checks to see if there is a valid transition as a result of E_one. There is a valid transition segment from state A to the connective junction. The transition segment labeled with a condition and action is evaluated for validity. Because the condition [C_one] is not valid, the complete transition from state A to state B is not valid. The transition segment from the connective junction back to state A is valid.

2. State A exit actions (exitA()) execute and complete.

3. State A is marked inactive.

4. The transition action A_two is executed and completed.

5. State A is marked active.

6. State A entry actions (entA()) execute and complete.

7. The chart goes back to sleep.

This sequence completes the execution of this Stateflow chart associated with event E_one.

Back to Top

For-Loop Construct Example

This example shows the behavior of a for loop using a connective junction.

Initially, the Stateflow chart is asleep. State A is active. Event E_one occurs and awakens the Stateflow chart. Event E_one is processed from the root of the Stateflow chart down through the hierarchy of the Stateflow chart:

1. The Stateflow chart root checks to see if there is a valid transition as a result of E_one. There is a valid transition segment from state A to the connective junction. The transition segment condition action, i = 0, is executed and completed. Of the two transition segments leaving the connective junction, the transition segment that is a self-loop back to the connective junction is evaluated next for validity. That segment takes priority in evaluation because it has a condition specified, whereas the other segment is unlabeled.

2. The condition [i < 10] is evaluated as true. The condition actions i++ and a call to func1 are executed and completed until the condition becomes false. A connective junction is not a final destination; thus the transition destination remains to be determined.

3. The unconditional segment to state B is now valid. The complete transition from state A to state B is valid.

4. State A exit actions (exitA()) execute and complete.

5. State A is marked inactive.

6. State B is marked active.

7. State B entry actions (entB()) execute and complete.

8. The Stateflow chart goes back to sleep.

This sequence completes the execution of this Stateflow chart associated with event E_one.

Back to Top

Flow Graph Notation Example

This example shows the behavior of a Stateflow chart that uses flow notation.

Initially, the Stateflow chart is asleep. State A.A1 is active. The condition [C_one()] is initially true. Event E_one occurs and awakens the chart. Event E_one is processed from the root of the chart down through the hierarchy of the chart:

1. The Stateflow chart root checks to see if there is a valid transition as a result of E_one. There is no valid transition.

2. State A checks itself for valid transitions and detects a valid inner transition to a connective junction.

3. The next possible segments of the transition are evaluated. There is only one outgoing transition and it has a condition action defined. The condition action is executed and completed.

4. The next possible segments are evaluated. There are two outgoing transitions; one is a conditional self-loop transition and the other is an unconditional transition segment. The conditional transition segment takes precedence. The condition [C_one()] is tested and is true; the self-loop transition is taken. Since a final transition destination has not been reached, this self-loop continues until [C_one()] is false.

   Assume that after five iterations [C_one()] is false.

5. The next possible transition segment (to the next connective junction) is evaluated. It is an unconditional transition segment with a condition action. The transition segment is taken and the condition action, {d=my_func()}, is executed and completed. The returned value of d is 84.

6. The next possible transition segment is evaluated. There are three possible outgoing transition segments to consider. Two are conditional; one is unconditional. The segment labeled with the condition [d<100] is evaluated first based on the geometry of the two outgoing conditional transition segments. Because the return value of d is 84, the condition [d<100] is true and this transition (to the destination state A.A1) is valid.

7. State A.A1 exit actions (exitA1()) execute and complete.

8. State A.A1 is marked inactive.

9. State A.A1 is marked active.

10. State A.A1 entry actions (entA1()) execute and complete.

11. The chart goes back to sleep.

This sequence completes the execution of this Stateflow chart associated with event E_one.

Back to Top

Transitions from a Common Source to Multiple Destinations Example

This example shows the behavior of transitions from a common source to multiple conditional destinations using a connective junction.

Initially, the Stateflow chart is asleep. State A is active. Event E_two occurs and awakens the chart. Event E_two is processed from the root of the chart down through the hierarchy of the chart:

1. The Stateflow chart root checks to see if there is a valid transition as a result of E_two. There is a valid transition segment from state A to the connective junction. Given that the transition segments are equivalently labeled, evaluation begins from a 12 o'clock position on the connective junction and progresses clockwise. The first transition segment, labeled with event E_one, is not valid. The next transition segment, labeled with event E_two, is valid. The complete transition from state A to state C is valid.

2. State A exit actions (exitA()) execute and complete.

3. State A is marked inactive.

4. State C is marked active.

5. State C entry actions (entC()) execute and complete.

6. The chart goes back to sleep.

This sequence completes the execution of this Stateflow chart associated with event E_two.

Back to Top

Transitions from Multiple Sources to a Common Destination Example

This example shows the behavior of transitions from multiple sources to a single destination using a connective junction.

Initially, the Stateflow chart is asleep. State A is active. Event E_one occurs and awakens the chart. Event E_one is processed from the root of the chart down through the hierarchy of the chart:

1. The Stateflow chart root checks to see if there is a valid transition as a result of E_one. There is a valid transition segment from state A to the connective junction and from the junction to state C.

2. State A exit actions (exitA()) execute and complete.

3. State A is marked inactive.

4. State C is marked active.

5. State C entry actions (entC()) execute and complete.

6. The chart goes back to sleep.

This sequence completes the execution of this Stateflow chart associated with event E_one.

Back to Top

Transitions from a Source to a Destination Based on a Common Event Example

This example shows the behavior of transitions from multiple sources to a single destination based on the same event using a connective junction.

Initially, the Stateflow chart is asleep. State B is active. Event E_one occurs and awakens the chart. Event E_one is processed from the root of the chart down through the hierarchy of the chart:

1. The Stateflow chart root checks to see if there is a valid transition as a result of E_one. There is a valid transition segment from state B to the connective junction and from the junction to state C.

2. State B exit actions (exitB()) execute and complete.

3. State B is marked inactive.

4. State C is marked active.

5. State C entry actions (entC()) execute and complete.

6. The chart goes back to sleep.

This sequence completes the execution of this Stateflow chart associated with event E_one.

Back to Top

Backtracking Behavior in Flow Graphs Example

This example shows the behavior of transitions with junctions that force backtracking behavior in flow graphs.

Initially, state A is active and conditions c1, c2, and c3 are true:

1. The Stateflow chart root checks to see if there is a valid transition from state A.

   There is a valid transition segment marked with the condition c1 from state A to a connective junction.

2. Condition c1 is true; therefore action a1 is executed.

3. Condition c3 is true; therefore action a3 is executed.

4. Condition c4 is not true; therefore control flow is backtracked to state A.

5. The chart root checks to see if there is another valid transition from state A.

   There is a valid transition segment marked with the condition c2 from state A to a connective junction.

6. Condition c2 is true; therefore action a2 is executed.

7. Condition c3 is true; therefore action a3 is executed.

8. Condition c4 is not true; therefore control flow is backtracked to state A.

9. The chart goes to sleep.

The preceding example shows the unanticipated behavior of executing both actions a1 and a2 and executing action a3 twice. To resolve this problem, consider this design.

This example provides two junctions that allow flow to end if either c3 or c4 is not true. This leaves state A active without taking any unnecessary actions.

Back to Top

Inner Transition Examples

Event Actions in a Superstate Example