Mastering the Arduino Case Switch: 12-Position Rotary Dial State Machine

To implement a robust arduino case switch for a multi-position physical dial, use a resistor ladder network on a single analog pin and map the ADC readings to a C++ switch...case state machine. This approach allows you to read a 12-position rotary switch using only one GPIO pin, saving 11 digital pins for other peripherals while keeping your firmware logic clean, non-blocking, and highly deterministic.

When you need to select between multiple hardware states—like choosing a waveform on a function generator or setting a PID tuning parameter on a reflow oven—mechanical rotary switches are vastly superior to pushbuttons. However, wiring a 12-throw switch to 12 separate digital inputs is a waste of silicon. By converting the physical position into a discrete analog voltage, we can read the dial with analogRead() and route the logic through a switch statement. Below is the complete blueprint for the hardware, the exact ADC thresholds, and the production-ready firmware.

The Hardware: Resistor Ladder ADC Thresholds

The core of this design is a series resistor ladder. We use a Single-Pole, 12-Throw (SP12T) rotary switch. Between each of the 12 terminals, we solder a 10kΩ 1% metal film resistor. The common wiper pin of the switch connects directly to the Arduino's Analog 0 (A0) pin. The first terminal connects to GND, and the last terminal connects to the 5V rail.

Because the resistors are in series, the total resistance is 110kΩ (11 resistors × 10kΩ). The current draw is a negligible 45.45 µA. As you rotate the dial, the wiper taps into a different node of the voltage divider, presenting a distinct voltage to the ADC. The 10-bit ADC on the ATmega328P maps 0-5V to integer values 0-1023.

Here is the exact data-dense mapping table you need to program your switch thresholds. Always design your code with a tolerance band (±15 ADC ticks) to account for minor resistor tolerances and ADC noise.

Parts List & Pin Mapping

Do not substitute 5% carbon film resistors for this build. The cumulative tolerance error across 11 resistors will cause the voltage bands at the extreme ends (positions 1 and 12) to overlap, resulting in misreads. Stick to 1% metal film.

Bill of Materials

• Microcontroller: Arduino Nano V3 (ATmega328P, 16MHz, 5V logic variant). Note: Do not use the Nano 33 IoT or Nano Every for this specific code without adjusting the ADC resolution and reference voltage.
• Switch: CUI Devices RSC-12 or generic SP12T rotary switch (approx. $2.50).
• Resistors: 11x 10kΩ 1% 1/4W Metal Film (Yageo MFR-25 series).
• Capacitor: 1x 100nF (0.1µF) X7R Ceramic Capacitor (for hardware RC low-pass debouncing).
• Pull-down Resistor: 1x 100kΩ (optional, ensures A0 reads 0 if switch wiper lifts off contact).

Pin Mapping Table

The Firmware: Debounced switch...case State Machine

The following C++ code targets the Arduino Nano V3 (ATmega328P). It uses a non-blocking timing loop to sample the ADC, applies a moving average filter to eliminate contact bounce, maps the stabilized reading to a Case ID, and executes the logic via a switch statement. This avoids the delay() function entirely, keeping your main loop responsive.

// Target Board: Arduino Nano V3 (ATmega328P, 5V, 16MHz)
// Project: 12-Position Rotary Switch State Machine

#define PIN_ANALOG_SWITCH A0
#define PIN_STATUS_LED    13
#define SAMPLE_INTERVAL   20    // Milliseconds between ADC reads
#define DEBOUNCE_COUNT    5     // Number of matching reads to confirm state

int currentCaseID = -1;
int rawADC = 0;
int adcBuffer[DEBOUNCE_COUNT] = {0};
int bufferIndex = 0;
unsigned long lastSampleTime = 0;

void setup() {
  Serial.begin(115200);
  pinMode(PIN_STATUS_LED, OUTPUT);
  analogReference(DEFAULT); // Ensure 5V reference on Nano
  Serial.println("System Initialized. Awaiting dial input...");
}

void loop() {
  unsigned long currentMillis = millis();
  
  // Non-blocking ADC sampling
  if (currentMillis - lastSampleTime >= SAMPLE_INTERVAL) {
    lastSampleTime = currentMillis;
    
    // Read and store in circular buffer
    rawADC = analogRead(PIN_ANALOG_SWITCH);
    adcBuffer[bufferIndex] = rawADC;
    bufferIndex = (bufferIndex + 1) % DEBOUNCE_COUNT;
    
    // Calculate moving average for hardware debounce
    long sum = 0;
    for (int i = 0; i < DEBOUNCE_COUNT; i++) {
      sum += adcBuffer[i];
    }
    int avgADC = sum / DEBOUNCE_COUNT;
    
    // Map ADC to Case ID
    int newCaseID = mapADCtoCase(avgADC);
    
    // Execute state machine only if state changes
    if (newCaseID != currentCaseID && newCaseID != -1) {
      currentCaseID = newCaseID;
      executeState(currentCaseID);
    }
  }
  
  // Other non-blocking tasks can run here
}

int mapADCtoCase(int adcVal) {
  // Define tolerance bands based on 10k resistor ladder
  if (adcVal >= 0 && adcVal <= 15) return 0;
  if (adcVal >= 78 && adcVal <= 108) return 1;
  if (adcVal >= 171 && adcVal <= 201) return 2;
  if (adcVal >= 264 && adcVal <= 294) return 3;
  if (adcVal >= 357 && adcVal <= 387) return 4;
  if (adcVal >= 450 && adcVal <= 480) return 5;
  if (adcVal >= 543 && adcVal <= 573) return 6;
  if (adcVal >= 636 && adcVal <= 666) return 7;
  if (adcVal >= 729 && adcVal <= 759) return 8;
  if (adcVal >= 822 && adcVal <= 852) return 9;
  if (adcVal >= 915 && adcVal <= 945) return 10;
  if (adcVal >= 1008 && adcVal <= 1023) return 11;
  
  return -1; // Out of bounds / Transitioning between detents
}

void executeState(int stateID) {
  digitalWrite(PIN_STATUS_LED, HIGH);
  
  switch (stateID) {
    case 0:
      Serial.println("State 0: System OFF");
      break;
    case 1:
      Serial.println("State 1: Low Power Mode");
      break;
    case 2:
      Serial.println("State 2: Sensor Calibration");
      break;
    case 3:
      Serial.println("State 3: PID Tuning P");
      break;
    case 4:
      Serial.println("State 4: PID Tuning I");
      break;
    case 5:
      Serial.println("State 5: PID Tuning D");
      break;
    case 6:
      Serial.println("State 6: Manual Override");
      break;
    case 7:
      Serial.println("State 7: Auto Sequence A");
      break;
    case 8:
      Serial.println("State 8: Auto Sequence B");
      break;
    case 9:
      Serial.println("State 9: Data Logging");
      break;
    case 10:
      Serial.println("State 10: WiFi Config Mode");
      break;
    case 11:
      Serial.println("State 11: Factory Reset");
      break;
    default:
      Serial.println("ERR: ADC_OUT_OF_BOUNDS");
      break;
  }
  
  delay(50); // Brief LED flash
  digitalWrite(PIN_STATUS_LED, LOW);
}

Debugging: Misreads and Fall-Through Errors

When working with analog multiplexing via resistor ladders, the physical world introduces noise that pure digital switches don't face. If your serial monitor is spamming ERR: ADC_OUT_OF_BOUNDS or the state is jumping erratically between adjacent positions, here are the first three things to check when it fails:

1. VCC Sag and USB Brownouts: The ADC thresholds in the table assume a perfect 5.00V reference. If your PC's USB port is sagging to 4.6V under load, the ADC reading for Position 12 will drop from 1023 to roughly 940, causing it to misread as Position 10. Fix: Measure the 5V pin to GND with a multimeter. If it reads below 4.8V, power the Nano via the VIN pin with a regulated 7-9V wall adapter, or use the analogReference(INTERNAL) command to switch to the stable 1.1V internal reference (requires recalculating the resistor ladder to max out at 1.1V).
2. Missing the Hardware RC Filter: Mechanical switch wipers bounce microscopically when crossing between terminals. If you omitted the 100nF ceramic capacitor between A0 and GND, the ADC will sample the open-circuit voltage during the bounce, resulting in wild spikes. Fix: Solder a 100nF X7R capacitor directly across the A0 and GND pins at the Nano header.
3. Resistor Tolerance Stacking: If you used 5% resistors, the cumulative error at the center of the ladder (Position 6) can shift the voltage by ±0.15V. This pushes the ADC reading outside the 450-480 tolerance band. Fix: Replace the ladder with 1% metal film resistors, or widen the tolerance bands in the mapADCtoCase() function to ±25 ticks.

Extending and Simplifying the Build

The beauty of the arduino case switch architecture is its scalability. You are not locked into a 12-position dial.

How to Simplify (4-Position Slide Switch)

If you only need a 4-position selector (e.g., Off, Low, Medium, High), swap the rotary switch for a standard SP4T slide switch. You will only need three 10kΩ resistors. The ADC values will be widely spaced (0, 341, 682, 1023), allowing you to use massive tolerance bands (±100 ticks) and eliminating the need for the moving average debounce buffer entirely. A simple if/else or 4-case switch will suffice.

How to Extend (24+ Positions)

The 10-bit ADC on the ATmega328P maxes out at 1024 discrete steps. If you attempt to build a 24-position ladder, the tolerance bands will overlap, and the system will become unreliable. To scale up:

• Option A (Higher Resolution): Add an external 16-bit I2C ADC like the ADS1115. This gives you 65,536 steps, easily accommodating a 24- or 32-position ladder with wide guard bands.
• Option B (BCD Switches): Abandon the resistor ladder entirely and use a BCD (Binary Coded Decimal) rotary switch. These output a 4-bit digital code (using 4 digital GPIO pins) representing the position 0-9, completely bypassing analog noise and ADC math.

By pairing a physical resistor ladder with a disciplined C++ switch...case state machine, you create a user interface that feels like professional test equipment while consuming minimal microcontroller resources. Always verify your VCC rail, respect your tolerance bands, and let the state machine handle the logic.