Entry, during, and exit actions in Simulink

Introduction

Entry, during, and exit actions help control what happens when a system changes states. They make sure the right steps run at the right time.

When you want to start a task as soon as a system enters a state.

When you need to keep doing something while the system stays in a state.

When you want to clean up or stop tasks right before leaving a state.

When modeling machines like traffic lights or elevators that have clear steps.

When you want to organize your system's behavior clearly and avoid mistakes.

Syntax

Simulink

State {
  entry: action_on_entry();
  during: action_while_in_state();
  exit: action_on_exit();
}

entry runs once when entering the state.

during runs repeatedly while in the state.

Examples

This state starts a timer when entered, checks a sensor while active, and stops the timer when leaving.

Simulink

State {
  entry: startTimer();
  during: checkSensor();
  exit: stopTimer();
}

This state turns a light on when entered, monitors a button press while active, and turns the light off when exiting.

Simulink

State {
  entry: turnLightOn();
  during: monitorButton();
  exit: turnLightOff();
}

Sample Program

This example simulates a traffic light state. It prints messages when the green light turns on, stays on, and turns off.

Simulink

state TrafficLight {
  entry: print("Green light ON");
  during: print("Green light active");
  exit: print("Green light OFF");
}

// Simulate entering, staying, and exiting the state
print("Entering state:");
TrafficLight.entry();
print("During state:");
for _ in range(2):
    TrafficLight.during();
print("Exiting state:");
TrafficLight.exit();

Important Notes

Entry actions run only once when the state starts.

During actions run repeatedly as long as the state is active.

Exit actions run once just before leaving the state.

Summary

Entry, during, and exit actions control what happens at different times in a state.

Use entry to start things, during to keep things running, and exit to stop or clean up.

This helps make your system clear and easy to manage.

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