BuildIts

Arduino Game Port Interface

2012-01-28T12:55:00.001-05:00

A while back I got my hands on an old analog PC joystick, and since then I have been meaning to build an adapter make the joystick work over USB. The adapter I finally built consists of an Arduino connected to a game port I hacked off an old sound card. The Arduino reads the analog (x and y movement) and digital (buttons) inputs and then sends them to the computer over serial. Then a Processing script running on the computer reads the serial data, and converts it into mouse movements and clicks using the Java Robot class.

I first made an adapter to break out the connections from the joystick. I hacked a game port off an old sound card, and wired three sets of connections to it, using the pinout I found. Although the particular joystick I have does not use every available pin, I went ahead an included all of them.

In the picture below, the top three header pins are the 5V and ground connections (red is 5V). The middle four are the analog connections, and the bottom four are digital, for the buttons.

Unfortunately you cannot just plug these pins directly into a microcontroller and get it go read useful information from the joystick. Pull down resistors must be added for each of the button connections. Also, the potentiometers in the joystick do not have their third pins connected to ground, so I had to add a 100k resistor after each of the analog pins, so that the potentiometers act as a voltage divider and the Arduino can read them properly.

In the picture below, orange jumpers are analog, green digital, and the two at the bottom are for 5V and ground:

Pull down resistors:

Everything connected (minus the USB connection to the computer):

The way the code works is fairly simple. The Arduino reads the values of the potentiometers and buttons, scales the values to under 255 (1 byte) so that they can be sent over serial, and then sends the values to the computer over the serial connection.

The processing script running on the computer reads the sequence of numbers being received. It compares the values form the potentiometer to the values when the joystick is centered, and then moves the mouse using the Robot.mouseMove() command based on the difference between the values. Moving the joystick farther one direction means that the mouse will move faster. The trigger button corresponds to left click, and the thumb button is right click. The secondary joystick (top center) is used for scrolling, and the remaining two buttons currently adjust the sensitivity of the joystick.

Due to the speed at which the processing script runs, I had to limit the rate at which the Arduino sent data over serial, because if data was sent too quickly, it backlogged and created a huge lag when moving the joystick. Therefore, the joystick is not quite as responsive as I hoped it would be, and you must hold down the button longer than you would a mouse for your clicks to register. A workaround for this would be to use something like a Teensy, which can be recognized as a HID, so that the microcontroller could control the mouse directly, eliminating the need for an interpreting script.

Code:

Arduino

Processing

Retro Rechargeable USB Booster

2011-11-23T21:53:00.001-05:00

This project started when I found a 7805 voltage regulator when I was searching through old circuit board for useful parts to scavenge. Since these chips are often used in DIY USB chargers, I decided to build such a charger, but with some major improvements over the typical 9V battery powered chargers housed in Altoids tins.

The two main things I wanted to improve upon were:

Aesthetics. There is nothing wrong with an Altoids tin, but there is alsoa lot of room for improvement as far as looks are concerned.

Batteries: The vast majority of DIY portable USB chargers use alkaline batteries, whichmeans that they must be replaced when they run out. Also, their capacityis not especially impressive.

My goal was to fix both of these problems, while using onlyparts I had lying around. Every single component of this charger I eitheralready had, or I pulled out of some broken electronic device. Because Ionly used what was available, the charging circuit uses a 7805 voltageregulator, meaning it is not especially efficient. On average, it willstill be more efficient than a 9V charger, because the peak voltage of theLi-Ion battery pack is around 7.5-7.8V. Had I built a Mintyboost typecircuit, it would no doubt have been more efficient. However, as thebattery pack I used is significantly larger than AA batteries or a 9V (it is 1/3of a 15" Macbook Pro battery, in fact), this device should be able topower any iPod, phone, or other USB powered device for hours at a time beforeit must be recharged.

So, how did I make it? First off, here's what I used:

Electronics:

7805 Voltage regulator
Resistors: 2x 49.7K, 1x 43K, 1x 74.9K (values do not need to be exact, and are taken from this instructable)
2X Lithium Ion Cells (I got mine from a "dead" Macbook Pro battery)
DPDTslide switch
Barrel jack
Thin gauge wire
Female USB connector
Heatsink (for the 7805)
iPod cable
13cm ribbon

Case and Structure:

Hot Glue - All the internal bits are glued together and insulated with this stuff
Aluminum flashing (approximately 12cm x 16cm)
1/4" plywood, preferably good looking (I used marine mahogany)
2x small wood screws
Epoxy
3mm Stainless Steel rod
Black paint
2x small neodymium magnets
Tung Oil
Satin spray-on acrylic

Tools

Soldering iron and solder
Dremel/rotary tool with sanding wheel
Needle files - square and circular
Scissors
Philips head screwdriver
Multimeter
Drill and small drill bit

Here's most of the Macbook battery I started with. The other cells appear to be dead, as they read under 1V. The cells on the right seemed to be fine though:

To get an iPod to recognize the charger, I followed the guide from this Instructable. I did not have the exact resistor values, so I improvised and created the correct resistances by soldering resistors of about double or half the required values in series or parallel. The result of this circuit is that the iPod gets 2.8V over both data lines, which signals the iPod to draw 1A from the charger. Many devices will charge without the added resistors, so if you do not own an iPod/iPhone do not bother with them.

After soldering the resistors together and to the voltage regulator, I connected a female USB connector to the appropriate parts of the circuit. When testing the circuit, be careful not to run it for too long, as the voltage regulator does not yet have a heatsink and will get hot.

Here's the (mostly) assembled circuit:

Working:

When building the charger, the most serious electronics problem I faced was that I only had a Li-Ion charger that could charge 1 cell, but in order to use the 7805 voltage regulator, I needed well over 5V, meaning that I had to use 2 cells in a series. To get around this problem, I designed a circuit using a DPDT switch. When the switch is flipped one direction, the two cells are wired in parallel, and are connected to a barrel connector for charging. When the switch is flipped the other direction, the cells are wired in a series, and output to the voltage regulator. This lets me charge the cells at 3.7V but discharge them at 7.4V.

Extremely informal schematic. The two top rectangles are the battery cells, and the two middle ones are SPDT switches. When I actually built the thing, I used 1 DPDT switch:

Wired switch. From left to right, top row then bottom row: Cell 1 +, cell 1 -, cell 2 +, cell 2 -, 7.4V out +, 7.4V ground, 3.7V ground, 3.7V out +:

Here's the circuit attached to the pair of battery cells, with a barrel connector soldered on to the charging input:

The only Li-Ion charger I had available was a camera battery charger, so I had to do some modifications to it so that it could charge this project. I opened up the charger, and soldered two wires connected to a barrel connector to the positive and negative terminals inside the charger. I then cut a small hole through the plastic wall of the charger, and routed the new wires out of the whole. Now, to charge the batteries, I simply flip the switch to the "charge" position, and plug the barrel connector coming out of the charger into the socket I added in the previous step.

Modified charger:

I decided it would be easier to build a good looking case if the charger had an internal structure holding it together. Then the case could be entirely aesthetic, rather than structurally important. To secure all the components, I simply hot glued them all to the battery cells, as compactly as possible. The downside of using lots of hot glue to hold everything together is that it is nearly impossible to fix any electrical problems that may arise. However, since the circuit used is very simple, I am hoping that nothing will go wrong any time soon. During this step, I added a heatsink to the voltage regulator as well. I used a thin segment of a heatsink pulled from a dead ATX power supply, and I cut and filed it to fit withing the dimensions of the charger. It already had a tapped hole in it, so I simply screwed it onto the 7805 with a little bit of thermal paste between the two. Before gluing everything together, make sure to test the circuit to see that nothing has gone wrong. You would not want to have to fix it once all the components are covered in glue.

Mostly glued together:

Heatsink:

All glued:

To eliminate the need for a cable when charging iPods or iPhone, I made a compact right-angle USB to 30 pin iPod adapter. To do this, I first cut both ends of an iPod cable. I removed as much plastic casing on both sides as possible, and on the Male USB end, I removed all the metal housing from the USB connector. I cut and stripped the four wires on both sides, and soldered the two ends back together with about 1-2 cm of wire connecting them. I then glued the two pieces together at a right angle, so that when the USB end was plugged into the battery pack, the iPod end would be in a plane parallel to the batteries. This way, when the iPod was charging, it could rest against the battery pack.

Stripped iPod plug:

Glued in position:

Plugged into the battery pack:

I made most of the case out of aluminum flashing. It is very thin, so it is very easy to bend and work with, but it also looks nice when finished properly. The casing fits very tightly around the internal components, so the insides are only held in position by friction. To bend the aluminum to the proper shape, I first cut a long strip about 1 cm longer than the length of the battery pack, and about 3 times as wide. I bent smooth curves by bending the aluminum around a 1 cm diameter dowel. I then put the electronics inside the rough aluminum case, and marked the locations of all the ports that needed to be cut: the USB port in the front, and the switch and charging ports along the side. To cut the holes for these ports, I first drilled small pilot holes and then used needle files to file the holes to shape.

When the aluminum was satisfactorily cut, I placed the electronics inside the aluminum, and plugged in a USB cable into the USB port and the charger into the charging port, to keep the enclosure properly aligned about the electronics. I then glued the seam in the metal with epoxy, and wrapped the assembly in electrical tape to hold the seam together while the glue dried

Flashing:

Roughly bent into shape:

Hole for charging filed:

I plugged things into the ports to hold everything in place while the epoxy was drying:

To give it a bit more strength and make it look better, I enclosed the USB to iPod adapter in aluminum as well. To do this, I bent a small piece of aluminum to fit the right-angle bend in the adapter. I then glued it in place, and filled out the rest of the adapter with glue, to give it an nice shape. To hide the color of the glue, I painted it all black.

To keep the adapter secured in place while connected to the battery pack, I embedded neodymium magnets into both the adapter and the charger. These magnets attract each other, and pull the adapter into place.

Way too much glue:

Painted black:

Magnet embedded:

Magnet glued just above the USB jack:

As I built the case, the switch that changes the battery pack from charging mode to discharging mode did not extend past the aluminum casing, and therefore could not be switched. To fix this, and make the switch look nicer, I made an extension for the switch out of a thin rod of stainless steel I had lying around. I drilled a small hole in the plastic sliding bit of the DPDT switch, and inserted a short length of the stainless steel rod into it. The bit of stainless steel extends past the aluminum housing, and lets the user actuate the switch.

Metal bit:

Plugged into the switch:

The aluminum enclosure is not covered at the ends, so I made wood endcaps to hold all the parts inside the aluminum. I chose to used some 1/4" mahogany marine plywood I had lying around, left over fromthe boat I built. I cut the basic shape using a coping saw, and then filed the pieces to shape. The final shaping was done with a very fine sanding wheel on my Dremel tool. I also ground out a lip that extends half way into each endcap, so that they can only push half way into the aluminum casing. I did this by using a routing attachment for my Dremel to keep the sanding wheel at exactly half the depth of the wood.

The electronic internals slide into the metal casing only from one direction, as the insides are thicker on the bottom than on the top. To fix the endcaps in place, I simply glued in the top one, since it never needs to be removed. To secure the bottom one, I added tabs out of glue, to artificially extend the depth of the cap. I then poke two very small holes into the sides of the aluminum casing, and screwed very small wood screws through them and into the glue tabs. This way, if I need to remove the insides of the charger, I can unscrew the bottom cap and just slide the insides out.

I also made wood caps for the the USB to iPod adapter, using the same method as before. These were just glued in place

I finished the wood by sanding it with 1500 grit paper, and then giving it a few coats of Tung oil.

Top end:

Bottom:

Finished with tung oil:

iPod adapter:

Screw hole:

Glue tabs on the bottom plate:

Screwed in:

By the time I had finished shaping the aluminum enclosure, it was quite scratched, and had an ugly seam down it where I glued it. To fix the seam, I filed down the edge of the seam so that the top layer of aluminum tapers down into the bottom layer. To fix the scratches, I brushed the aluminum with about 600 grit sandpaper, making sure to only sand in one direction. After sanding, the aluminum was much too shiny for my liking, so I sprayed it with two coats of satin acrylic spray. This evens out the color, makes it much less shiny, and also makes the metal feel nicer to the touch.

Surface before:

Surface after:

Since I wanted to be able to take it apart, I glued a ribbon onto the battery pack, which extends past the edge of the enclosure, and lets me pull out all the components. To assemble everything, you just push the glued together electronics into the case as far as they will go. Then you insert the bottom endcap, and screw it in place. Finally, you push the stainless steel switch extender into place through the slot for the switch.

Ribbon:

All put together:

Shellback Dinghy

2011-10-30T12:48:00.001-04:00

Back in the summer of 2007, I went to the Wooden Boat School in Maine with my granddad, and we took the Build a Shellback Dinghy class. We made very slow progress on the boat after that, and it is only now finished. The boat is made out of marine mahogany plywood, and it is just over 11 feet long. It has a mast, spars and sail in addition to oarlocks, but they do not fit on the boat in my granddad's indoor wood shop.

Here is the boat a couple of years ago:

Here you can see the red paint below the waterline:

In the back ground here is the Nutshell Pram my granddad has been working on since long before we started this boat:

I do not have any pictures of it completely done, but now it has the seats in, the rudder and tiller mounted, and all the hardware such as oarlocks in place.

iMac Mini

2011-09-22T16:46:00.000-04:00

I started this project because I had a small pile of Macbook laptops and white iMacs in various states of functionality. For this project, I used the stand and friction hinge from a 2006 iMac, the LCD from a Macbook that had coffee spilled on it, and the motherboard from a Macbook with a smashed screen. The keyboard header on the motherboard was missing, so I had no way to use it in a laptop. I decided to build a miniature iMac-like computer out of the parts I had. As it turned out, I built the computer only to find out that the USB ports on the motherboard I used were dead, rendering the computer useless. It was still a fun project though.

As you can see from this picture, the header for the laptop's top panel had been ripped off the logic board. It should be where the two rows of 5 grey rectangles now are:

Unfortunately, the power button on a Macbook is on the keyboard. However, they have two pins on the motherboard which can be shorted to turn the computer on. I soldered wires to these pins, so that I could later attach a new power button. The power button symbol is visible here:

Wires attached:

Here's the laptop's CPU. Not too shabby:

Here's the screen I used:

And the iMac stand:

Next, I worked on the LCD. To mount the LCD, I decided to flip the panel around within its frame, so that it faced outwards when the laptop was closed, instead of inwards. For this to work, I had to extend the wires to the screen's inverter:

Next, I cut out the back of the plastic LCD frame, so that the LCD panel would be visible. I did the rough cutting with a dremel, and filed it to shape:

I also cut holes for the webcam, webcam led, and microphone:

Here's the size of the frame compared to a 17" iMac:

The LCD panel was held into the plastic by a metal frame. I unscrewed it from the frame, flipped the LCD around, and screwed the frame back on. I then screwed the frame down to the modified plastic enclosure:

Here is the LCD placed back on top of the rest of the laptop:

To attach the modified laptop to the iMac stand, I first cut a piece of steel sheet to fit the back of the laptop:

I filed the friction hinges smooth:

I then soldered the friction hinge to the metal sheet, using some heavy solder and a propane torch:

Not very pretty at first:

Cleaned up with sandpaper:

Here's the piece screwed to the base:

I removed the friction hinge that normally held the laptop's screen in place, and replaced it with four metal brackets. These brackets screw first into the LCD's frame, and then into the base of the laptop, holding the two parts together:

I cut a hole in the back of the metal back sheet for the MagSafe power adapter port:

I also drilled a hole for a power button. I reused the power button from a white iMac:

To fix the metal back to the base of the laptop, I just epoxied it in place:

I extended the wires for the MagSafe connector, and glued the port in place. I then assembled the computer:

I stuck a hard drive from another mac in the computer, and booted it up only to find out that the USB ports do not work, rendering the computer completely useless. USB devices get power, but the computer does not respond to them in either the OS or the EFI. I may be able to circumvent this problem by buying a firewire to USB hub, or using bluetooth, but I have not yet had the chance to try.

Tree Climbing Robot

2011-08-29T21:40:00.001-04:00

After I got comfortable programming and building with an Arduino, I decided to build a robot. I did not have any particular type in mind, so I wracked my brain (and the internet) for cool robot ideas. Eventually, somehow the idea popped into my head to build a robot that could climb trees. At first I dismissed the idea as beyond my skill level, but after further thought, and some time in Sketchup, I decided to take a shot at the challenge. This is the result of my efforts.

Cross posted from my Instructable here:
http://www.instructables.com/id/Tree-Climbing-Robot/

I started out by creating a basic design in Sketchup. The robot was to consist of two segments, joined by a spine which could be extended or retracted. Each segment would have four legs with very sharp points as feet. To climb, the legs on the top segment would pinch together and the sharp feet would dig into the bark, securing the robot. Then the spine would be retracted, pulling up the bottom segment. The legs on the bottom segment would then grip the tree, and the top segment would release. Finally, the spine would extend, pushing the top segment upwards, and the process would repeat. The climbing sequence is somewhat similar to the way an inchworm climbs.

In my original design (show in the images above), all four legs in each segment were controlled by one highly geared down motor. I decided to ditch this idea for a few reasons. Firstly, I could not find the type of spur gear needed to mesh the legs together. Also, with all the legs linked together, the robot would have a hard time gripping uneven surfaces. Finally, I decided that the robot would be much easier to build if the motors drove the legs directly.

The other significant change I made from my original design was the way the spine worked. In my model, I used a rack and pinion type gearing system to extend and contract the spine. However, I could not find the necessary parts to build such a system, so I ended up using a threaded rod coupled to a motor to actuate the spine.

Original design:

Tools and Materials:

Microcontroller

Arduino Uno (any will work)

Motor Controller

3X L298HN - these can be gotten for free as samples from ST
2.5" x 3.125" Perf Board
Terminal Strips
22AWG Solid core wire
3X Aluminum heatsinks (I cut in half an old northbridge heatsink)
Thermal paste

Power

9V Battery (to power the Arduino)
Approximately 12V LiPo or Li-ion battery (I modified a laptop battery, so I did not even need to buy a charger)
5V regulator (To regulate power to the motor controller logic circutry)
9V Battery clip
Barrel connector (Must fit the Arduino power connector)

Other Electronics

4X 7 RPM Gear Motor (These power two legs each)
4X Thin linear trim pots (Rotation sensors for the legs)
DPDT Toggle switch (Power switch)
SPDT Slide switch (User input)
2X Mini Snap Action Switch (Limit switch)
3 10K resistors (Pull down)
Headers
Signal Wire (Old IDE cables work really well, and let you organize your wires easily)
Heat Shrink Tubing

Hardware

12' 3/4" x 1/8" Aluminum Bar (These come in 6' lengths at my local hardware store)
6" x 3" acrylic sheet (Electronics are mounted to this)
6x Standoffs with screws
1' Threaded rod and corresponding 1/2" nut
2X 1' x 3/16" steel rod
1' x 3/16" I.D. Brass Tubing
4X 5mm Aluminum Universal Mounting Hub
Pack of large T Pins
4X 3/32 screws (to mount the motors)
An assortment of 4/40 screws and nuts
Assorted hex screws and nuts
4X Bic pens (I used the plastic shafts to fix the pots on the legs in place)
4X Locknuts
5 Minute epoxy
Sheet metal scraps (For spacing and mounting things. Bits of Meccano work well)
Stick on Velcro (For holding on the batteries)
Hard Drive reading head bearing
3/4" Plastic angle
Electrical Tape
Zip Ties

Tools

Electric Drill / Drill press (As well as a lot of bits)
Hacksaw
Soldering Iron
Pliers
Allen wrench
Assorted screwdrivers
Wire Strippers
C Clamp (These can be used to make nice 90 degree bends in the aluminum)
Ruler
Files

Nonessential

Bench PSU
Multimeter
Breadboard

Arduino:

Motor controller parts:

Motors:

The motor controller I built for this robot is based off the L298HN Dual Full Bridge chip. To use the chip, I followed the guide here. To start out, I placed all the components on a piece of perf board, to figure out the layout. With this chip, each motor requires three inputs to work: an enable signal and two input signals. The enable signal is used to control the motor speed with PWM, but since I did not need to control PWM, I just wired all the enable pins in parallel to a 5V line when I hooked the controller up to the Arduino. Once I figured out the layout, I soldered all the components in place, and made connections with 22AWG solid core wire. Finally, I spread some thermal paste on the back of the L298's, and screwed on the heatsinks. The particular heatsinks I used were made by cutting in half a northbridge heatsink from a computer motherboard, and drilling and tapping a hole for the screw. They are probably much larger than needed, but there is no harm in having over sized heatsinks. A higher resolution image of the labeled board can be found here.

When finished, this motor controller should be able to bidirectionally control 4 DC motors at up to 2A each (probably 2A continuously, because of the size of the heatsinks). As you may notice, this leaves me one motor short. My original design used a servo to actuate the spine, but I had to change my design to using a DC motor. To power it, I wired my third L298 chip to a molex connector (so I can disconnect the motor) and soldered on wires for all the connections. It does not look as pretty as my controller on a circuit board, but it works.

I have a writeup building the motor controller here:

http://build-its.blogspot.com/2011/06/dual-l298hn-motor-driver.html

Here's the controller:

The robot's power is supplied by two different sources. The Arduino and the motor controller logic circuitry are powered by a 9V battery, while the motors are powered by an approximately 12V Li-Ion battery pack.

I wanted to avoid having to buy an expensive LiPo/Li-Ion battery pack and charger, so I searched through my piles of electronic junk for a device with an appropriate battery. I settled on the battery from a 12" iBook laptop. The battery was 10.8V and 50Wh, but it was a little large and heavy for my needs. To fix this, I tore it open and had a look at the internals. I found that the battery was comprised of six 3.7 volt cells. These cells were organized in pairs of two wired in paralleled. The three pairs were then wired in a series, making a total 11.1V. To shrink the pack but keep the voltage, I simply removed one cell from each pair. The final battery pack had only half the capacity and half the discharge rate of the original (now only 2C), but the full voltage. I then wrapped the cells together with electrical tape so they would hold their shape, and soldered a quick-disconnect connector to the battery leads.

Original Battery:

Casing removed:

New layout:

Wrapped in electrical tape:

The Arduino and the logic circuitry for the motor controller are both powered by a 9V battery. While the Arduino can take 9V input, the logic circuitry requires 5V, so I wired a 5V regulator in paralleled to the 9V going to the Arduino. Now, why did I not just take advantage of the Arduino's internal 5V regulator? Well, basically I ran out of pins, and I did not want to overdraw the Arduino. In addition to the regulator, I soldered a barrel power connector to the 9V end of the circuit, to fit into the Arduino. Finally, I added a DPDT toggle switch to break the 12V battery circuit as well as the 9V battery circuit.

On/Off switch:

5V regulator:

The legs are some of the most important parts of this robot, because their design determines whether or not the robot can grip onto trees. I decided to have four pairs of legs, each pair controlled by one motor.

To make the legs, I cut four 8.5" lengths of the aluminum bar. I marked the segments 2.5" from each end. At those marks, I bent the aluminum at a right angle, to make a "U" shape. If you do not have a bending brace (which I don't) you can get a clean bend by clamping the aluminum with a c-clamp right on the mark, and pushing the unclamped end against a solid surface, like a work bench.

Legs:

To grip the tree, the robot has very sharp feet at the end of its legs (where else?). The feet are made from jumbo-sized T pins, which you can get at your local fabric store. To fasten them to the legs, I made some clamps out of aluminum. I cut 8 3/8" or so lengths of aluminum, and filed a thin groove lengthwise into each of them, for the pins to fit into. Then I drilled a pair of holes into the aluminum, and corresponding holes into the ends of the legs. The clamps were then bolted down to the legs, with the pins inserted in the grooves. I left about 3/8" of an inch of the pins extending form the legs, but the length can be adjusted by loosening the bolts.

The next step is to couple the legs to the motors. I found these handy 5mm mounting hubs, which were perfect for the job. I drilled four holes in a square on one side of each pair of legs, and screwed the hub to the legs with 4/40 screws. To fix the motors to the legs, you simply line up the flat side of the motor shaft with the screw in the hub, and tighten the screw.

Hubs mounted:

Fixed to the motors:

With the legs finished, the next step was to build a frame to hold the motors and legs together and in place. I started the frame by making a plate out of aluminum to hold the motors together. I drilled the plate to fit the screw holes of the motors and the gearbox shaft. The motors are held in place by 3/32 screws.

Next, I made a matching plate for the opposite side of the leg assembly. This plate holds the legs straight while they turn. I drilled holes through the legs, opposite to the motor hubs. Then I bolted the legs through the plate with washers and a locknut to hold them in place and let them spin freely on the bolt.

Next, I made a piece out of aluminum to fix the two opposite plate together. This piece sits between the pair of legs on each assembly, and is the primary structural support of each segment. As well as holding the robot together, it provides a place to mount the electronics and other components later on.

I bent the aluminum at right angles using a c-clamp, and drilled four holes in each end. I drilled matching holes in the motor plate and the opposite plate in each leg assembly, and then bolted everything together with 4/40 screws.

Once both segments of the robot were built and structurally sound, I could test their tree-gripping ability by hooking the motors up directly to a battery. Fortunately, they worked quite well, or I would have had nothing else to share.

Aluminum backbone:

To hold the electronics, I cut an approximately 6" x 3" piece of acrylic. I drilled six holes in it and screwed standoffs into the holes, to support the Arduino and the motor controller. Then I drilled four holes in the top of the leg assembly, and bolted the acrylic to the assembly, with spacers to lift it up above the motors. Finally, I screwed the Arduino and motor controller into the standoffs.

Rotation sensors are key to the operation of this robot. It has one rotation sensor per motor, so the robot knows the exact position of each leg at all times, allowing for precise control of the legs. For my rotation sensors, I used four very thin trimpots I had lying around. Pots are extremely easy to interface with the microcontroller, and are plenty precise for my purposes. They were not, however, very easy to interface with the hardware of my robot.

While designing and building the leg assemblies, I neglected to build in an easy way to connect the potentiometers to the legs. In the solution I came up with, one side of the pot is fixed to the inside of the leg by the protruding screw heads. The other side of the pot is fixed to the locknut on the end of the bolt that holds the leg in place. When the leg turns, the side of the pot fixed to the leg turns, while the side fixed to the locknut is held in place.

To interface the pots and the legs, I first sanded the plastic side of the pots flat. I took four squares of acrylic, approximately 3/4" on each side, and drilled four holes in each, corresponding to the four screw heads in each leg. Then I glued a potentiometer to the center of each acrylic square.

To fix the opposite side of the pots to the locknut I had to get even more creative. First, I glued metal standoffs scavenged from a PowerMac G5 case to the metal side of the pots. Then I glued the plastic shaft from a Bic pen to the metal side of the pots. The other ends of each pen were cut to fit within the metal legs. Then the pen shaft was forced over the square locknut and epoxied to it.

Pots glued to acrylic:

To move up and down a tree, the robot extends and contracts by spinning a threaded rod that is fixed to the top segment. When the rod is spun clockwise, the two segments are pulled together, and the are pushed apart when it spins counter clockwise. To spin the rod, I needed a relatively high-torque low-speed motor that would run at 12V, and I happened to find just such a motor in my box of parts. This particular motor came fitted with a brass gear. To assist with coupling the motor to the threaded shaft, I filed two sides of the gear flat.

To mount the motor to the robot, I bent a short length of aluminum to an "L" shape. I drilled a large hole out of the center of one of the faces (for the motor shaft and gear) and two small holes in both faces for bolting the motor to the metal and bolting the metal to the robot. I drilled corresponding holes into the back of one end of the segment of the robot without the electronics, so that the motor was positioned between the two legs.

There are a couple problems with getting a threaded spine to spin smoothly. First, it must be coupled to the motor well, and second it must have some sort of bearing fixed to it on which it can spin. One of the first things I found while trying to couple the motor shaft to the threaded rod was that the connection should be flexible for smooth operation. I made my coupling out of two segments of clear nylon tubing. A wider diameter segment fits tightly over the gear attached to the motor shaft, while a thinner segment fits into the larger tubing and tightly over the outside of the threaded shaft. The coupling is secured with a zip tie.

With only the coupling, the threaded shaft still can not bear any load, because it would just pull off the motor. To support load, I made a bearing for the shaft out of an old hard drive read/write head bearing. I drilled out the center so that the threaded rod could pass through it. I then fed the rod through it, and fastened a nut on each side of the bearing, to hold the threaded rod in place. I then bolted the bearing down to the back of the robot's frame.

Bearings:

Coupling:

For the spine to work, it must pass through a nut that is fixed to the other segment of the robot. For ease of mounting, I used a large 1/2" long nut. To fix it to the segment of the robot, I cut two ~4" lengths of aluminum, drilled them to match the bolts that hold the acrylic piece, and mounted them through the screw holes, across the frame. These will later become supports for linear slides. I then drilled four more holes around the center of the back of the robot, with enough space between them for the nut to fit. I cut a piece of aluminum to run along the back of the robot, and drilled it to match the holes. I then placed the nut on the back of the robot, placed the bar of aluminum on top of it, and bolted through the bar, to sandwiched the nut between the two pieces of aluminum. Finally, I threaded the rod through the nut.

Without something holding the two segments of the robot in the same plane, the top segment would turn when the threaded rod turned, instead of moving up or down. To keep the two halves of the robot in the same plane, I built linear slides out of two steel rods and brass tubing.

First, I added a pair of aluminum bars to the segment of the robot without the electronics, to match the pair on the other segment. To mount the steel rods and the brass tubing to these, I made a clamp system similar to the clamps holding the feet in place. To do this for the large diameter rods, I first clamped two 3/4" squares of aluminum together. I then drilled a 1/8" hole down the intersection of the squares, and then took them apart. I drilled two holes in each square, and corresponding holes in each supporting arm. Then I repeated the process four times. To get the slides perfectly parallel to the threaded rod, I had to bend up the supporting arms on the non-electronics segment of the robot.

Clamps:

The next step is to wire all the electrical components of the robot together. I started out by soldering long wires to the contacts on the motors. I twisted the wires together by chucking one end in an electric drill and holding the other end with pliers (a trick I learned from the Ben Heck show). Next, I wired together the pots on the legs. I did this using segments of ribbon cable from an old IDE cable. I wired the pots so that they all had a common ground and input voltage. The input voltage was connected to the +5V pin on the Arduino, and the four signal wires were soldered to headers and then connected to analog inputs A0 - A3 on the Arduino.

Because this robot is autonomous, I needed a method for controlling the robot's actions so that I could get it to release from the tree. For this, I just used a simple slide switch connected to a digital input on the Arduino

Next, I wired the digital output pins on the Arduino to the inputs on the motor controller. First, I connected all the motor enabling pins on the motor controller to eachother. The rest of the wiring went as follows:

Enable Motors
Motor 4 Input 2
Motor 4 Input 1
Motor 3 Input 2
Motor 3 Input 1
Control Switch
empty
Motor 2 Input 2
Motor 2 Input 1
Motor 1 Input 2
Motor 1 Input 1
Motor 5 Input 2
Motor 5 Input 1I then connected the motor's leads to the terminal strips on the motor controller, and connected the motor voltage terminal to the 12V battery pack, via a toggle switch. I connected the 5V regulator to the logic voltage terminal, via the same toggle switch.

I collected the umbilical cord of wires running between the two segments of the robot into a bundle, and fastened them together with zip ties and electrical tape, to keep them organized.

Pot wiring:

Arduino to motor controller wiring:

Umbilical cord:

Control switch:

Power switch:

Because I used a regular DC motor instead of a servo or a stepper to spin the threaded rod that is the spine, the robot can not know the degree of extension of the spine at all times. Therefore, limit switches must be used to prevent it from extending or contracting too much.

The spine has two limit switches. One is pressed in when the two segments of the robot are pulled close together, and the other becomes un-pressed when the threaded rod retracts past it. The latter is a switch like this glued parrallel to the threaded rod, on the segment of the robot with the electronics. When the spine retracts, it pushes down the lever of the switch, and when it retracts, the switch opens.

The second limit switch is a push button switch that requires very little force to actuate. I mounted it on a strip of aluminum from the front of the electronics segment.

Both the switches are connected to the same 5V and ground lines as the potentiometers on the legs, and their signals go to inputs A4 and A5, which the Arduino is set to read as digital inputs rather than analog.

The last mechanical part of this project was to create a way to hold the batteries, while making sure that they are easy to remove for replacement or charging.

The perfect place for mounting the 9V battery was right above the Arduino, so I created a mounting system for it out of some scrap metal. A piece of metal (with an electrical tape insulated bottom) screws on above the Arduino through one of the standoffs. On top of the metal is a bit of stick-on velcro. A piece of metal bent into a "U" shape clips onto the 9V battery, and then sticks to the velcro above the Arduino board, holding the battery in place.

To hold the larger battery pack, I cut two brackets out of some soft plastic angle bar I had lying around. These brackets screw into the arms that hold the linear slides. The battery stays in mostly by friction, but a bit of velcro on one side helps to stop it from slipping out.

9V holder:

Battery pack holder:

To climb up a tree, the robot goes through a simple series of motions. First, the top segment grips the tree and the bottom segment releases form the tree (if necessary). Then the spine contracts, pulling the bottom segment up towards the top segment. Next the bottom segment grips the tree, and afterwards the top segment releases from the tree. Finally, the spine extends, pushing the top segment upwards, and the cycle can start over again. For ease of programming, I wrote a function corresponding to each basic motion. These are as follows:
closeTop
closeBottom
openTop
openBottom
Lift
PushBy combining these functions in the proper order, the robot can be made to ascend or descend trees.

Opening the legs is very simple. The legs turn outwards from the tree until their rotation sensors reach a point set in the program. Then power is cut off to the motors. Closing the legs on the tree, however, is a little bit more complex. Since trees vary in diameter, the legs need to be able to grip a wide variety of diameters without reprogramming the robot for each size. To figure out when to cut off power to the motors, the controller first calculates the speed at which the legs are moving towards the tree. It does this by sampling the position of the legs' pots every .05 seconds. It subtracts the previous value of the pot from the current one to find the distance traveled by the legs over the time period. When the distance travels becomes close to zero (I used 1 in my program), it means that the legs have gripped into the tree and are beginning to slow down. Then the controller cuts of power to the motors, to prevent them from stalling out, or damaging themselves, the motor controller or the gearboxes.

The last piece to the programming puzzle is the method of controlling the robot's actions. If you look at the above movement cycle, you will notice that the robot is gripping the tree at all times. This makes it difficult to remove the robot, so I programmed the control switch to manually control the behavior of the robot. While the switch is off (circuit open), the robot keeps its legs open. Once the switch is turned on, the robot begins its climbing cycle. To remove the robot from the tree, the switch is turned back to the off position.

Update
This project was featured on Hack A Day! Thanks for the great article.

You can download the code for this project here:

http://www.instructables.com/files/orig/FQ7/33F3/GRFMV1BK/FQ733F3GRFMV1BK.tmp

Predator-Prey Simulation

2011-08-16T13:28:00.000-04:00

Since I started programming, I have thought it would be interesting to attempt to approximate life within a computer program. I started this project on my own, but finished it, collected data from it, and wrote a paper on if for my final CS class project.

What my final program does is create a virtual Petri dish with two types of cells in it: predator cells and prey cells. As the cells move around in their virtual environment, the predator cells try to chase down the prey cells, and the prey try to escape the predators. If the predators do not eat for a long time, they die of starvation. As the cells move in the simulation, the also replicate. All of the cells, both predator and prey, have two individual attributes: sight radius and movement speed, which are passed on from parent cells to child cells. However, as the cells replicate, there is a small chance that the child cells "mutate." In other words, one or both of their attributes has a slightly different value than the parent cell's attributes. These random mutations allow for natural selection to occur within the simulation, provided it runs for long enough. The most effective predators will survive the longest, and therefore produce the most offspring, so their desirable attributes proliferate. The same applies to prey cells that can escape most easily. As the simulation runs, it outputs the average attributes of all of each type of cell to a text file at regular intervals. If the simulation is run for a long period of time, these values can be evaluated, and one can see if natural selection occurred or not, on average.

In the simulation's graphics, red squares represent predator cells. Other colors represent the prey. The color of they prey is determined by the cells movement speed, in order to help visualize the mutations that occur. Green prey are the slowest, and magenta prey are the fastest. Along the bottom of the window, the average speed of the prey (the black dots) and the predators (the red dots) are graphed. Vertical black lines indicate the start of a new simulation. This happens when all of one type of cell become extinct. Alternatively, the graph can be used to track the populations of the predators and prey. For faster data collection, the graphics can be disabled, which increases the speed at which the program runs by about ten times.

The python 3 code can be found on Instructables, here:

http://www.instructables.com/files/orig/FVL/IYEL/GREPYCQF/FVLIYELGREPYCQF.py

The graphics can be enabled or disabled by commenting out the line "canvas.update()" in the function "run()."

The program, especially when run with the graphics, is highly CPU dependent, and the speed will decrease significantly as the simulation is populated. To change the results of the simulation, the cells starting attributes (including rate of reproduction and rate of mutation along with the two others descibed) can be modified, as can the starting populations and the map size.

More Blacksmithing

2011-08-16T12:06:00.000-04:00

I spent another 4 days blacksmithing, and came up with this:

I mostly made up the piece as I went along. The entire thing can be taken apart and put together without any fasteners, and there are close-up pictures after the break:

This is the bit that converts the circular motion to a linear motion:

This piece is part of the stand, and it clips onto the rails of the above piece. The bottom fits into the circular base:

Here you can see the grooves that the linear actuator clips into:

This part fits onto the stand above. The bell fits onto the hook at the left end, and the arm with the slot hits the bell when it is moved back and forth by the linear actuator. The slot was cut with a die grinder and filed smooth:

This circular bit supports the rest of the gizmo:

This is the bell. It was forged out of a short segment of 1" round steel pipe:

Here you can see how the linear actuator fits into the slot to move the arm that hits the bell:

In this picture you can see how the linear actuator fits into the stand, and how the bell and arm holder attach to the stand:

The spiral handle is attached in grooves, so it spins as you turn the crank around:

Dual L298HN Motor Driver

2011-06-25T17:48:00.000-04:00

I built this motor controller to power the motors for an Arduino-controlled robot I am working on. It uses 2 L298HN dual full-bridge chips, each of which is capable of powering 2 DC motors at 2A each, with bidirectional control. You can get up to 3 of the L298HN chips for free from the ST website. The rest of the parts needed are as follows:

Components:

Placement:

Soldered:

I cut an old northbridge heatsink in half and drilled and tapped it to fit the chips:

Here's the board's layout:

Next to an Arduino for a size reference:

In use:

GUI Controlled LED Matrix

2011-06-23T16:08:00.004-04:00

I recently got an Arduino Uno, and it quickly became my favorite toy. After learning the basics of how the platform operates, I became interested in interfacing the Arduino with personal computers. After seeing a large number of LED matrix projects on Instructables and the rest of the web, the LED matrix seemed like a perfect project to attempt to interface with a computer.

I chose to build a 3 x 3 matrix, because I thought it would be best to start small (and I did not have enough LED's for a larger one). Also, 3 x 3 is about the largest size it is safe to power directly from the Arduino, without using an external power supply. However, the design for the matrix and the software in this Instructable should be fairly easy to scale up to 8 x 8 or so, by using an external power supply and some transistors.

Unlike most of my projects, this one is not very hardware focused, so the materials list is not too long. If you have played with an Arduino before, you will likely have all of these parts on hand.

To build the matrix, you will need:

Arduino microcontroller: I used an Arduino Uno, but pretty much any will work.
9 LED's: Any sort should work. I had some left over from my bicycle's spoke lights
3 resistors: These are to prevent the pins/LED's from burning out. I used the 330 Ohm variety, but anything around there should work
A breadboard
1 Foot of thin gauge electrical wire: To connect the negative ends of the matrix to the breadboard
6 breadboard jumpers
Soldering materials

To run the software:

A Mac or PC with the Arduino IDE and Python 2.6/2.7. Unfortunately, I could not get Python 3 to talk to the Arduino, so you'll have to use python 2.

The matrix itself is fairly simple to build, and if you are building one as small as 3 x 3, it can be built without any sort of jig to align the LED's or circuitboard to hold the components.

To start out, bend the anodes (the longer leads) of all 9 LED's to a 90 degree angles, perpendicular to the plane the leads are on. Then bend the cathodes (the shorter leads) to 90 degree angles parallel to the plane of the leads. Make sure the leads extend farther out of the LED before bending on the cathodes than the anodes.

Next, divide the LED's into groups of three. Solder the cathodes of all three LED's together, so that the LED's form a chain. The anodes of the chain should all stick out in the same direction. Once you have done this three times, you will have three chains of three LED's. Then you can solder the anodes of each chain to the anodes of the next chain. If all your bends are 90 degrees, and you secure the LED's while you solder them, the LEDs' leads should form a nice grid.

Once all the LED's are soldered together, solder a resistor to the three anode leads that are not connected to other LED's. Finally, solder a short length of wire to each of the three cathode leads protruding from the matrix.

For ease of construction and disassembly, I hooked the matrix up to my Arduino using a mini breadboard and breadboard jumpers. I simply plugged the matrix into the breadboard by the three anode pins. To attach them to the breadboard, I soldered solid metal leads to the ends of the cathode wires. I used the leads that I clipped off the resistors.

I attached the leads to the Arduino in the following order:

Left anode: Pin 2

Center anode: Pin 3

Right anode: Pin 4

Top cathode: Pin 5

Middle cathode: Pin 6

Bottom cathode: Pin 7

The advantage of building the matrix to be controlled by rows and columns is that you do not need a pin to control every single LED. The downside, however, is that certain LED's cannot be displayed simultaneously without lighting up other unwanted LED's. To prevent unwanted LED's from lighting, the display must be multiplexed, wich takes advantage of an effect called persistance of vision (POV). To use this effect, the Arduino will actually only light one row of LED's at a time, but it will cycle through the rows so quickly that the image will look solid.

Now, I do not know if there is a standard for how LED displays cycle through the rows/columns, but I wrote my POV controlling program from scratch. If you go down to the basics, it works like this:

The Arduino's code contains a set of arrays (one could also use a single 2D array), one for each row, that indicates which LEDs in the row are activated. The program scans through these arrays one at a time, and the Arduino lights only the LED's which are indicated in the one row. It lights the LED's in the row by setting the pin for the row to "LOW" and the pins for the lit LED's to "HIGH." Every cycle, the program also runs a function which gathers input over a serial connection. Inputs are in the form of integers, which correspond to an LED on the matrix. The matrix is arranged as such:

[0, 1, 2]
[3, 4, 5]
[6, 7, 8]

If the code receives the number "6" over serial, the state of the bottom left LED in the array is switched.

You can download the code for the Arduino here:

http://www.instructables.com/id/GUI-Controlled-LED-Matrix/step4/Programming-the-Arduino/

I programmed the program and GUI that control the LED matrix in Python, using the built-in Tkinter graphics module. The design of the GUI is very simple. It contains nine buttons, each representing one LED. When the buttons are clicked, they turn orange, and when they are clicked again they turn white. As the buttons are clicked, they update the LED matrix in real-time.

In order for Python to communicate with the Arduino, it needs the Pyserial module. Once this is installed, you can read and write to the Arduino over the serial connection.

In my program, whenever a button is clicked, the button calls a function which writes the number of the button to the Arduino. Using that number, the Arduino figures out which LED the number corresponds to, and switches the state of that LED.

When running it, there are a few things to note:

If you run the file in Windows, it is advisable to simply double click the file instead of opening it in IDLE (the python IDE) and running it from there. Also, you will have to set the serial port to use within the code. By default, it is set to 2, which corresponds to COM3 on Windows.
Mac users: I have not tested the program on a mac. Please let me know if there are any problems with it, so I can try to fix them. Python sometimes behaves differently on Macs, especially when dealing with graphics stuff.

You can view or download the Python code here:

http://www.instructables.com/id/GUI-Controlled-LED-Matrix/step5/Programming-the-User-Interface/

To test the matrix, plug it in to your computer, and download the program to it from the Arduino IDE. Then run the Serial Monitor. You can use the number keys, 0-8, to test each LED and make sure the program is running correctly. Then you can run the Python GUI program. Before you do so, make sure you have closed the Serial Monitor in the Arduino IDE, or the Python will not be able to connect over Serial, since the port is already in use. When you quit the GUI, you can go ahead and connect to it in the Arduino IDE again, because the GUI closes its connection when it quits.

Have fun playing with your GUI controlled LED matrix! I have found that it is almost infinitely entertaining to small children. If you build your matrix with different color LED's, you can easily change the color of the buttons in the GUI to match your LED's, using hexadecimal color codes. The section of the code that must be changed is clearly commented.

I would like to create a much larger 8x8 version of this matrix. 8x8 is the largest size you can build on an Arduino Uno without using shift registers or other controlling circuitry, other than some transistors for the power. If you build one of these, please post pictures, and I will post them in this last step. The construction of the matrix actually very little work. Programming it took far longer, and I have already done that part for you.

Useless Machines

2011-06-05T18:26:00.000-04:00

I built three "Useless Machines" within the last few months, and here are two of them. I made one for my younger sister to decorate and give to her science teacher, and the other out of leftover parts I had. The circuits of both have been modified from the standard circuit to include an LED strip. The LED's are wired through the bumper switch, so they only light up when the box is open and the arm is moving.

I made the wiring extremely need for this one, both for looks and serviceability.

Here's a video of it working. You can see how bright the LED's are well in it.

The second box is a completely different design, because I had smaller box and different shaped gear motor.

Messy wiring and DIY battery clip:

For more info on building useless machines, go HERE.

How to Fit Your PC in a Power Mac G5 Case

2011-04-17T11:47:00.000-04:00

Whether you are an apple fan or not, it is hard to disagree with the fact that the Power Mac G5 computer looks great, inside and out. My goals for this project were to preserve the look of the case, inside and out; fit my PC's hardware, including a full length ATX motherboard, 2 GPU's, and a CoolIt ECO; and keep the system fully upgradeable, meaning no modifying the hardware.

I started out with a broken Dual 1.8 Ghz G5 with all the parts save the HDD's.

Although it looks very neat and tidy on the inside, the G5 is an absolute pain to completely disassemble. Here are the CPU's mounted to their heatsinks. The stock AMD cooler is for size reference:

Here is the PSU compared to a standard ATX one:

Motherboard:

Interestingly, the motherboard has its chipset heatsinks on the back of the board, rather than on the front:

To start, I completely emptied out the case, including the latching mechanism that holds the side panel on:

Since this case must fit a full ATX length motherboard, I had to cut the top divider to give the board clearance:

Since the motherboard now sat where the HDD cage was mounted, I had to move the cage forwards so the board could fit under it. For it to fit, I had to cut the cage's plastic shorter:

Then I screwed it to the divider:

I then reinstalled the latching mechanism:

Since I wanted to keep the original internal look of the G5, I rewired all the stock fans to fit standard Molex connectors. All fans run of 5V, since they sound like leaf blowers at 12. I used wiring diagrams found HERE. For the front pair of fans, I reused the slide-in plug, so the fans can be hot-swapped.

I ended up not using the HDD bay fan and blower for clearance reasons, but I did wire them up as well:

To mount the motherboard, I removed the stock standoff by popping them out with pliers, and built a motherboard tray out of the steel side panel of an old case and some aluminum flat bar.

Because the stock G5 PSU is much longer and shorter than an ATX one, mounting the power supply was one of the most difficult parts of this project. Also, the front fans and the CPU cover both mount to the bottom divider, which is screwed directly into the stock power supply. To fit an ATX one but keep the bottom divider, I cut a hole in both the divider and the casing of the original power supply. I then added an aluminum bracket which the PSU can be screwed to on one side using a thumb screw. The other side of the power supply is fixed down with a neodymium magnet I glued to the bottom of the stock PSU. If you happen to have to glue a strong magnet, remember not to used JB Weld, as it has steel in it. The glue is attracted to the magnet, so it flows around the magnet and tries to coat the outside of the magnet evenly.

When the CPU cover and fans are in place, the PSU is nearly invisible:

The next step was to rewire the G5's front panel to fit standard ATX headers. The wiring diagrams for this can be found in the same place as the fan pinouts.

Next I made a new back panel for the case out of some thin aluminum sheet scavenged from an old baking sheet. As it was, the back panel fans interfered with the motherboard's I/O, so I had to move the fans off-center. All the rough cuts were done with my a rotary tool, and then filed.

I used used the original fan grill as well:

I cut out the original back panel, and mounted the new one with hex screws:

Since I had to move the fans, they stuck out of the case, so I had to cut their plastic mounting bracket shorter:

Then I cut the PCI divider so that the motherboard could fit under it, and made a mounting bracket for it out of aluminum:

The PCI divider supports 3 fans as well as the CPU cover:

I epoxied the motherboard tray in place:

Then I transplanted my PC's innards into the case:

I removed the ECO's stock fan, and bolted it to the pair of back panel fans using spacers. This has had absolutely no impact on CPU temps:

My second GPU just barely fits: the passive heatsink is actually touching the top divider.

PCI divider and fans installed:

With the CPU cover:

Bench PSU

2011-04-01T23:02:00.004-04:00

This is a bench-top power supply built to power my various electronics projects. It is built from a PC Power and Cooling Silencer 470 watt PSU.

Here is the stock PSU:

Power ratings:

28A at 3.3V

32A at 5V

26A at 12V

.8A at -12V

Here is the inside of the PSU. It is pretty crowded in there as it is.

Next I installed a switch on the front to turn it on and off:

I then cut all the connectors off.

I installed 5 banana jacks on the front: Ground, 3.3V, 5V, 12V, and -12V.

I then connected the wires to crimp-on connectors, which can be screwed to the back of the banana jacks. Blue is -12V, red is 5V, orange is 3.3V, and yellow is 12V. I used up to 3 wires per connector, and up to four connectors per jack in order to get the maximum possible current flow.

Switch:

All the internals wired together:

Power LED:

Leads connected to the power jacks:

Switch connected:

In order to start, modern ATX power supplies require a load on them, so I used these ohmite resistors to put load on the 5V and 3.3V rails.

The 5 Ohm resistor on the 5V rail got quite hot, so I built a heatsink for it out of some scraps:

Completely assembled:

Powered on:

Here are 10 possible voltage outputs:

Doodle4Google Entry

2011-03-15T20:15:00.002-04:00

My entry to this year's Doodle4Google contest:

The drawing was created in Photoshop, and the fragments of code come from a python program I wrote that simulates predator and prey cells, which can replicate, mutate and hunt each other down. If you check carefully enough and are Google-savvy enough, you may find some surprises!

Birch and Mahogany Home Theater PC

2011-02-19T10:14:00.003-05:00

This is a home theater PC I built from mostly spare parts. It was designed to be as compact and quiet as possible, given the parts I used, and also not look intrusive in a living room setting.

First of all, you will need all the hardware required for a fully functioning computer: A Motherboard, CPU, RAM, Video card, Power Supply, Hard Drive, DVD Drive, and an cooling components.

To build the case, you will need:

1/4" sheet of marine mahogany

3/4" sheet of birch veneer plywood

12' of 3/4" aluminum angle bar

"L" brackets and screws

Lots of machine screws and nuts

Scrap of sheet steel- I cut mine from an old CD player

Perforated aluminum sheet, "Modders Mesh"

Varnish

2 large momentary push buttons

Tools:

Wood Saw

Dremel/Rotary tool

Sand paper

Drill

Pliers

Screw drivers

Hacksaw

This slot loading DVD drive was pulled from an old ibook, and I soldered leads on it for the eject button

Mini-ITX motherboard, 1 Gb Ram, 2.6 ghz Celeron CPU

To mount the cpu cooler, I cut out the outer fins, drilled holes lining up with the holes in the motherboard, and bolted in the cooler.

I built my motherboard tray out of a scrap bit of metal cut out of an old CD player. I used this, because the height of the folded up part on the left happened to be almost the exact height of the video card I used. The motherboard needs to be raised from the surface, so I mounted standoffs in the proper positions. I also cut a hole for the back panel out of the side of the metal. To secure the video card, I drilled a hole in the top lip of the metal. The video card is bolted to this through the hole in the low profile back panel adapter.

Metal with standoffs attached.

Backplate hole cut:

The video card is secured by being screwed into the lip in the top of the metal.

To save space, I decided to mount the DVD drive directly to the bottom of the motherboard tray. To do this, I just cut the aluminum drive bracket out of an old laptop, and screwed it to the bottom of the motherboard tray. I glued sheets of felt to the top and bottom of the slot in order to eliminate vibrations.

I decided to build the internal frame of the case out of aluminum angle bars, because it is light, versatile, and easy to work with. The design had to be as compact as possible, but the case also had to be well ventilated and parts had to be relatively easy to install. All the parts were drilled and bolted together with hex nuts- the same ones used in erector sets.

The motherboard trey was screwed into the frame:

Test fit with spare CD drive:

To mount the hard drive, I added another bar of aluminum along the bottom, and drilled it to fit the holes in the HDD.

I cut holes in the motherboard tray adjacent to the 24 pin power socket and the IDE socket, to make routing cables easier. Once your frame is finished, take some time to practice installing the hardware, as there will probably be some installation quirks with your case. For example, you have to screw in the hard drive in mine before you screw in the PSU, because if you don't, the screw holes on one side are inaccessible. These are not big issues, but it is good to take note of them. Especially practice routing cables, as this is probably the most difficult thing to do in a cramped space.

All hardware installed:

Cable routing is pretty tricky:

Most of the outside of the case is made of birch plywood, but the front is a strip of marine mahogany left over from the boat I am building. I cut notches in the plywood, so the mahogany just slides in. The plywood is held together with brass "L" brackets.

The case needs to be well ventilated, especially since I am using a passively cooled GPU, so I made the top of the case out of aluminum modders mesh. I cut the sheet a few inches wider than the case, and folded in the edges. To fix the aluminum to the wood, simply screw it in from the inside with a few wood screws. Make sure you can remove them though, as it is best to fix the aluminum after you sand and finish the wood.

I designed the exterior of the case so that the aluminum frame, and all the computer hardware, can slide out of the case, giving easy access to the hardware.

All the metal edges were folded in:

If you have been paying close attention, you may have noticed that the intake fan on the PSU is facing directly into a solid piece of plywood. To fix this problem, I cut a series of slots in the side panel of the case using a jigsaw and the router dremel attachment, and cleaned them up with lots of sanding.

There also needs to be a way to mount the switches to the outside of the case. I did this by simply drilling two holes of the same diameter as the switches in the mahogany front panel.

The wires on the switches lead to a molex connector, so that I can disconnect the switches if I need to remove the hardware.

One of the downsides to having a cool slot-loading DVD drive is that you have to cut a slot in your case that is perfectly aligned with your DVD drive. I marked the drive by removing the aluminum from the case, installing the frame with the DVD drive, and inserting a CD part way into the drive before hand. This lets you see where the CD touches the mahogany, so you can mark it to be cut. The cutting was done with a Dremel. Be very careful when you do this and go very slowly, or it will probably look bad. Finish the slot out by sanding the inside edges.

The particular motherboard I used only had 2 back panel USB ports, so I decided to mount the wireless card to the internal USB header. I started by stripping the wireless card of its casing, and screwing it into the bottom corner of the aluminum frame. I insulated it with strips of electrical tape along the bottom, and I drilled a slot that served as a hinge for the antenna. I mounted a two port USB panel from the front of an old case next to the wireless card, and connected it to the motherboard's USB header and the wireless card using an extra short USB cable I made.

To finish the wood, I chose to use gel varnish, which gives the mahogany a fantastic color. I also sprayed the aluminum with a coat of clear acrylic, which evens out the color and prevents oxidation. This would also be a good time to add rubber feet to the bottom of the case.

Install all your hadware into your internal frame, and then install the frame into the case. To attach the DVD and Power switches from the front of the case to the motherboard, I wired the switches to a spare molex connector. This way, whenever I need to remove the hardware, I simply unplug the switches and pull out the frame with the components. I also added a metal lip to the bottom of the frame, so it can screw into the base of the wood and prevent the hardware from sliding out by accident.

Final pictures:

*Update*

The hardware has now been upgraded, so streaming playback has been significantly improved.

I had do some modifications to the new optical drive to get it to work. I pulled it out of a macbook, so it did not have any eject button. I opened up the case, and found the pin for ejecting it, and soldered a wire to it to connect to the eject button.

New hardware installed:

Triple Monitors

2011-02-13T11:26:00.002-05:00

I recently switched GPUs from an HD3650 to a 9800GTX+, and because I also have an old 8500gt, I now have two nVidia cards. This means that in Windows Vista, I can run two video cards (Vista requires the two cards to use the same drivers, but W7 does not). To get the setup working, I had to do some modifications to the 8500gt, as well as build a stand for my monitors, since my desk is too small for three.

The first problem was that both my video cards use PCIe X16, and my computer only has 1 x16 slot. Fortunately, it has four x1 slots, and all speeds of the PCIe interface are electrically compatible with each other. But an x16 card will physically not fit in an x1 slot. To get around this, I just cut off the extra pins on the video card.

The 8500gt's cooler was also very loud, so I put the passive cooler from my old 3650 on it. The holes in the PCB for mounting the cooler were too small for the push pins the heatsink used, so I had to drill them out to get the cooler to fit.

To get all the monitors to fit side by side, one of them had to be on my work desk, next to my computer desk. The work desk is about three inches higher than the computer desk, so I built a stand for the monitors that extends my computer desk and doubles as a storage unit for disks.

Now, why would I want three monitors, besides the awesome-factor? Here is one example: I can have a Photoshop window in full screen on my center monitor, have all the tools open on the right monitor, and have a browser window open on the third. This setup gives me a total resolution of 4224 x 1080.

Artillery Game

2011-01-15T17:18:00.002-05:00

This is a basic artillery game I wrote in python. There are still some minor issues I need to fix, but it works and is playable. It includes wind, movement, and variable-height terrain.

Here is the code:

from tkinter import *

from sys import getfilesystemencoding

import time

import random

import math

height = 600

width = 800

global t, Vo, P1Vo, P2Vo, P1A, P2A, counter,wind,active

Vo=0

t=0

Angle=0

counter=2

P1Vo=0

P1A=0

P2Vo=0

P2A=0

wind=0

active=False

def windspeed():

global wind

x=0

for i in range(4):

x+=random.randint(-20,20)

wind=x//4

return wind

canvas = Canvas(highlightthickness=0, height=height, width=width, )

canvas.master.title("Artillery")

if getfilesystemencoding() == 'utf-8': # only for mac

canvas.master.call('console', 'hide')

canvas.pack()

canvas.create_rectangle(0,600,800,590,fill='green', outline='green', tag = 'ground')

class missile():

"blows junk up"

def __init__(self,power=Vo,angle=Angle, start=0,y=590, direction='right'):

global t

self.power=power

self.angle=angle

self.x=start

self.y=y

self.d=direction

self.id = canvas.create_oval(self.x,self.y,self.x+5,self.y-5,fill='red')

def trajectory(self,start, starty):

"calculates the position of the missile"

global t

#canvas.coords(self.id,self.x,self.y,self.x+5,self.y-5)

#canvas.create_oval(self.x,self.y,self.x+1,self.y-1)

if self.d=='right':

self.x=int((self.power*t*math.cos(self.angle))//1)+start

else:

self.x=int(-((self.power*t*math.cos(self.angle))//1))+start

self.y=int((-(((-9.8*(t**2))//2) + (self.power*math.sin(self.angle)*t)//1))+starty)

canvas.coords(self.id,self.x,self.y,self.x+5,self.y-5)

t+=.005

class tank():

"shoots some missiles"

def __init__(self, pos=50,health=100,movement=100, side=10,):

self.pos=pos

self.side=side

self.health=health

self.pic=canvas.create_rectangle(self.pos, 590, self.pos+20, 580)

self.display_health()

self.movement=movement

self.display=canvas.create_text(self.side+50, 50, text=(self.movement))

self.barrel_r()

def display_health(self):

"displays the tank's health bar"

self.x=canvas. create_rectangle(self.side, 20, self.side+self.health, 23, fill='red')

def move_left(self):

global Angle

canvas.coords(self.pic, self.pos-2, 590, self.pos+18, 580)

canvas.update()

self.movement-=1

self.pos-=2

a_up(Angle/.0174532925)

self.display_mov()

def move_right(self):

canvas.coords(self.pic, self.pos+2, 590, self.pos+22, 580)

canvas.update()

self.movement-=1

self.pos+=2

a_up(Angle/.0174532925)

self.display_mov()

def display_mov(self):

"displays the amount of movement left"

canvas.delete(self.display)

self.display=canvas.create_text(self.side+50, 50, text=(self.movement))

def barrel_r(self):

global Angle

self.b=canvas.create_line(self.pos+10, 580, 15*math.cos(Angle)+self.pos+10, 580- 15*math.sin(Angle))

self.tip=(15*math.cos(Angle)+self.pos+10)

self.y=(580- 15*math.sin(Angle))

canvas.update()

def barrel_l(self):

global Angle

self.b=canvas.create_line(self.pos+10, 580, 15*math.cos(Angle-(math.pi))+self.pos+10, 580- 15*math.sin(Angle))

self.tip=(15*math.cos(Angle-(math.pi))+self.pos+10)

self.y=(580- 15*math.sin(Angle))

canvas.update()

class terrain():

"a hill that is placed in the middle of the map"

def __init__(self):

height=random.randint(50,600)

self.shape=canvas.create_polygon(100, 600+height, 250, 200+height, 300, 250+height,400, 0+height, 700, 600+height, fill='green')

hill=terrain()

wind=windspeed()

z=canvas.create_text(400,20,text=('Wind Speed: %.2d') %(wind))

tank1=tank()

tank2=tank(pos=720, side=690)

def shoot(tank, p, a):

"animates the missile, along with lots of other stuff"

global t,counter, P1Vo, P2Vo, P1A, P2A, Angle, Vo, tank1, tank2,wind,z,active,text, hill

active=True

if counter %2 ==0:

tank=tank2

target=tank1

else:

tank=tank1

target=tank2

if tank==tank1:

d='right'

else:

d='left'

x=missile(power=p,angle=a,start=tank.tip+1, y=tank.y-3, direction=d)

while True:

x.x+=int((wind*t**2)/5)

x.trajectory(start=tank.tip, starty=tank.y)

hit=target.pos

if (hit<= x.x <= hit+20) and 590>=x.y>=580:

target.health-=20

print (target.health)

t=0

canvas.delete(x.id)

counter+=1

tag=target.x

canvas.delete(tag)

target.display_health()

if target.health==0:

if target==tank1:

player='Player 1'

else:

player='Player 2'

text=canvas.create_text(400,300, text=("%s wins") % (player))

canvas.update()

break

elif x.y>600 or x.x>800 or x.x<0:

t=0

canvas.delete(x.id)

counter+=1

break

elif hill.shape in (canvas.find_overlapping(x.x, x.y, x.x+5, x.y-5)):

canvas.delete(x.id)

t=0

counter+=1

break

time.sleep(.001):

canvas.update()

if counter % 2 == 0:

p_adjuster.set(P1Vo)

a_adjuster.set(P1A/.0174532925)

else:

p_adjuster.set(P2Vo)

a_adjuster.set(P2A/.0174532925)

wind=windspeed()

canvas.delete(z)

z=canvas.create_text(400,20,text=('Wind Speed: %.2d') %(wind))

active=False

def keypress(event):

global tank1, Vo, Angle, counter, P1A, P2A, P1Vo, P2Vo,active

if not active:

if event.keysym=="space":

if counter % 2 == 0:

Angle=P1A

Vo=P1Vo

else:

Angle=P2A

Vo=P2Vo

shoot(tank1, Vo, Angle)

if event.keysym=='Right':

if counter %2 ==0:

tank=tank2

else:

tank=tank1

if tank.movement > 0 and tank.pos<778:

tank.move_right()

else:

pass

elif event.keysym=='Left':

if counter %2 ==0:

tank=tank2

else:

tank=tank1

if tank.movement > 0 and 0<tank.pos:

tank.move_left()

else:

pass

def retry(event):

global tank1, tank2,text,counter, P1Vo, P2Vo, P1A, P2A, hill

counter=2

canvas.delete(text)

canvas.delete(tank1.pic)

canvas.delete(tank2.pic)

canvas.delete(tank1.b)

canvas.delete(tank2.b)

canvas.delete(tank1.x)

canvas.delete(tank2.x)

canvas.delete(tank1.display)

canvas.delete(tank2.display)

canvas.delete(hill.shape)

hill=terrain()

P1Vo, P2Vo, P1A, P2A=0, 0, 0, 0

tank1.health=100

tank2.health=100

tank1=tank()

tank2=tank(pos=720, side=690)

p_adjuster.set(0)

a_adjuster.set(0)

def p_up(x):

global Vo, Angle,counter, P1Vo, P2Vo

if counter % 2 == 0:

P1Vo=int(x)

Vo=P1Vo

else:

P2Vo=int(x)

Vo=P2Vo

def a_up(x):

global Vo,Angle,counter, P1A, P2A, tank1, tank2

if counter % 2 == 0:

P1A=int(x)*.0174532925

Angle=P1A

tank=tank2

canvas.delete(tank.b)

tank.barrel_l()

else:

P2A=int(x)*.0174532925

Angle=P2A

tank=tank1

canvas.delete(tank.b)

tank.barrel_r()

p_adjuster = Scale(canvas.master, length=400, orient=HORIZONTAL, command=p_up, from_=0, to=200, label="Power")

p_adjuster.pack(side=LEFT)

a_adjuster = Scale(canvas.master, length=400, orient=HORIZONTAL, command=a_up, from_=0, to=90, label = "Angle" )

a_adjuster.pack(side=RIGHT)

canvas.master.bind("<Key>", keypress)

canvas.master.bind("<Key-Return>", retry)

####

canvas.mainloop()

In order to run the game at a reasonable speed, it may be necessary to adjust the numbers in line 64:

"t+=.005"

or line 183:

"time.sleep(.001):"

To play, you can move your tank with the arrow keys, and press space bar to fire. Power and angle are adjusted with the sliders.

Christmas White-board Animation

2010-12-30T11:48:00.001-05:00

This video is my first attempt at stop-motion animation using a white board. The process is very simple: all you have to do to animate your characters is redraw them in a a new position over the old drawing, and then erase away the old drawing with your finger. The video was shot using a gorilla pod tripod, which is why the frame shifts slightly.

World's Smallest Milling Machine

2010-11-26T13:37:00.006-05:00

I was talking to a fellow member of my school's robotics team, and we got to thinking that we should build ourselves a CNC mill to machine custom parts with. While doing some research, I came across and Instructable called "How to make a mini milling machine- manual or CNC!." The design of this particular machine is very good for a small scale milling machine, and I got to thinking I could scale it down even farther- much farther. This project is the result.

This project is entered in a few contests on Instructables.com. You can vote for me in the first contest here, in the top left corner:

http://www.instructables.com/id/Worlds-Smallest-Milling-Machine/

It really does not take much in the way of materials to build this. Here are the tools and materials I used.

Square dowels- lots of them, a few different sizes helps

1/8" plywood. Mine is marine mahogany, because I have some scraps of it.

Furniture nails- use anything thicker and the wood will split almost every time

Wood glue

Drill with lots of small bits

Brass tubing

Stainless steel axles- these can be taken from RC cars

3 long bolts and twice as many nuts

Dremel tool with flexible shaft attachment.

Saw

Box cutter- for cutting the brass tubing

Wood carving knife

"U" screws with bolts

Pliers

Axles:

In this mill design, the base of the mill contains the Y axis. To approximately match the length of the axles, I made the base 3.25" square. To make the rails for the platform to slide on, I drilled 4 holes through opposite sides so that the axles fit parallel to each other at the same height. All the joints are both nailed and glued in place.

The next platform up contains the X axis. It is constructed similarly to the base, but with dimensions of 1.25" by 2.75", and the rails are raised up. On the base of this level, two sockets are fixed that slide on the rails of the base. The sockets are short segments of dowel which have been drilled out and have a piece of brass tubing in them.

The sliding bits are made up of these two pieces:

The two platforms attached to each other:

The next step is to build the milling platform. The platform is the part of the mill that whatever you are milling is fixed to. I estimated the range of motion of the mill, and cut a platform to the corresponding size out of mahogany plywood. Onto the bottom, I fixed sockets that slide on the rails of the second platform.

The next step is to build the tower to hold the motorized part of the mill (in this case a Dremel flex shaft) and contains the Z axis. This was once again built with square wooden dowels. Unfortunately, I ran out of stainless steel axles, so I used some thiner brass tubing instead. It is very important that the tower extends the right amount outwards, or the milling bit will not be able to cover all of the platform. With this design, the bit has to be a little in front of the center of the base.

The original design:

The next step is to build the part of the tower that will actually move up and down, and will hold the dremel. The base of this part is made up of more plywood. I added two segments of dowel down the middle and carved their corners out to fit the contours of the dremel attachment. On the back of the piece, I fitted two more sockets to slide on the rails of the tower.

In order to make the platform and milling bit actually move, I had to add lots of threads. In the base of each moving part, between the two rails, I fixed a set of nuts that a long bolt fits through. If the bolt is held in place and turned, the platform moves forward or backward depending on the direction you turn the screw. The end of each bolt was fixed with a locknut and a piece of wood to stop it from moving. It is critical that the nuts are lined up perfectly perpendicular to the rails, or when the bolt passes through them it will not be parallel, which will cause problems when the platform moves.

Platform:

Assembled:

Stops:

I mounted the Dremel attachment to the mill using "U" shaped bolts and some perforated aluminum. In order to not block the rails, the lower U bolt was bent at a 90 degree angle, and the threads protrude forwards instead of backwards like the first. I bent a piece of perforated aluminum to fit around the Dremel and hold it in place when bolted down.

Mills tend to work better when they are fully assembled, so I had to find a way to sturdily fix the tower to the base of the mill. I started out by simply nailing and gluing it to the base, but this proved to be fairly flimsy, so I built a larger base and triangular supports for the tower.

To actually use the mill, will need to mount whatever you are milling to the milling platform. I accomplished this with very small wood screws. Obviously, this will not work with any material more substantial with wood, but past that point the entire mill would probably break, so it is not really an issue. It is helpful to hang your dremel up above the mill while using it, so that the weight of the flex shaft does not tip the mill over. I have a loft bed, which makes hanging it above my desk very easy.

Test piece screwed into the milling platform: