State transition table approach in Embedded C - Step-by-Step Execution

Concept Flow - State transition table approach

Start

↓

Current State

↓

Input Event

↓

Look up next state & action in table

↓

Perform action

↓

Update current state

↓

Wait for next input or exit

The program starts with a current state and input event, looks up the next state and action in a table, performs the action, updates the state, and repeats.

Execution Sample

Embedded C

typedef enum {STATE_IDLE, STATE_BUSY} State;
typedef enum {EVENT_START, EVENT_STOP} Event;

State current_state = STATE_IDLE;

void process_event(Event e) {
  switch (current_state) {
    case STATE_IDLE:
      if (e == EVENT_START) {
        // action
        current_state = STATE_BUSY;
      }
      break;
    case STATE_BUSY:
      if (e == EVENT_STOP) {
        // action
        current_state = STATE_IDLE;
      }
      break;
  }
}

This code changes state from IDLE to BUSY on START event, and back on STOP event.

Execution Table

Step	Current State	Input Event	Lookup Result (Next State, Action)	Action Performed	New State
1	STATE_IDLE	EVENT_START	(STATE_BUSY, Start action)	Start action executed	STATE_BUSY
2	STATE_BUSY	EVENT_START	(No transition)	No action	STATE_BUSY
3	STATE_BUSY	EVENT_STOP	(STATE_IDLE, Stop action)	Stop action executed	STATE_IDLE
4	STATE_IDLE	EVENT_STOP	(No transition)	No action	STATE_IDLE
5	-	-	-	No more events, stop	-

💡 No more input events to process, execution stops.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
current_state	STATE_IDLE	STATE_BUSY	STATE_BUSY	STATE_IDLE	STATE_IDLE	STATE_IDLE

Key Moments - 3 Insights

Why does the state not change on step 2 when EVENT_START is received in STATE_BUSY?

Because the state transition table has no entry for EVENT_START in STATE_BUSY (see execution_table row 2), so no action or state change occurs.

How does the program decide which action to perform?

It looks up the current state and input event in the transition table to find the matching next state and action (see execution_table column 'Lookup Result').

What happens if an input event is not in the table for the current state?

No transition occurs, no action is performed, and the state remains unchanged (see execution_table rows 2 and 4).

Visual Quiz - 3 Questions

Look at the execution_table, what is the current_state after step 3?

A STATE_BUSY

B STATE_START

C STATE_IDLE

D No state

💡 Hint

Check the 'New State' column in execution_table row 3.

At which step does the program perform the 'Stop action executed'?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look for 'Stop action executed' in the 'Action Performed' column.

If EVENT_START is received in STATE_BUSY, what happens according to the execution_table?

A State changes to STATE_IDLE

B No action and state remains STATE_BUSY

C Start action executed and state changes

D Program crashes

💡 Hint

See execution_table row 2 for EVENT_START in STATE_BUSY.

Concept Snapshot

State transition table approach:
- Define states and events.
- Use a table to map (state, event) to (next state, action).
- On event, lookup table, perform action, update state.
- If no entry, stay in current state.
- Makes state management clear and scalable.

Full Transcript

This example shows how a program manages states using a state transition table approach. It starts in STATE_IDLE. When EVENT_START occurs, it looks up the table, finds to move to STATE_BUSY and performs the start action. If EVENT_START happens again in STATE_BUSY, no change occurs because no transition is defined. When EVENT_STOP occurs in STATE_BUSY, it transitions back to STATE_IDLE and performs the stop action. If EVENT_STOP occurs in STATE_IDLE, no change happens. This approach helps organize state changes clearly by using a lookup table for transitions and actions.

Practice

1.

What is the main purpose of a state transition table in embedded C programming?

easy

A. To store global variables for the program

B. To map current states and events to the next states

C. To handle memory allocation dynamically

D. To perform arithmetic calculations efficiently

Solution

1. Step 1: Understand the role of state transition tables

   A state transition table is used to define how a system moves from one state to another based on events.

2. Step 2: Identify the correct purpose

   Mapping current states and events to next states is exactly what a state transition table does.

3. Final Answer:

   To map current states and events to the next states -> Option B

4. Quick Check:

   State transition table = map states and events [OK]

Hint: Think: state + event leads to next state [OK]

Common Mistakes:

• Confusing state tables with variable storage
• Thinking it manages memory
• Assuming it performs calculations

2.

Which of the following is the correct way to declare a state transition table in embedded C?

typedef enum {STATE_IDLE, STATE_RUN, STATE_STOP} State;
typedef enum {EVENT_START, EVENT_STOP} Event;

State state_table[][2] = { ... };

easy

A. State state_table[3][2];

B. int state_table[2][3];

C. State state_table[2][2];

D. Event state_table[3][2];

Solution

1. Step 1: Analyze the enums and dimensions

   There are 3 states and 2 events, so the table should have 3 rows (states) and 2 columns (events).

2. Step 2: Match the declaration with dimensions

   State state_table[3][2]; declares a State 2D array with 3 rows and 2 columns, matching the enums.

3. Final Answer:

   State state_table[3][2]; -> Option A

4. Quick Check:

   Rows = states, columns = events [OK]

Hint: Rows = states, columns = events in table declaration [OK]

Common Mistakes:

• Swapping rows and columns
• Using wrong data type for table
• Mismatching array size with enums

3.

Given the following code snippet, what will be the output?

typedef enum {IDLE, RUN, STOP} State;
typedef enum {START, STOP_EVENT} Event;

State state_table[3][2] = {
  {RUN, IDLE},
  {RUN, STOP},
  {IDLE, IDLE}
};

State current_state = IDLE;
Event event = START;

current_state = state_table[current_state][event];
printf("%d", current_state);

medium

A. 2

B. 0

C. 1

D. Compilation error

Solution

1. Step 1: Identify current state and event indices

   current_state = IDLE (0), event = START (0)

2. Step 2: Find next state from table

   state_table[0][0] = RUN (1)

3. Final Answer:

   1 -> Option C

4. Quick Check:

   state_table[0][0] = 1 (RUN) [OK]

Hint: Use enum values as indexes to find next state [OK]

Common Mistakes:

• Mixing event and state indices
• Assuming output is enum name, not int
• Forgetting zero-based indexing

4.

Identify the error in the following state transition table code snippet:

typedef enum {S0, S1} State;
typedef enum {E0, E1} Event;

State state_table[2][2] = {
  {S1, S0},
  {S0}
};

medium

A. Wrong enum type used for state_table

B. State enum values are not initialized

C. Array size should be [2][1] instead of [2][2]

D. Missing second element in second row of the table

Solution

1. Step 1: Check array initialization

   The first row has 2 elements, but the second row has only 1 element.

2. Step 2: Compare with declared size

   The array is declared as 2x2, so each row must have 2 elements.

3. Final Answer:

   Missing second element in second row of the table -> Option D

4. Quick Check:

   Array rows must match declared column size [OK]

Hint: Check all rows have correct number of elements [OK]

Common Mistakes:

• Ignoring incomplete row initialization
• Confusing enum initialization with array size
• Assuming default values fill missing elements

5.

You want to implement a state machine with states OFF, ON, and ERROR, and events POWER_ON, POWER_OFF, and FAULT. Using a state transition table approach, which of the following correctly defines the next state when the current state is ON and the event is FAULT?

typedef enum {OFF, ON, ERROR} State;
typedef enum {POWER_ON, POWER_OFF, FAULT} Event;

State state_table[3][3] = {
  {ON, OFF, ERROR},
  {ON, OFF, ???},
  {OFF, OFF, ERROR}
};

hard

A. ERROR

B. ON

C. OFF

D. POWER_OFF

Solution

1. Step 1: Identify current state and event indices

   Current state is ON (index 1), event is FAULT (index 2).

2. Step 2: Determine correct next state for fault event

   On fault, the system should move to ERROR state.

3. Step 3: Fill the missing table entry

   state_table[1][2] should be ERROR.

4. Final Answer:

   ERROR -> Option A

5. Quick Check:

   Fault event from ON leads to ERROR state [OK]

Hint: Fault event usually leads to ERROR state [OK]

Common Mistakes:

• Using event names as states
• Assigning ON or OFF instead of ERROR on fault
• Confusing event and state enums