What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Yes—you can build a useful gaming controller yourself. The best first choice depends on the result you want: a native-USB Arduino is the simplest way to turn buttons into keyboard presses, while an RP2040 board running GP2040-CE is the better starting point for a genuine USB gamepad, arcade stick or leverless controller. Build it wired and with digital buttons first; Bluetooth, rumble, batteries and console authentication add substantial complexity.
Choose the controller you are actually building
“DIY controller” can describe several different projects. Decide the input identity and target platform before buying parts.
| Build type | What the computer sees | Best for | Main limitation |
|---|---|---|---|
| Keyboard controller | Keyboard keys | Learning electronics and PC games with keyboard controls | Not a standard gamepad; no native analog, rumble or controller prompts |
| USB gamepad | USB HID joystick/gamepad, or another firmware-selected mode | PC games, emulators, arcade sticks and custom layouts | Console support varies by protocol and authentication |
| Arcade stick | Usually a digital gamepad | Arcade and fighting games | Requires a panel, joystick and secure button mounting |
| Leverless controller | Digital gamepad with direction buttons | Compact fighting-game layouts | Rules, firmware settings and ergonomics need careful attention |
| Handheld gamepad | Gamepad with analog sticks, triggers and shoulder buttons | Portable custom hardware | Calibration, enclosure design, power and firmware are much harder |
| Accessibility controller | Whatever HID or keyboard layout you configure | Large switches, remapping and unconventional control arrangements | May need switch interfaces, mounting solutions or custom software |
| Wireless controller | Bluetooth or another radio HID device | Cable-free use | Pairing, sleep, reconnect, battery safety and radio firmware are additional projects |
For a first build, use a wired USB design with four to eight momentary buttons and no rechargeable battery. A cardboard or breadboard prototype can prove the layout before you buy arcade hardware, a custom PCB or a 3D printer.
Pick the right electronics path
Native-USB Arduino: easiest learning project
An Arduino Leonardo, Micro or another board with a USB-capable ATmega32u4 or SAMD microcontroller can use the Keyboard.h library. Arduino’s official example maps buttons to W, A, S and D, but specifically warns that the illustrated Uno is not compatible with that approach: Arduino’s DIY game-controller example.
Free tools Windows power users keep installed
One-click scans. No signup required.
#1 Best Overall
- Beautiful LED Arace Game DIY Parts for MAME JAMMA Project!
- 100% Zero Delay USB Encoders and Perfect work for all windows systems!
- Perfect Parts for 2 Player Arcade MAME DIY Project!
- Made with highest quality materials!Heat resistant plastic!
- Perfect LED Kit for Arcade PC Game DIY Project! Easy Install!
- Advantages: beginner-friendly IDE, clear documentation and a very small sketch.
- Limitations: the result is keyboard emulation, not an Xbox-style controller; analog axes, triggers and gamepad-only menus require a different design.
RP2040 plus GP2040-CE: best general-purpose route
A Raspberry Pi Pico or another supported RP2040 board provides USB, many GPIO pins and ADC inputs for analog controls. GP2040-CE supplies configurable controller firmware rather than making you write a USB report implementation from scratch. Its downloads page lists builds for boards including Raspberry Pi Pico, Pico W, Pico 2, Adafruit KB2040, Seeed XIAO RP2040 and Waveshare RP2040-Zero: GP2040-CE downloads.
The downloads page showed version 0.7.12 when checked; confirm the current release and the exact board build before flashing. RP2040 GPIO is 3.3 V logic, so do not feed a GPIO a 5 V signal: Adafruit’s RP2040 product information.
Custom HID firmware: maximum control, maximum work
Adafruit’s SNES-like controller project demonstrates an RP2040 with Arduino or CircuitPython tooling, custom USB HID reports, button layouts and axis definitions: project guide and Arduino implementation. Choose this route when learning HID descriptors, debouncing, D-pad encoding or unusual input counts is the goal—not when you want the fastest working arcade stick.
Dedicated arcade encoder: quickest fixed-layout panel
An encoder avoids most firmware work. X-Arcade’s Build Your Own Arcade Trimode Kit was listed at $40 and advertises USB XInput and DirectInput modes: product page. It is suited to a cabinet or fight-stick panel, but less adaptable than an RP2040 and the page warns that some documentation may be old, so verify current wiring instructions.
Rank #2
- When receiving the package. Have any questions. Please contact us first
- Perfect Parts for 4 Player Arcade MAME DIY Project!
- Made with highest quality materials!Heat resistant plastic!
- 100% Zero Delay USB Encoders and Perfect work for all windows systems!
- Beautiful LED Arace Game DIY Parts for MAME JAMMA Project!
The simplest build: Arduino keyboard controller
Parts
- Arduino Leonardo, Micro or another officially supported native-USB board
- Four momentary push buttons
- Breadboard, jumper wires and a USB cable
- Optional cardboard, foam board, wood or printed enclosure
Wire the buttons
Connect one terminal of each button to a digital input and the other to ground. Configure every input as INPUT_PULLUP. The pin reads HIGH while open and LOW when pressed, so no external resistor is needed. Arduino’s example uses pins 2 through 5: official wiring reference.
Upload a held-key sketch
#include <Keyboard.h>
const int upPin = 2;
const int leftPin = 3;
const int downPin = 4;
const int rightPin = 5;
void setup() {
pinMode(upPin, INPUT_PULLUP);
pinMode(leftPin, INPUT_PULLUP);
pinMode(downPin, INPUT_PULLUP);
pinMode(rightPin, INPUT_PULLUP);
Keyboard.begin();
}
void loop() {
if (digitalRead(upPin) == LOW) Keyboard.press('w');
else Keyboard.release('w');
if (digitalRead(leftPin) == LOW) Keyboard.press('a');
else Keyboard.release('a');
if (digitalRead(downPin) == LOW) Keyboard.press('s');
else Keyboard.release('s');
if (digitalRead(rightPin) == LOW) Keyboard.press('d');
else Keyboard.release('d');
delay(5);
}Keyboard.press() must remain active while a button is held, with Keyboard.release() on release. Keyboard.write() produces a short event and is unsuitable for continuous movement.
Test safely
- Upload the sketch.
- Open a text editor and press each button to confirm the intended letter.
- Assign those keys in the target game.
- If the game requires a gamepad device, move to an RP2040 gamepad build.
If the board starts typing uncontrollably, disconnect it. Add a startup delay before Keyboard.begin(), change the sketch so no key is pressed during startup, and test in a text editor before using a form or other sensitive application.
The better all-purpose build: RP2040 with GP2040-CE
Parts and board choices
- Supported board such as Raspberry Pi Pico, Pico W, Pico 2, KB2040, QT Py RP2040, XIAO RP2040 or RP2040-Zero
- Momentary buttons, digital arcade joystick or directional buttons
- USB cable, wire and connectors
- Breadboard, perfboard or controller PCB
- Optional analog stick module and enclosure
Adafruit’s Pico page showed a price signal of $4 without headers and $5 with loose or pre-soldered headers when checked; variants and stock change by region and date: Pico buying page. The QT Py RP2040 was listed at $9.95 in Adafruit’s leverless guide: guide. These are dated observations, not guaranteed prices.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Rank #3
- Exquisite LED arace game DIY MAME parts selection!
- 100% Zero Delay Encoder and USB work perfectly all Windows systems!
- 2 Player Arcade MAME DIY Style Perfect Accessory!
- Use the highest quality materials! Made of high temperature resistant plastic!
- Perfect LED Kit Arcade PC Games DIY Choice! Easy to install!
Flash the firmware
- Download the build matching the exact board from GP2040-CE’s downloads page.
- Hold the board’s boot button while connecting USB, or follow that board’s bootloader procedure.
- Wait for the removable bootloader drive to appear.
- Copy the matching
.uf2file to the drive and let the board reboot. - Open the current GP2040-CE configuration interface.
- Assign GPIO pins to directions, buttons, analog axes and auxiliary controls.
- Select the required input mode, save, and test in the operating system’s controller panel or a browser gamepad tester.
Adafruit documents the drag-and-drop UF2 process and browser configuration workflow in its arcade-stick and leverless guides: arcade-stick preparation and leverless software.
Wire digital controls
Connect one side of each button to its assigned GPIO and the other to ground. Use the firmware’s documented pull-up and active-low configuration. Do not copy a pin diagram from a different board or firmware version: GPIO numbers are not universal, and pins may be reserved for other functions.
Add an analog stick
Most modules expose X output, Y output, power, ground and sometimes a stick-click switch. Connect X and Y to suitable ADC inputs, power and ground at the module’s specified voltage, and wire the click switch as a separate digital input. Modules differ in supply requirements, output range and center voltage; check the module before connecting it to a 3.3 V board.
- Leave the stick untouched during startup or calibration.
- Check that neutral is near the center.
- Move fully in every direction and look for missing travel or drift.
- Increase the dead zone only enough to remove unwanted movement.
- Calibrate again after mounting, because enclosure pressure can shift the neutral point.
Wire inputs reliably
Digital switches, pull-ups and ground
A normally open momentary switch needs a defined idle state. An internal pull-up holds the input HIGH; pressing the button connects it to ground and produces LOW. Floating inputs cause random presses. A shared ground bus is convenient, but a loose common ground can make several controls fail together.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Rank #4
- Additional Color Options: Multiple color variations available for this arcade kit to match your cabinet design preferences
- Easy Installation: Designed for wood or metal control panels and mounts securely in standard 1-1/8 inch holes
- Durable Microswitches: High-quality microswitches included and tested to withstand 10,000,000 cycles for long-lasting performance
- Versatile Compatibility: Replace or build video arcade, emulator, and MAME cabinet controls with this comprehensive kit
- Zero Delay USB Interface: 100% Zero Delay USB Interface PCB with Auto-Fire Mode support for responsive 2-player arcade PC gaming
Debounce mechanical buttons
Contacts can oscillate for a few milliseconds. Start with a small firmware debounce interval or the arcade firmware’s debounce setting, then test rapid presses. A state-change timer is more robust than blindly adding a long delay; hardware RC filtering is an advanced option.
Use voltage discipline
- Confirm the board’s logic voltage and every module’s supply requirement.
- Keep RP2040 GPIO at 3.3 V; fitting a 5 V connector does not make a signal safe.
- USB power is generally adequate for buttons and passive inputs, not automatically for motors, displays, lighting or radio accessories.
- Use one GPIO per button for a first build. A matrix saves pins but adds ghosting risks, diode requirements and scanning firmware.
Design an enclosure that can be repaired
Prototype the hand position before committing to a final case.
- Cardboard or foam board: fastest way to test spacing and reach.
- Wood: durable and approachable with basic tools.
- Acrylic or laser-cut panels: clean arcade layouts but require accurate drilling.
- 3D printing: repeatable custom shells, with inevitable design and print iterations.
Leave space for wire bends, quick-connect terminals and firmware access. Add strain relief where the USB cable exits, protect wires from sharp edges, avoid conductive panels touching exposed contacts, and keep the case serviceable rather than permanently gluing it shut. Adafruit’s leverless project shows a compact 3D-printed approach: leverless controller guide.
Add advanced controls only after the wired core works
- Extra buttons and shoulder controls: consume GPIOs and need new assignments.
- Analog triggers: require suitable ADC inputs, calibration and a firmware report that exposes axes rather than simple on/off buttons.
- Rotary encoders and LEDs: add GPIO, current draw and configuration work.
- Rumble: needs a driver stage and a power budget; never drive a motor directly from a GPIO.
- Accessibility switches: can be wired as ordinary digital inputs, but mounting, remapping and simultaneous-input behavior matter as much as the electronics.
- Wireless: requires suitable radio hardware, pairing, battery management, sleep and reconnect behavior. A wireless-capable board alone does not guarantee Bluetooth gamepad support.
Test the controller before closing the case
- Inspect for solder bridges, stray wire strands, reversed connectors and shorts.
- With USB disconnected, verify each switch closes only when pressed.
- Connect USB without touching controls; stop if there is heat, smell, smoke or repeated resetting.
- Confirm the expected USB device or firmware mode appears.
- Test every button individually.
- Test combinations such as up plus left and several action buttons.
- Check analog center, full travel and drift.
- Try an emulator and one ordinary PC game.
- Gently move the cable and connectors to expose intermittent faults.
- Use it for 15–30 minutes before permanently closing the enclosure.
Troubleshoot by symptom
The computer sees a keyboard, not a controller
You flashed keyboard firmware or used Keyboard.h. Configure the game for keyboard input or replace it with true gamepad firmware.
Recommended Free Tools
Best Value
- New Style DIY Arcade Kit, LED arace game DIY MAME parts DIY Accessories.
- 100% Zero Delay Encoder and USB work perfectly all Windows systems.
- 2 Player Arcade MAME DIY Accessories, DIY Your Own Arcade Game Console.
- Use the highest quality materials! Made of high temperature resistant plastic.
- Perfect LED Kit Arcade PC Games DIY Choice! Easy to install!
The board is not detected after flashing
- Recheck the exact board firmware.
- Re-enter bootloader mode.
- Try a known data-capable USB cable and another port.
- Remove external wiring and flash the board alone.
- Check that the board’s boot button procedure differs from the one you used.
All buttons appear pressed
Inspect the shared ground, active polarity, firmware pin map and possible signal-to-ground short.
One button does nothing
Check its connector and switch continuity, verify the GPIO assignment, look for mechanical binding and ensure the pin is not assigned to another function.
The analog stick drifts
Recalibrate, increase the dead zone slightly, verify power/ground and ADC wiring, remove mounting pressure, or replace a defective module.
Rapid inputs are missed
Review debounce settings, tighten quick-connect terminals, shorten excessively long unshielded wires and confirm the firmware is not scanning too slowly.
It works on PC but not on a console
The console may require a different protocol, mode, licensed adapter or authentication. Check the exact console model, firmware mode and game; generic USB HID support is not a promise of Xbox, PlayStation or Switch support.
Understand compatibility before promising a platform
| Target | Expectation |
|---|---|
| Windows, macOS and Linux | Keyboard input is common; generic USB HID gamepads are commonly supported, while XInput behavior depends on firmware mode. |
| RetroArch and emulators | Usually workable once the operating system exposes the intended keyboard or gamepad device. |
| Raspberry Pi | Commonly workable with supported USB modes; configure the emulator or frontend. |
| Android | Firmware and USB host support determine the result; test the specific device and adapter. |
| Nintendo Switch | Firmware mode and, in some setups, an adapter are required; do not infer support from PC operation. |
| PlayStation | Platform-specific modes or adapters may be required; authentication can limit generic devices. |
| Xbox | Authentication and licensed-device requirements make generic DIY compatibility especially uncertain. |
Adafruit describes GP2040-CE use across PC, Raspberry Pi, Android, retro and selected Nintendo and PlayStation scenarios, but the exact mode and hardware requirement still need checking in the current documentation: arcade-stick guide and leverless guide.
Build or buy?
A bare board can be inexpensive, but a complete controller also includes switches, joystick or analog modules, wiring, connectors, enclosure, tools, shipping, failed prototypes and your time. Build when you value a nonstandard layout, accessibility, repairability, learning or a custom arcade aesthetic. Buy when guaranteed console support, wireless reliability, rumble, motion sensors, a polished shell or minimal troubleshooting matters more.
Quick Recap
| Criterion | Keyboard Arduino | RP2040 + GP2040-CE | Custom HID firmware | Arcade encoder |
|---|---|---|---|---|
| Beginner difficulty | Low | Medium | High | Low–medium |
| Programming | Small sketch | Flash and configure | Significant | Little |
| Standard gamepad identity | Usually no | Usually, mode-dependent | Yes if correctly implemented | Encoder-dependent |
| Analog support | Custom work | Board and firmware-dependent | Highly customizable | Often limited |
| Arcade suitability | Fair | Excellent | Excellent | Excellent |
| Layout flexibility | High | High | Very high | Medium |
| Best use | Learning and keyboard games | General DIY controller | Research and unusual hardware | Fast fixed arcade panel |
Recommended starting plan
- Sketch the layout and decide whether the target game expects keyboard input or a gamepad.
- Prototype four directional buttons on cardboard or a breadboard.
- Choose a native-USB Arduino for keyboard learning, or an RP2040 and GP2040-CE for a real gamepad.
- Keep the first version wired, digital and one-pin-per-button.
- Test every input before adding analog controls or a final enclosure.
- Only then add accessibility switches, triggers, LEDs, rumble or wireless features.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
