Raspberry Pi Pico vs Arduino Micro: Which USB HID Controller Wins?

The Verdict: Raspberry Pi Pico vs Arduino Micro for USB HID

When building custom USB Human Interface Devices (HID) like macro pads, stream decks, or custom keyboards, the Raspberry Pi Pico (RP2040) and the Arduino Micro (ATmega32U4) are the two most common breadboard-friendly contenders. Both feature native USB controllers, eliminating the need for external USB-to-serial bridge chips.

For new projects in 2026, the Raspberry Pi Pico is the definitive choice. At roughly $4, it offers a dual-core 133MHz ARM processor, 264KB of SRAM, and robust support for the TinyUSB stack. The Arduino Micro (or its Pro Micro clones) remains relevant only if your circuit strictly requires 5V native logic levels without level-shifting, or if you are maintaining legacy AVR-based Arduino code that relies on hardware-specific registers. If you are starting fresh, the Pico's price-to-performance ratio and PIO (Programmable I/O) state machines make the Micro obsolete for HID applications.

Silicon Showdown: RP2040 vs ATmega32U4 Spec Sheet

The architectural gap between these two boards is massive. The Pico uses a modern 32-bit ARM Cortex-M0+ dual-core architecture, while the Micro relies on an 8-bit AVR microcontroller designed in the early 2000s. Here is how the silicon actually compares on the bench.

Parts List and Pin Mapping for a 6-Key Macro Pad

To demonstrate the practical differences, we are building a 6-key USB macro pad. This project targets the Raspberry Pi Pico H (the variant with pre-soldered headers, saving you 20 minutes of soldering).

Exact Parts List

• Microcontroller: Raspberry Pi Pico H (RP2040) with pre-soldered headers.
• Switches: 6x Cherry MX Brown (or any MX-compatible mechanical switch).
• Diodes: 6x 1N4148 switching diodes. Do not use 1N4001 rectifier diodes; their reverse recovery time is too slow for high-speed matrix scanning and will cause ghosting.
• Wiring: 22 AWG solid core hook-up wire.
• Connection: High-quality USB-C to USB-A data cable (verify it has data lines, not just power).

Pin Mapping Table

We are using a 2x3 matrix. Here is the exact GPIO mapping for the Pico, alongside the equivalent pins if you were forced to use an Arduino Micro.

Wiring and Build Steps

1. Prep the Diodes: Bend the cathode (black stripe) leg of each 1N4148 diode into a small hook. Solder the cathode to the right-side pin of each Cherry MX switch. The anode (unmarked leg) will point downward to form the column wiring.
2. Wire the Columns: Strip a small section of insulation off a single length of 22 AWG wire. Solder this bare wire across all three anode legs in Column 0. Repeat for Column 1 and Column 2. These connect to Pico GPIOs 4, 5, and 6.
3. Wire the Rows: Solder a continuous wire across the left-side pins of the switches for Row 0. Repeat for Row 1. These connect to Pico GPIOs 2 and 3.
4. Connect to Pico: Insert the Pico H into your breadboard. Use jumper wires to connect the row and column wires to the designated GPIO pins. Connect the Pico GND to the breadboard ground rail (though not strictly required for this simple matrix, it is best practice).
5. Verify Continuity: Before plugging in USB, use your multimeter in continuity mode. Press each switch and verify it bridges the correct row and column without shorting to adjacent traces.

The Code: Native USB HID on the Pico

The following C++ code targets the Raspberry Pi Pico H (RP2040). It uses the Earle Philhower RP2040 board package in the Arduino IDE, leveraging the Adafruit_TinyUSB library for robust HID descriptor handling. This code includes explicit pin definitions, matrix debouncing, and USB mount error handling.

#include "Adafruit_TinyUSB.h"

// --- PIN DEFINITIONS ---
const uint8_t ROW_PINS[] = {2, 3};
const uint8_t COL_PINS[] = {4, 5, 6};
const uint8_t NUM_ROWS = sizeof(ROW_PINS);
const uint8_t NUM_COLS = sizeof(COL_PINS);

// HID Report Descriptor for a standard 6-key rollover keyboard
uint8_t const desc_hid_report[] = {
  TUD_HID_REPORT_DESC_KEYBOARD()
};

Adafruit_USBD_HID usb_hid(desc_hid_report, sizeof(desc_hid_report), HID_ITF_PROTOCOL_KEYBOARD, 2, false);

// Keymap: Maps matrix positions to USB HID keycodes
// Example: Row 0, Col 0 = 'A', Row 0, Col 1 = 'B', etc.
uint8_t keymap[NUM_ROWS][NUM_COLS] = {
  {HID_KEY_A, HID_KEY_B, HID_KEY_C},
  {HID_KEY_D, HID_KEY_E, HID_KEY_F}
};

bool prev_key_state[NUM_ROWS][NUM_COLS] = {false};
unsigned long last_debounce_time = 0;
const unsigned long debounce_delay = 5; // 5ms debounce

void setup() {
  Serial.begin(115200);
  
  // Initialize Row pins as OUTPUT (driven HIGH)
  for (uint8_t i = 0; i < NUM_ROWS; i++) {
    pinMode(ROW_PINS[i], OUTPUT);
    digitalWrite(ROW_PINS[i], HIGH);
  }
  
  // Initialize Col pins as INPUT_PULLUP
  for (uint8_t i = 0; i < NUM_COLS; i++) {
    pinMode(COL_PINS[i], INPUT_PULLUP);
  }

  // Initialize TinyUSB
  TinyUSBDevice.setManufacturerDescriptor("ElectricalFlux");
  TinyUSBDevice.setProductDescriptor("Pico Macro Pad");
  usb_hid.begin();
  
  // Wait for USB to mount with timeout error handling
  unsigned long start_time = millis();
  while (!TinyUSBDevice.mounted()) {
    if (millis() - start_time > 3000) {
      Serial.println("ERROR: USB Failed to mount. Check cable and TinyUSB board settings.");
      break;
    }
    delay(10);
  }
}

void loop() {
  if (!usb_hid.ready()) {
    return; // Wait for HID stack to be ready
  }

  uint8_t current_keys[6] = {0}; // Max 6 keys for standard boot protocol
  uint8_t key_count = 0;

  for (uint8_t r = 0; r < NUM_ROWS; r++) {
    digitalWrite(ROW_PINS[r], LOW); // Drive row LOW
    delayMicroseconds(10); // Allow voltage to settle

    for (uint8_t c = 0; c < NUM_COLS; c++) {
      bool is_pressed = (digitalRead(COL_PINS[c]) == LOW);
      
      if (is_pressed && !prev_key_state[r][c] && (millis() - last_debounce_time > debounce_delay)) {
        if (key_count < 6) {
          current_keys[key_count++] = keymap[r][c];
        }
        prev_key_state[r][c] = true;
        last_debounce_time = millis();
      } else if (!is_pressed) {
        prev_key_state[r][c] = false;
      }
    }
    digitalWrite(ROW_PINS[r], HIGH); // Release row
  }

  // Send report to host
  usb_hid.keyboardReport(0, 0, current_keys);
  delay(2); // Scan rate limiting
}

Debugging: "USB Device Not Recognized" and Bootloader Bricks

When working with native USB microcontrollers, the most common failure mode is the host OS rejecting the device descriptor. If you plug in your Pico and Windows throws the USB device descriptor failed error, or Linux dmesg outputs device descriptor read/64, error -110, do not panic. The hardware is rarely dead.

The First Three Things to Check When It Fails

1. Verify the USB Cable and Port: 40% of "dead board" issues are caused by charge-only USB-C cables that lack the D+ and D- data lines. Swap to a verified data cable. Also, plug directly into the motherboard's rear I/O; front panel headers and unpowered USB hubs often cause voltage droop that crashes the RP2040's USB PHY during enumeration.
2. Check for BOOTSEL Mode Lock: If the Pico was unplugged while holding the BOOTSEL button, or if the flash memory is corrupted, it will boot into UF2 mass-storage mode instead of executing your HID code. The host sees it as a USB drive named RPI-RP2, not a keyboard. Unplug it, ensure you are not holding the white BOOTSEL button, and plug it back in.
3. Validate IDE Board and USB Stack Settings: In the Arduino IDE, selecting the standard "Raspberry Pi Pico" board defaults to the standard Mbed OS core, which handles USB differently. You must select Raspberry Pi Pico (Earle Philhower) under the boards manager, and in the Tools menu, set USB Stack: Adafruit TinyUSB. If you leave it on Pico SDK, the Adafruit_TinyUSB.h include will fail to compile or crash at runtime.

Extending and Simplifying the Build

Once your 6-key matrix is reliably sending keystrokes, you have two distinct paths forward depending on your project goals.

How to Extend the Build (Adding Hardware)

The RP2040's 3.3V logic and abundant GPIO make expansion trivial.

• Add a Rotary Encoder: Wire a KY-040 rotary encoder to GPIO 7 (CLK) and GPIO 8 (DT). Because the Pico runs at 133MHz, you can poll the encoder pins in the main loop without missing detents, or use the RP2040's PIO state machines to decode the quadrature signal in hardware with zero CPU overhead.
• Add an OLED Display: Connect a 128x64 SSD1306 I2C OLED. Wire SDA to GPIO 4 and SCL to GPIO 5 (you will need to move your matrix columns to GPIO 6, 7, and 8). Use the Adafruit_SSD1306 library to display the current active macro layer or CPU stats from your PC.

How to Simplify the Build (Ditching Raw Code)

If your goal is purely to build a custom keyboard and you do not want to maintain raw C++ matrix-scanning code, flash QMK or KMK firmware.

• KMK (MicroPython): Since the Pico has 2MB of flash, it easily runs CircuitPython/KMK. You simply drag and drop a code.py file onto the Pico's virtual drive. KMK handles the matrix scanning, debouncing, and USB HID descriptors via a simple Python dictionary.
• QMK (C-based): For the lowest latency, compile a custom QMK firmware targeting the rpi_pico board. This allows you to use VIA or VIAL for real-time GUI key remapping without ever recompiling the code. This is the industry standard for custom mechanical keyboards in 2026.

For further reading on the RP2040 architecture, refer to the official Raspberry Pi RP2040 Datasheet. If you are maintaining legacy AVR hardware, the Arduino Micro documentation details the ATmega32U4's specific USB register limitations. For the HID library used in this project, consult the Adafruit TinyUSB Arduino repository for the latest descriptor examples.