Rombus-CT - A Raspberry Pi powered mini cocktail arcade

If you follow my blog, you may recall my ROMBUS3000 project from a few months ago, which went down quite the storm. This was my attempt at fulfilling a long lived desire to create an arcade machine.

Well, when looking to create something to take to an event I am helping organise, CodeCabin, an arcade machine seemed the perfect fit. I could of course just take the ROMBUS3000, however I thought it would be much more fun to create a 2 player arcade so that multiple people can play together.

Looking around at case designs, there are many bar top options to choose from, but none of them really inspired me, until I came across an old video of a mini cocktail arcade.

When I had been looking to make an arcade machine many years ago, it was a cocktail arcade I was looking to make. I actually made a ton of progress including buying all the components, designing the case and cutting much of the wood, but I never actually put it all together, so this seemed like the perfect way to fulfill that dream, and thus ROMBUS-CT was born.

Design

Probably the longest running phase was the designing phase. This was all done in inkscape, and started by drawing out a few core components that I knew I wanted to use, such as the ZIPPYY joysticks (they have a nice short shaft, and are nice and cheap whilst still feeling “arcady”), the Sanwa 24mm diameter buttons (smaller than the standard arcade buttons) and the 8” monitor available from Pimoroni. With those in mind, the case design was built up around them.

A requirement of the design was that it must be able to be cut on my A3 laser cutter, so this pretty much defined the overall size of the top.

After a few nights work, I had a design I was happy with, and had broken it all out into flat panels to cut out on my laser cutter.

Prototype

With the design ready, I decided to go through a prototyping phase. I had a ton of laser ply in the garage, so this was perfect for experimenting with. I cut out all the panels, and dry fit everything together using masking tape to keep things together.

The prototyping phase was a really worthwhile process as it helped identify several little issues, allowing tweaks to be made to the design files before the real build began.

Build

With the design files ready for final production, the build began.

MDF was purchased from my local B&Q and cut down to A3 size, then the various panels were cut out and painted using a black satin wood paint to cover all visible faces and edges. A roller was used to give a much smoother finish.

Whilst the wood was coming out nice, reviewing the original video that inspired me, I really loved the wood effect finish they had, so at this point I started to look into wood effect vinyls, and came across some great options by d-c-fix (the guys at Pimoroni were suitably impressed too as they are now looking to stock this). I purchased a couple of metres of a few I liked the look of and proceeded to cut out a few sample panels on my plot cutter. The end result was nothing short of awesome, so I went ahead and cutout panels for all the external faces in a mix of light oak and black wood effect.

With all the panels ready, assembly began. M4 high tensile bolts were used (any bolts should work fine, but I liked the look of the black, high tensile ones) along with some 19mmx19mm metal brackets purchased from ebay to hold it all together. Care had to be taken not to tighten too much and ripple the vinyl, but it was usually a case of tighten them till it ripples and then do a quarter turn back.

The lid was attached via a couple of dolls house hinges, and all the buttons and joysticks were put into their associated locations.

Wiring

With the case built, the next step was to wire it up. Thankfully the guys at Pimoroni were kind enough to donate a couple of wiring looms from their Picade arcades (you can make your own really easily, they are just a bit time consuming so this saved me a bunch of time). I started by wiring all the buttons and joysticks, and then moved on to planning the internals and testing where components should sit.

Given how easy it was to use the Picade PCB in my ROMBUS3000 project, it was a no brainer I would used this again, however given that I now have 2 controllers this meant 2 would be needed (this requires a bit of fiddling code wise, but I’ll get onto that a little later). I also decided to upgrade the Raspberry Pi to a v3 with in built wifi and better processing speed. The only other piece I needed to fit inside was a little custom board I made with just some male PCB headers on to be used as a power distribution board so I could grab 5v/Gnd for various components, such as the monitor and some 5v LED’s in some of the buttons.

After a bit of jiggery pokery, I found a nice layout for everything and proceeded to drill some holes in the base so that I could screw all the components down. To save space I decided to stack the 2 Picade PCB’s together.

With everything in place, all the wires were attached to the various boards, and a power test was run. Of course it all worked first time :)

Programming

With the case built and wired, it was now the time to bring it to life.

The latest RetroPie was downloaded and burnt to the SD card and the Pi was booted up.

The first change I needed to make was to rotate the screen as it needs to be oriented in portrait mode (the top is actually designed so you can have it in either portrait or landscape mode, but I wanted to go with the classic cocktail arcade portrait mode). To do this I connected to the pi and updated the boot config file by running the command:

sudo nano /boot/config.txt

And then added/updated the display_rotate option as follows:

display_rotate=3

With that saved and the system rebooted, the display was now running in portrait mode. The next thing to configure was the Picade boards. By default, these come with a firmware that makes them act as a keyboard, which normally works fine, but when you are connecting 2 at the same time, RetroePie doesn’t differentiate them so there is no way to separate player 1 from player 2. Luckily, Phil at Pimoroni has been working on a new firmware that allows the boards to work as game controllers, which CAN be seen as separate controllers.

Before you can use the new firmware though, you’ll need to flash it to the boards. The easiest way to do this is from the pi itself.

Start by cloning the firmware repo:

git clone https://github.com/pimoroni/Picade-Sketch.git
cd Picade-Sketch/update

Now, with just 1 of the Picade boards attached, run the following command:

./update picade_2016.hex

Disconnect the Picade board, and do the same for the second board.

With the firmware flashed, we can now configure them as game controllers. To do this, you’ll need to connect to them over serial. I did this by connecting the board to my PC, and used Putty in serial mode, however you should be able to do this using Arduino’s serial monitor if you like. Just make sure you connect to the right COM port, and at baud rate 9600. With a connection made, configuring it as a game controller is as simple as typing the letter ‘g’. This will apply a default game controller config, however this will also replace the volume and esc/enter keys with alternative keys, but we want to keep these as they were with the keyboard setup. Luckily you can map these back by running the following commands:

b 12 176
b 13 177
b 14 250
b 15 251

With the controller configured, type ‘s’ to save the configuration to the Picade boards EPROM, and then repeat for the second one.

With the Picade boards configured as game controllers, you can now map them in RetroPie by running the gamepad mapping tool in the options menu. It’s best to connect the Player 1 controller first and configure the mapping, then connect the Player 2 controller. The Raspberry Pi seems to remember which USB port the controllers are connected to, so it should keep Player 1 as Player 1 and vica versa (though I’m not entirely sure how it does this). With the controllers configured, the only thing left is to load up some ROM’s. If you are using MAME, it’s worth going into the options menu with a game loaded (press tab), and go into the DIP Settings option and see if there is a “Cabinet” option. If there is, be sure to set it to “cocktail” and it’ll automatically flip the screen when it’s Player 2’s go. You’ll need to do this for each game individually. Another thing you can do if a game isn’t ordinarily cabinet friendly (this mainly works for top-down games such as Gauntlet or Bomberman) is in the options menu, tweak the controller settings for “this game” and invert player 2’s controls so that they can essentially play the game upside down.

And with that, the arcade is complete

Conclusion

All in all I think the cabinet came out awesome (I actually think it’s the best thing I’ve ever built). Some of the nice design touches I’m really happy with are using some large light up arcade buttons with a custom “coin slot” insert for the coin buttons, and the top decal printed onto acetate and cut out on the plot cutter.

Overall, it feels great to finally realize the project of building a cocktail arcade that I started so many years ago, and I can’t wait to see how well it goes down at the event.

PS. Be sure to checkout my youtube channel for some additional videos of the ROMBUS-CT in action.

UPDATE 2016-05-05

The guys at Pimoroni were kind enough to invite me onto their Bilge Tank show, so be sure to checkout episode 035 for an in depth look at the ROMBUS-CT :)

Raspberry Pi Zero USB hub mod with case

If you were lucky enough to get your hands on one of the new Raspberry Pi Zero’s, one of the first things you are likely going to want to do is hook it up to a USB hub to add things like WiFi and a keyboard and mouse. Of course you can just connect an ordinary USB hub, but there isn’t many compact solutions available just yet. There are a few methods that have been posted online so far, from hacking an off the shelf USB hub, to manufacturing a custom hub yourself. These are all great, but are either a little unpolished or require some advanced maker skills, so I thought I’d have a go myself at something that is a but more approachable by the average maker, and uses predominantly off the shelf parts. So here is what I came up with.

My approach is based on the USB hub mod by Frederick Vandenbosch but wraps it up in a bit of a neater package, and avoids some of the trickier soldering.

To create your own you’ll need a Pi Zero, a USB hub (Frederick uses a LogiLink UA0160 but you can also use a Belkin F5U404), a short Mini to Micro USB cable and a bit of wire. For the case you’ll want to download and laser cut my design files from here, and you’ll need some nylon M3 nuts and bolts (9 sets in total, at least 30mm in length).

You’ll want to copy Frederick’s instructions on disassembly, and attaching the power leads, but once you’ve done that, just use the purchased USB cable for connecting the hub to the Pi instead of wiring direct to the USB port (those connections are might small).

Once you’ve added the power lines, simply build up the case as pictured by attaching the Pi to the Pi layer first (use the nylon screw + bolts, then cut the remainder of the screw shaft off), then stack everything else together, making sure to add the centre screw (this is used to keep USB hub tightly in position) and tightening everything up and cutting screws to length.

We’re pretty sure someone will start selling a much better solution real soon, but in the meantime we hope this provides a manageable solution for the general maker right now that also looks pretty nice sat on your desk.

Rombus3000 - A Raspberry Pi mini arcade machine

Like many makers, a mame arcade machine has been on my list of things to build for quite a while. Recently though I had the pleasure of catching up with the Pimoroni guys and got to check out their PiCade arcade machine they launched on Kickstarter a few months back. Needless to say, playing around with the PiCade made my urge to build an arcade machine bubble back to the surface. I toyed with just buying one of the PiCade kits, which really are exceptional, but that’s not really my style as I tend to like to hack / re-purpose old technology, so instead I decided to modify an old 80’s desktop computer game instead.

The game itself was an old Grandstand Scramble desktop arcade machine which I stripped bare and mounted a Raspberry Pi 2 with a 5” HDMI TFT screen inside along side a PiCade controller board (available to buy seperately) to provide the control inputs needed aswell as an audio amplifier. The chasis was modified to accept additional buttons around the back and sides, and a custom controller panel was designed and laser cut to hold a miniature joystick and more buttons, and was mounted to the front.

For sound, a 4 ohm speaker was mounted in the old battery compartment and then everything was connected up using spade connectors and attached to the appropriate ports on the PiCade board via screw terminal blocks. The PiCade board connects to the Raspberry Pi via a short flexible micro USB cable, as well as a short AUX cable for the audio input. The original barrel jack was then modified by attaching a female USB connector on the end of the original wires and connected to the Raspberry Pi by another short flexible micro USB cable to provide power.

As a couple of added extras, WiFi and wireless keyboard dongles were attached to allow for internet access / keyboard usage without the need to open the chassis, and for the final touches, a custom decal was designed and printed on a brushed aluminium sticker as a nod back to the original Grandstand Scramble decal.

With the actual build itself complete, the final bit was to install and configure the Retropie software and upload a few ROMs and the gaming fun could now begin.

All in all, this was actually a pretty quick build which was mainly due to how easy it was to bolt everything together, from the TFT screen to the PiCade controller board, and the simplicity of Retropie. In less than a weeks hacking I now have a one of kind, retro arcade machine, which I’m pretty pleased with (if I do say so myself).

If you are looking at building your own arcade machine then, this is definitely a setup I would recommend, and for those not so comfortable hacking their own machine together, the PiCade kit uses essentially the same setup in a more flat-pack setup.

Whichever route you take, I’m certain you’ll end up with a great little arcade rig.

Happy gaming!

Vectorise all the things

Lately I’ve been working on some educational kits that I’m hoping to release soon. One important element for me is to be able to brand the products up so people know the kits are authentic circuitbeard. Originally I was just going to raster etch them, however this takes way too much time, so today I spent a bit of time creating vector versions of my logos to speed things up.

Laser cut logos

With the new vector versions, it now takes just seconds to brand an item, rather than minutes. It may not sound like much, but when you are talking about creating lots of kits, every saving is a worth while saving (I’ve been learning this lesson a lot lately).

Spark Core Cheat Sheet

Having recently been working on a IoT workshop based around the Spark Core from Spark Devices (more on this later), I really wanted a nice and simple way for the attendees to have instant access to all the core commands the Spark is capable of. There are already a plethora of cheat sheets available for various other platforms, however with the Spark Core being so new, there wasn’t anything out there yet, so I thought I’d go ahead an make one myself.

Here then is my cheat sheet for the Spark Core. I hope it comes in handy for people (and do let me know if you see any errors in it).

Spark Core Cheat Sheet