For no practical purpose at all, I wanted to see if I could make a screwdriver into a car key. What fun it would be to impersonate the look of a stolen car with a screwdriver jammed into the ignition! And maybe I could empty my glove box all over the seat so it looks like I was scrounging for spare change and prescription drugs too!

Read on to make your own.

Hit the thrift store or a nearby garage sale and get a beat up old screwdriver with a shaft about the same thickness as the width of your car key. Don’t get a new screwdriver; you want one with some character, one that looks like it might have stabbed someone. Cut the shaft down to about an inch long.

Cut a slot 1/4″ – 3/8″ deep in the end of the shaft. This is not a precision job.

Round the end on a grinder or with a file. This will give a nice, smooth transition between the key and the screwdriver shaft.

Take your car key out to the car, put it in the ignition, and mark how far in it needs to go to start the car. Add the depth of the slot you cut in the shaft to that mark, then cut. Oh, and use a spare key for this. Not your one-and-only original.

The key needs to fit into the slot you cut in the screwdriver, so unless you gut a lucky match between your key and your kerf you can either widen the slot or narrow the key. I chose the latter and thinned it on a belt sander. Don’t take off to much because you want the key to fit tightly.

Put some flux on it the key, then tap it into the slot on the screwdriver shaft. Be sure that everything is lined up. With a torch, silver solder the key to the screwdriver.

With a file or grinder, taper the edges of the key to meet the screwdriver shaft. Smooth it with some sandpaper and clean it with a wire wheel in a Dremel.

All done! Now cruise around like the grand theft auto thug you are!

If you make your own, take a picture and email it to me (nathan@ the domain name of this site) and I’ll share it here if you’re willing. Bonus points if the picture includes police in the background ordering you out of your car!

NOTE:  Having this much weight and leverage hanging out of your ignition is not going to be good for it. One bump and your tumblers are toast. It also won’t work if you’ve got a modern car with a chip in the key. Consider yourself warned.

[May 6, 2013] Haha Bird reader Richie emailed pictures of the screwdriver key he made. Nice work!

So why not do what grocery stores and fast food restaurants figured out long ago and automate the change dispensing so any middle-school dropout can do it? I present to you the Change-O-Matic.

I picked up a used change dispensing machine on eBay, and after some trouble with the seller sending Australian coin canisters instead of US, I got it working. The model is a Telequip Transact 2+ CE. I can’t vouch for how well my system would work with other machines in their lineup, but I would assume some compatibility.

I found some basic documentation online about what connection settings it expected (9600 baud, 7 data, 1 stop bit, even parity), then with a serial monitoring program and a copy of the test & configuration software I was able to see what was being sent to and from the machine.

First to be sent are some control codes to reset the machine and tell it a change request is coming. Then the change amount is sent along with a checksum. I didn’t know how the checksum was calculated, but with only 99 options it was easy to record them all with the serial monitoring program and store them.

To drive it I used an Arduino, a serial shield, an LCD display, a numeric keypad, and some buttons and switches, and built it all into a Radio Shack project box that I milled some openings into. Paint and custom waterslide decals turned it into the Change-O-Matic. The outside looks a lot better than the mess I crammed inside. I plan on improving the design later with a custom PCB combining the microcontroller and serial driver, a serial port on the outside of the box instead of just a hole cut for the cord to pass through, and a rechargeable battery pack. I think I can get it down to about half the size.

I programmed two modes into Change-O-Matic: Oscar mode, where you enter the number of winners and the number of players and it calculates and dispenses the take for the winners, and Change mode, where you simply enter the amount of change and the number of times dispensed (0.35 x 3, for example). A two second delay between each batch of coins allows time to scoop out the change before the next comes.

At the party everything worked as planned, and change was dispensed quickly and accurately all night long. I wasn’t able to find a middle-school dropout to run it, but a friend’s elementary student took the job instead, freeing me for more drinking and yelling.

I’m not going to post the code for the entire project, but only the basics required for the interface with the change machine. I couldn’t find anyone else that had done this work with the change machine; everything else you can find better examples for online.

Interestingly, there doesn’t seem to be any kind of authentication between the change machine and whatever’s sending it commands. If you plugged this into the dispenser at the grocery store I think it would start spitting out the change you asked for. Standing there for 5 suspicious minutes while the machine dispenses $100 in loose change is not a risk/reward ratio that many people would find worthwhile, though.

Here’s a quick video of it in action, though I use the term “action” quite loosely. You’ll find the code immediately below that.

Change-O-Matic from HaHaBird on Vimeo.

#include "Wire.h"
//============================================
//            Inits
//============================================

// control codes used to communicate with the dispenser
byte STX=0x02;
byte ETX=0x03;
byte EOT=0x04;
byte ENQ=0x05;

// array of checksums, their position in the list 
// relating to the change amount requested
// so to get 45 cents you would also need to send checkSumArray[45].
int checkSumArray[]={ 
  0x00, 0x32, 0x31, 0x30, 0x37, 0x36, 0x35, 0x34, 0x3B, 0x3A, 
  0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x0A, 0x0B, 
  0x01, 0x00, 0x03, 0x02, 0x05, 0x04, 0x07, 0x06, 0x09, 0x08, 
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 
  0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0F, 0x0E, 
  0x06, 0x07, 0x04, 0x05, 0x02, 0x03, 0x00, 0x01, 0x0E, 0x0F, 
  0x05, 0x04, 0x07, 0x06, 0x01, 0x00, 0x03, 0x02, 0x0D, 0x0C, 
  0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x0C, 0x0D, 
  0x0B, 0x0A, 0x09, 0x08, 0x0F, 0x0E, 0x0D, 0x0C, 0x03, 0x02, 
  0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02, 0x03};

//============================================
//            Setup
//============================================

void setup() {  
  Serial.begin(9600,SERIAL_7E1); // serial settings required by the Transact
}

//============================================ 
//            Main Loop 
//============================================

void loop(){
   // dispense change from 1 - 99 cents with a 2 second delay
   for (int i=1; i<100; i++){
        dispenseChange(i);
        delay(2000);
    }
}

//============================================ 
//            Change Dispense 
//============================================

void dispenseChange(int cents){

    //send reset
    Serial.write(EOT);
    Serial.print("Cr");
    Serial.write(ENQ);

    //send the change command
    Serial.write(EOT);
    Serial.print("C");
    Serial.write(STX);

    //send the change amount
    Serial.print(cents);   
    Serial.write(ETX);

    //send the checksum
    Serial.write(checkSumArray[cents]);
}

But first, an update on Counting Box Version 1. It’s been in service for 17 months and is showing a count of 121,860. This is three less than the highest number it’s reached. My son doesn’t seem to be a fan of negative numbers because -93 is the lowest the box has counted. The increment button has been pushed 18,422 times and the decrement button 4227. It’s only been recharged twice that I know of, so that giant battery was total overkill.

Now here’s how to build your own.

Please read through the entire build first and get an idea what you’re in for. I write with the assumption that you’ve got a basic understanding of electronics assembly, programming, and how to use the Arduino IDE. I’m only going to tell you to solder X to Y, not how to solder, what temperature to use, and so on. Also be aware that these instructions are only for the circuit, not for the enclosure. As you build it, think ahead to what kind of case you want to put it into because that could influence decisions like how long to make certain wires.

Circuit Parts & Pieces

• Arduino
  An Uno, Duemilanove, or other similar board using an ATMega328. We’ll be pulling that ATMega chip out and putting it in our own standalone circuit.
• ATMega328 w/ Arduino bootloader
  This will replace the chip you pull from your Arduino. I know you can burn your own bootloader, but this is easier.
• 74HC00 quad NAND IC for debouncing the buttons
• 24LC256 EEPROM chip for storing the count and related statistics
• 28 pin IC socket for the ATMega328
• 14 pin IC socket for the 74HC00
• 8 pin IC socket for the 24LC256 EEPROM
• 2 Adafruit 7-segment displays with I2c backpacks (choose any color you like)
  For the display and its driver in the first version of the Counting Box I used a MAX7219 IC and a pair of 4-digit seven-segment LEDs. These Adafruit displays are a little bit more expensive but really simplify the wiring.
• 2 arcade-style buttons
  I used this and this from SparkFun. The circuit is built for SPDT switches but would work with SPST if you used a different method for debouncing.
• 10-position coded rotary switch and knob
• 2 22pF capacitors
• 16MHz crystal
• 2 perf boards
  I like the half-size Perma-Proto boards from Adafruit
• Resistors: 10kΩ (x5), 220Ω (x1)
  I’m not going to link to each for purchase at 2 cents each because if you’re building a project like this you should have a big assortment already. If not, go get one.
• 1 LED

Power Supply Parts

I’m breaking these out separately because you might want to do something else for the power supply. My original counting box used a USB charger and battery combined with a step-up voltage converter.

• 7805 voltage regulator
• 2 10uF capacitors
• Battery holder, either 9v or 6x AA. 6x AA will last longer.

Tools

• Soldering iron & solder
• Breadboard
• Wire, the more colors the better
• Wire stripper
• Multimeter

With all of that gathered, let’s start building!

Assemble the Displays

Instead of replicating the steps here, I’m just going to tell you to follow the assembly instructions that came with the 7-segment displays. You’ll be soldering the 4 digit display to the I2C backpack, then soldering a 4-pin header to that.

Short the A0 jumper on one of the backpacks to change its address, as seen circled below.

Wire the Rotary Switch

The rotary switch has 4 switch pins on one side and a ground pin on the other. One pin is for a value of 1, the next for a value of 2, the next for 4, and the last for 8. Hey, that sounds like a binary number system! It is. When the switch is set to 7, for example, the pins would read 0111.

Review the datasheet for your switch to understand which pin is which and how the pins are read.

I found the leads on the switch to be pretty fragile, so I soldered it onto a small perf board (here, from SparkFun). I routed the ground to the same side as the switch pins, then ran it all to a ribbon cable about 6″ long. Individual wires work fine if you don’t have ribbon cable available.

Wire the Buttons

The arcade switches are SPDT, so each has 3 leads. Solder an 8″ wire to each lead. I recommend using different colored wires so you can keep track of which is which. The switch itself can be removed from the button to make it easier to work with.

You can use buttons that aren’t SPDT, but you’ll need to come up with a different method for debouncing them.

Breadboarding

We’ll build the counting box circuit on a breadboard first to make sure everything works.

A Note on Pin Numbering

The ICs we’re using all have a notch on one end so you can orient them correctly. Pin numbers start with 1 at the top left as you’re looking at the IC with the notch on top. The numbers proceed down the left side, hop over to the bottom of the right side, then go up to the top right in a counter-clockwise pattern.

Breadboard the EEPROM

When I first wrote about the original Counting Box, some people recommended that instead of using the external EEPROM chip I should make a circuit that would only write to the internal EEPROM when power was switched off. This way I could use the internal memory but not worry about hitting its write limit. It’s a good idea, but the problem is that I’m not an electrical engineer and I couldn’t figure out a reliable circuit to do that. It would require a way to accurately sense the incoming voltage and a capacitor that can keep the circuit running for the 66ms or so that it would take to write all of the data (3.3ms per byte x 20 bytes).

Or I could buy a $1.50 chip and not have to worry about it.

The EEPROM needs pins 1 through 4 connected to ground. 1-3 are used to set the address in case you want multiple chips in the same circuit. Pin 4 is the ground. Connect pin 8 to +5v.

Pin 6 on the EEPROM is the clock. It connects to analog pin 5 on the Arduino (via the green wire in the photo below). Pin 5 on the EEPROM is the data line, and it connects to analog pin 4 on the Arduino (via the yellow wire below).

Breadboard the Display

Put the two displays side-by-side on the breadboard and run +5V and ground to the appropriate pins on each one. The displays are on the same I2C bus as the EEPROM chip, so run the data and clock lines from the 24LC256 to the displays. EEPROM pin 5 is data and will connect to the pin marked “D” on the display backpack, and EEPROM pin 6 is the clock connecting to the “C” pin on the backpack.

For the code I’ve written, the display with the shorted jumper needs to go on the right-hand side.

Breadboard the Debounce Circuit

Without some way to debounce the switches, each press will register as multiple presses and change your count by dozens or more. A pair of NAND gates coupled together will ensure that the SPDT switch is only in one state at a time, and the 74HC00 IC has 4 NAND gates on it. You can learn more about debouncing here.

Insert the 74HC00 into the breadboard with the notch toward the power supply. Run wires between pins 2 and 6 and between pins 8 and 12. Then between 3 and 4 on the left and 10 and 11 on the right. Connect 10k resistors between +5v and pins 1, 5, 9, and 13. The ground from the switches goes to ground, and the normally-open and normally-closed switch wires go to the same pins as the resistors.

Connect pin 14 to +5v and pin 7 to ground.

Connect pin 3 of the 74HC00 to pin 3 on the Arduino, and pin  8 on the 74HC00 to pin 2 on the Arduino.

To help myself understand and remember where everything went I made the breadboard diagram below. It might help you too.

Connect the Rotary Switch

The common wire from the rotary switch connects to GND on the Arduino.

Switch value 1 connects to Arduino digital pin 8, switch value 2 to pin 7, switch value 4 to pin 6, and switch value 8 to pin 5. Even though there’s the gap between pins 7 & 8 on the Arduino, the pins have a convenient placement on the standalone circuit we’ll build later.

When everything’s assembled it should look roughly like the photo below, except you probably don’t have the prototyping tray I made.

Programming

Download my code here (CountingBox2_1.ino.zip), unzip it, and install. You’ll also need to download and install the Adafruit GFX library and the Adafruit LED Backpack library. I’ve tried to comment my code as much as possible, but here’s a general overview of the main processes:

On startup the code loads the variables for the count, the minimum number reached, the maximum number, and the number of button presses. It initializes all of the buttons then checks to see if the counting box is being launched in standard counting mode, delete mode, or stats mode.  Delete mode is triggered by turning the rotary switch to 8 while holding the decrement button during startup. It’ll confirm you want to delete, and revert to standard mode if there’s not a prompt response. Stats mode is triggered by setting the rotary switch to 3 while holding the increment button during startup. Each push of the green button will step through a stat — max number, min number, increment button presses, and decrement button presses — before reverting to standard mode.

During the main loop the program compares the current count to the previous count. If they’re the different it saves to the EEPROM, if they’re the same then it does nothing. The button presses are triggered by interrupts, so there’s no checking for button presses during this loop.

The count (or any other number displayed) is broken into an array of its individual digits, then the array is stepped through and each digit is sent to the displays individually. I would have preferred sending a 4-digit number to each, but the library for the displays pads the left side with zeroes, so that sending 45 would end up as 0045.

A  timer blanks the display after one minute and puts the ATMega into low-power sleep mode. Pushing any button wakes it up.

Building a Standalone Circuit

When you’re satisfied that it all works then it’s time to tear it apart, move it away from the Arduino, and build it onto a standalone board.

Power Regulator

The counting box is going to need power, and you’ve got a couple of options for providing it.

In my original counting box I used a huge battery and a separate converter & charger. If this is your plan, skip this power regulator step and instead connect the +5v and ground from your power supply to the power rails on the prototyping board.

To keep things a little  simpler—not to mention cheaper—we can build our own circuit to convert 9v from common batteries to the nice, steady 5v the circuit needs.

Solder the 7805 into the first three rows on the protoboard. Run a wire from the middle pin to the ground column on the rail, then another from the right-most pin to the + column. In front of the 7805 put a 10uF capacitor between the input line on the left and the ground line in the middle. The silver stripe on the capacitor goes on the ground side.

Over on the other rail put another 10uF between power and ground.

You can connect the two rails now or later with a pair of wires across the bottom.

The breadboard diagram below might help clarify what goes where.

Put 9v into the input and use your multimeter to check that you’re getting 5v on the rails. I left off a power-indication light to save a tiny bit of power, but you could add one with a 220Ω resistor and an LED between +5V and ground.

ATMega 328

Solder the 28 pin socket with the notch toward the power supply. Be sure it doesn’t share any rows with the power supply.

Connect pin 7 to +5v and pin 8 to ground. Connect pins 20 & 21 to +5v on the other side, and pin 22 to ground.

Solder a 16MHz crystal between pins 9 and 10. It’ll fit parallel to the socket if you bend the leads in. Connect a 22pF capacitor between pin 9 and ground, and another between pin 10 and ground.

Solder a 10k ohm resistor between pin 1 and +5v.

To get power over to the left side, connect the two power rails at the bottom of the board if you didn’t already in the previous step.

Connect a 9v power source (6AA cells or 1 9v battery) to your power regulator. Be sure that the positive and negative leads go to the right location.

Load the sample blink sketch on your Arduino, then disconnect it from power. Gently pry the ATMega328 chip from the Arduino using a chip extraction tool or a small flat-head screwdriver. If you’re using a screwdriver, alternate sides and go slowly so that the pins aren’t bent.

Insert the ATMega into your socket, ensuring that the notch is facing the right direction. Connect a 220 ohm resistor and LED between pin 19 on the ATMega328 (equivalent to Arduino pin 13) and ground, then connect your power. If everything is assembled correctly the LED should blink.

Congratulations, you’ve built a standalone microcontroller! The design up to here can be used in other projects, but now we’re going to add components specific to the counting box.

24LC256 EEPROM

Solder the 8 pin socket onto the board right next to the 28 pin socket. The notch should be pointing toward the power supply.

Next, connect pins 1-4 to ground (the black wires circled below) and pin 8 to +5v.

I forgot to take a picture of this step, so pretend that I haven’t already soldered the 14 pin socket. Connect pin 6 of the EEPROM to pin 28 of the ATMega, and pin 5 of the EEPROM to pin 27 of the ATMega. Pins 27 and 28 on the ATMega are the equivalent of analog pins 4 & 5 on the Arduino.

The breadboard diagram below might clarify what goes where.

74HC00 Debounce Circuit

Solder the 14 pin socket right below the 8 pin socket, making sure again that the notch is toward the power supply.

Solder a wire between pins 2 and 6, and another between pins 8 and 12. It can help to refer to the circuit you built on the breadboard, because this is exactly the same.

Solder a wire between pins 3 and 4, and another between pins 10 and 11. With the wires connecting the power rails and the circles I drew to highlight the wires in this step, doesn’t the picture below look like a smiling face?

Wire pin 7 to ground and pin 14 to +5V. Now the face is getting a little cockeyed.

10k resistors go between +5V and pins 1, 5, 9, and 13.

Now connect the debounce circuit to the ATMega by running a wire from 74HC00 pin 3 to ATMega pin 5, and another from 74HC00 pin 8 to ATMega pin 6. The wire on the right-hand side will need to be routed to the left.

Solder the buttons to ground and to the same pins that you added the resistors. The normally-open side of the switches should go to pin 1 on the left side and pin 9 on the right.

Rotary Switch

Solder the common line from the rotary switch to ground, then switch 1 to ATMega pin 14, switch 2 to ATMega pin 13, switch 4 to ATMega pin 12, and switch 8 to ATMega pin 11.

Display

Get out a new protoboard to mount the seven-segment displays on. Don’t solder them yet, but find a good placement and note where each header pin is going. Remove the displays and connect the + and – rows where the display backpacks will connect to the + and – rails on the protoboard, circled below.

Now we need to route the clock and data signals to the appropriate rows. The photo-illustration below shows how it’ll be wired, but the wiring will be done on the back so it doesn’t get in the way of the display backpacks.

And this is what it looks like after you’re done and flip it over. Please excuse the sad condition of this protoboard; I desoldered a previous build of this step.

We need to get power and signal from the main board to the display board, so solder on a 4-conductor ribbon cable (or individual wires) to the +5v column, the ground column, the first row for clock, and the second row for data.

Solder the displays to the protoboard. Make sure that the pins line up correctly with the wires you attached and that the displays are parallel. There’s a surprising amount of room in which to get components out of alignment in those little holes.

Now solder the other end of the cable/wires to the main board. Ground and +5V go to their respective locations on the power rail, the clock line goes to pin 6 on the EEPROM, and the data line goes to pin 6 on the EEPROM (remember, the display and the EEPROM are on the same I2C bus).

Carefully insert all of the chips into their sockets. Be sure that the notches on the chip line up with the notches in the sockets.

Battery & Switch

Solder a switch on the input line from your power source. Now flip the switch and start counting!

The Box

I’m not going to give detailed instructions on how to make a box to put this into because I think that should be a decision that matches your sense of style, your ability, and the tools at your disposal. In my original counting box I used laser-cut bamboo from a pattern I made. Some other things that might work for housings would be a lunchbox, a cigar box, or even a clear plastic storage bin so the circuit can be seen. The buttons could be mounted on the top or from the side like on a pinball game.

Whatever box you use, you’ll need to at least do the following:

• Drill a 1/4″  hole for the shaft of the rotary switch. You’ll also want to print out and glue down a label for the numbers around the switch. You can download a label that I made to fit around the knob linked to in the parts section. Push the rotary switch through the hole from the inside, thread the nut on to hold it in place, then push the knob on. You may need to rotate the switch to get the locations of each stop to line up with the labels.
• Drill a 1-1/8″ hole for each arcade button. Separate each switch from its button and unscrew the large nut. Drop the button in from the outside of the box, tighten the nut against the inside, then re-attach the switch.
• Drill a hole for your power switch and mount as appropriate, whether screw-in or snap-in.
• Cut an opening for the display. I measure mine at .75″ x 4″, but you should check your own just in case they’re slightly different. There are holes at the corners of the LED backpacks you could use to attach to your box with screws, or you could use hot glue.
• Be sure there’s a way to change the batteries when they run out. You don’t want the box permanently sealed, but if it’s for a child you don’t want the interior easily accessible either.

Finally, please share if do build your own counting box. Post a link to your website, Flickr account, etc. in the comments, or email pics and let me know whether or not it’s OK to post.

If you’ve got any questions I’ll do my best to answer, but I’m not an electrical engineer so I can’t get too technical. If you’ve got suggestions or can improve the design, I’d love to hear those ideas too.

UPDATE March 21, 2013:

Reader Marty has kindly created a schematic and shared it. Thanks Marty!
Counting_Box_V2_Schematic.pdf (16KB)

The Idea

One of my habits is to write down all the crazy, fleeting ideas I have, then go back to review later rather than judging right off the bat, or even worse, forgetting them.  Earlier in the month I was looking through that idea notepad and found “Make Tetris Pumpkins” from sometime last year. My original plan had been to make forms to shape pumpkins into Tetris pieces as they grew, then stack them together for Halloween. Since Halloween was only a few weeks away and it was too late to start growing pumpkins, I thought “Why not make a pumpkin you can play Tetris on instead?”

I had a LOLShield I hadn’t assembled yet, and I knew that someone had already written Tetris for it, so I figured it would be a simple matter to poke some holes in the pumpkin to match the LEDs, make a controller, and be done. But oh no, that would be too simple, and would look kind of lame. Little tiny LEDs, all stuck together on a 2×3″ area? Nahhhh.

Plan B: Still use the LOLshield, but instead of mounting LEDs in the shield I would wire them up externally so I could space them out more on the pumpkin. Luckily, I didn’t get too far down that route before I realized that the bundle of wires between the LEDs and the shield would be as thick as my wrist and a nightmare to solder and organize.

I was going to have to make my own LED matrix and program my own Tetris. With the decision made, I ordered 140 amber LEDs from Mouser and a pair of LED Matrix I2C “backpacks” from Adafruit. These little circuits come with a mini (.8″ square) LED matrix that I could use for programming instead of having to wire up my own LED matrix right from the start..

Time to Solder

The first step was to make the LED matrix, and for that I’m grateful to have found this guide on hackaday.com to making a 70 LED matrix. My construction steps were essentially the same (plus 58 more LEDs), but I’ll go through them here anyway. For more theory, check out their post. Mine leans toward “what I did” rather than “why you should do it this way.”

It started with cutting 112 pieces of 2.5″ wire and 16 pieces of 8″ wire. The short ones would go between each LED, and the long ones would run to the controller. A cutting mat made it easy to quickly and accurately measure out the lengths.

Next I soldered seven short wires and one long one into a daisy chain. Then again 15 more times—one for each row and one for each column in the matrix.

A jig was needed for assembly, and here I differed from Hackaday. Instead of drilling hardboard, I opted to poke holes into 1/4″ foam-core board with an awl. It was a lot quicker than a drill would be, and the foam-core board had a little bit of give so that I could make the holes small and they’d stretch out to hold the LED securely while I soldered.

With a row of LEDS poked into holes, I tinned the base of each anode and clipped it short, then soldered the wire daisy-chain down the line. At each joint I slipped on a half-inch of heat-shrink tubing before soldering. I’m proud to say there were only a couple of times I forgot the heat-shrink and had to go back. What caused more trouble was being in a hurry and sliding the tubing down to the joint while it was still hot. It would start to shrink up and wouldn’t fit over the connection on the LEDs.

When eight rows of LEDs were finally strung together, it was time to mount them all into the jig and solder on the cathode columns. The procedure with the heat-shrink was the same. As each column was finished I would pull it out of the jig and fold it out of the way in order to reach the next column.

Check it out!  A finished LED matrix!

But guess what? That’s only one, and 8×8 isn’t enough room for a game of Tetris, so it all got done again! I’ll spare you a rerun on the pictures and description, but if you want to you can go back up and read it again to get the full experience.

The Adafruit LED Matrix Backpack is meant to have its LED matrix soldered right to the board, but instead I soldered on female headers that would permit me to plug in either the mini LED matrix for code testing or the large matrix for deployment. Someone will probably be along to tell me I need a resistor here or there or I’m going to blow some chip up—and they’re likely right—but it seems to have worked so far as-is.

To connect my own matrix to the I2C Backpack, I cut down a piece of prototyping board and soldered in the male headers, then connected the 8″ wires from the last row and last column of the matrix to the board.

Would it work, though? I needed some code in order to find out.

Code

I did all coding with the hardware mounted on my bamboo prototyping board. The mini matrices in the I2C backpack sockets fit on the desk much better than the big, floppy matrices I built would have.

There are seven Tetrominos—yes, that’s what they’re called—in the game. Each has four points, as implied by the “tetra” prefix. A three-dimensional array stores the location of every pixel of every shape, in each of four possible rotations. Storing each rotation is a lot easier (for my brain at least) than calculating it on the fly. As an example, here’s the T shape:

/* T */ {
 /* angle 0 */ { {0,1}, {1,1}, {2,1}, {1,2} },
 /* angle 90 */ { {1,0}, {1,1}, {2,1}, {1,2} },
 /* angle 180 */ { {1,0}, {0,1}, {1,1}, {2,1} },
 /* angle 270 */ { {1,0}, {0,1}, {1,1}, {1,2} } 
 }

To draw the active piece the program keeps an activePiece variable (the index of the shape in the array) and a rotation variable (the index of the rotation description of that shape), then offsets each pixel pair that it pulls out by a yOffset and xOffset of how far down the screen it’s moved and how far left or right.

It also keeps an array describing the status of each “fixed” piece. With every move of the active piece, whether by gravity or by user control, it checks against that fixed-piece array to see if the requested move can be made without a collision. If the forbidden movement is left, right, or a rotation, it simply doesn’t make the move. If the forbidden movement is vertical it considers the piece to have landed and writes the piece to the array of fixed pieces, then launches a new active piece. Along the way it keeps score, tracks the level, speeds up the drop of the active piece as the game goes on, etc.

You can download a copy of the code here. In order to use it you’ll also need to download the Adafruit LED Backpack library and Adafruit GFX libraries and install them on your computer by copying each to the “libraries” folder of your computer’s Arduino sketch folder.

The Wet Work

This project required the perfect arcade cabinet—errr, I mean pumpkin. It had to be tall enough that the eight-inch tall matrix wouldn’t wrap too far around the bottom or top, and it needed a nice straight stem. I bought 3 pumpkins in a row, thinking each was perfect until I got it home and realized one thing or another wouldn’t work. Finally I found what I needed and the other pumpkins were relegated to prototyping duty for practice drilling holes and cutting.

To get inside the pumpkin I cut a large opening on the back. It wouldn’t work to cut from the top because I wanted the controller up there, and it would be easier to put the LEDs straight in from the back rather than the top.

With a paper template taped on to the pumpkin, I poked guide holes through the orange flesh.

Once the holes were marked I drilled through with a 13/64″ bit.

And since round pixels just would not do for a proper Tetris game, I cut a square around each hole with an X-Acto blade. The ends of the holes on the inside of the pumpkin were left round.

To turn the stem into a joystick I carefully sawed the it off at its base and drilled a 1-1/8″ hole right where the shaft would pass through.

I squared off the inside of the pumpkin below the stem, cut down some drywall anchors so they wouldn’t poke through the pumpkin, and screwed them in. Later I would attach the joystick with short screws into the drywall anchors.

For a controller I used short handle joystick from SparkFun, with the red ball unscrewed and replaced with the stem of the pumpkin. I think I’m going to call this the  ”joystem” from now on, as disgusting as that may sound. I drilled a hole in the detached stem and epoxied in a 6mm bolt, then screwed that into a coupling nut on the joystick shaft.

One at a time, I started to poke each LED into its slimy place. It wasn’t long before a problem became apparent: there were 16 rows of holes on the outside, but only 15 on the inside. The angle that the holes were drilled toward the top of the pumpkin had the two rows coming together into a single row. I was eventually able to squeeze the LEDs past each other and direct them into their appropriate shafts. Once the LEDs were in, I attached the joystem.

I plugged each matrix into the I2C backpack and then that into the Arduino. Usually I’ll build a standalone bare-bones controller board, but since this was definitely not a permanent piece I used the Arduino board. Power was provided by eight rechargeable AA batteries.

It was time to play Pumpktris!

Everything worked great, except for some occasional glitches in the top matrix as the night went on. Maybe a power supply issue, but it’s also possible there might be some intermittent shorts that happen when you bury that many electrical connections inside a pumpkin. It’s also weird playing with the controller on the top and the display underneath, so if I were to do it again I would wire the joystem into a separate pumpkin, either wireless or with the wire made to look like a vine.

Next up? Porting Halo to a watermelon.*

By the numbers:

• 128 LEDs
• 256 pieces of heat-shrink tubing
• 313 solder joints
• around twelve hours of work over a week and a half
• 9800-point high score so far

* No, not really.

UPDATE: I did a more in-depth writeup on how to make your own (as opposed to this story about how I made mine) at Instructables.

The bracelet is made from layers of bubinga veneer, glued around a form one layer at a time. Individually, each piece of wood is flexible, but when they’re glued together they hold their shape. Below are veneer sheets cut into 1.5″ wide strips for the bracelet.

The first step was to make a form for the bracelet. I drew out the shape in Illustrator, printed it, then spray-mounted it to a scrap of 2×4. I cut around the edges with the band saw, then smoothed it right up to the line with the belt sander.

To make the bracelet I spread some glue on a strip of veneer, wrapped it around the form with the glue side out, then wrapped another strip around it. Hose clamps held its shape until it dried, then I added another layer, let it dry, added another, and so on until seven layers were built up.

My first attempt (this project wasn’t successful until the third try) had indentations in the wood from the clamps, so on later attempts I put a layer of brass sheet around the wood to spread the pressure of the clamps. A scrap of baking parchment keeps any glue squeezed out from sticking to the clamps.

Once I had all 7 layers finished I drilled holes through the wood for the rods that the beads would slide on. Unfortunately, because of the bit’s small size, the characteristics of the wood, and some poor alignment on my part, the perfectly spaced and centered holes on one side wandered all over on the other side. On my second attempt I tried to be more careful in alignment. It was slightly better than the first attempt, but still not good enough.

For my third try I realized I could make some channels for the rod before I glued on later layers. These would serve as pilot holes when I drilled. I stopped at the 4th layer of wood and clamped it into my milling machine, then ran an engraving bit across the layer (as seen in the photo below). This ensured that the channels were straight and evenly spaced.

When I glued on the last three layers I had to take care that glue didn’t block the channels, so as it dried I passed a piece of guitar string back and forth through each channel to keep it clear. The photo below shows this, but without the clamps and the form.

Once all the layers were formed and dried, I squared the edges on the belt sander and clamped it into the mill again. This time I routed out the openings where the beads would go. The photo below shows this step on an early attempt, without the pilot holes/channels in the middle.

With everything roughed in, I drilled the pilot holes to size. It worked perfectly—the holes were just as aligned on one side as on the other.

After sanding and applying a finish, I pushed the wires through and threaded the beads.

I cut each wire shorter than the width of the bracelet so that it would be inset in the holes, then filled the holes with a paste made from super glue and sawdust from the bracelet (for matching color). When that was dry I sanded down the excess so it only remained in the holes, smoothed it, and applied more finish to the edges.

Here you can see the edge where the holes were. They’re still visible, but don’t jump out at you.

And here it is, finished and ready for all your on-the-go calculation needs!

I’ve seen acrylic plates for mounting a half-sized breadboard and an Arduino (here’s one at Adafruit & here’s one at Sparkfun), but they don’t appeal to me. First, I prefer using a full-size breadboard, and second, I don’t like the look of  the acrylic. Time to make my own.

It’s laser cut from two pieces of bamboo plywood, sized to the P1 (smallest available) sheet at Ponoko. The thin sheet is the base, and the thick piece glued to the top holds the Arduino and a breadboard. A cut-out on the thick piece creates a tray for holding components.  I had room, so I engraved a resistor color code guide for handy reference*.

If you want to make it yourself, you can add it directly to your Ponoko account from my showroom, or you can download the zipped EPS files here. The file “protoboard_3plybamboo_p1.eps” is the top piece and should be made with 3-ply amber bamboo, and “protoboard_blondebamboo_p1.eps” is the bottom piece made with single-ply blonde bamboo. The total cost was around $15 + shipping.

A stack of plastic washers on each bolt acts as a standoff to raise the Arduino off the wood, but this isn’t strictly necessary. On the back, the nuts are recessed. If you make your own, be sure that the bolt holes in the top sheet are centered in the nut holes on the bottom when you glue the two pieces together. Rubber feet in the corners keep it from sliding around.

I sanded the charred edges off the outside, but left them on the inside (because I’m lazy and the belt sander couldn’t reach), and protected it all with a few coats of polyurethane.

*In my haste to get this made, I forgot to include the GOLD and SILVER on the resistor chart when I exported and uploaded. Whoops. I’ve re-done the file now to include those, and also to express the multiplier values in what I think is an easier to read format: xxK and x.xM, for example, instead of x1,000 and x100,000. This is what it looks like on the files linked/attached:

update 4/16/2013: reader Matt made another variation that you can download on Thingiverse. Very cool!

I’ve gotten a few emails and comments asking for plans for the giant adirondack chair I built. The trouble is that I prefer building things to documenting them. But because I love you all, I buckled down and made some plans. Don’t get too excited, because these aren’t formal blueprinty plans. To do that right would require building another chair to test everything out, and there’s only room for one of these in my yard. So instead I measured the already-built chair, tried to remember what I’d done (and in some cases what I’d do differently), and rebuilt it in Google Sketchup.

Please note: this description isn’t intended to be a step-by-step guide with every 1/8 of an inch and every angle accounted for.  Read through the entire thing before building. Then read it again. This will get you close, but you’ll need to figure some things out on your own as you go. No guarantees are made as to the accuracy or suitability of it for any purpose, and you’re responsible for what you build and for any damage when it inevitably falls down.

Here’s a materials list for the lumber:

You’ll also need some deck screws (2.5″ or 3″), eight 1/2″ galvanized hex bolts (length depends on how you build it, but I think I used 3″), washers, and nuts.

Seat/Base

Cut your 12-foot 2×10 in half so you’ve got two 6-foot pieces.  These will be the rails along the side that support the seat slats.  Decide what angle your chair will rest at. Mine’s at 20 degrees, and in regular-sized Adirondack chair plans I’ve seen everything from 17 – 22 degrees or so.  Cut this angle across one end of each of these boards, something like this:

The angle you cut will be the back foot that the chair rests on. If you want to round that corner (shown in red), do so now. This would also be the time to cut a contour in the seat (again in red), should you desire. The seat contour shouldn’t be very deep, and should end about 30″ back where the back of the last seat slats will go.

Measure 9 inches from the front of the 2×10 frame rail, along the bottom.  Starting there, draw a line at 90 degrees to the angle you used before. It’ll be 9″ back on the bottom tilting to barely under 6 inches back on the top. It’s illustrated in yellow in the photo below. This line will be where the front edge of the front vertical support goes.  Do it again on the opposite side of the other rail.

Cut a 4-foot piece from the 8-foot 2×10 to connect the two side rails at the front of the seat.

Put the frame rails four feet apart (from outside edge to outside edge) and make sure everything is parallel and square, then attach the 4-foot 2×10 across the front with a few deck screws in each end.

Cut the 8-foot 2×12 into two 42″ long pieces.  These will be the front vertical supports that hold up the seat and the armrest.

With some friends, stand the vertical supports on either side of the base frame you made, then start lifting the front of the base until the line you drew is parallel with the support.  Getting this right will also mean that that the corner you cut at the rear of the rail is now flat on the ground.

Clamp the rails and the supports together firmly so you don’t need to hold it all up by hand, then drill a pair of  half-inch holes all the way through.  You can use a Forstner bit partway through to sink the bolt head (I used half-inch galvanized bolts) out of the way, but that’s not necessary.  Carriage bolts might be another option, so that the outside would be more smooth.

Cut both of the 8-foot 2x8s in half so you have four 4-foot pieces. These will be the slats you sit on.  I used a round-over bit in the router to soften the top edges, but that’s optional depending on your tool set.

Attach the first 4-foot 2×8 across the top with deck screws, overlapping the edge of the 2×10 on the front. Work your way back attaching each slat about half an inch away from the one before.

Backrest

Now it’s time to make the backrest. This part is tricky, but I’ll do my best to describe it. Make a lot of measurements and do a lot of fitting and testing before you cut. Build to the measurements you end up with, and not strictly to mine.

Cut your three 12-foot 2x12s in half so you’ve got six 6-foot boards. You’ll only need five of them for the slats, and the other will be used elsewhere.

The first problem to be overcome is that the boards are each 11-1/4″ across, and you’ll want a half-inch gap between them. Five boards and four gaps equals 58.25″. That’s fine for the top of the backrest, but the bottom needs to fit the 48″ width of the chair base. You’ll need to taper each board down from 11.25″ to 9.2″ (let’s go with 9.25″ for ease of measurement). 9.25″ x 5=46.25.  Add 2″ for the gaps between and you get just a bit over 48″. That’s close enough.

There’s no need to cut 1″ from each side; instead you can take 2″ off of one side, as long as you can round over the board’s edges to match on both sides. How you cut this is going to depend on the tools you’ve got. I used a circular saw and made a guide to ensure a straight cut.

Once all 5 back slats are cut, lay them onto the ground and space them about half an inch apart at top and bottom. This is mostly a check to make sure all the cuts are correct and the spacing is right. The width on the bottom should be just over 48″. If you want to cut an arch across the top of the slats (shown in red on the picture below), draw it on now while all of the boards are lined up, then cut each board individually. If you want the top to be square, snap a chalk line across the top, then cut each board along the line. The bottom edge of the boards will not be even, and you shouldn’t try to make them even yet.

There are two supports for the back slats, one at the bottom and one about halfway up. Let’s do the bottom one first.

You should have one 6-foot piece of 2×12 left. Cut it down to 4 feet long, then measure 7.25 inches in from the edge and draw a line all the way across (red in the diagram below). You’re basically making a 2×8. Next draw a shallow arc from one corner of that 2×8 piece to the other. This will be a rough guide to the contour of the seat back.

Now divide the arc into five 9-3/4″ (or so) straight segments. These segments will let each back slat fit square against the support. If you cut right along the arc, only the corner of each slat would be supported. Cut as neatly as you can along the lines because you’ll use the convex piece later.

There’s another support halfway up the back, and this one really relies on you making your own measurements based on the back slats you’ve got laid out. Measure 4 feet up from the middle of the center slat and mark it. Draw a straight line all the way across the slats at that mark. Measure the width of each board at the line you’ve drawn and write each down. Because of the way they fan out, the width of the outside boards at the line will be more than the center board. Add a little bit to each measurement, since the curve will make that half-inch gap at the front of the board slightly wider at the back.

Cut the remaining 8-foot 2×8 in half, then mark off your measurements from the center of one piece and cut another segmented arc with these measurements, much like you did with the bottom support. The boards on the edge of the backrest won’t be fully supported, so the outside segments of the arc will be shorter than the rest.

To attach the upper back support to the chair, mark your chosen angle 60″ up the 12-foot 2×6. Measure 60″ off the other side of the angle and cut straight across, so you’ve got one support for each side. Keep the scrap piece to use later as an armrest support.

Lay the two vertical supports 45″ apart, get everything square, then attach the upper horizontal support with screws. There will be a 1.5″ overhang on each side.

Attaching this rear support frame takes some attention to detail, because you want the verticals completely, well, vertical. And at the same time, you want it positioned front to back so that the angle between the seat and the back equals 90 degrees. You might have another method, but what I did was to tie a string between the centers of the upper and lower rear slat supports, then move the support frame back and forth until a framing square held against the seat slats showed the string was at a right angle. The picture below illustrates this method. When everything is lined up and square, clamp the support frame to the rails, drill, and bolt just like you did for the front supports.

Now you can attach the vertical slats! I put four screws into each slat (2 top, 2 bottom). You might have to remove a seat slat or two in order to get access for drilling & screwing. Be careful at this stage: without the armrests tying it together, the chair is very unstable.

Because of the way you cut the angle into the back slats, there may be some unevenness along the bottom where it attaches to the support (see image below). You can either ignore this or mark a line on each slat, take it down, cut it, then re-attach. If you do remove your slats, it’s a good idea to mark which is which so everything can fit back where it’s meant to be.

Armrests

The armrests are 60″ 2x12s. Cut two from the 10-foot 2×12 and contour them as you’d like. The back of each armrest is attached by screws to a small block on the the vertical support in the rear of the chair (see the inset detail below). Cut the blocks from a piece of the 2×8 left over from the 8-foot 2×8 you used for the upper back slat support. Screw the block to the vertical support, then screw the armrest to the block.

In the front, cut two 2x6s about 1 foot long (use the scrap piece from the rear vertical supports) and contour as you like, then attach with deck screws to each front vertical support in a T formation. This will give the armrest a wide, stable surface to rest on.

Now for the problem of how to intersect the armrest and the rear vertical slats. Take a close look at the picture above and see where they meet. It’s a compound angle, possibly even extending into dimensions we haven’t discovered yet. The slats lean back and curve inward. I basically cut it in place by fitting the armrest as close as I could against the vertical slat, marking it, cutting, test fitting, cutting some more, and so on. If you’ve got a laser level, that may help you transfer lines where you need them. All I can really say is “good luck,” or maybe build a chair without the fanned back; then you don’t need to worry about it.

Once you’ve got your armrests attached, fill the gap between the vertical slats and the rearmost seat slat. Remember the convex piece from your 2×12? You’re basically putting these two pieces back together with the backrest between them. You might need to trim the straight side of the board to fit. Leave a gap between this board and the back slats for any rain to drain down.

You’re done! Now you’ll probably want to take it all apart in order to paint it and/or move it to its final destination.

If you do end up building a giant chair based on this page, please send pics. I’d love to see your work. I also welcome any ideas to make the project easier; I’ll add them here to help the next builder.

Here’s the materials list again, this time with each type of board color coded. It corresponds with the picture below where each board is colored the same as in the materials list, so you have a better idea which pieces are used where.

And here’s a PDF (61KB) of all the lumber with cuts marked:

Last week I ordered a MintyBoost charging kit from AdaFruit. The MintyBoost is a circuit that takes power from a pair of AA batteries and outputs 5v through a USB port, so you can charge your phone or other similar device where you might not have access to another power source. It gets its name because it’s commonly built into an Altoids mint tin, but I wanted something a little heavier duty than candy and tiny batteries.

The MintyBoost kit was well-documented and went together quickly. I verified that it worked with a pair of AA batteries in the provided battery holder, then started hunting around for more power.

AA batteries have a capacity of about 2800mAh (milliAmp hours). The iPhone 4s I would most likely be charging has a battery capacity of about 1400mAh. When you figure in the inefficiencies of the charger, the fact that batteries usually overstate their capacity, and other factors, it turns out that the AA batteries might top off a phone that’s down to about 1/4 power. That’s it. Then you need to get a new pair of AAs.

On the other hand, D-cell batteries have a capacity of almost 15,000mAh—over 5x that of AA batteries. I just needed a good case to hold the D batteries and the MintyBoost, and what better than a flashlight?

I scrounged through a box of junk and found an old USGI right-angle flashlight. These things are uglier and tougher than almost anything around, and mine was no exception on either count, scarred up from who-knows-how-many youthful camping trips and midnight troublemaking expeditions.

The source material: an old USGI right-angle flashlight and an Adafruit Mintyboost circuit.

The USGI flashlight comes apart in a ton of different places. There are two tail caps: one to hold an assortment of lens filters and the other to provide access to the battery compartment. A ring screws off of the front of the lens to hold a filter, and the bulb assembly screws out of the head of the flashlight. I figured that somewhere in there would be room for the tiny MintyBoost.

The flashlight disassembled. There’s a lot of room in there.

I poked the circuit into various nooks & crannies of the flashlight, trying to see where it would fit best. One possibility was in the head of the flashlight behind the bulb assembly.

The MintyBoost in the head of the flashlight.

Another likely spot was in the tail cap where there’s a compartment for storing a spare bulb.

MintyBoost in the tail cap.

I decided on the tailcap, but not poking out the side like in the picture above. Rather, it would come out the rear of the flashlight. There was a reinforcing area for the D-ring that was exactly the right size for the USB port and would provide a solid surface for mounting. It would also be easier to put an on-off switch on the flat base than on the head or out the side of the flashlight.

After milling a slot in the tail cap, I squared the corners with a knife.

A slot for the USB port.

Neither of the two tailcaps on their own had enough room, but together they were quite spacious. I only needed to open the wall between them. To do this, I chucked a small flush-cutting bit into the router and ran it around the inside of the cap. It’s a little bit rough, but the picture below is the last time anyone will see the inside anyway. Doing this sacrificed the storage for the filters, but I never used them in the first place.

The solid base routed out of the battery cap.

Even when it’s not in use, a circuit can like this can draw a minuscule amount of power and drain the batteries over time, so I added an on/off switch in the tail cap to control the power to the MintyBoost. In reality, it’s completely unnecessary since the batteries would probably leak and corrode before the unused charger emptied them, but why not wear suspenders with that belt? The charger operates completely independently of the flashlight; either can be on or off regardless of the state of the other.

Countersinking holes for the switch mounting screws.

I attached the MintyBoost with high-strength two-part epoxy on three sides of the USB port and on the edge of the circuit board where it made contact with the inside of the tail cap.

The finished cap.

The cap looked great on its own, but now I had to get power to it. I could tap right into the spring in the tail cap for the negative terminal, but for positive I’d have to run a wire from the head. I soldered a wire to the springy copper strip that contacts the bulb and ran it down through the battery compartment. There’s plenty of room in the battery tube for a wire held down with electrical tape.

The positive terminal at the head of the flashlight, showing the line feeding to the charger.

In the tail cap, I ran the negative wire to a bent strip of copper I made to hang over the lip that the battery spring rests on. Since the copper strip stays in place as the cap screws on (and the spring possibly rotates with it), it’s one less wire to get tangled up. Things weren’t so easy with the positive wire, but it works well enough to run the wire through the spring so that as the cap and spring are screwed on, the wire rotates through the spiral.

The MintyBoost circuit inside the tail cap.

With everything screwed together, I plugged in the iPhone and flipped the switch on the base of the flashlight. Ahhh, the relief of hearing that sweet beep-boop from the phone as it acknowledged the charge. It works!

It charges!

To save the flashlight batteries even more I swapped the incandescent bulb for a drop-in LED replacement. It’s not too bright, as far as modern LED technology goes, but it’s still brighter than the original bulb and should ensure that using the flashlight as an actual flashlight will still leave plenty of juice for a phone charge.

Using the flashlight to charge my iPhone, so I can use its flashlight too.

I’m going to use it next week to charge up on a supported long-distance bike ride (meaning someone drives my gear—including this—to the campsite while I pedal there). After that it’ll probably stay in the back of the car as an emergency light/charger.

So, what to call it? It’s a MintyBoost at its heart, but the flashlight’s green is more of an olive. So how about the OliveDrabbyBoost?

A quick survey online found some instructions on making your own or even buying pre-made ones. Ignoring all, I plunged ahead. After all, this is about learning, building, and probably screwing up, not just having a finished product.

I found a cheap, unopened cassette tape at a local surplus store, but it turned out to not have the screw-joined halves I thought it would. I was going to have to raid my old stash of tapes from the corner of the basement. I haven’t listened to a tape in at least a decade, don’t even have a tape player, and certainly don’t still have the old Yamaha multitrack recorder these were recorded with, but I still had a tough time sacrificing it. Why, there could be a heartfelt masterpiece on that tape that 22-year-old me recorded. Someday the archivists (or prison psychologists) will want to study it!

Oh well.  Onward!  I at least chose one without a label, on the theory that if I hadn’t thought it worthy of labeling back then, it couldn’t be that important. Now we’ll never know.

With tape in hand, I needed a flash drive. I had a few laying around, so after disassembling the tape to see just how much room there was inside, I spent an hour or so trying out different drives for fit. I wanted the tape to retain its original profile, but I wasn’t sure whether the USB drive should slide out, swivel on this axis or another, or just present a port that would require a separate cable. The drive that seemed most promising was a 2GB SanDisk Cruzer and its sliding action; it would require the least modification to the tape and would be the strongest.

The donor drive, in and out of its original housing.

On a side note, I’m amazed by the fact that I live in a world where it’s hard to find a cassette tape, but I’ve got multiple gigabyte+ storage options buried in my junk drawer.  I remember when these cassette tapes used to be the storage for my computer. Three cheers for progress!

With a 3/16″ end mill I milled the port for the USB connector to slide in and out of. Then, after measuring and re-measuring more times than I can count and mapping out the exact numbers of turns and even which direction to turn the handles on the mini-mill (I’ve only had it for a month, and this was my first project after getting it set up), I plunged the mill into the tape and started cutting the opening for the sliding mechanism. I put the opening on side B of the tape, so that side A would look stock while it was in the case. All the planning worked out well, because when I popped the tape out of the vise, the drive fit perfectly.

Unfortunately, the two halves of the cassette didn’t quite fit together. If the SanDisk folks had made their drive just the smallest fraction of an inch thinner, it would have slid right in for a perfect fit. I was going to have to thin the cassette shell.

The finish is a little rough, but it works. You can see the opening for the slider, the thinning of the case, and the notch that keeps the drive locked into place when it’s all the way out. With side B milled out, I tried to put the two halves of the cassette shell together again. No luck, and side B couldn’t stand to lose any more plastic, so I did the same thinning on side A.

A test fit found everything sliding easily when it was supposed to and locking down when required, so I moved on to the reels next.

As you can see in the photo, the take-up reel got in the way of the memory. I attacked it with the belt sander and ground it down just barely to the inside sprockets, then glued it into place (below). It would have been nice to retain the tape functionality, but it wasn’t to be.

The spool of tape on the other reel was a little bit too large and kept the memory assembly from being able to slide all the way back. I didn’t want to unspool too much and lose the full-tape look, so I experimented with the spare tape I got from the surplus store and put some superglue across half of the reel. The thin glue quickly soaked in and glued the layers of tape solid enough that I was able to cut it right through with an X-Acto knife without it unspooling. The cut was a little rough, but that could be cleaned up. More detrimental was that it would be obvious from looking at the little crusts of dried glue through the tape’s window that it wasn’t quite right. Maybe something useful can be done with this tape-solidifying knowledge later.

So after that I decided it might not be so bad after all to lose the 1/4 inch of tape needed for clearance. Finally, a part of the project my four-year-old could help with: “Take this end and pull until I say stop!”

When our fun was over with, I threaded the tape back around the rollers and through the guides.

I know there are some problems with the tape path in this picture. I realized and corrected after the photo.

At last, I put the two halves in place and screwed them together. I didn’t have any labels for the tape, so I trimmed down an address label and used that, then plugged it in to the computer and reformatted to use the name “Mix Tape” (what else could it be?).

The drive works well on my laptop and in the USB port on my desktop machine’s keyboard, but because of the weight and leverage, I don’t know how it would hold up being unsupported in a port higher up on a desktop machine.

If I’d labeled it when I was 16 it probably would have had more stars, spirals, and other doodles on it than today’s version.

Side A looks just like a standard tape, so much so that if it’s still in the case you’ll only notice the USB on the side if you look closely. I’ve handed it to a couple of friends, saying “I’ve got some music I want to share,” only to have them laugh and complain they had nothing to play it on. They have to be told to take it out and flip it over.

And now I have to go make some for them. That’s the trouble with making cool stuff.