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 us that we could build all three as a modular solution with modules that 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 have so far spent less than 100€.

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: Display Module Construction

I started the Display Module construction with the side panels, marking and cutting out the first from dimensions measured from the SketchUp file using the virtual tape measure. I then used the first panel as a template to mark out the second.

Next I cut out the lower back panel, screwed on some angle brackets and then screwed it to the side panels. At this stage I verified that my monitor would fit. It was a little tighter than I expected but there was sufficient space.

I then added the lower front panel and cut holes in it to match the control module. To mark these out I placed the control module up against the display module and scribed around the inside of the existing hole in the control module.

At this stage I was able to bolt together the two modules using two cabinet connector bolts. Now I could see the final shape of the combined bar-top module!

Next step was routing the edges of the panels. For this I disassembled the unit again. I also cut out the hole for the powers inlet and switch. For this I first marked out the hole, then drilled corners with a small wood bit and finally cut out the remaining material using a spiral saw.

I then reassembled the unit gluing each piece together this time. As I was also using brackets I didn't need to use clamps to hold the pieces together.

Now that the unit was in its final form I cut out the screen panel and fit it in place, working on it with sand paper until it fit snugly. When I was happy with the fit I popped it out and used a jigsaw to cut out the hole for the display to match the visible screen area. This done I was able to test the screen in place using some brackets to hold the monitor loosely in position.

I put the two modules together to see what it looked like and then finished gluing the screen surround in place. To do this I added some extra pieces of 6mm MDF behind the screen surround in order to make sure that it was solid and to avoid cracks in the paint later.

Step 9: Finish

Once the glue had dried completely on the display module I generously applied wood filler to all the joints and blemishes and sanded it down with coarse grade sandpaper.

I then coated it with watered down PVA bonding as a first seal layer. Next I applied multiple coats of a mixture of PVA and white general purpose wood/steel paint that I found in the garage.

These initial coats were all applied using a regular 2" paint brush.

When the base coats dried out I did a light sanding with fine grain sandpaper. After that I added another coat of white paint.

When that was dry I sanded lightly again and then applied a couple of coats of inexpensive general purpose spray paint from cans I picked up at the hardware store.

Before repeating the process for the control module I cut out the upper back panel of the display module. This panel has a hole in it so that I can carry the display module more easily. It also acts allows sound for the built-in monitor speakers to get out of the case.

At this stage I also decided to remove the screws from the top panel of the control module and glue it in place instead. To make sure it was secure I glued in some extra support pieces first.

When the control module was painted I used a Dremel to clean up the button holes continually testing them for size with one of the buttons. Finally I glued the furniture connector nut into the back of the control modules.

I was reasonably satisfied with the resulting finish at the end of this step given the amount of time and effort spent. It was by no means perfect and could be improved given more time during this stage. It's really depends on what level of finish you want to achieve as to how much time this step will take.

Step 10: Display Module Components

  • 19" Widescreen Monitor with speakers
  • Raspberry PI 2 Single Board Computer (SBC)
  • Raspberry PI 2 Case
  • 2Amp USB power adapter
  • Micro-usb cable
  • 3.5mm audio cable
  • HDMI cable
  • Mains chassis socket (kettle lead type)
  • Mains kettle lead
  • Double mains socket

Step 11: Display Module Wiring

First I added a base and rear panel to the display module shell.The rear panel was secured in place using magnetic catches so that it can easily be removed for quick access to the components.

I then wired up a power switch to a double power socket for powering the PI and monitor. I soldered the power wires to the switch and sleeved the cables with heat-shrink tubing. If you are not completely comfortable about this part get some help from someone qualified. Do NOT take any risks with mains wiring.

After I fixed the switch securely to the case I placed the monitor in position. Given the already tight fight a couple of extra plastic brackets were all that was required to secure the screen in place.

Next I plugged in a USB power adapter for the PI and a kettle lead for the monitor. All that remained was to plug in the audio and video signals to the monitor.

As the monitor has no HDMI-in I used a HDMI to DVI adapter. Audio was supplied to the built-in monitor speakers via a 3.5mm audio cable from the PI. With the back panel on and audio settings on max the audio volume is okay but not loud. I might add speakers and a mini amplifier in a future update.

Finally I plugged a USB hub into the PI and was able to let the testing of the fully operational display module begin.

Step 12: Final Assembly and Thoughts

The last job before final assembly was re-wiring and assembling the Control Module after painting. This went pretty smoothly apart from breaking one wire which had to be re-soldered.

Before combining the Control and Display Modules I cut out a couple of discs of clear adhesive contact film to avoid the furniture connector barrels protruding from the Control Module from scratching the Display Module's paintwork.

It was then just a simple task of placing the modules and screwing them together. At this stage the bar-top unit is fully complete and ready for action. It looks like this will be the preferred configuration so I will not need to construct the Stand Module for a while at least. If and when I do, I'll update this post. The Stand Module itself should be the most simple of all. It's basically a simple storage cabinet with bolt holes in the top to connect to the bar-top unit.

I have had a great time working on this project with my kids. We learned a lot and are now looking forward to playing lots of old arcade and console classics on the new machine. Thanks for reading and let us know what you think of the project in the comments!

Game Life Contest

Participated in the
Game Life Contest