Use Connective Junctions to Represent Multiple Paths

Label Format for Transition Segments

The label format for a transition segment entering a junction is the same as for transitions entering states, as shown in the following example. The chart uses implicit ordering of outgoing transitions (see Implicit Ordering of Outgoing Transitions).

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 from S1 to S2 exists.

  5. State S1 exit actions execute and complete.

  6. State S1 is marked inactive.

  7. The transition action transition_action executes and completes.

  8. The completed state-to-state transition from S1 to S2 occurs.

  9. State S2 is marked active.

  10. State S2 entry actions execute and complete.

If-Then-Else Decision Construct

This example shows the behavior of an if-then-else decision construct. The chart uses implicit ordering of outgoing transitions (see Implicit Ordering of Outgoing Transitions).

Initially, the chart is asleep. State A is active. Condition [C_two] is true. Event E_one occurs and awakens the chart, which processes the event from the root down through the hierarchy:

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

    A valid transition segment from state A to the connective junction exists. Because implicit ordering applies, 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.

Self-Loop Transition

This example shows the behavior of a self-loop transition using a connective junction. The chart uses implicit ordering of outgoing transitions (see Implicit Ordering of Outgoing Transitions).

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

  1. The chart root checks to see if there is a valid transition as a result of E_one. A valid transition segment from state A to the connective junction exists. Because implicit ordering applies, the transition segment labeled with a condition 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.

For-Loop Construct

This example shows the behavior of a for loop using a connective junction. The chart uses implicit ordering of outgoing transitions (see Implicit Ordering of Outgoing Transitions).

Initially, the chart is asleep. State A is active. Event E_one occurs and awakens the chart, which processes the event from the root down through the hierarchy:

  1. The 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, executes and completes. Of the two transition segments leaving the connective junction, the transition segment that is a self-loop back to the connective junction evaluates next for validity. That segment takes priority in evaluation because it has a condition, whereas the other segment is unlabeled. This evaluation behavior reflects implicit ordering of outgoing transitions in the chart.

  2. The condition [i < 10] evaluates as true. The condition actions i++ and a call to func1 execute and complete until the condition becomes false. Because a connective junction is not a final destination, the transition destination is still unknown.

  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 chart goes back to sleep.

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

Flow Chart Notation

This example shows the behavior of a Stateflow chart that uses flow chart notation. The chart uses implicit ordering of outgoing transitions (see Implicit Ordering of Outgoing Transitions).

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

  1. The 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. Only one outgoing transition exists, and it has a condition action defined. The condition action executes and completes.

  4. The next possible segments are evaluated. Two outgoing transitions exist: a conditional self-loop transition and an unconditional transition segment. Because implicit ordering applies, the conditional transition segment takes precedence. Since the condition [C_one()] 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()}, executes and completes. The returned value of d is 84.

  6. The next possible transition segment is evaluated. Three outgoing transition segments exist: two conditional and one unconditional. Because implicit ordering applies, the segment labeled with the condition [d < 100] evaluates first based on the geometry of the two outgoing conditional transition segments. Because the returned 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.

Transition from a Common Source to Multiple Destinations

This example shows the behavior of transitions from a common source to multiple conditional destinations using a connective junction. The chart uses implicit ordering of outgoing transitions (see Implicit Ordering of Outgoing Transitions).

Initially, the chart is asleep. State A is active. Event E_two occurs and awakens the chart, which processes the event from the root down through the hierarchy:

  1. The chart root checks to see if there is a valid transition as a result of E_two. A valid transition segment exists from state A to the connective junction. Because implicit ordering applies, evaluation of segments with equivalent label priority 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.

Transition from Multiple Sources to a Common Destination

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

Initially, the chart is asleep. State A is active. Event E_one occurs and awakens the chart, which processes the event from the root down through the hierarchy:

  1. The chart root checks to see if there is a valid transition as a result of E_one. A valid transition segment exists 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.

Transition from a Source to a Destination Based on a Common Event

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 chart is asleep. State B is active. Event E_one occurs and awakens the chart, which processes the event from the root down through the hierarchy:

  1. The chart root checks to see if there is a valid transition as a result of E_one. A valid transition segment exists 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.

Backtrack in Flow Charts

This example shows the behavior of transitions with junctions that force backtracking behavior in flow charts. The chart uses implicit ordering of outgoing transitions (see Implicit Ordering of Outgoing Transitions).

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

  1. The 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 and action a1 executes.

  3. Condition c3 is true and action a3 executes.

  4. Condition c4 is not true and control flow backtracks 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 and action a2 executes.

  7. Condition c3 is true and action a3 executes.

  8. Condition c4 is not true and control flow backtracks to state A.

  9. The chart goes to sleep.

The preceding example shows the unexpected behavior of executing both actions a1 and a2. Another unexpected behavior is the execution of action a3 twice. To resolve this problem, consider adding unconditional transitions to terminating junctions.

The terminating junctions allow flow to end if either c3 or c4 is not true. This design leaves state A active without executing unnecessary actions.

Was this topic helpful?