[Tim Hunkin], builder extraordinaire and host of The Secret Life of Machines is a bit frustrated with the current economic climate and decided to take out his frustrations with a game of Whac-A-Banker.

[Tim]‘s version of the classic Whac-A-Mole game uses tiny air cylinders to actuate five banker figurines up and down. The figures were cast with polyurethane and are reportedly holding up well. The cabinet is really interesting. When the game isn’t being played, a really boring front panel is displayed. After inserting a few coins, the panel drops into the machine to show the fun and exciting scoreboard.

If you’re ever around Suffolk, England, you can check out the Whac-A-Banker and a lot of other [Tim Hunkin] creations at the Southwold Pier. Thanks [John] for sending this one in. Yes, we did get The Secret Life of Machines in the states on the Discovery Channel, but it has been replaced with shows about trucking. Here’s an archive of the entire series for your viewing pleasure. Kiss your evening goodbye.

[John Zitterkopf] is in the middle of restoring a vintage Sega Star Trek Captain’s Chair arcade game for the upcoming 2012 Texas Pinball festival, though one prerequisite for the show is that the game supports some sort of free play mode. At this point he doesn’t have the option of tracking down a freeplay ROM for the device, so he had to come up with a solution of his own.

He did not want to alter the machine’s operation in any significant manner, and this meant preserving the functionality of the coin chutes. To do this, he put together a small circuit that uses a pair of cascaded 555 timers to provide the machine with the proper signaling to simulate coin insertion, while still accepting coins. You might initially think that this could be easily accomplished by shorting a pair of contacts in the coin chutes, but as [John] explains, the process is a tad more complex than that.

If you have some old arcade games kicking around and are looking for a non-invasive way to make them free to play, be sure to check out his site for schematics and a complete BoM.

[Aaron's] arcade controller really makes us want to put in a button order. There aren’t any secrets hidden in his design or fabrication, but he did a remarkably clean job of putting it together.

The housing is a writing box he bought at the hardware store (but he also shows off an emtpy Xbox 360 case hosting the same control layout). It has a hinged cover which is perfect for getting at the components inside, and is also at a nice angle for your wrists during long gaming session.

An Xbox 360 controller provides the connectivity for the device. Obviously it will work with the Microsoft hardware, but all modern operating systems have methods available for interfacing with these controllers as well. In the video after the break you can see [Aaron] gut the controller, soldering wires to all of the button pads and connecting those to some terminal strips. This makes the wire organization inside quite clean. He uses crimp connectors to jumper the buttons and joy stick to the other side of the terminals. Add  a nice paint job and you’ve got a controller that will look right at home in your living room.

We’re guessing that if you ever though of buying an arcade cabinet it was only briefly, and you decided against based on the difficulties of moving and finding a place for such a large and heavy item. You could go the opposite way and build a controller for a  MAME box, but for some, there’s no replacement for the real hardware. This Christmas gift is the best of both worlds, a JAMMA box which uses traditional hardware in a more compact cabinet.

[Majtolycus'] boy friend is a sucker for a game of Battle Balls. She looked around for an original logic board and after several weeks of searching had to settle for the Japanese version of the game called Senkyu. To patch into the board she also picked up a JAMMA harness, power supply, RGB to VGA video converter, speaker, and some Happ arcade controls. The whole thing goes into a wood box which connects to a VGA monitor (or the VGA port on your HDTV).

The system is easier to store than a full-sized cabinet, and if a deal comes along, you can buy additional JAMMA logic boards to play.

[Thanks Adam]

For those of you that have a wireless keyboard laying around, you might be tempted to turn it into something else, like a wireless MAME controller. For those not familiar with it, MAME stands for “Multiple Arcade Machine Emulator” and is generally used to run older arcade games on a computer.

Encoders are available for this purpose, however, intending to save some money, and having an unused wireless keyboard, I decided to try to make one myself.  As far as I know there are no wireless encoders available for this purpose, so that was part of the motivation for trying this.

In this post I go over my mechanical design for the cabinet as well as the electrical process of going from keyboard to MAME controller. I did eventually get the thing working, but if more than a couple buttons were pressed simultaneously, some presses were omitted. The conclusion I eventually came to was that it was better to use an encoder to control everything. Not wireless, but much more reliable. If I absolutely needed a wireless controller in the future, I would think modding an actual wireless controller (or two) in a similar manner would have worked better for my purposes.

Like many Xbox 360s out there, [Aaron’s] console succumbed to the dreaded three red lights of death. Since it seemed to be unrepairable, there wasn’t a lot that could be done with it other than throw it out. Rather than be wasteful however, [Aaron] thought of a great way to reuse the console’s outer shell.

He’s a big fan of fighting games, and as everyone knows, this genre is best played with an arcade-style controller. The 360’s shell seemed to be just about the right size, so he gutted it and got busy constructing his own arcade controller. With the console cleared out, he installed all of his arcade bits, wiring them to a stripped third-party Xbox controller.

He installed a four port USB hub to the front of the console, enabling use of the 360’s USB ports, and rewired the power button to trigger the Xbox Guide button. A shiny coat of paint later, and he was ready to play.

Keep reading to see a short video of [Aaron's] arcade stick in action, and check out the picture gallery he put together of the controller’s construction.

[Alex] wanted to play video games with an arcade stick and buttons, but got sticker shock after seeing the price of commercially available controllers that connect to a computer via USB. He set out to build his own and ended up with the controller-in-a box that you see above.

At first he tried using an mbed microcontroller board but was unhappy with the latency built into the system that detected a button press, sent it via USB as a keyboard press, which was then interpreted as input by the game. He ditched the microcontroller completely and picked up a couple of 4021 parallel-to-serial shift registers. He had previously used this method to make his own SNES controller. The SNES uses two 8-bit shift registers to generate an 16-bit serial packet to send to the console. [Alex's] reused that system, adding an SNES controller plug to his arcade box, and using the SNES to USB converter he already had to connect to the computer. Now he’s got a portable controller for the cost of three buttons, the stick, and two IC’s.

He explains the project himself in the clip after the break.

[Luke] wanted an arcade-style controller that he could use for some gaming at home. He decided to use a portable game emulator as a base and then added his own joystick and buttons along with a custom case.

The donor hardware is a Dingo A320. It’s a nice little handheld with a 2.8″ screen, and plenty of potential to emulate games like Donkey Kong seen above, or to play homebrew. It’s even been the target of some RAM upgrades we looked in on in the past. The best part for [Luke's] project is that it includes a video out port.

In the clip after the break you can see that [Luke] now has a compact controller with a huge arcade joystick, four buttons on the top surface, and the rest of the controls all around the edges of the enclosure. The video out option is selected in the menu system, so he preserved the original LCD for use during configuration.

While many people would be satisfied leaving a MAME console on their desk, others take the time to put their MAME creations in a nice, authentic arcade cabinet. Some people like [Simon Jansen] take the craft to a whole new level, crafting a TARDIS from the ground up in order to house a MAME console.

It all started with a computer that had no real purpose. [Simon] decided it would be great to use as a MAME console, so he started brainstorming ideas for an enclosure. As he tells it, he was staring out a window looking for inspiration when his eye caught a giant billboard for [Dr. Who], complete with a TARDIS. The rest was history.

The MAME cabinet is about 3/4 the size of an on-set TARDIS, and crafted mostly from MDF. Plenty of time was spent analyzing the different TARDIS designs featured on the show over the years, paying special attention to even the smallest of details. Once the construction of the TARDIS was complete, [Simon] started work on the MAME portion of the project.

His MAME console was built to completely fit inside the TARDIS when closed, but it also had to take into account the box’s inward folding doors, which take up a good bit of space. The base was also made from MDF, and includes a durable white plastic panel in which the controls are mounted.

The final result is amazing – it does the TARDIS justice, and it looks like plenty of fun to play as well.

If you are a frequent reader, you are undoubtedly familiar with hacker [Sprite_tm]. He has been working with fellow members of the TkkrLab hackerspace to get things ready for their official grand opening on May 28th, and wrote in to share a project he recently completed to kick things off.

As part of their preparations, they have been stocking the joint with all sorts of hacker-friendly goodies including plenty of tools and Club Mate, as well as a vintage ‘1943’ arcade cabinet. The game is a group favorite, though every time the power is turned off, it loses all of the hard-earned high scores. [Sprite_tm] knew he could improve on the current paper-based score register, so he pulled the machine open to see what could be done.

He used an AVR to tap into the machine’s Z80 logic board, allowing him to read and write to the entirety of the game’s RAM whenever he pleased. This enabled him to keep tabs on the high scores, restoring them to memory whenever the machine is powered back on. The addition of the AVR also allowed him to add a TCP/IP interface, which is used to send high scores to Twitter whenever someone beats the previous record.

His modular bus tap can be used in all sorts of Z80-based hardware, so if you have some vintage equipment laying around, be sure to swing by his site for a more detailed look at the build process.

[Vincenzo] wanted to read some 82S129 bipolar proms, and why not, they were very common in the 1980′s arcade scene. The problem is that its kind of an odd ball part now, and typically only (even) more expensive EPROM programmers can read them. An Arduino, breadboard and some quick scripting quickly takes care of that problem with this Arcade Rom Reader.

You stick the prom in your breadboard, and wire it up to the appropriate ports and pins of the Arduino, which bit bangs the prom and returns the results though the serial connection of the Arduino. Using a terminal program on the pc side you capture the text and use a script to convert the ascii values into a binary nibble format and save as hex.

This makes it much easier for us to dump roms from old arcade boards, because you never know when you might run across an old Polybius arcade board on your next outing to the salvage or scrap yard.

Join us after the break for all the details and as always comments!

82S129 bipolar proms are very common in '80 Arcade Jamma boards. Unluckly, only more expensive EPROM programmers can read them. I used an Arduino Duemilanove to dump 82S129 contents to PC for backup use.
I used a breadboard to connect 82S129 pins to Arduino. Please follow this schematic:

Arduino pins  ------>  82S129 pin    (function)
+5v                    16              Vcc
GND                     8              GND
Digital 2               5              A0
Digital 3               6              A1
Digital 4               7              A2
Digital 5               4              A3
Digital 6               3              A4
Digital 7               2              A5
Digital 8               1              A6
Digital 9              15              A7
Digital 10             12              O1
Digital 11             11              O2
Digital 12             10              O3
Digital 13              9              O4
GND                    13              CE1
GND                    14              CE2

Here is pde program to send in Arduino:

Begin pde program
------------------------------------------------
/*
  82s129 Arduino reader
  By Vincenzo Femia (enzofemia@gmail.com)
 */
byte indirizzo=0;//"indirizzo" is Italian for "address" :-)
boolean a0=0;//address bits
boolean a1=0;
boolean a2=0;
boolean a3=0;
boolean a4=0;
boolean a5=0;
boolean a6=0;
boolean a7=0;
//
boolean o0=0;//data bits
boolean o1=0;
boolean o2=0;
boolean o3=0;
byte output=0;
void setup()
{
//pin0 & pin1 reserved for serial communication
  pinMode(2,OUTPUT);//set pins for address
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
  pinMode(10,INPUT);//set pins for data (it's a nibble)
  pinMode(11,INPUT);
  pinMode(12,INPUT);
  pinMode(13,INPUT);

}

void loop()
{

    for (indirizzo=0; indirizzo<256; indirizzo++)// from 00 to FF address
   {
    a0=bitRead(indirizzo,0);//read status bit of address...
    a1=bitRead(indirizzo,1);
    a2=bitRead(indirizzo,2);
    a3=bitRead(indirizzo,3);
    a4=bitRead(indirizzo,4);
    a5=bitRead(indirizzo,5);
    a6=bitRead(indirizzo,6);
    a7=bitRead(indirizzo,7);

    //...and set output
    if (a0==1) {digitalWrite(2,HIGH);}
    else {digitalWrite(2,LOW);}

    if (a1==1) {digitalWrite(3,HIGH);}
    else {digitalWrite(3,LOW);}

    if (a2==1) {digitalWrite(4,HIGH);}
    else {digitalWrite(4,LOW);}

    if (a3==1) {digitalWrite(5,HIGH);}
    else {digitalWrite(5,LOW);}

    if (a4==1) {digitalWrite(6,HIGH);}
    else {digitalWrite(6,LOW);}

    if (a5==1) {digitalWrite(7,HIGH);}
    else {digitalWrite(7,LOW);}

    if (a6==1) {digitalWrite(8,HIGH);}
    else {digitalWrite(8,LOW);}

    if (a7==1) {digitalWrite(9,HIGH);}
    else {digitalWrite(9,LOW);}

    //Wait so outputs can be set by 82S129
    delay (50);

    o0=digitalRead(10);//read bit from data outputs
    o1=digitalRead(11);
    o2=digitalRead(12);
    o3=digitalRead(13);
Serial.begin(9600);//Setting serial communication
//Write in binary ASCII address read and "->"
     if (a7==0) {Serial.print("0");}
     else {Serial.print("1");}
     if (a6==0) {Serial.print("0");}
     else {Serial.print("1");}
     if (a5==0) {Serial.print("0");}
     else {Serial.print("1");}
     if (a4==0) {Serial.print("0");}
     else {Serial.print("1");}
     if (a3==0) {Serial.print("0");}
     else {Serial.print("1");}
     if (a2==0) {Serial.print("0");}
     else {Serial.print("1");}
     if (a1==0) {Serial.print("0");}
     else {Serial.print("1");}
     if (a0==0) {Serial.print("0 -> ");}
     else {Serial.print("1 -> ");}   

//Write in binary ASCII output nibble

    if (o3==0) {Serial.print("0");}
      else {Serial.print("1");}

    if (o2==0) {Serial.print("0");}
      else {Serial.print("1");}

    if (o1==0) {Serial.print("0");}
      else {Serial.print("1");}

    if (o0==0) {Serial.println("0");}
      else {Serial.println("1");}

    if (indirizzo==255) {Serial.println("ROM has been read");}
    Serial.end();
    }
}
-----------------------------------------
END pde program



Using Minicom or similar program you can log serial data on PC.
Using an editor now correct log file so that first line is:
00000000 -> XXXX

and last line is:
11111111 -> XXXX

Please verify that file contains only 1 cicle of reads (256 lines).

Now we have to convert this ASCII .txt file in binary file.
Since I use Linux I write in Gambas programming language (http://gambas.sourceforge.net/) a little program to do this conversion.
However Windows user can port it in Visual Basic or other languages.
Simply it read nibble bits, build nibble value (00-0F), write binary value in output .hex file.
Here's the source:

Begin of Gambas program
--------------------------------------------------
PUBLIC SUB Main()
DIM ingresso AS Stream
DIM uscita AS Stream
DIM stringa AS String
DIM o0 AS String
DIM o1 AS String
DIM o2 AS String
DIM o3 AS String
DIM valore AS Byte
ingresso = OPEN "/home/enzo/temp/datafile.txt" FOR INPUT
uscita = OPEN "/home/enzo/temp/datafile.hex" FOR OUTPUT CREATE
WHILE NOT Eof(ingresso)
LINE INPUT #ingresso, stringa
o3 = Mid$(stringa, 13, 1)
o2 = Mid$(stringa, 14, 1)
o1 = Mid$(stringa, 15, 1)
o0 = Mid$(stringa, 16, 1)
valore = 1 * Val(o0) + 2 * Val(o1) + 4 * Val(o2) + 8 * Val(o3)
PRINT #uscita, Chr$(valore);
WEND
CLOSE ingresso
CLOSE uscita
END
-------------------------------------------------------------
End of Gambas program



For questions can contact me:
Vincenzo Femia
enzofemia@gmail.com
Reggio Calabria, ITALY.

[Ed] had a netbook he no longer needed and decided to make it into a mini MAME cabinet for some of his family members. MAME cabinets are pretty plentiful, but this one was so nicely done, we wanted to share it.

He removed the monitor from an EeePC 901 in order to get some precise measurements, then went about crafting a mini cabinet from MDF. The whole thing was wrapped in sticky label paper adorned with old-school Galaga graphics, then covered in plexiglass for a nice sleek look that also protects the artwork.

He used an iPac 2 controller board to wire up all of the buttons and joystick to the netbook, opting to solder the controller’s wires directly to the USB header on the eeePC’s motherboard. A power switch was added up on top for easy operation, and the cabinet was sealed shut, though the back does open easily in the event that maintenance is required. The system is managed using the Maximus Arcade front end for MAME, which [Ed] claims is incredibly easy.

If you are interested in making your own MAME cabinet, check out some of the other MAME-based projects we have featured in the past, and don’t miss the video below of [Ed's] cabinet in action.

MIDI controllers can be relatively expensive depending on feature sets and requirements, so Instructables user [fraganator] went about building one on his own for just under $100. He originally wanted to replicate a commercially available MIDI controller, which used arcade buttons in lieu of the more common rubberized buttons, since they are large and have a better feel when pressed. Once he drew up plans for his MIDI clone, he realized he wanted more features in his controller than were available in the commercial version, so he started revising.

His final plan included three rows of four arcade buttons as well as four rotary and two sliding potentiometers. All of the components were mounted in a small keyboard enclosure, then wired to an Arduino clone, which manages all of the controller’s functions. The controller is connected to a PC via USB and can perform any number of operations once the buttons are mapped in MIDI-compatible software.

There are no videos of the controller in action just yet, though [fraganator] says one is forthcoming.

[Daniel] is making a mini arcade cabinet with an SNES housed inside. He wanted to build an arcade controller for it and chose to construct something from scratch instead of destroying an original piece of hardware. We can almost feel you guys sighing with relief at that one. He sent us some nice photos of his build and pointed out that he’s using one of the Evilmadscientist AVR boards housing an ATtiny2313. The arcade buttons are readily available at sparkfun. The source code for this project is available after the break.

/**
 * Emulate a 16-bit input shift register with integrated pullup resistors.
 * In other words, a SNES controller.
 *
 * Daniel Holth
 */

#include
#include
#include

ISR(SIG_PIN_CHANGE)
{
 /* Pin change interrupt for latch */
 USIDR = PINA | (PIND & 0b01111100) | (PINB << 7);
 USISR = (1 << USIOIF); // clear overflow bit, set counter to 0
 USICR |= (1 << USIOIE); // enable overflow interrupt
}

ISR(SIG_USI_OVERFLOW)
{
 /* USI finished shifting out 8 bits... */
 USIDR = (PINB << 3) | 0x0f;
 USISR |= (1 << USIOIF); // clear overflow bit
 USICR &= (0xff ^ (1 << USIOIE)); // disable overflow interrupt
 // TODO: output should be low after all 16 bits have been read out,
 // according to <a href="http://www.raphnet.net/electronique/arcade_control/arcade_control_en.php" target="_blank">http://www.raphnet.net/electronique/arcade_control/arcade_control_en.php</a>
}

int main() {

 USIDR = 0xff;
 USICR = (1 &lt;&lt; USIWM0) | (1 &lt;&lt; USICS1); // 3-wire mode; external, positive edge.
 // USICR = (1&lt;&lt;USIWM0)|(1&lt;&lt;USICS0)|(1&lt;&lt;USICS1); // negative edge

 DDRA = 0;
 DDRD = 0;
 DDRB = 1 &lt;&lt; 6; // MISO

 // Enable pullups
 PORTA = 0x3;
 PORTB = 0b11111;
 PORTD = 0xfc;

 // USIDR is shifted out MSB first.

 // pin change interrupt for latch pin
 PCMSK = (1 &lt;&lt; 5);
 GIMSK |= (1 &lt;&lt; PCIE);

 sei();

 while (1) {
 sleep_mode();
 }
}

[Bomber Punk] built his own arcade cabinet, but you won’t find any MAME games here. He made the enclosure to house a Meggy Jr. 8×8 pixel graphics game console. Proper coin-op buttons and a joystick replace the stock tactile switches that come with the kit. [Bomber Punk] has also added a lighted coin slot. A three-cell battery pack powers the beast, with a programming port to one side so that different games can be loaded from a PC. We’d like to see a processor upgrade that would allow multiple games to be stored on a stand-alone system.

Take a look at the video after the break, it’ll bring a smile to your face.

[via Evil Mad Scientist Laboratories]