State transition table approach in Embedded C

Introduction

The state transition table approach helps organize how a system moves from one state to another based on inputs. It makes complex behavior easier to understand and manage.

When you have a device that reacts differently depending on its current mode.

When you want to control a machine with clear rules for each step.

When you need to handle multiple inputs that change the system's behavior.

When debugging state changes in embedded systems.

When designing simple games or user interfaces with different screens.

Syntax

Embedded C

typedef enum {STATE1, STATE2, STATE3} State;
typedef enum {EVENT1, EVENT2, EVENT3} Event;

State state_transition_table[][3] = {
  // EVENT1, EVENT2, EVENT3
  {STATE2, STATE1, STATE3}, // STATE1 transitions
  {STATE1, STATE3, STATE2}, // STATE2 transitions
  {STATE3, STATE2, STATE1}  // STATE3 transitions
};

State current_state = STATE1;

void handle_event(Event e) {
  current_state = state_transition_table[current_state][e];
}

The table rows represent current states.

The columns represent events or inputs.

Examples

This example shows a simple machine with three states and three events.

Embedded C

typedef enum {IDLE, RUNNING, STOPPED} State;
typedef enum {START, STOP, RESET} Event;

State state_table[][3] = {
  {RUNNING, IDLE, IDLE},    // IDLE
  {RUNNING, STOPPED, IDLE}, // RUNNING
  {IDLE, STOPPED, IDLE}     // STOPPED
};

Updates the current state based on the input event using the table.

Embedded C

State current = IDLE;
Event input = START;
current = state_table[current][input];

Sample Program

This program simulates a simple machine changing states based on events using a state transition table.

Embedded C

#include <stdio.h>

typedef enum {IDLE, RUNNING, STOPPED} State;
typedef enum {START, STOP, RESET} Event;

const char* state_names[] = {"IDLE", "RUNNING", "STOPPED"};
const char* event_names[] = {"START", "STOP", "RESET"};

State state_table[][3] = {
  {RUNNING, IDLE, IDLE},    // IDLE
  {RUNNING, STOPPED, IDLE}, // RUNNING
  {IDLE, STOPPED, IDLE}     // STOPPED
};

int main() {
  State current_state = IDLE;
  Event events[] = {START, STOP, RESET, START, STOP};
  int n = sizeof(events) / sizeof(events[0]);

  printf("Initial state: %s\n", state_names[current_state]);

  for (int i = 0; i < n; i++) {
    printf("Event: %s\n", event_names[events[i]]);
    current_state = state_table[current_state][events[i]];
    printf("New state: %s\n", state_names[current_state]);
  }

  return 0;
}

Important Notes

Make sure the table covers all states and events to avoid undefined behavior.

Use enums to keep states and events clear and readable.

This approach makes adding new states or events easier by updating the table.

Summary

The state transition table maps current states and events to next states.

It helps organize and simplify complex state changes.

Using enums and tables makes code easier to read and maintain.

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