Simple state machine with switch-case in Embedded C - Step-by-Step Execution

Concept Flow - Simple state machine with switch-case

Start

↓

Current State

↓

switch-case on State

↓

State A

↓

Action

↓

Update State

↓

Loop back to Current State

The program checks the current state, runs code for that state, updates the state, and repeats.

Execution Sample

Embedded C

enum State {STATE_A, STATE_B, STATE_C};
enum State current = STATE_A;

switch(current) {
  case STATE_A: current = STATE_B; break;
  case STATE_B: current = STATE_C; break;
  case STATE_C: current = STATE_A; break;
}

This code cycles through three states A, B, and C in order.

Execution Table

Step	Current State	switch-case branch	Action	Next State
1	STATE_A	case STATE_A	Set current = STATE_B	STATE_B
2	STATE_B	case STATE_B	Set current = STATE_C	STATE_C
3	STATE_C	case STATE_C	Set current = STATE_A	STATE_A
4	STATE_A	case STATE_A	Set current = STATE_B	STATE_B

💡 The state machine loops indefinitely cycling through states A, B, and C.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
current	STATE_A	STATE_B	STATE_C	STATE_A	STATE_B

Key Moments - 2 Insights

Why does the state change after each switch-case?

Because each case sets 'current' to the next state before breaking, as shown in the execution_table rows 1-3.

What happens if there is no 'break' after a case?

Without 'break', execution would continue to the next case, causing unexpected state changes. The execution_table shows one case per step due to breaks.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'current' after Step 2?

A STATE_C

B STATE_B

C STATE_A

D Undefined

💡 Hint

Check the 'Next State' column for Step 2 in the execution_table.

At which step does the state machine return to STATE_A?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Next State' column in the execution_table to find when 'current' becomes STATE_A.

If the 'break' statements were removed, what would happen in the execution_table?

A Each step would only execute one case as before.

B The state would update multiple times per step, skipping states.

C The state would never change.

D The program would crash.

💡 Hint

Recall that without 'break', switch-case falls through multiple cases in C.

Concept Snapshot

Simple state machine uses a variable to track state.
Use switch-case to run code based on current state.
Each case updates the state variable.
Use break to prevent fall-through.
Loop to cycle through states repeatedly.

Full Transcript

This example shows a simple state machine in embedded C using switch-case. The variable 'current' holds the current state. The switch-case checks 'current' and runs code for that state. Each case sets 'current' to the next state and breaks to stop fall-through. The execution table shows step-by-step how 'current' changes from STATE_A to STATE_B, then STATE_C, then back to STATE_A, cycling indefinitely. Key points include the importance of break statements to avoid running multiple cases at once. The visual quiz tests understanding of state changes and switch-case behavior.

Practice

1.

What is the main purpose of using a switch-case statement in a simple state machine?

easy

A. To create loops that repeat forever

B. To handle different states clearly and execute code based on the current state

C. To declare variables for each state

D. To stop the program immediately

Solution

1. Step 1: Understand the role of switch-case in state machines

   The switch-case statement lets the program choose what to do based on the current state value.

2. Step 2: Recognize how states are handled

   Each case corresponds to a state, so the program runs code specific to that state.

3. Final Answer:

   To handle different states clearly and execute code based on the current state -> Option B

4. Quick Check:

   switch-case manages states = To handle different states clearly and execute code based on the current state [OK]

Hint: Switch-case matches states to actions clearly [OK]

Common Mistakes:

• Thinking switch-case creates loops
• Confusing variable declaration with state handling
• Assuming switch-case stops the program

2.

Which of the following is the correct syntax for a switch statement in embedded C?

switch(state) {
  case 0:
    // code
    break;
  case 1:
    // code
    break;
  default:
    // code
}

easy

A. switch state { case 0: ... break; case 1: ... break; default: ... }

B. switch(state) { case 0: ... case 1: ... default: ... }

C. switch(state) case 0: ... break; case 1: ... break; default: ...

D. switch(state) { case 0: ... break; case 1: ... break; default: ... }

Solution

1. Step 1: Check the syntax structure of switch-case

   The switch statement requires parentheses around the variable and braces around the cases.

2. Step 2: Verify the use of colons and breaks

   Each case must have a colon and usually ends with a break to prevent fall-through.

3. Final Answer:

   switch(state) { case 0: ... break; case 1: ... break; default: ... } -> Option D

4. Quick Check:

   Correct switch-case syntax = switch(state) { case 0: ... break; case 1: ... break; default: ... } [OK]

Hint: Remember switch needs parentheses and braces [OK]

Common Mistakes:

• Omitting parentheses after switch
• Missing colons after case labels
• Forgetting break statements

3.

What will be the output of this code snippet?

int state = 1;
switch(state) {
  case 0:
    printf("State is zero\n");
    break;
  case 1:
    printf("State is one\n");
    break;
  default:
    printf("Unknown state\n");
}

medium

A. Unknown state

B. State is zero

C. State is one

D. No output

Solution

1. Step 1: Identify the value of state

   The variable state is set to 1 before the switch statement.

2. Step 2: Match the case with state value

   The switch matches case 1, so it prints "State is one" and then breaks.

3. Final Answer:

   State is one -> Option C

4. Quick Check:

   state=1 prints "State is one" [OK]

Hint: Match state value to case label to find output [OK]

Common Mistakes:

• Confusing case 0 with case 1
• Forgetting break causes fall-through
• Assuming default runs when case matches

4.

Find the error in this state machine code snippet:

int state = 0;
switch(state) {
  case 0:
    printf("Start\n");
  case 1:
    printf("Running\n");
    break;
  default:
    printf("Unknown\n");
}

medium

A. Missing break after case 0 causes fall-through

B. Switch statement missing parentheses

C. Default case should be first

D. Variable state is not initialized

Solution

1. Step 1: Check each case for break statements

   Case 0 does not have a break, so after printing "Start", it continues to case 1.

2. Step 2: Understand fall-through effect

   This causes both "Start" and "Running" to print when state is 0, which may be unintended.

3. Final Answer:

   Missing break after case 0 causes fall-through -> Option A

4. Quick Check:

   Missing break causes fall-through = Missing break after case 0 causes fall-through [OK]

Hint: Always add break after each case to avoid fall-through [OK]

Common Mistakes:

• Ignoring missing break leads to unexpected output
• Thinking default must be first case
• Assuming uninitialized variable error

5.

You want to design a simple state machine with three states: INIT (0), PROCESS (1), and DONE (2). The machine should start at INIT, then move to PROCESS, and finally to DONE. Which code snippet correctly updates the state inside the switch-case?

int state = 0;
switch(state) {
  case 0:
    // Move to PROCESS
    state = 1;
    break;
  case 1:
    // Move to DONE
    state = 2;
    break;
  case 2:
    // Finished
    break;
}

hard

A. Correctly updates state from INIT to PROCESS to DONE

B. Does not update state, stays in INIT forever

C. Skips PROCESS and goes directly to DONE

D. Causes infinite loop without state change

Solution

1. Step 1: Check state transitions in each case

   Case 0 sets state to 1 (PROCESS), case 1 sets state to 2 (DONE), case 2 does nothing (finished).

2. Step 2: Confirm the order of states

   The code moves from INIT to PROCESS to DONE in order, updating the state variable correctly.

3. Final Answer:

   Correctly updates state from INIT to PROCESS to DONE -> Option A

4. Quick Check:

   State updates follow sequence = Correctly updates state from INIT to PROCESS to DONE [OK]

Hint: Update state variable inside each case to move forward [OK]

Common Mistakes:

• Not updating state variable inside cases
• Skipping intermediate states
• Forgetting break causing unexpected behavior