Rotary Encoder Arduino Wiring, Code, and Interrupt Debugging Guide

If you need precise rotational input for a menu system, volume knob, or motor positioning, a standard potentiometer won't cut it. You need a quadrature rotary encoder. The direct answer for the most common setup: wire the CLK pin to Arduino Pin 2, the DT pin to Pin 3, and the SW (switch) pin to Pin 4. Use hardware interrupts on Pins 2 and 3 to catch every detent without blocking your main loop.

This guide covers the exact hardware variants, a table-forward pin mapping, bulletproof C++ code targeting the Arduino Uno R3 (ATmega328P), and the specific debugging steps to fix the infamous 'skipping counts' issue that plagues most beginner builds.

Hardware Selection & Specification Matrix

Not all encoders are created equal. The cheap modules you find in starter kits behave very differently from bare industrial components. Here is the data-dense breakdown of the three most common variants you will encounter on the bench in 2026.

Pin Mapping & Step-by-Step Wiring

The Arduino Uno R3 and Nano v3 (both ATmega328P-based) only have two dedicated hardware interrupt pins: Pin 2 (INT0) and Pin 3 (INT1). Because a quadrature encoder requires reading two out-of-phase square waves (CLK and DT) to determine direction, we must assign these to the hardware interrupt pins to ensure we don't miss steps while the microcontroller is doing other tasks.

Wiring Steps with Hardware Debounce

Software debouncing wastes CPU cycles and can still miss fast rotations. The professional approach is hardware debouncing.

1. Power Down: Disconnect the Arduino from USB and external power.
2. Connect Power: Wire the encoder VCC to the Arduino 5V pin, and GND to GND.
3. Wire the Switch: Connect the SW pin to Arduino D4.
4. Wire Quadrature Pins: Connect CLK to D2 and DT to D3.
5. Add Hardware Debounce (Crucial): Solder or plug a 0.1µF (100nF) ceramic capacitor between CLK and GND, and another between DT and GND. This creates a low-pass RC filter (with the module's 10k pull-ups) that physically absorbs the mechanical contact bounce before it ever reaches the ATmega328P's Schmitt trigger inputs.

Complete Arduino Code: Quadrature Decoding

This code targets the Arduino Uno R3 and Nano v3. It does not rely on external libraries, giving you full visibility into the state machine. It uses a robust quadrature decoding method inside the Interrupt Service Routine (ISR) that checks both pins to determine direction, eliminating the 'direction reversal' glitch common in naive edge-triggered code.

/*
 * Rotary Encoder Quadrature Decoder
 * Target: Arduino Uno R3 / Nano v3 (ATmega328P)
 * Hardware: KY-040 or EC11 with 0.1uF debounce caps
 */

// --- PIN DEFINITIONS ---
#define ENCODER_CLK 2  // Must be hardware interrupt pin (INT0)
#define ENCODER_DT  3  // Must be hardware interrupt pin (INT1)
#define ENCODER_SW  4  // Pushbutton switch pin

// --- VOLATILE VARIABLES (Modified in ISR) ---
volatile int encoderCount = 0;
volatile bool buttonPressed = false;

// Keep track of previous state for edge detection
volatile uint8_t previousState = 0;

void setup() {
  Serial.begin(115200);
  
  // Configure pins
  pinMode(ENCODER_CLK, INPUT); // KY-040 has external pull-ups
  pinMode(ENCODER_DT, INPUT);  // If using raw EC11, use INPUT_PULLUP
  pinMode(ENCODER_SW, INPUT_PULLUP); // Switch is active LOW

  // Read initial state of both quadrature pins
  previousState = (digitalRead(ENCODER_CLK) << 1) | digitalRead(ENCODER_DT);

  // Attach interrupts to both pins on CHANGE to catch all quadrature edges
  attachInterrupt(digitalPinToInterrupt(ENCODER_CLK), readEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(ENCODER_DT), readEncoder, CHANGE);

  Serial.println("Rotary Encoder Initialized. Ready for input.");
}

void loop() {
  // Safely read volatile variables by temporarily disabling interrupts
  int currentCount;
  bool isButtonPressed;
  
  noInterrupts();
  currentCount = encoderCount;
  isButtonPressed = buttonPressed;
  buttonPressed = false; // Reset flag after reading
  interrupts();

  // Handle Encoder Rotation
  static int lastReportedCount = 0;
  if (currentCount != lastReportedCount) {
    Serial.print("Position: ");
    Serial.println(currentCount);
    lastReportedCount = currentCount;
  }

  // Handle Button Press
  if (isButtonPressed) {
    Serial.println("[BUTTON PRESSED] - Resetting count to 0.");
    noInterrupts();
    encoderCount = 0;
    interrupts();
    lastReportedCount = 0;
    delay(50); // Simple software debounce just for the button
  }
}

// --- INTERRUPT SERVICE ROUTINE (ISR) ---
void readEncoder() {
  // Read current state of both pins
  uint8_t currentState = (digitalRead(ENCODER_CLK) << 1) | digitalRead(ENCODER_DT);
  
  // We only act if the CLK pin actually changed (avoids double-counting)
  if ((currentState & 0x02) != (previousState & 0x02)) {
    // Quadrature logic: compare current DT with previous CLK
    if ((currentState & 0x01) != (previousState & 0x02)) {
      encoderCount++;
    } else {
      encoderCount--;
    }
  }
  
  // Update previous state
  previousState = currentState;

  // Check button state inside ISR to avoid polling delays
  if (digitalRead(ENCODER_SW) == LOW) {
    buttonPressed = true;
  }
}

Debugging: 'Encoder Skipping Counts' & Compile Errors

When working with rotary encoders, you will inevitably hit issues. The most common runtime symptom is the serial monitor showing erratic jumps (e.g., Position: 1 -> 4 -> 2 -> 15). The most common compile-time error when moving code between boards is: error: 'digitalPinToInterrupt' was not declared in this scope.

The First Three Things to Check When It Fails

Before rewriting your code, verify these physical and configuration baselines:

1. Verify the 0.1µF Capacitors: Are they physically installed between CLK/GND and DT/GND? Without them, mechanical bounce triggers 4-5 interrupts per detent, causing the count to race ahead.
2. Check VCC Logic Levels: If you powered the KY-040 with 3.3V but are using a 5V Arduino Uno, the HIGH threshold might not be met reliably, causing floating reads. Power the module with 5V.
3. Confirm Interrupt Pin Mapping: Did you accidentally wire CLK to Pin 4 and DT to Pin 5? On the Uno R3, attachInterrupt() will silently fail or throw a compile error if you pass non-interrupt pins to the macro.

Ranked Causes for 'Skipping Counts' (Runtime Erratic Values)

Extending and Simplifying the Build

Depending on your project timeline and target hardware, you may want to alter the approach outlined above.

How to Simplify (The Library Route)

If you don't want to manage ISRs and volatile variables manually, use the industry-standard PJRC Encoder Library. It handles pin-change interrupts across almost all Arduino-compatible boards automatically.
Trade-off: It uses more flash memory and abstracts away the hardware reality, making it harder to debug if you run into I2C bus contention or timer conflicts later in a complex project.

How to Extend (ESP32 and OLED Integration)

If you are migrating this build to an ESP32 DevKit v1 for an IoT menu system:

• Pin Changes: The ESP32 supports interrupts on almost any GPIO. Move CLK to GPIO 25 and DT to GPIO 26 to avoid the strapping pins (GPIO 0, 2, 12).
• Logic Levels: The ESP32 is strictly 3.3V. You must power the KY-040 with 3.3V, or use a logic level shifter. Feeding 5V into ESP32 GPIOs will permanently damage the silicon.
• Display Output: Extend the loop() to map the encoderCount to a menu index, and render it on an SSD1306 I2C OLED. Use the U8g2 library for flicker-free partial screen updates so the I2C bus traffic doesn't starve your encoder polling.

By understanding the physical quadrature waveforms and respecting the ATmega328P's interrupt architecture, you can build rotary input systems that feel as responsive and precise as commercial audio equipment. For deeper reading on quadrature signal theory, refer to the All About Circuits encoder guide or the official Arduino attachInterrupt() documentation.