Mastering the Arduino Switch Case: Build a Rotary Encoder State Machine

Why Use a Switch Case in Arduino Projects?

When your embedded project moves beyond blinking a single LED and starts handling multiple discrete states—like navigating a menu, decoding a rotary encoder, or managing a multi-step sensor calibration sequence—chaining if-else if statements becomes a maintenance nightmare. The switch case statement is the C++ control flow tool designed exactly for this. It evaluates a single variable against a list of exact matches, compiling down to highly efficient jump tables on the ATmega328P, which saves crucial clock cycles in your loop() function.

In this guide, we will build a physical state machine: a menu navigation system driven by a KY-040 rotary encoder and displayed on an I2C LCD. We will cover the exact hardware wiring, provide a fully compilable C++ implementation utilizing enum and switch case, and debug the specific compiler errors that trip up makers when scaling their code.

Hardware Build: Rotary Encoder State Machine

To demonstrate the switch case in a real-world scenario, we are building a menu selector. The rotary encoder provides three distinct inputs: Clockwise (CW), Counter-Clockwise (CCW), and Button Press (SW). We will map these inputs to state transitions.

Parts List with Exact Variants

• Microcontroller: Arduino Nano V3 (ATmega328P, 16MHz crystal variant). Do not use the ATmega168 variant, as the SRAM limits will constrain larger state arrays.
• Input Module: KY-040 Rotary Encoder Module (includes built-in 10k pull-up resistors on the breakout board).
• Display: 16x2 I2C LCD Module with an HD44780 controller and an I2C backpack (default address 0x27).
• Wiring: Half-size breadboard, 22 AWG solid core jumper wires.

Pin Mapping Table

Wire the components exactly as specified below. The encoder CLK and DT pins must go to hardware interrupt-capable pins (D2 and D3 on the Nano) for reliable quadrature decoding without blocking the main loop.

The Code: Compilable Switch Case Implementation

The following code targets the Arduino Nano V3 (ATmega328P). It uses an enum to define discrete menu states, which makes the switch case readable and prevents magic numbers from cluttering your logic. We also implement bounds-checking error handling to prevent the menu index from overflowing the array limits.

Note: You must install the LiquidCrystal I2C library by Frank de Brabander via the Arduino Library Manager before compiling.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// --- Pin Definitions ---
const int ENCODER_CLK = 2; // Interrupt pin
const int ENCODER_DT = 3;
const int ENCODER_SW = 4;

// --- I2C LCD Setup ---
// Address 0x27, 16 columns, 2 rows
LiquidCrystal_I2C lcd(0x27, 16, 2);

// --- State Machine Definitions ---
enum MenuState {
  STATE_HOME,
  STATE_SETTINGS,
  STATE_ABOUT,
  STATE_MAX // Used for bounds checking
};

volatile MenuState currentState = STATE_HOME;
volatile bool encoderChanged = false;
volatile int encoderDirection = 0; // 1 for CW, -1 for CCW

// Menu labels mapped to the enum order
const char* menuLabels[] = {"Home Screen", "Settings", "About Device"};

void setup() {
  pinMode(ENCODER_DT, INPUT);
  pinMode(ENCODER_SW, INPUT_PULLUP);
  
  // Attach interrupt to CLK pin for falling edge
  attachInterrupt(digitalPinToInterrupt(ENCODER_CLK), readEncoder, FALLING);
  
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("System Booting...");
  delay(1000);
  updateDisplay();
}

void loop() {
  // Handle rotary encoder rotation
  if (encoderChanged) {
    int newState = currentState + encoderDirection;
    
    // Error Handling: Bounds checking to prevent array overflow
    if (newState < 0) {
      currentState = STATE_HOME; // Or wrap around to STATE_MAX - 1
    } else if (newState >= STATE_MAX) {
      currentState = static_cast<MenuState>(STATE_MAX - 1);
    } else {
      currentState = static_cast<MenuState>(newState);
    }
    
    encoderChanged = false;
    updateDisplay();
  }

  // Handle button press using a switch case
  if (digitalRead(ENCODER_SW) == LOW) {
    delay(50); // Simple debounce
    if (digitalRead(ENCODER_SW) == LOW) {
      handleButtonPress();
      while(digitalRead(ENCODER_SW) == LOW); // Wait for release
    }
  }
}

// --- Switch Case Implementation ---
void handleButtonPress() {
  switch (currentState) {
    case STATE_HOME:
      lcd.clear();
      lcd.print("Home Selected!");
      delay(1000);
      break;
      
    case STATE_SETTINGS:
      lcd.clear();
      lcd.print("Settings Menu");
      lcd.setCursor(0, 1);
      lcd.print("[Under Constr.]");
      delay(1500);
      break;
      
    case STATE_ABOUT:
      lcd.clear();
      lcd.print("Flux OS v1.0");
      delay(1500);
      break;
      
    default:
      // Fallback for undefined states
      lcd.clear();
      lcd.print("Error: Bad State");
      currentState = STATE_HOME;
      delay(1000);
      break;
  }
  updateDisplay();
}

void updateDisplay() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Menu:");
  lcd.setCursor(0, 1);
  lcd.print(menuLabels[currentState]);
}

// --- Interrupt Service Routine ---
void readEncoder() {
  if (digitalRead(ENCODER_DT) != digitalRead(ENCODER_CLK)) {
    encoderDirection = 1; // CW
  } else {
    encoderDirection = -1; // CCW
  }
  encoderChanged = true;
}

Debugging Switch Case Errors: Exact Strings and Fixes

When your switch case logic scales up, the Arduino IDE (GCC compiler) will throw specific errors. If your build fails, here are the first three things to check:
1. Did you declare a new variable inside a case without wrapping it in curly braces {}?
2. Are you accidentally switching on a float or String object instead of an integer/char?
3. Did you forget a break; statement, causing unintended fall-through logic?

Below are the exact compiler error strings you will encounter and how to fix them.

1. The Variable Scope Error

Exact Error String: error: jump to case label [-fpermissive] or crosses initialization of 'int myVar'

Cause: In C++, a case label does not create its own scope. If you declare a variable inside a case, it exists in the scope of the entire switch block, but its initialization is skipped if the switch jumps to a later case. The compiler blocks this to prevent undefined behavior.

Fix: Wrap the contents of the case in curly braces to create a local scope.

// WRONG
case STATE_SETTINGS:
  int threshold = 50; // Causes compiler error
  break;

// RIGHT
case STATE_SETTINGS: {
  int threshold = 50; 
  break;
}

2. The Missing Break Fall-Through

Exact Error String: This does not throw a compiler error, but causes a runtime logic bug where multiple cases execute sequentially. However, if you use the -Wimplicit-fallthrough flag in advanced GCC settings, it will warn: warning: this statement may fall through.

Cause: You forgot the break; at the end of a case block.

Fix: Add break; before the next case. If fall-through is intentional, add a comment // fall through to document it and suppress warnings.

3. The Duplicate or Invalid Type Error

Exact Error String: error: duplicate case value OR error: switch quantity not an integer

Cause: You either used the same integer/enum value in two different cases, or you tried to evaluate a float or a String object. The Arduino switch case reference strictly requires integer types (int, char, short, long, or enum).

Fix: Ensure your switch variable is an integer type. If comparing strings, use if (myString.equals("target")) instead.

Extending and Simplifying the Build

Once the base state machine is running, you will inevitably need to adapt it. Here is how to scale the architecture up or down based on your project constraints.

How to Extend the Build (Sub-Menus)

To add sub-menus without creating a tangled web of global variables, use nested switch cases or a 2D state array. Track your current menu depth using a secondary enum.

switch (currentMenuDepth) {
  case DEPTH_MAIN:
    handleMainMenu(); // Contains its own switch case
    break;
  case DEPTH_SUB_SETTINGS:
    handleSettingsMenu();
    break;
}

This keeps the SRAM footprint low on the ATmega328P, as you aren't loading all possible sub-menu strings into memory simultaneously. For a deep dive into C++ switch optimizations, refer to the C++ standard switch documentation.

How to Simplify the Build

If you are prototyping and don't have an I2C LCD on hand, strip the display logic and use the Serial Monitor. Replace the lcd.print() calls inside the switch cases with Serial.println(). You can also drop the rotary encoder and simply use three momentary push buttons tied to D2, D3, and D4, reading them via digitalRead() inside the loop to trigger state changes directly.

Frequently Asked Questions

Can I use strings or floats in an Arduino switch case?

No. The C++ standard dictates that the condition inside a switch() must evaluate to an integral type (such as int, char, byte, or an enum). If you need to branch logic based on a text string received over Serial, you must use an if-else if chain with the String.equals() method, or map the string to an integer ID via a lookup table before passing it to the switch.

What happens if I forget the break statement in a case?

The code will 'fall through' and execute the instructions of the next sequential case block, continuing until it hits a break or the end of the switch. While this is occasionally used intentionally by advanced programmers to group cases (e.g., case 1: case 2: doSomething(); break;), forgetting it is one of the most common sources of erratic behavior in embedded state machines.

Is a switch case faster than an if-else ladder on an ATmega328P?

Yes, generally. When you have more than three or four cases, the GCC compiler optimizes a switch statement into a jump table. Instead of evaluating conditions sequentially (which takes longer the further down the chain the true condition is), the microcontroller calculates a memory offset and jumps directly to the correct code block in a single clock cycle. This makes it highly efficient for real-time interrupt handling and fast loop execution.

How do I handle multiple variables in a single switch case?

A standard switch statement only evaluates one variable. If you need to evaluate two variables (e.g., menuState and buttonPress), you have two options. First, use nested switches (a switch inside a switch). Second, use bitwise operations to combine two small integers into a single 16-bit integer and switch on that combined value, though this sacrifices readability for a marginal performance gain.