Introduction: Power Glove 20th Anniversary Edition

About: I make video games. I have a BS in Mathematics and a PhD in Astrophysics.

I'm a video game programmer by day, and I love playing with custom input peripherals. I decided to mod a Nintendo Power Glove to work with some of the games I've worked on. It replaces the original Power Glove's ultrasonic sensors with an accelerometer, the microcontroller with an open-source Arduino, and the wired connection with Bluetooth. I'll show you how to mod your own Power Glove, so you can make it into something more than just a crappy controller for your NES!

Make the future you remember from your childhood, and recycle that glove that was just gathering dust!

I encourage you to do three things before starting:
1) Download the schematic, Arduino code, and sample reader code.
2) Download (or have on hand) the video I've made to go along with this Instructable. I explain some steps in more detail and there are additional visuals that complement the pictures here.
3) Watch the entire video and read this entire Instructable before starting! If there's conflicting information, this guide takes precedence.

For all download links to the video, code, etc, check my website.

Step 1: Design and Parts

I'll start with the goals I had in mind when designing the project and picking parts:
1) Retain as much functionality from the original glove as possible. Sure, you could just plug in the guts from a wiimote, but those bend sensors are so fun!
2) Fit everything in the existing housings. Part of the Power Glove's awesomeness is its ludicrous, sleek, retro-futuristic look. I didn't want to spoil that with wires and gubbins sticking all out.
3) Make it wireless, and robust. No one wants to fake-punch if they're afraid of ripping their computer off their desk or breaking the device.
4) Reduce power consumption as much as possible. I hate wasting and/or constantly recharging batteries, so I picked components (like the accelerometer) that advertised low power consumption.
5) Reduce cost as much as possible, while retaining ease of creation. I've opted to use components sold with breakout boards instead of making a custom board, and I've cannibalized parts from either the original Power Glove or commonplace items (like old computers) where I can.

Here's the full list of parts I used to mod my Power Glove:

Original Nintendo Power Glove -- $40 (ebay)
Arduino Pro Mini 3.3V (8MHz) -- $18.95 (Sparkfun)
ADXL330 3-axis accelerometer with breakout board -- $34.95 (Sparkfun)
CD74HC4067 Analog/Digital MUX with breakout board -- $4.95 (Sparkfun)
BlueSMiRF Silver Bluetooth communications module -- $49.95 (Sparkfun)

Battery clip and battery. I used a rechargeable 3.7V 1100mAh battery (Sparkfun), but anything over 3.3V should work. 2x AA is insufficient.
100k ohm resistor (Brown-Black-Yellow-Gold)
Old computer ribbon cables (optional) for creating your own custom ribbon cables
Berg-style connectors (optional) for making removable sensor connectors (cannibalize these from an old PC)
Right-angle pin headers (optional) for making removable sensor connectors

You'll also need the following tools:

Soldering iron
Utility knife
Wire strippers
Jeweler's saw (or any other tool capable of making precision circuit board cuts)
Prototyping breadboard
Programming interface for the Arduino Pro Mini (such as Sparkfun's USB to Serial Breakout Board)
Dremel rotary tool (optional, but very useful)

Step 2: Creating Custom Ribbon Cables

There are a number of areas in this project where multiple wires are bundled together. Specifically, connecting the control pad wrist board to the Arduino, connecting the Bluetooth module to the Arduino, and connecting the multiplexer outputs to the palm board. I found it useful to use ribbon cables for each of these connections. Here's a way to make ribbon cables out of old computer cables. Nobody uses floppy drives anymore, so they're a plentiful source to cannibalize from.

To make a custom ribbon cable, simply take a ribbon cable from an old floppy or CD drive, cut it to the proper length, and carefully use a razor blade to cut the proper number of wires from the original ribbon. These are a very nice, easy way to keep wires from getting tangled and confused inside the housings.

Step 3: Disassembly

First, carefully disassemble the original Power Glove. There are four screws for the wrist housing, found on its underside, and four screws for the palm housing. Remove the interior screws holding the wrist and palm boards in place, and remove the boards.

Using sidecuts, cut all the wires that attach to the wrist board, cutting as close to the board as possible. Discard the cable that originally connected to the game console. Cut all wires from the main wrist-palm bundle where they attach to the palm board, except the common output from the bend sensors (light blue in my model). DO NOT cut the wires that run from the palm board into the fingers. These connect to the bend sensors, and we'll keep them intact.

Desolder the wires that you cut from the palm board, as we'll be using these connections to connect the multiplexer outputs to the palm board.

Step 4: Cut the Original Boards

Mark the original palm and wrist boards where you will cut them. On the palm board, ensure that your cut keeps intact all of the traces related to the bend sensors. On the wrist board, make sure that the cut keeps intact all of the traces that connect to the contacts for the D-Pad, Start, Select, A, and B buttons, and leaves ample room on these traces to solder new leads.

I've included photos of these boards with the cuts marked in pencil -- ensure you know where to make the cuts before you start cutting!

Now, cut the boards using a jeweler's saw, or your tool of choice. Remember that the cuts are small and precise, so if you aren't completely confident in the steadiness of your hands, it's probably better to use the saw than a power tool.

Step 5: Attach Leads to the Control Pad Board

Now we'll attach wires to the Control Pad section that we cut from the wrist board.

Identify each of the relevant traces on the board. There is a common ground and one each for Up, Down, Left, Right, B, A, Start, and Select -- 9 traces total. For each trace, use the Dremel to drill a small hole next to the trace, near the edge of the board. Ideally the holes should just touch the edge of each trace. Use a razor blade to etch off some of each trace's protective coating near the holes, exposing the copper trace. Finally, insert a wire through each hole and solder it to the exposed trace.

I suggest using the aforementioned ribbon cables for these connections -- one ribbon cable for each half of the board, and the common ground as a single wire by itself. Leave the cables long for now, you can shorten them later once you have an idea of how everything will fit together.

Step 6: Insert and Connect the Accelerometer

Place the accelerometer in the palm housing, orienting it so that its axes align roughly with the direction of the fingers. I placed it with X right, Y forward, and Z down, though these can be re-oriented in software later.

I suggest Dremeling a single hole in the unused area of the breakout board, so you can insert a screw through it. Use the screw holes in the original palm board to find the proper sized bit. Otherwise, you can use double-sided adhesive foam after you solder the leads to the board.

Solder the VCC, ground, and 3 axes of the accelerometer to 5 of the wires in the main bundle that connects the palm housing to the wrist housing. I used the following colors:
Red - VCC
Black - GND
Yellow - X
Green - Y
Dark Blue - Z

If you use adhesive foam to secure the boards, DO NOT attach it yet! We still have two wires to solder to this board.

Step 7: Insert and Connect the Analog Multiplexer

Place the MUX breakout board in the palm housing, testing it for fit. You may need to trim the plastic palm housing somewhat.

Solder wires to short the S3 and S2 pins to the GND pin of the multiplexer. We only plan to use the first four outputs (for the four bend sensors), so we want the multiplexer's upper two select bits to always be 0.

Also short the SIG pin to the VCC pin. We'll use the same 3.3V signal to run the multiplexer and as the input voltage for the bend sensors.

Connect the first four multiplexer outputs (C0, C1, C2, C3) to the inputs for the four bend sensors on the cut palm board. I suggest using a ribbon cable for this, and try to maintain a sensible order -- the traces on the palm board are labeled with the fingers that they connect to. I used:
C0 -- Thumb ("T" on palm board)
C1 -- Index Finger ("I" on palm board)
C2 -- Middle Finger ("M" on palm board)
C3 -- Ring Finger ("R" on palm board)

Connect the remaining two select pins (S0 and S1) to two of the wires in the bundle that connects the palm housing to the wrist housing. I used:
S0 -- White
S1 -- Peach

Finally, connect the VCC and GND pins on the multiplexer to the VDD and GND pins on the accelerometer.

Step 8: Close the Palm Housing

Replace all screws that held the original palm board in -- even if they aren't securing a board anymore. They help secure the palm housing to the glove. Replace the palm housing cover, ensuring that the main palm-wrist wire bundle is properly seated. Replace the four screws that hold the palm housing cover in place.

Step 9: Solder Leads to the Bluetooth Module

Solder a length of wire between the CTS-I and RTS-O pins of the BlueSMiRF to short them. These are used for hardware flow control, which we don't need.

Cut four wires (or better yet, a ribbon cable) and solder them to the VCC, GND, TX-O and RX-I pins of the BlueSMiRF. Again, you can leave these long and cut them to size later, when you get an idea for how much space you are working with.

Step 10: Test the Sensors and Buttons

Before you start soldering things to the Arduino, now is a good time to test that all the sensors and buttons are working. It's a pain but you'll thank yourself later.

Download my Arduino program (see link in intro) and make sure the pin definitions match what you're using. If you're unsure about which pins to connect anything to, take a look at the schematic (again linked in the intro).

First, prepare your board. If you have an Arduino Diecimilla or Duemilanove, these work great for prototyping. Otherwise, you can solder some test leads to the Arduino Pro Mini.

If you test using a 5V board (Diecimilla, Duemilanove, etc), connect the 3.3V pin to your breadboard's + rail. Then connect the + rail to the AREF pin on the Arduino, and change the line analogReference(DEFAULT) to analogReference(EXTERNAL) within the Arduino code.

If you test using a 3.3V board (Arduino Pro, Pro Mini, etc), connect any VCC pin to your breadboard's + rail.

Connect the GND pin on your test Arduino to the - rail on your breadboard.

Connect all the sensors in the palm to a prototyping breadboard. If you've been using the same colors as I, your main wire bundle should be:
Red: VCC
Black: GND
White: Bend Select 0
Peach: Bend Select 1
Yellow: Accel X
Green: Accel Y
Dk. Blue: Accel Z
Lt. Blue: Bend Output
Grey, Pink, Brown, Orange: Unused

Connect the Red wire to the breadboard's + rail and the Black wire to the breadboard's - rail.
Connect the Yellow, Green, and Dk. Blue wires to analog inputs 0, 1, and 2 on the Arduino.

Connect the White wire to digital pin 12, and the Peach wire to digital pin 13.

Connect the 100k ohm resistor from the bend sensor output (Lt. Blue) to ground (- rail). Connect this junction (the Lt. Blue wire) to analog input 3 on the Arduino.

On the control pad assembly, connect the common ground wire to GND on the Arduino. Connect the Up, Down, Left, Right, B, A, Start, and Select wires to digital pins 2, 3, 4, 5, 6, 7, 8, and 9, respectively.

Upload the program to the Arduino. If using the Pro Mini, you'll need to use your USB-FTDI programmer. Check that you're getting good data by opening the Serial Monitor in the Arduino software (select the USB serial port under Tools -> Serial Port, 9600 baud). Type A into the box and press send -- you should see 8 numbers separated by tabs, which will change as you move the sensors around.

If everything seems to be working, disconnect power and connect the BlueSMiRF. Connect VCC to the + rail, GND to the - rail, RX-I to Arduino digital pin 0 (TX), and TX-O to Arduino digital pin 1 (RX). Disconnect your programmer or USB and connect an external power supply. Swap the appropriate jumper if you have an older Arduino board.

If you haven't yet paired your BlueSMiRF to the computer, do that now and set up a serial port. My BlueSMiRF identified as "Sparkfun-BT" by default.

Now select the serial port you just set up in the Arduino software (Tools -> Serial Port) and open the serial monitor. Again, type A into the box and press send. Verify that you've got a good data stream.

Step 11: Prepare the Wrist Housing

The original Power Glove had 12 programming buttons at the top of the wrist. I didn't have room (in the wrist housing or pins on the Arduino) to use these. However, since we cut the board out from behind them, they don't have anything to press against now, except the internal electronics, oh no!

To prevent this, find a piece of strong, thin cardstock and cut it to cover the button backs. A postcard or Off-Road Velociraptor Safari promotional card should work. Punch three small holes where the screws went through the original PCB. Screw the cardstock in, as in the photo.

The control pad board will also work slightly better if it has some shims to press against. Cut two small pieces of layered cardstock or artboard and place them in the bottom corners of the wrist housing, as in the photo.

Cut a notch into the bottom half of the wrist housing's plastic, between the holes for the main wire bundle and the cable that connected to the console. Size this to fit your battery clip. I've included a photo of mine.

Step 12: Prepare the Arduino Pro Mini

I suggest creating connectors for the sensors rather than just soldering them to the Arduino.

Cut 9-pin right-angle header. There's not much vertical clearance in the wrist housing, so if they're very tall, you'll want to push the pins through somewhat (see image). Solder this header to pins GND, 2, 3, 4, 5, 6, 7, 8, 9, 10 on the Arduino Pro Mini.

Cut a second 9-pin right-angle header, again pushing the pins through if needed. Place the 100k ohm resistor's leads in the GND and A3 pins on the other side of the Mini, as in the photo. Now, push the 9-pin header into pins GND, RST, VCC, A3, A2, A1, A0, 13, and 12 and solder it into place. It will be a tight fit due to the resistor, but shouldn't give too much trouble.

If you're using an external battery clip, such as a 9V, knot the clip's wires about a centimeter from the clip. This will ensure that yanking the clip pulls only the knot and not the solder joints. Solder the battery clip with its positive lead into the RAW pin, and its negative lead into one of the GND pins (I used BLK, which is also connected to the board's ground plane).

If you haven't yet uploaded the program to the Mini, do so now. Make sure that you've changed back to analogReference(DEFAULT) and changed any pin definitions back to what they were.

Test the whole thing again with USB before soldering in the BlueSMiRF. I know, you don't want to. Do it anyway. You'll thank yourself later.

If everything is working, cut the BlueSMiRF's ribbon cable to length (see photos) and solder the wires into the top of the Mini. VCC to VCC, GND to GND, RX-I to TX(0) and TX-O to RX(1).

Use sidecuts to cut all the leads and header pins as flush as possible to the back of the board.

Step 13: Add Connectors to the Sensor and Button Wires

Cut the ribbon cables and wires from the Control Pad Board to size now. You should be able to get a decent idea of how long they need to be now. Consult the photos if needed. Don't make them too long or the inside of the housing will end up crowded. Don't make them too short or you'll have to cut new ones!

Don't cut the wires from the main wrist-palm bundle any shorter than they are already.

Insert the wires for each of the headers into appropriately-sized Berg connectors using a crimp tool and (optionally) solder. I grouped mine as follows (see photos as well):

Side 1 (Control Pad):
Up, Down, Left, Right
B, A, Start, Select

Side 2 (Main Palm-Wrist Wire Bundle):
Black, [space], Red, Lt. Blue
Dk. Blue, Green, Yellow
Peach, White

Step 14: Insert the Arduino Pro Mini and BlueSMiRF Into the Wrist Housing

The BlueSMiRF fits snugly into the channel in the back of the wrist housing. Secure it in place with double-sided tape. Set the battery clip so it's poking out of the notch we cut for it, with the knot in its wires on the inside of the housing.

Attach thin foam or other non-conductive material to the bottom of the Mini with tape or adhesive. Let the Mini float freely, but position it roughly where it will go (as in the photos).

Step 15: Connect the Sensors and Buttons to the Arduino

Place the bottom of the wrist housing back on the wrist of the glove. Connect the sensors via the main wire bundle, clipping the Berg connectors into place. Connect the Control Pad buttons using their Berg connectors on the other side of the Arduino.

Test-fit the pieces of the wrist housing together. It will be a tight fit, but everything should fit into place. If it doesn't, re-tinker the connector placements and cable routing until it does.

Step 16: Close the Wrist Housing

Once the two halves of the wrist housing fit together snugly, connect them, ensuring that the main wire bundle is seated properly. Replace the strap anchor on the underside of the glove and screw the wrist housing back together.

Step 17: Secure and Connect the Battery (Rechargable Lithium-Polymer)

If you're using a rechargeable Lithium-Polymer battery, first cut a small slit into the glove's rubber, between the battery clip and the existing slit for the velcro strap. Wedge the battery into the plastic strap anchor on the glove's underside, with the battery leads sticking out through the slit you cut. If you used the same battery I did, it should fit snugly without the need for additional anchoring.

Connect the battery to the battery clip. Remember to unclip it when you're not using it!

Step 18: Secure the Battery (External Batteries, Such As 9V)

If you used a large external battery like a 9V, it will be flopping around freely right now. You can solve this however you like, but I used a loop of velcro to hold the battery in place. This lets me easily remove it when I need to replace it, while holding it securely.

Cut a slit the width of your velcro strap into the rubber glove just above the existing slit for the wrist strap. Loop your velcro strap through this, and secure the battery on the outside of the glove (see photos).

Step 19: Write Some Games to Use Your New and Improved Power Glove!

That's it! You now have a Power Glove that sends accelerometer orientation, bend values for 4 fingers, and a bitmask for pressed buttons via Bluetooth. Since you have a serial port set up, you can read these in with any language that has serial access. Remember that to start receiving data, you have to send the string A first.

For making games, I'd seriously recommend Unity3D. If it weren't for this one tool and how slick and easy it makes the process, I wouldn't be making games professionally or as a hobby right now.

In the downloads I linked in the intro, I've included a Java program that reads the serial data and spits it out as a text file. This way, if you tech doesn't support serial I/O but can read a text file, you can do that instead.

I've also included two sample Unity3D scripts (written in Unity Javascript, an ActionScript-alike) that are the input manager I use for the Power Glove. They show a simple way to use the raw data to get more human-usable information.

Next step: Off-Road Velociraptor Safari with the Power Glove?

Epilog Challenge

Participated in the
Epilog Challenge