Modular Arcade Machine

Introduction: Modular Arcade Machine

About: Sometimes I make stuff for reasons.

My two boys and I wanted to build an arcade machine but we couldn't decide what type to build between a full stand-up cabinet, a bar-top or a fight-stick style console to plug into a TV. It eventually occurred to me that I could do all three as a modular solution which can be used individually or combined as desired.

Due to the simple design and component choice this is also a quite inexpensive build compared to many home arcade machine projects and you should be able to achieve for under 200€/$ in materials. I already had most of the woodwork materials and electronics laying around so I only spent ~50€ which mainly went towards the joysticks and buttons and the secondhand monitor which I picked up for 10€.

Step 1: Design

The basic design concept is a two player arcade system comprised of a set of independent modules that each have some individual function and also complement each other when bolted together.

  • The Control Module contains all the controls and control electronics including the USB controllers. This module may be used a fight stick style controller connected to a a console or Raspberry PI.
  • The Display Module houses the display and Raspberry PI (or your choice of SBC) and may be used standalone as an "all-in-one" computer or connected to the Control Module to form a bartop arcade unit.
  • The Stand Module acts as a storage unit in standalone mode and when combined with the bartop forms a complete stand-up arcade machine.

We tried to keep the design as simple and functional as possible taking some design cues from 70s and 80s vintage - tabletop - games and avoiding non-functional elements such as the light up marquee and T-molding found in many cabinets. Of course you can modify the design to add in these elements if desired.

I decided on a fairly classic button layout that I seemed to recall from the arcades of my youth with a "straight six" button cluster beside each of the joysticks (StreetFighter2 FTW). I placed Start and Select buttons on the front panel to cater for console emulation as well as coin input and player selection duties. I also placed a button on each side for pinball games. Of course you are free to modify the design to your own tastes and desired input methods e.g. trackballs. weighted spinners etc.

I did an initial rough concept sketch of the bar-top unit on paper and then recreated scale correct models in SketchUp - see the attached files for each of the modules and combinations.

I based the dimensions around a 19" widescreen monitor that I bought secondhand for €10. This resulted in an overall cabinet width of 500mm leaving about 30mm play in case I need to change the monitor.

Check the SketchUp files for exact measurements on all the dimensions. When cutting a specific panel or hole I used the tape measure tool in SketchUp to measure the dimension in the model before marking out the cuts on the construction material.

Step 2: Woodwork Tools and Materials



  • Screwdriver and screws
  • Table saw or circular saw
  • Jigsaw
  • Drill and misc bits including 28mm hole saw for the buttons
  • Sandpaper
  • Router and rounding corner bit


  • 19mm (3/4") MDF sheeting
  • 6mm (3/4") MDF sheeting
  • Angle brackets (I used some really handy plastic ones - see the construction photos)
  • Wood filler
  • Paint (see "Finish" steps later for details)

Step 3: Control Module Construction

I started the Control Module by cutting out the sides from the 19mm MDF based on the dimensions from the SketchUp model.

Next I cut the front and back panels. I marked out the bevels on these panels by placing them tight up against the sides and marking the angle with a pencil and then joining the marks on either side with a straight edge. I then cut it by sight in the table saw and finished with sandpaper. I'm quite sure there is a better way to do this with more tools and/or better skills but this worked out fine for my needs and didn't take long.

I then cut out the front and side button holes and connected up all the panels with the angle brackets and screws. I initially planned to use glue but my tests with gluing to an MDF cut edge seemed to indicate that this wouldn't be strong enough. Also I already had a bunch of brackets that I recycled from an old project ;).

I also rounded the top front-facing edges at this stage using the router with the corner rounding bit. This gives a nicer look and more comfortable feel to the module and roves harsh edges where your hands naturally rest beside the controls.

Next I cut out the top and bottom from the 6mm MDF. I beveled the top panel as with the front and back panels to ensure a snug fit and seamless finish. I didn't bevel the bottom panel as I don't plan to fill and paint it. Instead I will use it as a maintenance access panel. I drilled and coutersunk screw holes and drilled matching holes in the corner brackets.

I then disassembled the rear panel and cut a large hole for regular access to the USB cables and Raspberry PI.

Finally I cut the top panel button and joystick holes and reassembled. I didn't fix the top panel in place at this stage as I wanted to keep it loose during the wiring process.

Step 4: Electronics Tools and Materials

NB: This list is only necessary if you want to go full nerd on the electronics. You can and probably should get all this stuff as part of a plug and play kit (like these ones) and avoid all the soldering and custom wiring. Having done this once "the hard way" I will definitely go down the kit route if I ever make another cabinet.


  • Multimeter/connectivity tester
  • Soldering iron
  • Wire cutter
  • Crimping tool (I just used the wire cutter)


  • Arduino Leonardo/Pro Micro with USB HID joystick profile (I used cheap clones)
  • USB hub
  • Arcade joystick and buttons.
  • Crimp connectors to match your selected joystick and buttons
  • 2x Mini breadboards
  • Connecting wires (I mainly used Dupont jumper wires)
  • Electronics solder (still had my original rosin core reel from college)
  • Heat shrink tubing

Step 5: Control Module Wiring

Again, I recommend considering a plug and play kit instead of the approach documented here. Only follow this approach if you:

A. Want full control of the low level button handling code

B. Really enjoy soldering and custom wiring (who doesn't)

C. Already have the tools and parts and/or want to save a few bucks

D. Want to learn more about this stuff or just practice

My personal motivations were a mix of the above. Ok, so here's how I did the wiring:

First I made adapter cables to join the crimp connectors on the buttons to the Dupont connector wires. I made one of these for the micro-switch in each of the buttons and the four in each of the joysticks. Shout out to outlaw Larry for a dig out on the production line for these.

I then used these custom cables to connect the buttons and joysticks to input pins on each of the micro-controllers via the breadboards.

NB: In this design there is a separate micro-controller and hence USB cable for each player. Divide the joystick and button micro-switches accordingly between them and wire both the pinball buttons to the same micro-controller. Check out the photos which show a progression through the wiring stages if you get stuck.

Next I needed to add a wire to send a signal to each of the micro-switches which would then return the signal to the micro-controller input pin when the button was pressed. I used the 4 twisted pairs in some some Cat 5e cable to provide the signal to the joysticks by soldering them all together at one end and attaching a Dupont connector cable connected to the signal pin on the micro-controller.

I made a little daisy-chain cable for each of the 6 button clusters and finally used my custom adapter cables on the start/select and pinball buttons again all wired to the micro-controller signal pin.

Wiring the micro-switches to the micro-controllers was pretty straightforward due to the use of the mini-breadboard and Dupont connectors which meant I could easily move the wires around as necessary.

Step 6: Controller Code

The code is pretty basic. I modified a gamepad example from the excellent Arduino Joystick Library

You can learn more about getting started with that library from this handy instructable.

At the end of this step we had a functioning 2 player fight-stick controller so we celebrated with a few rounds of StreetFighter2 on my laptop!

I originally planned to connect the micro-controllers directly to the Raspberry PI via USB but while testing on the laptop I found that connecting and disconnect the micro USB connectors to the micro-controllers via the access panel was very fiddly and I eventually broke off the micro USB connector from one of the micro-controllers.

The solution to this was to include a USB hub in the control module. This meant that only a single connection was exposed form the Control Module and the overall solution was much more robust. With the wiring complete I added countersunk screw holes to the top panel and screwed it in place.


// Simple gamepad example that demonstraits how to read five Arduino
// digital pins and map them to the Arduino Joystick library.
// The digital pins are grounded when they are pressed.
// NOTE: This sketch file is for use with Arduino Leonardo and
// Arduino Micro only.
// Modified version of original code by Matthew Heironimus
// 2018-08-11
Joystick_ Joystick;
voidsetup() {
// Initialize Button Pins
pinMode(2, INPUT_PULLUP);
pinMode(3, INPUT_PULLUP);
pinMode(4, INPUT_PULLUP);
pinMode(5, INPUT_PULLUP);
pinMode(6, INPUT_PULLUP);
pinMode(7, INPUT_PULLUP);
pinMode(8, INPUT_PULLUP);
pinMode(9, INPUT_PULLUP);
pinMode(10, INPUT_PULLUP);
pinMode(16, INPUT_PULLUP);
pinMode(20, INPUT_PULLUP);
pinMode(21, INPUT_PULLUP);
// Initialize Joystick Library
Joystick.setXAxisRange(-1, 1);
Joystick.setYAxisRange(-1, 1);
// Last state of the buttons
int lastButtonState[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int pins[12] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 16, 20, 21};
voidloop() {
// Read pin values
for (intindex = 0; index< 12; index++)
int currentButtonState = !digitalRead(pins[index]);
if (currentButtonState != lastButtonState[index])
switch (pins[index]) {
case2: // UP
if (currentButtonState == 1) {
} else {
case3: // RIGHT
if (currentButtonState == 1) {
} else {
case4: // DOWN
if (currentButtonState == 1) {
} else {
case5: // LEFT
if (currentButtonState == 1) {
} else {
Joystick.setButton(0, currentButtonState);
Joystick.setButton(1, currentButtonState);
Joystick.setButton(2, currentButtonState);
Joystick.setButton(3, currentButtonState);
Joystick.setButton(4, currentButtonState);
Joystick.setButton(5, currentButtonState);
Joystick.setButton(8, currentButtonState);
case21: {
Joystick.setButton(9, currentButtonState);
lastButtonState[index] = currentButtonState;
view rawgamepad.ino hosted with ❤ by GitHub

Step 7: Raspberry PI Setup

I recommend a Pi 3 for maximum game performance and compatibility but if you are only interested in older games a lower powered device like the Pi Zero would also be fine. I am using a spare Pi 2 that I already had laying around.

There are a load of great resources on the web describing how to set up you chosen Pi or other SBC with different emulators and front ends. I personally use and recommend RetroPie and I found these - excellent - videos from ETA Prime to be a great way to get up and running quickly.

Step 8: Control Module Finish

I haven't gotten this far yet but I plan to fill and sand the module using Wood Filler and medium grade sand paper, then a coat or two of undercoat and fine grade paper. Finally I want to experiment with some Tri-Coat matte black metal paint that I use on my gates. If that doesn't work well I will try some gloss auto spay paint to finish. I am also planning to use the wood filler, perhaps watered down to seal the MDF edges first.

Step 9: Display Module Construction

This step will largely follow the methods described in the Control Module construction for what should be a much more simple module. I expect the monitor mounting to be the most interesting part.

Step 10: Stand Module Construction

The Stand Module should be the most simple of all. Its basically a simple storage cabinet with bolt holes in the top. The most intriguing aspect for me is the finish as the two tone design will require the sides to be finished in both colors with a clean line between them.

Step 11: Final Thoughts

I am having a great time working on this project with my kids - we are all learning a lot and plan to continue at least as far as the full bar-top and perhaps the complete stand-up solution depending on where we decide to put the thing when its done.

I will continue to update this instructable as we progress. Thanks for reading and let me know in the comments what you think of the progress so far!

Game Life Contest

This is an entry in the
Game Life Contest



    • Game Life Contest

      Game Life Contest
    • Organic Cooking Challenge

      Organic Cooking Challenge
    • Creative Misuse Contest

      Creative Misuse Contest