Entry, during, and exit actions in Simulink - Step-by-Step Execution

Concept Flow - Entry, during, and exit actions

State Start

↓

Entry Action

↓

During Action

↓

Check Transition Condition

↓

Exit Action

↓

Next State or End

This flow shows how a state in Simulink executes entry actions once when entered, then repeatedly runs during actions while active, and finally runs exit actions when leaving the state.

Execution Sample

Simulink

state MyState {
  entry: disp('Enter');
  during: disp('During');
  exit: disp('Exit');
}

This code defines a state with entry, during, and exit actions that print messages when triggered.

Execution Table

Step	Action	Output	Next Step
1	Enter state MyState	Enter	Run during action
2	During action runs	During	Check transition condition
3	Transition condition false	No output	Run during action again
4	During action runs	During	Check transition condition
5	Transition condition true	No output	Exit state
6	Exit state MyState	Exit	Move to next state or end

💡 Execution stops after exit action when transition condition becomes true.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4	After Step 6
State Active	False	True	True	True	False
Transition Condition	False	False	False	True	True

Key Moments - 3 Insights

Why does the entry action run only once?

The entry action runs only when the state is first entered, as shown in execution_table step 1, to initialize or set up the state.

Why do during actions repeat multiple times?

During actions run repeatedly while the state is active and the transition condition is false, as seen in steps 2 and 4, to perform ongoing behavior.

When exactly does the exit action run?

Exit action runs once when the transition condition becomes true and the state is about to change, as shown in step 6.

Visual Quiz - 3 Questions

Look at the execution table, what is the output at step 1?

A Enter

B During

C Exit

D No output

💡 Hint

Check the 'Output' column in execution_table row for step 1.

At which step does the transition condition become true?

A Step 4

B Step 5

C Step 2

D Step 3

💡 Hint

Look at the 'Next Step' and 'Action' columns around steps 3 to 5 in execution_table.

If the transition condition never becomes true, what happens to the during action?

A It runs once then stops

B It never runs

C It runs repeatedly forever

D Exit action runs immediately

💡 Hint

Refer to execution_table steps 2 and 4 where during action repeats while transition condition is false.

Concept Snapshot

Entry, during, and exit actions in Simulink states:
- Entry action runs once when entering the state.
- During action runs repeatedly while state is active.
- Exit action runs once when leaving the state.
- Transition conditions control when exit happens.
- Useful for managing state behavior clearly.

Full Transcript

In Simulink state machines, each state can have entry, during, and exit actions. When the state starts, the entry action runs once to set up. Then the during action runs repeatedly while the state is active and no transition occurs. When a transition condition becomes true, the exit action runs once before moving to the next state. This flow helps organize what happens at each phase of a state's life. The execution table shows these steps with outputs like 'Enter', 'During', and 'Exit' printed at the right times. Variables track if the state is active and if the transition condition is met. Understanding when each action runs helps avoid confusion about state behavior.

Practice

1. In Simulink Stateflow, what is the purpose of an entry action in a state?

easy

A. To execute code continuously while the state is active

B. To execute code once when the state is entered

C. To execute code once when the state is exited

D. To define transitions between states

Solution

1. Step 1: Understand what entry action means

   An entry action runs only once when the state becomes active, right at the moment of entry.

2. Step 2: Compare with other actions

   During actions run continuously while in the state, exit actions run once when leaving the state, and transitions define movement between states.

3. Final Answer:

   To execute code once when the state is entered -> Option B

4. Quick Check:

   Entry action = runs once on entering state [OK]

Hint: Entry actions run once at state start, not continuously [OK]

Common Mistakes:

• Confusing entry with during actions
• Thinking entry runs multiple times
• Mixing entry with exit actions

2. Which of the following is the correct syntax to define an exit action in a Simulink Stateflow state named Idle?

easy

A. exit() { disp('Exiting Idle'); }

B. on exit: disp('Exiting Idle');

C. exit: disp('Exiting Idle');

D. exit_action: disp('Exiting Idle');

Solution

1. Step 1: Recall exit action syntax in Stateflow

   Exit actions are defined with the keyword exit: followed by the action code.

2. Step 2: Check each option

   exit: disp('Exiting Idle'); uses correct exit: syntax. on exit: disp('Exiting Idle'); uses incorrect on exit:. exit() { disp('Exiting Idle'); } uses function style which is invalid. exit_action: disp('Exiting Idle'); uses exit_action: which is not recognized.

3. Final Answer:

   exit: disp('Exiting Idle'); -> Option C

4. Quick Check:

   Exit action syntax = exit: code [OK]

Hint: Exit actions start with 'exit:' keyword followed by code [OK]

Common Mistakes:

• Using 'on exit:' instead of 'exit:'
• Trying to define exit as a function
• Using incorrect keywords like 'exit_action:'

3. Consider the following Stateflow state Processing with these actions:

entry: count = 0;
during: count = count + 1;
exit: disp(count);

What will be displayed when the state Processing is exited after being active for 3 simulation steps?

medium

A. 3

B. 1

C. 0

D. 4

Solution

1. Step 1: Track variable changes during state

   On entry, count is set to 0. During each step, it increments by 1. After 3 steps, count = 3.

2. Step 2: Determine exit action output

   On exit, disp(count) prints the current count, which is 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Count increments 3 times, exit prints 3 [OK]

Hint: Count increments during each step, exit prints final count [OK]

Common Mistakes:

• Forgetting entry sets count to 0
• Assuming exit prints 0 or 1
• Counting one extra increment

4. You have this Stateflow state code:

entry: x = 5;
during: x = x + 2;
exit: disp(x);

But when you run the simulation, disp(x) shows 5 instead of increasing values. What is the likely error?

medium

A. The during action is not executing because the state is not active long enough

B. The entry action resets x every step

C. The exit action is placed incorrectly inside the during block

D. The variable x is not declared

Solution

1. Step 1: Analyze why during action might not run

   If the state is active only one step or immediately exited, the during action does not get a chance to increment x.

2. Step 2: Check other options for correctness

   Entry runs once on entry, not every step. Exit action placement is correct. Variable declaration is not required to see this behavior.

3. Final Answer:

   The during action is not executing because the state is not active long enough -> Option A

4. Quick Check:

   During runs only while state active [OK]

Hint: During runs only if state stays active multiple steps [OK]

Common Mistakes:

• Thinking entry runs every step
• Misplacing exit action inside during
• Assuming variable declaration causes issue

5. You want to count how many times a state Active is entered during a simulation. Which approach correctly uses entry, during, and exit actions to achieve this?

hard

A. Use entry: count = 0; to reset count every time state is entered

B. Use during: count = count + 1; to increment count continuously while active

C. Use exit: count = count + 1; to increment count when leaving the state

D. Use entry: count = count + 1; and initialize count outside the state; no during or exit needed

Solution

1. Step 1: Understand counting entries

   To count entries, increment count once each time the state is entered. This is done in the entry action.

2. Step 2: Evaluate other options

   During increments continuously, not suitable for counting entries. Exit increments on leaving, not entering. Resetting count on entry loses previous counts.

3. Final Answer:

   Use entry: count = count + 1; and initialize count outside the state; no during or exit needed -> Option D

4. Quick Check:

   Entry action increments count once per entry [OK]

Hint: Increment count in entry action, initialize count outside [OK]

Common Mistakes:

• Incrementing count in during action
• Resetting count on every entry
• Incrementing count on exit instead of entry