FangleTronics

Homemade Christmas Presents

2012-01-28T23:15:00.000-08:00

Every Christmas, Lin makes a load of lovely presents for friends and family, and I run with the excuse that I'm too busy to make anything. Well, this year, I thought it was about time I got off my arse and made a few presents for friends and family and not just sit around watching Lin make awesomeness.

We came up with a hunormous list of things we'd like to make for people and very quickly realised we'd have to think a little smaller - Delyth was only 4 months old and had regressed into bad sleeping patterns so Lin and I had to take turns holding her in the evening, which didn't leave much time for, well, anything really.

I'm enjoying a little bit of woodworking at the moment (I think I can blame the CNC build for that) & I liked the idea of making a few wooden toys for friends & family back in Blighty. I found a scroll saw on sale at home depot one day & couldn't resist - so I've been playing with it (partly with the help of this book). It came in pretty handy when making Carys' birthday present (which I'll blog about next since it turned out really well) and got some good usage making these Christmas presents.

A few of the presents were cut from patterns in this scroll saw book, which has a load of good ideas - I'm most fond of the ones that make something the kidlets can play with, so those are the things I chose to try first. I particularly liked the interlocking/nested animal patterns & there were a couple of beginner ones that I could start - a zebra/horse set and some elephants.

Here's the first set of horses I cut (out of poplar); Lin finished them off for me by whittling the sides and giving them a couple of coats of tung oil.

Since the horses turned out well, I used them as an excuse to pop down to my local woodcraft to pick up some more wood to experiment with. The woodcraft in San Carlos stocks a load of interesting and beautiful wood. You can buy it by the board foot (a uniquely North American unit of measure), which means that you can pick up a small amount of a variety of wood to play with without it costing an arm and a leg.

After a long lunchtime looking at, feeling, and smelling all the interesting wood, I ended up buying some purple heart wood and some zebrawood (no prizes for guessing what that one is going to be used for). The purple heart wood is just so visually striking! I'd never seen a wood that was naturally purple!

I used the same horse/zebra pattern with the zebrawood and tried out an elephant pattern with the purple heart wood:

The last present I want to talk about was something we made for my nephew. I have some very fond memories of receiving hand made gifts from my granddad around Christmas time; he made me and my brother a few cool things - school desks, go-karts and a wooden castle are the ones that I remember fondly (they all got a ton of use and play!).

My nephew is 19 months old and loves anything with wheels. Lin came up with the idea of a truck made into the shape of his name; I'd had a different plan that I'd been trying out, but it was complicated, fiddly and a little frustrating - we were a little short on time at this point so it was a huge relief to have something more tractable to work on. Also, we had all the necessary pieces on hand!

The truck was cut out of some 2x4 Douglas fir I had left over from building the CNC machine (If you're interested there are a few posts about that here: part1, part2, part3, update). Here are a few gratuitous "in-progress" shots:

The wheels were from a bag of wooden shapes that LiEr (from ikatbag) sent to us when Delyth was born. Thanks, LiEr! That bag of wooden tidbits has been a life saver.

I really like how the truck turned out - It's personal, robust and simple. I think Harry liked it too, he certainly played with it a lot over Christmas :)

Battery pack for medical device

2011-12-09T07:35:00.000-08:00

Any guesses as to what I've been up to? It certainly looks a lot more dangerous than it really is. The object on the left is an electronic ambulatory infusion pump used by medics. The object on the right is a makeshift battery pack I put together to power the pump.

A little while ago a friend of mine came to me with a problem - he was running an in-vivo experiment using one of these pumps to provide a continuous nutrient supply; the problem was that he needed to run the pumps continuously throughout a two week experiment. The pumps only accepted AA batteries and would run out of juice after only 4 hours of use. Having to go to the lab and change batteries every four hours sounds a bit too much like experiencing the sleep debt of having a very young child... So, he asked me if there was a quick and easy way to improve the situation.

Connecting the pumps directly to the mains was out of the question; they needed to remain portable and untethered. So I thought we could add an external battery pack instead which would house larger, D size, batteries to increase the available power supply.

These pumps cost around $800 each, so I wanted to make the least invasive upgrade possible - yes, I'm a scaredy cat. Rather than ripping them open and soldering directly onto the circuit board, I decided to make some fake AA batteries to interface with the internal battery terminals. A couple of screws at the end of correctly sized dowels should do the trick. So, I measured an AA battery (length and diameter) and headed over to OSH to pick up some doweling (I know... I feel like I was cheating on home despot).

I cut two AA sized cylinders and decided on the right length of wire. I attached the wire to the ends of the dowel using a circular crimp terminal and a couple of wood screws. I had to drill a small hole in the pump casing in order to have the wire accessible, I threaded the wire through the hole and attached a mono jack plug to the end. For some reason I have a bag of these plugs and paired sockets sitting on my workbench... I figured they'd make life easier when replacing batteries by allowing the pump and battery pack to be separated and, if needed, I could make a few packs which would allow even quicker battery replacement.

If you've read any of my other posts you won't be surprised to hear that I opted for PVC pipe when making the main body of the battery packs. It turns out that D batteries fit snugly in 1 1/4" PVC piping, which is readily available in Lowe's/OSH/Home Depot.

I bought some single D battery holders from RadioShack so I could cannibalize the springs (and wire). I dissected them using a proxxon (a dremmel variant gifted to Lin by my PhD buddy Claire) and glued them to a couple of PVC end caps. If you look at the picture below you can see that one of the end caps consists of two pieces where one slides onto the main body and the other screws onto that piece. I glued the spring onto the inside lip of the larger piece, drilled a hole in the smaller cap to fit the jack plug and soldered it all together. The connecting wires were passed through small holes drilled in the sides of the cap. The black tape you can see is to secure the wire that connects the lower terminal with the jack socket. I thought about passing the wire down the inside of the case, but I figured that having the wire on the outside would make it very obvious how far the wire can be stretched safely. If it was on the inside someone might pull the cap off too hard/far and damage the battery pack - not good halfway through an experiment!

It turns out that the modified pumps and battery packs worked well. The D batteries supplied enough juice to run the pumps at full pelt for over 16 hours; Result!

CNC update

2011-12-07T22:50:00.000-08:00

I just realised that I haven't posted about the CNC machine for over a year! Judging by the blog, it looks like I failed and let it die a quiet death... but in reality it's been pretty great; it is up and running and working better than I had originally hoped.

Admittedly, it took longer to get into a decent state than I had planned for, but then I never had a lot of time to dedicate to it and I am not "skilled in the art" (oh no, not by a long shot!). One of the main reasons for embarking on the CNC build was to push myself into learning a lot of new skills; with that in mind it's been a huge success :) I picked up more woodworking skills, some metal working skills, knowledge of CAD, CAM, gcode and learned a ton of other random facts and figures along the way. But, best of all, I have this amazing contraption in my garage that can craft things out of wood, plastic, foam and aluminum with speed and precision that I couldn't possibly hope to achieve by hand.

So, what have I done with it so far? Well, a lot of the things I've made so far have been improvements and additions for the machine itself. First off, I made some hold downs (thingyverse thing:776) and some knobs to go with them (gcode provided free by solsylva.com, which is where I bought the CNC plans from in the first place).

You can see the new knobs and a couple of the hold downs in use here, holding down some 1/2" MDF with some more hold downs being cut out.

At the start of the year I upgraded the leadscrews from all-thread to ACME rod (the cheap stuff from Enco) which meant that I needed new leadnuts (also from Enco) and leadnut holders - I designed these in CamBam and cut them out on the machine (after a few false starts mostly to do with my understanding of g-code). I guess I should upload those designs to thingyverse really; though I'm not sure how useful they are to others.

The leadscrew upgrade removed a lot of backlash and resulted in faster and smoother performance.

I noticed that the cutting surface wasn't level so next up was to add some MDF planks and level them using the machine to mill the entire surface flat. After spending a couple of hours following the router bit with a vacuum hose and still getting myself and everything in the garage covered in a fine layer of MDF dust (not nice) I decided the next upgrade should be a vacuum system - I went with the one described on the Solsylva site with one minor modification. I had a lot of trouble getting the ring cut from a 2 liter plastic bottle to fit around the vacuum attachment, so I cut it open and attached it with duct tape... frustrated, moi? That was a bit unstable (and ugly) and I ended up replacing the tape with a #56 band clamp, which has been working fine so far. I intend on cutting out a few more in order to have quick change vacuum feet with different length bristles on each of them.

It's not all been machine related production though. Some of the first things I made were random carvings for the kids. I carved their names into blocks of wood; made spirals, hearts and shapes for them to colour-in and mess around with; I made a few door signs for bathrooms; name plates for kids friends bedrooms; and a few other random objects.

I've also mocked up a small version of Carys' birthday present and cut it out on the machine. I can't wait to be able to post about the completed full sized birthday project, but that's going to have to wait until it's finished. I love the fact that the kids birthday presents are always collaborative efforts with my lovely missus - all the projects are so much better when she's involved. Remember the colour conundrum? That would just have been an ugly cardboard box with wires sticking out if it weren't for her creative talents and influence!

The current crop of unphotographed and unfinished projects include "kids name marble mazes" and rubber band guns. I've been wondering how hard it would be to make simple versions of star wars ships like the millenium falcon and mill them out. I guess I wouldn't be able to share the files though (or I'd risk getting sued). The one thing I haven't really thought about is actually one of the reasons I thought the CNC machine would be ace - PCB milling. It turns out that getting boards through DorkbotPDX is much simpler than milling your own (unless you're in a rush) and the results are fantastic - you can see a few of my completed boards here.

Techliminal PCB design workshop

2011-11-01T23:35:00.000-07:00

A while ago, as part of the bay area workshop weekend, Techliminal held a 3 hour "introduction to PCB layout" class instructed by Malcolm Knapp. I'd tried using EAGLE a year ago when I first wanted to produce some schematics for my blog posts, but I found it a bit unintuitive and very frustrating. I went along to the class hoping it would be a quick and easy way to get to grips with schematic design and board layout. In short - it was. Malcolm is a really good teacher and I think everyone in the class got to grips with the software pretty quickly and got a lot out of the session. This course is being run again this coming weekend; if you're around and want to quickly get to grips with Eagle I strongly recommend signing up (just click here)!

After the class I headed home and immediately created my first schematic and board. There are a few I want to make but I figured the simplest would be a board for the traffic lights I made for the kids ages ago. I got a little bit carried away and made designs for a POV writer, an RGB LED night light and for a smaller version of "Dr Boardman's Color Conundrum". Here's the first schematic for the POV writer:

And here's the board layout:

I was immensely proud to be able to put this together. I know this is simple stuff for many people, but this isn't the easiest software to work out late at night (the only time I have available).

I submitted my gerber files to the DorkbotPDX PCB order and waited (eagerly). The boards cost $4 per square inch (for which you get 3 copies of each board) and arrived a couple of weeks later.

Here they are fresh from the fab:

That's four designs with two boards positioned so you can see the front and back of each (the boards are actually double sided).

I've had a chance to solder parts on to all of these. Of course I found a couple of mistakes and oversights in these first designs, but that's no surprise really. This is all a learning process. They all work though - which is a big shocker!

All in all this has been a great experience. It's fantastic to go from idea -> design -> PCB -> working device; this is very empowering. I'll write more about the individual boards later, but for now I just wanted to post something to give a shout out to Malcom and to encourage anyone interested to head over to the workshop.

PVC Pipe goal posts

2011-08-03T23:10:00.000-07:00

The girls have been going to summer "soccer" practice over at a local gymnasium They've really been enjoying it and I thought it be fun to set up a goal at home for them to have a play with. I noticed that the goal posts at the gym are made out of one of my favourite materials: PVC pipe (see here, here and here for more evidence on my apparent obsession). So, I had a look online to get some inspiration by seeing what designs other people have come up with. If you perform an image search for "pvc soccer goal" you should get a pretty good overview of the basic designs.

Afer sketching something on our blackboard and making sure the girls were excited by the idea we headed out to OSH to pick up the bits. We decided on a goal which measured 4' wide, 3' tall and 2' deep and came home with 4 x 8' lengths of 1" pipe, 6 x 90 degree elbows and 4 x Tees.

Here it all is, cut to length all ready to be put together (this took less than 10 mins):

The lengths are: 2x 3'7"; 2 x 3'; 2 x 2'; 4 x 1'6"; and 2 x 1'. Working out the lengths of the diagonal braces was the first time I've used Pythagoras' theorem in ages.

Here you can see my little helper, 'helping out' midway through the build (she was keen to get playing, bless her):

And here's the final product being put to good use:

I was hoping to find some netting at the same time as the pipes, but we had no joy. It seems to work well enough without the net for now though (the kids have been enjoying it anyway).

I know things have been a little quiet around here recently. It's mainly because we've just had a 50% increase in the number of girls in the house (sorry Lin, I'm not counting you). If you're interested in meeting the latest addition, take a look at Lin's post - here. Yes, this was from a month ago... as you can tell, Lin is much more on the ball than I am :)

From Futon to Planter Boxes

2011-05-28T23:18:00.000-07:00

When I first moved to the US, I had about 5 cardboard boxes of stuff to my name. None of those boxes contained any furniture and so a very kind young lady lent me her futon so that I'd have something comfy to sleep on. The futon has stayed with us from one move to the next, but it's time has come. It's last incarnation was as part of the kids bed (we merged the futon base with the main body of a kids single bed) but we recently bought a loft bed for them to share and the futon was suddenly in the way. The mattress is currently a sofa/bed in the kids room which left this lovely source of untreated pine just staring at me wanting to be used. Rather than put it on craigslist, I gave in to my urges and decided to transform it into something we needed (and would keep for a long time to come). We've been experimenting with growing fruit and veg in our back yard since last year so it seemed like a good use of the wood to make some planter boxes.

The base was kept together with bolts and screws - no glue! which made for a fun half hour with screwdrivers for me and the kids.

Here are the spoils (except the two 2"x2" poles which were bought at Home Despot):

I figured we could make a couple of planters from all this wood. Lin had the bright idea of using some metal mesh we had left over (from some stacking wire storage cubes) as the base of the planters and it just so happens that the 2"x2" poles fit snugly in the corners after a bit of metal snipping.

After measuring the wood and the wire mesh, it turns out that I could make two planters around 17" tall. I cut up the 2"x4" planks into smaller pieces each 14 1/4" in length and cut 4 legs from the 2"x2" - each measuring 17".

Here are a few rough sketches I made whilst trying to think it through:

And here are all the bits cut to length and ready to be assembled:

I routed out a 1/4" wide by 1/4" deep dado around 1/2" from the bottom on 4 of the small planks so that the wire mesh fitted snugly.

I routed out a similar channel on two adjacent sides of the legs (higher up though, so that the legs stick out the bottom) and then secured the planks to each other and to the legs with wood screws.

Then it was just a matter of attaching the rest of planks. I went for an alternating spiral like pattern.

To finish off I added a lip by cutting and mitering (45 degrees) some siding from the futon and gluing it on (with yellow wood glue). The wood already had a groove in the middle which slotted nicely in place on top of the planters. Then the kids personalised them with some watered down food colouring.

I put on a couple of coats of polyurethane to protect them from the elements (i.e. the kids). Lastly, Lin used some black plastic sheeting to line the inside and attached some cheap acrylic felt to the wire mesh to allow drainage.

The green planter already has some sugar snap peas sprouting out and the red one has some pole beans. Can't wait to start munching on them! Om nom nom!

There's still quite a bit of wood left over (all the thicker pieces and the two widest planks). I think I'll make those into another type of planter when I get the chance (similar to the one in the bottom left of the above picture).

I must get to posting a few more 'tronics' things... The CNC machine has been up and running for months (and is an endless source/sink for tinkering/tweaking) and I have a load of things to post about it. But I think some charlieplexed LEDs should come first since I mentioned them so long ago, built a few prototypes and then went silent. In my defense, building the CNC machine took a lot of time and effort and we're expecting baby#3 any day now. There always seems to be lots going on :) Oh, I found an old Atlas Cabinetmakers saw at a garage sale down the road as well! I think it was built around 1959 & I've got that up and running too. Now that I've gotten over my fear of table saws it'll be good to use it for something creative.

Kid made go-kart

2011-03-15T22:50:00.000-07:00

A few weekends ago we popped into the city to meet up with a blogger friend of Lin's. She was working with Gever Tulley on a tinkering workshop. We were a little late but caught the tail end of people as things were winding down and being cleared away. Carys was very excited to see that the kids in the workshop had make some go-karts. She immediately wanted to make one of her own and when we got home she drew up some plans at the kitchen table.

I was so impressed with this that, of course, I had to help her build it. We headed out and picked up a few supplies:

2' x 4' board of plywood (just about fits in the trunk of our Nissan Dissapointment)
4 casters (I got ones that were rated up to 80lb)

Everything else we had lying around (some 1" x 2" wood, wood screws, nylon rope).

The base of Carys' car is a big circle, so we first drew out two circles on the plywood (I thought we were going to make two cars, but we've only made one so far). I wanted Carys to do as much of the building as possible so we drew the circle by hammering a nail at the center of the circle and then tying a pencil to the nail with some string. I measured out enough string to have the pencil reach the edge of the board - this gave us a 2' diameter circle, plenty big enough for the kids to sit on.

I used a jigsaw to cut out the circle - this was the only step I didn't let Carys do (partly because she couldn't stand the noise and partly because she wouldn't take off her roller-skates). The kids then sanded down the rough edges.

Time for a quick break :) It turns out tape measures are also good for pulling people round on roller-skates. Who knew?

Then we cut a couple of lengths of 1' x 2' wood for attaching the casters to the base (this was part of Carys' plan). Both Carys and Ffion had fun sawing the wood (with a hand saw). Then I marked out the hole placements for the casters and Carys drilled the pilot holes.

Time to attach the casters. Carys was really steady and accurate with the drill, but she needed a little bit of extra weight (i.e. me pushing down on the back of the drill) when using the screwdriver bit.

Et voilà!

The plans also had a rope loop tied to the front to pull the car around with. I decided to add handles to the side to keep the kids on the car during the inevitable speed racing. I marked out the positions and Carys drilled the holes using a 1/2" drill bit - this looked comically large with her using it! I put some scrap/sacrificial wood under the car whilst drilling so that the drill-bit didn't hit concrete on it's way out.

By now it was getting dark and cold so we retired to the kitchen where the kids set about decorating their creation using permanent markers.

Then it was just a matter of adding the rope (2 handles and 1 long line for pulling).

Carys is immensely proud of her car. Doing all the planning, building and decorating has given her an amazing sense of ownership and accomplishment. She's already planning a ton of new projects, unfortunately this includes a death-defying bionic zip line out of the bedroom window to the reclaimed play structure... I wonder if I can persuade her that she wants to build an electric guitar or a laser cutter.

PVC Pipe Dressing-Up Rack

2011-03-05T23:16:00.000-08:00

We started playing around with PVC piping at home quite some time ago (see the marshmallow gun post) we quickly realised that it was a cheap and easy medium for building simple things (take a look at the projects page on this site: http://pvcfittings.com/ for a ton of examples). The kids 'building box' outside has a load of pipe and connectors in it for impromptu creative fun. Most of these bits were left over from Carys' pirate-superhero-mermaid birthday party where we put together marshmallow-gun party favour bags (If you're interested you can read about that on Lin's blog post over on FilthWizardry).

The kids have most of their make-believe/dressing-up items in a single toy box in their bedroom. The original lid on this didn't stand up to the test of multiple children piling into it day after day, so it's been an 'open plan' box for most of it's stay. On a daily basis we find the complete contents of the dressing up box emptied onto the bedroom floor. I guess that's the only way the kids can find the clothes for that day's dressing up desires.

We're a bit tight on space in the kids bedroom, so it seemed like a good idea to build a clothes rack that'd fit inside the box; then we could hang up most of the clothes for easy access and keep the hats, crowns and other accessories in the box itself. At least this way they wouldn't have to completely empty the box each time and we wouldn't have to tidy it up every day!

This is actually something I've made twice now (hence deciding to post about it)... The first one was dismantled and used to build random things out in our backyard a few months back; we soon realised the folly of our ways when we were once again greeted with the dressing up clothes piled on the floor day after day. Time to build another!

It's really, really simple. The fixtures and piping are 1/2" schedule 40 PVC. They're available in Lowe's, Home Despot, OSH, ACE hardware etc. and they're pretty cheap. This was today's shopping list from the local Lowe's:

1. 8 * 5' of pipe = $8.96 ($1.12 each) - I bought extra for other fangling.
2. bag of 10 tee junctions = $1.95
3. bag of 10 thread to slip adapters = 20c
4. bag of 10 elbow joints (90 degree) = $1.80
5. 4 x 3-way corner elbow = $5.28 ($1.32 each).

Ok, so $18 may not seem that cheap, but there's left over material for other projects and the rack itself will get re-used as something else when it's no longer needed. On the other hand, good luck finding something that'll exactly meet your requirements for $18 ;).

Here's everything I used:

I measured the inside of the dressing up box (before deciding on the parts) and sketched out how I wanted the rack to look. Then it's just a matter of measuring, marking and cutting the pipe and then sticking it all together. You don't even need glue/cement, unless you want the final 'product' to be permanent and durable.

Here's a load of in-progress shots to give you a feel:

And here's the final frame. I added a little nubbin afterwards for Ffion to hang her handbag collection on... you can see it in the action shot below to the left of the ballerina. I replaced a tee junction with a 4-way and slotted in a small bit of pipe terminated with a pipe cap (all left overs from previous messing/building).

The shoes are now all paired up and hung up as well. I think these were the main culprits of the 'toss everything on the floor' routine. Fingers crossed for a slightly tidier bedroom from now on.

CNC Machine Build - Part III "It's Alive!"

2010-10-06T22:21:00.000-07:00

Finally... after a lot of work and learning, the CNC machine is up and running.

I got the main machine finished and connected to a computer about a month ago, but I've been having trouble getting the z-axes working properly. I tried tuning/adjusting it as described in the plans and I even remade the leadnut bracket, replaced the leadnut (twice), replaced the leadscrew (twice) and went through 3 couplers (these are only made out of cheap hose so that was no biggie). But, each time I put it back together, the axes would stall part way through a job (ruining the workpiece and usually destroying the coupler). Eventually, I had to walk away for a week to cool down - at least that gave me time to make the Millennium Falcon dolls house for Carys' birthday.

Last weekend I went back to it. I replaced the lead-nut and lead-screw assembly (again), this time making sure to buy some new threaded rod that was straight. It turns out that the previous ones were slightly warped and this was causing most of the drag. I guess that's the problem with building a CNC machine with bog standard threaded rod as a lead-screw, they're not meant to be used in applications where the rod has to be straight... I also updated the coupler tubing - I'd been using clear vinyl tube from Lowe's (the kind used for irrigation) which is weak and slippery. I bought some fuel pipe from Kragen and this works a lot better.

I did a couple of test runs on some kitchen cutting board and quickly realized that I'd have to work out how to hold/clamp things down whilst cutting. I have a few clamps, but none of them fitted well between the slats so I made up a few hold downs using some left over wood and some bolts (you can see them in the picture below).

If I were to start this again, I think I'd opt for the more expensive ACME lead-screws/nuts and associated couplers. I spent a lot of time over the last few weeks tuning the axes and I think a lot of this would have been avoided if I'd gone with the better rods and lead-nuts. All in all though, I'm very chuffed that this is actually working! Last year Lin did a detailed pumpkin carving of our CSO, this lead to some geeky conversations at work about how you could automate the process but we ended up deciding that it was too complicated (mainly due to the issues of mapping an image onto the surface of a pumpkin in order to carve it). I'm wondering if I can actually achieve that this year using the CNC machine - just like this guy did. I bet all the CNC carving time gets eaten up with hearts and unicorns though... you know how it is ;)

DIY Millennium Falcon

2010-10-02T13:11:00.000-07:00

Carys was turning six at the beginning of October and had recently become StarWars obsessed (we let them watch the original 3 movies a few weeks back and they loved them). Lin and I like to add a few home made presents to the mix on the kids birthdays; So, we decided to make a few StarWars themed things for Carys' birthday.

Lin started out making a set of StarWars figures using wooden craft pegs (more about that on her post here). We were going to make a Millenium Falcon using a couple of plastic frisbies, but then thought it'd be nicer to create something a bit larger and more durable so that they could use it with the figures for some make-believe fun.

It took us a little while to decide on the components to use. We found this weird wooden board at the local thrift/charity store. I think it's used for carving meat and the grooves capture the juices (there's even a "patent applied for" stamp on the back). I forgot to get a picture of it in its original state; the picture below shows it after a little bit of modification. It was originally symmetrical - I rounded off one of the handles/ears and cut a groove in the other in preparation for adding the front prongs.

Here's a quick overview of the components:

There's the weird carving board, a plastic lid (another lucky thrift store find as it fits perfectly in the groove of the carving board), some PVC pipe (2" diameter) and a 90 degree elbow joint (both from Home Depot). There's a dollar tree airfreshener case (the white tear drop thing by the black pipe) and some wood. There are some other bits and bobs that aren't in this picture (I hadn't figured out what was going to be used at the time): a hinge for the cargo bay ramp, some more wood for the internal walls, screws, nuts/bolts, wood glue, some grey spray paint, a few plastic bottle caps, and the outside case of a CD spindle.

From the 'ingredients' picture you can see that I cut and sanded the carving board first and then made the front 'prongs'. For the prongs, I looked at a few online plans and scaled the dimensions to fit the cutting board. I used a scroll saw to cut out the shapes and then screwed and glued them onto the main board.

While the glue was drying I made the internal structure. It's made from the outside of a CD spindle and some wooden boards (2" hobby board from Home Depot). I cut the CD spindle to fit the height of the lid and then measured out the boards to fit up to the edge of the curve. That was a bit of a mistake as the lid didn't fit with the boards that long and I ended up having to sand the ends down a bit.

I thought it'd be fun to have internal doors but didn't think the spindle would survive with large chunks cut out of them, so I just put some painters tape where I wanted the doors and then painted it all leaving some see-through areas after the tape is removed.

I gave the lid it's first coat of paint, bolted on a few bottle caps and wood disks to mimic some of the structures seen on the original, and then gave it all another coat. The lid needs to be cut in a couple of places to make room for the cockpit attachment/corridor and for the cargo bay ramp.

I used a miter saw to cut one end off the PVC elbow (so that the cockpit would face forward) and to cut an angle into the corridor (makes it easy to screw the pipe into the base). My first attempt failed as the corridor was too short, but I had plenty of pipe left over for another go. Everything was given a coat of paint.

I cut the airfreshened body down to a size that would fit snugly over the pipe and then used hot glue to attach it. I like the fact that the cover comes on and off so we can put pilots in there.

Here's the final set-up (with cargo bay ramp attached with a hinge):

Lin made some ace characters for Carys' birthday and the two presents go really well together. I love the fact that Darth Vader's helmet comes off to show his pale splotchy face :)

And, just to finish off, a gratuitous set of action shots:

CNC Machine Build - Part II

2010-08-26T23:21:00.000-07:00

I bet you'd all thought I'd given up on this! Well, I just got a little sidetracked with a few other projects - the main one being the play-structure restoration and a load of garden "improvements" (I hope the landlord agrees!).

Well, I was wondering if I could finish it before posting again, but I got impatient. Most of the hardware is done, but there's still some fine tuning to do on the axes and I still have all the electronics to sort out.

I've been really happy with the plans I bought from solsylva.com, they are detailed and straightforward to follow. Most of this has been new to me, so I've taken my time (not that I had much choice) and it's been working out ok. It must have been comedic seeing my sleep deprived carcass hanging around the wood or screws/bolts at Home Depot around midnight on Saturdays, looking confused and eyeing everything up suspiciously. I had no idea what all the numbers and specifications meant on the parts when I was first buying them... trying to match up what was in the plans with what was on the shelves took a lot longer than I'm willing to admit.

There were a few choices to make when building the machine:

What wood to use.
What leadscrews/leadnuts to use (ACME rod or hardware store threaded rod).
What bearings to use.
What stepper motors, power supply and controller board to use (main choices seemed to be hobbycnc and xylotex.

Since cost is definitely an issue for me, I mostly went with the cheapest options. So, whatever wood was available at Lowe's/HD (pine and Douglas-Fir); threaded rod leadscrews (I can always upgrade to ACME later); hardware store tee-nuts as the leadnuts; skateboard bearings from Slam N City's ebay store; and I ended up choosing the xylotex 3 axis system kit for the electronics/steppers. I went with Xylotex over HobbyCNC mainly because the HobbyCNC kit appeared to require more work to get it up and running (like buying a separate transformer and fitting it in with the rest of the kit).

Here's a few in-progress shots:

This is after installing the y-gantry on the x-rails.

These are the bearing flanges cut out of kitchen cutting board. I bought some Forstner bits from ebay in order to cut the recesses. There are a few holes in the wood that require either spade or forstner bits as well -> the bits have been handy on other projects like drilling recesses for the bolts on the play-structure and making holes in our upside-down tomato plant buckets (you can see them somewhere in the middle of one of Lin's more epic posts).

This image shows the machine after the x-axes leadscrews and nuts have been added - there's one on each side of the machine. The x-axes stepper motor is connected to the two leadscrews by a belt and pulley system (suppliers and part numbers were given in the plans for these, so there was no confusion).

This is the cage that moves along the y-gantry rails and houses the z-axes spindle plate.

This shows the cage in position with the z-axes leadscrew assembly and stepper motor. The rods in the right hand picture are tension rods to press the bearings into the rails and allow the cage to run smoothly along the y-gantry black piping.

and here's the z-axes complete with spindle plate. The metal band at the front is used to clamp the router onto the spindle plate (as you can see in the picture below).

So, I think all I have left to do is to wire up the steppers, controller board and power supply; connect these to a computer (I'm planning to use linuxcnc on an old disused laptop - so old it has a parallel port!) and then work out how to use the software. Can't wait to carve out my first test pattern!

Rescuing a CedarWorks Swing Set

2010-07-31T00:14:00.000-07:00

We had the good fortune recently of being offered an old play-structure by a lovely couple who'd recently bought a house with it in the garden, but their kid was too old for it. They'd tried to give it away a few times over the last year or so, but no one who came to look at it had any clue how to take it apart - I'm beginning to suspect that they were just sensible and realised how much work would be involved in deconstructing and reconstructing it all ;)

It was completely worth the effort though. These CedarWorks play-structures are fantastic (seriously, check out that link, it's like swing set porn) and there's no way our kids would ever have had anything like this under other circumstances. We managed to salvage the whole thing for about the cost of the metal steering wheel it came with (~$160).

I took a look and thought, yeah, that'll come apart easy and should squeeze in our back-yard. So the missus and I went down one Sunday with a big U-Haul truck (one of these) and spent about 4 1/2 hours taking it apart with the help of the original owners (and Jessen and Lani who were looking after the filthwizards). We'd actually been down the day before to show the kids and to get started (we spent about 1 1/2 hours there that day). These things are definitely built to stay up!

Most of it was pretty straightforward to deconstruct, it's mostly held together by long bolts and hex-screws. The hardest part was removing all the dowel rods... These were all kept in place with nails driven through the main posts... this turned out to be the biggest ~~pita~~ time-sink of the day. I ended up clearing some of the wood around each of the nail heads by hammering a 7mm socket around the top of them and then using a claw hammer to pull the nail out. We left parts of the structure intact (the smaller tower, the monkey bars and 3 rows of the larger tower). Phew! That was quite hard in the midday sunshine... and guess who forgot his hat! Doh!

We did joke a couple of times that we may have landed ourselves some very elaborate firewood.

Here it is, taken apart and stored down the side of our house waiting for some attention (both of us quietly hoping not of the bonfire variety):

Whilst taking it apart we found that the lower 6 inches of the structure was rotten (including the A-frame support beams/crossmembers) so we'd have to come up with a plan for fixing it up. A few of the dowels were rotten as well and one of them wouldn't come out, so we ended up sawing it in half in order to get the frame apart and out of the garden.

We decided to stain the wood to protect it from further water damage and to make it look a bit nicer. We picked up the stain from Home Depot (Red, Brown and a small pot of green for the horse swing) and set to work.

It took a couple of weeks of preparation (mainly painting and grabbing some supplies) and an entire weekend of painting, sawing, hammering, drilling, lifting, squeezing, sneezing, spluttering (I got a lot of sawdust up my nose and in my mouth) and standing on-top of things with my mate, Jessen, bashing away with a big rubber mallet to get it finished and in a good state to play on. I sawed off the lower 6" or so of the entire structure (16 vertical legs and 3 A-frame legs) and replaced the unsalvageable, A-frame crossmembers with some 8' 4"x4" from Home Depot.

It was going dark on Monday night by the time the kids got a chance to test it out - They were very excited and I had to fend them off for a little while whilst finishing up the A-frames. You would have thought the sight of me running back and forth with a big drill in the twilight would have been intimidating enough... apparently not.

Well, it's still not quite finished. The platforms that go inside the main structure still need sanding and painting, but we can do those piecemeal. Hopefully this means I've got some time to get back to building that CNC machine!

It feels like we're pretty good at not necessarily biting off more than we can chew, but rather biting off enough to give us very sore jaws... It really felt worthwhile when Ffion came running over and hugged my leg, saying "you're the best dad ever!" and Carys shouts out (from the apex of a high swing) "This is AWESOME!". Yeah fine... they have me wrapped around their little fingers...

CNC Machine Build - Part I

2010-06-23T08:36:00.000-07:00

I've started a 'little' project that promises to take up most of my free time (what little there seems to be of it at the moment) - I've decided to build a CNC machine.

To be honest, I've had gadget lust for a CNC machine for some time now... all the talk on the blogs about Cupcakes and Makerbots and RepRaps got me looking into CNC machines some time ago. I could never bring myself to spend the money on one though since they're a little pricey. The cheapest options that looked any good were the Zen Toolworks machines, which came with stepper motors but no power supply, controller boards or router/spindle. The cheapest of these can be got from Amazon for under 350 dollars. Still, it only works on a 7"x7"x2" area. The next machine up is around $600 and works on a larger area of 12"x12"x2". At this price I get a little scared and only being able to carve a foot is a little disapointing.

Anyway, I held off for ages but then came across these plans at solsylva.com which detailed the construction of a CNC machine that would cost a little bit more than the larger zen toolworks one (all inclusive), would use mostly materials from Lowes or Home Despot and also promised to be pretty easy to follow (a definite bonus for me, since I chose to do needlework and cookery rather than woodwork and metalwork when given the choice at age 13...). I've seen lots of online instructions for building various types of CNC machine (like this one, and this one, and this one... well, you get the idea), but they all left me a bit confused and unconfident about being able to build something worthwhile.

The promise of the solsylva plans were enough to make me order the 25"x25"x7" plans to see if they were idiot proof enough to give me the confidence to get started.

I received the plans a few weeks ago, read them over and then excitedly started to spend money on wood, bolts, washers, screws, pipes, all thread (threaded rod), forstner bits and skate bearings. So, yes, they appeared to be detailed and simple enough for me to follow from start to finish.

I like the fact that the solsylva plans allow for someone who doesn't have a truck. The wood measurements are for planks 8' and smaller, which fit fine in my little Nissan disappointment (with the back seats down). Recently I've been taking advantage of craigslist in order to pick up a few power tools on the cheap. I got hold of a drill-press ($50) and a miter saw ($60), which have been very useful so far. You'll laugh at me, but they were a bit intimidating to use at first - especially the miter saw. I kept having these images running through my mind of flying fingers and trips to the ER (in my defense, the miter saw is very loud). After a bit of practice I've become ~~flamboyantly reckless~~ much more confident. I'm definitely enjoying learning the new skills involved.

The pictures at the start of this post are the main base of the machine, put together over a few hours on the weekend. In the picture below I've added the X-rails and X-stepper motor support (this was done on the following weekend).

So far, it seems that things are going well. I'll keep you posted.

Upcycling: wine rack to doll bed

2010-06-16T22:22:00.000-07:00

We found this little wine rack in the local thrift store (savers). Lin thought it'd be cool to turn it into a bed for the kids baby dolls. We bought an American Girl doll crib ages ago at a garage sale that was made of plastic and it inevitably fell to pieces... So the idea of the girls playing with a more sturdy one that I'd made was appealing, especially since they had a lot of make believe fun with the old one.

The idea was very simple: Take the rack apart, stick it back together again with some wood-glue for added strength, cut out a base, screw this on and then paint.

I was going to make a crib by adding doweling bars between the cross beams, but the way the rack was put together made this a bit too fiddly so I decided to just replace the bottom beams and make a baby bed instead.

I sanded the pieces to get rid of some of the murky dirt. Then I painted on some wood-glue to the ends of the beams, reattached them and left it all to dry overnight (with a toolbox weighing it all down from above so that it'd set straight).

I used one of our "new" purchases (a very old scroll saw) to cut out a base. Very straightforward really, just measure the distances on the wine rack, mark those out on some wood and then cut.

Ooo look, a rectangular bit of wood ;)

I drilled out holes at the points where the new base board met the cross beams and then fixed the base to the frame using some wood screws.

Then I let the kids paint on a layer of primer. I think they quite enjoyed it.

After the primer had dried I painted on a coat of gloss. Hopefully that'll keep it in good condition for a while.

I wasn't sure if the kids were taken with it or not until the next morning when a couple of their friends came over for a play date. "Dylan! Dylan! Come and see! I've got something AMAZING to show you!" cried Carys. To be honest I wasn't sure what she was going to show off, but was very touched to find out that it was the baby bed we'd made. Poor Dylan was a little bemused as to why she was so excited ;)

Pixie-Dust Bottles

2010-05-17T16:25:00.000-07:00

It occurred to me whilst making some RGB nightlights for the kids that it'd be fun if they could make the lights change to whatever colour they wanted; kinda like the Philips LivingColors lamp, but about $100 cheaper. Lin suggested that having a few of these (say 5 - 7) would give the kids more room for imaginative fun, so I set about making a prototype and then a few more when that was up and working.

The kids love them (which is always good) and have been claiming that the bottles contain pixie dust (hence the title of this post).

Can you guess what Ffion's favourite colour is? She claims that this is the 'right colour' for pixie dust.

The hardware is pretty straight forward. I used a potentiometer with an in-built on/off switch, like this one, to simplify things. I thought it'd look much nicer than having a separate switch. The rest of the parts are the same as for the RGB nightlights project. The trickiest part was the coding, mainly because I'm doing it late at night when my brain isn't working quite so well...

Ingredients:

1. Potentiometer with switch
2. ATtiny45
3. 8-pin IC socket
4. coin cell battery holder
5. RGB LED (common anode) - I bought mine from EMSL. These are 10mm diffused RGB LEDs.
6. hookup wire, solder etc.

Methods:

I soldered the coin cell holder onto the potentiometer first.

Then I hooked up the RGB LED to the DIP socket. I'm using common anode LEDs so the long LED lead is soldered onto pin 8 of the IC socket. I have the RGB channels/leads connected to pins 5, 6 and 7 and the potentiometer output (middle pin from the pot) connected to pin 3.

After that, all you have to do is solder on the potentiometer's middle terminal to the IC socket and finish off connecting the ground and power connections.

And there we have it. Some kind of strange Borg eye ready to be put somewhere.

We had some plastic kids drink bottles sitting in the recycling bin - they're made from white plastic so I thought they'd diffuse the light nicely. I drilled a hole in the bottle cap for the potentiometer shaft and fitted it all together. Finally, I added a knob (radioshack purchase) to make it a bit prettier and easier to use.

Coding:

I'd already worked out how to do the software PWM (pulse width modulation) and how to measure a variable voltage input using ADC (analogue to digital conversion) so all that needed to be figured out, for this project, was how to map the ADC input values to the desired range of colours.

I wanted to let the kids cycle through the entire spectrum in much the same way the previous night-lights cycled automatically.

So, in the RGB nightlights project there were 6 transitions/steps:

step	Red channel value	Green channel value	Blue channel value	changing channel	colour range
1	255	0	0	increase Green	Red to Yellow
2	255	255	0	decrease Red	Yellow to Green
3	0	255	0	increase Blue	Green to Cyan
4	0	255	255	decrease Green	Cyan to Blue
5	0	0	255	increase Red	Blue to Purple
6	255	0	255	decrease Blue	Purple to Red

If we use a 10-bit ADC we have 1024 values (2^10) available for mapping to colours in the above steps. This means that each step can contain 170 values/colours (1024/6 = 170.666...).

So, to map the ADC value to a colour we first assign it to one of the 6 steps and then use it to determine the value of the varying channel (Red/Green/Blue) for that step.

There are 6 steps and each step can have 170 ADC values associated with it. So I binned the ADC values into steps like so:

step	ADC value
1	< 170
2	< 342
3	< 512
4	< 683
5	< 854
6	>= 854

Here's an example to clarify: Say the potentiometer is set just over half way, then the ADC value should be between 512 and 683; this would put us in step 4 where the red channel is off, the blue channel is completely on (255) and the green channel is varying (in this step the green levels are decreasing from 255 -> 0 as the ADC value increases from 512 -> 683). We calculate the green level by translating the ADC range to 0 - 170 (in this case by subtracting 512) and then multiplying by a scaling factor (255/170) to transform the 0 -> 170 range to a 0 -> 255 range. If we're increasing the level of the channel (steps 1, 3 and 5) then we just use this scaled value as the channel value. If we're decreasing the level of the channel (as is the case for step 4) then we inverse the scaled value by subtracting it from 255.

Here's the bit of code that sets the RGB values (see the complete listing here: selectableColourLight.c):


#define SCALING_RANGE 170
#define SCALING_FACTOR 255/SCALING_RANGE

...

void setRgbLevels(uint16_t pValue)
{
 if(pValue < SCALING_RANGE)
 {
  mRgbValues[RED_INDEX]   = 255;
  mRgbValues[GREEN_INDEX] = pValue * SCALING_FACTOR;
  mRgbValues[BLUE_INDEX]  = 0;

 }
 else if(pValue < 342) //SCALING_RANGE * 2
 {
  mRgbValues[RED_INDEX]   = 255 - ((pValue - SCALING_RANGE) * SCALING_FACTOR);
  mRgbValues[GREEN_INDEX] = 255;
  mRgbValues[BLUE_INDEX]  = 0;
 }
 else if(pValue < 512) //SCALING_RANGE * 3
 {
  mRgbValues[RED_INDEX]   = 0;
  mRgbValues[GREEN_INDEX] = 255;
  mRgbValues[BLUE_INDEX]  = (pValue - 342) * SCALING_FACTOR;
 }
 else if(pValue < 683)//SCALING_RANGE * 4
 {
  mRgbValues[RED_INDEX]   = 0;
  mRgbValues[GREEN_INDEX] = 255 - ((pValue - 512) * SCALING_FACTOR);
  mRgbValues[BLUE_INDEX]  = 255;
 }
 else if(pValue < 854)//SCALING_RANGE * 5
 {
  mRgbValues[RED_INDEX]   = (pValue - 683) * SCALING_FACTOR;
  mRgbValues[GREEN_INDEX] = 0;
  mRgbValues[BLUE_INDEX]  = 255;
 }
 else
 {
  mRgbValues[RED_INDEX]   = 255;
  mRgbValues[GREEN_INDEX] = 0;
  mRgbValues[BLUE_INDEX]  = 255 - ((pValue - 854) * SCALING_FACTOR);
 }
}

Saving a Disney Princess Remote Controlled Car

2010-03-22T08:53:00.000-07:00

During a trip to Savers I spotted this Disney princess car:

I noticed the sensors in the head and tail lights, they looked like IR receivers. At first I thought the LED in the body of the car was an IR LED and that the IR receivers detected the IR light bouncing off objects in the cars path (not that the tail lights would make much sense in this context), but when I got it home and put batteries in it, the LED turned out to be just a colour changing LED put there for decoration.

A while back I headed over to Noisebride on a Monday night to check out their circuit hacking/soldering workshop (hosted by Mich Altman). During the workshop I put together one of Mitch's kits - "The Trippy RGB Waves" kit (here's my Noisebridge post if you're interested in reading about the experience). The point is that this gizmo uses an IR LED and an IR receiver to detect overhead objects. The LED pulses IR light at 38KHz (not to be confused with the actual frequency of IR light which is ~ 3THz or 3 x 10¹² Hz) which the IR receiver detects if there's an object above the LED reflecting the pulses back down.

I wondered if the car has a similar set-up and was just missing the remote control (which would have a pulsing IR LED). First off I tried a regular remote control, which had no effect so then I tried pointing the Trippy RGB LED kit at the car and voila! It reacted to the light. So, I set about creating a wand/gun for the kids to use to interact with the car.

First off I tried setting up a 555 timer to pulse an IR LED at 38KHz. It worked but the signal was weak (maybe I got the values off a little). I decided to use a microcontroller instead. The ATtiny range are pretty cheap - I bought some ATtiny45s for $1.20 each which is ~3x the cost of a 555. The hardest part was finding/creating a housing for the circuit. I looked around and decided to make my own out of PVC piping. They look like tiny guns and work a treat :)

Methods:

Here are the final "guns".

Ingredients:

The pipe is 1/2" PVC piping from Lowes (Home Depot have it too).

PVC elbow joint
PVC pipe (cut to a v.small length 1 1/2")
PVC pipe cap
Coin battery holder (3v, 20mm)
8-pin DIP socket
momentary push button
IR LED
ATtiny45 (originally made with an ATtiny13).

The plastic dome is the case from a 25c toy from our local taqueria. The base fits snuggly on the end of the elbow joint and I've used it to cover the battery holder in the final 'product'. The piping paraphernalia was all left over from the marshmallow-gun fun.

The wiring is all very straightforward. The hardest part was adjusting the elbow joint so that my coin cell holders fitted snuggly inside (and getting the pushbutton in place).

So, first off is to drill some holes: 1 in the end cap for the LED and one in the elbow joint for the pushbutton. Then I used a rotary tool (Proxxon) to carve out some of the innards of the elbow joint until the battery holder fitted snuggly inside.

Then I soldered one short and one long lead to the pushbutton and fitted it into the elbow joint (see below).

Then I soldered a long ground lead to the battery holder and connected the short positive wire from the pushbutton and placed the battery holder in the end of the elbow joint.

Solder on the DIP socket. Using a socket was a great choice for me because it turns out that the code I was running was not getting the best results from the car. Having the socket let me replace the uC after I'd worked out the kinks. I guess it'll also let me easily recover the uC when the kids are bored of this toy. I stripped a little bit of insulation from near to the end of the ground lead and soldered it to the ground pin (rather than adding a couple of wire ends at that point).

Then it's just a matter of connecting the LED, placing the uC in the socket and fitting the remaining piping.

I made two so both girls could play. Although that also opens up a huge opportunity to fight over who's in control as well...

And here's the code (for some reason the car reacted best if the IR was pulsed for ~170 microseconds with a 400 microsecond pause before the next set of pulses):

/*
 * IrLedPulse.c
 *
 * Distributed under Creative Commons 3.0 -- Attib & Share Alike
 *
 * Created on: Dec 26, 2009
 *      Author: Paul
 */
#include <avr/io.h>
#include <avr/delay.h>

#ifndef F_CPU
    #define F_CPU 1000000UL
#endif


// Use Timer 0 to pulse the IR LED at 38KHz
void pulseIr()
{
    TCCR0A = 0 | (1 << COM0A0) | (1 << WGM01); // COM0A0=1 to toggle OC0A on Compare Match

    TCCR0B = 0 | (1 << CS01);    // 1/8 prescale
    OCR0A = 104;  // to output 38KHz on OC0A (PB0, pin 5)

    _delay_us(170);   // delay 170 microseconds

    // turn off Timer0 to stop 38KHz pulsing of IR
    TCCR0B = 0;  // Stop Timer0 (turn off IR emitter)
    TCCR0A = 0;  // Disconnect OC0A from PB0 (pin 5)
}

int main(void)
{
    DDRB |= (1 << PB0); // set PB0 to output
    PORTB = 0xFF; // all PORTB output pins high (LED off).
    while(1)
    {
        pulseIr();
        _delay_us(400);
    }
}

The Amazing Dr Boardman's Colour Conundrum

2010-02-28T10:46:00.000-08:00

"Roll up! Roll up! Try your hand at The Amazing Dr Boardman's Colour Conundrum!"

This is a little game I've been planning on making for quite some time. I finally got round to learning the necessary microcontroller details to pull it together. The basic idea is that that there are two, full colour 'bulbs'. One bulb lights up with a random color and the player tries to match this color by adjusting the RGB values of the second bulb (the bulbs are actually RGB LEDs with ping-pong ball diffusers). When the colors are similar enough then the player 'wins'.

This was quite hard to do for the younger kids, so I added a speaker to the mix & set it so that the sound frequency increased the closer the player got to the correct colour. It's still pretty hard, even with the speaker on.

I added a difficulty switch so that the daring/cocky can turn the speaker off.

Here's a little video of it in action. My 5 year old daughter kindly agreed to walk us through it.

How it was put together

Ingredients:

3 potentiometers (20K ohm - but the absolute value isn't very important)
3 knobs for the potentiometers
8 ohm speaker
wooden box (I found this one at Savers)
perf board
2 baby food jars
2 ping-pong balls
28 pin DIP socket
ATmega8
2 RGB LEDs (common anode)
2 toggle switches (for power and speaker on/off)
hook-up wire

Methods

First off drill holes in the ping pong balls, the box and in the baby food lids. Obviously, the size of the holes will depend on what you want to put through them so you'll have to work this out yourselves). Here's the layout I used:

There are 3 holes in a row for the potentiometers, two holes for the LEDs, one hole in the middle for the difficulty switch and one on the side for the power switch.

Next up is to solder leads to the pots. I used speaker hookup cable for the +ve and GND connections and then soldered 3 different coloured wires to the center terminals (I would have used blue instead of black, but I don't have any blue wire). These are going to control the red, green and blue levels of the 'player' RGB LED.

I sanded the LED lenses to make them diffused (I could have just bought diffused lenses... doh!) and then soldered the leads in place. I used some speaker cable again here too to keep things simple (and some heat shrink tubing to prevent shorts).

Then solder the DIP socket onto the perf board. Add the potentiometer leds and the power supply. All the wires were cut to be a little generous in length - I wasn't sure how everything was going to fit so I figured I'd play it safe and allow for wiggle room in the box.

I used one of the IC perfboards because I figured having the central Vcc and GND rails would make life easier as well as the already connected pads around each pin of the uC.

Attach the LEDs to the board:

Then add the speaker and difficulty switch (this just connects/disconnects the speaker from GND rather than being directly controlled by the microcontroller) and test the set-up for shorts, cold solder joints etc.

The LEDs are poked through the holes in the box without the ping-pong balls on (no surprise there). I had them on in the above photos to see how well they worked.

Place everything into the case and hot glue it all securely - I glued the switches and the LEDs in place.

I positioned the uC within easy reach so that I can tweak the software and update easily. Next time I think I'll just add programming headers to the board.

If you're very lucky then you're either artistically gifted or you have a talented partner in crime who can make your project look a hell of a lot better. Lin (my lovely lady and the hostess of filthwizardry.com) had the fabulous idea of creating a Coney Island theme for this game. I take no credit for how good it looks, that was all down to Lin. I think I was going to put it in some old Tea box and leave it at that. Thanks, hon! She was also responsible for the game name. I'm far too British to call myself amazing. Oh, and the American spelling of colour she claims was for symmetry purposes.

I drilled a few holes in the back to increase the apparent volume of the speaker. Also, it took me a while to work out how to keep the lid/base on the box (there were no fasteners built in, the lid was meant to be kept on by gravity). I'd almost given up and was going to attack it with nails when I realised I could simply drill some holes in a couple of washers and screw them into the base... I'm stupidly proud of that little idea. Ah, the little things...

Software

The code is available here on code.google.com.

The output from each potentiometer is read via ADC. These values are used as the 'player' RGB values and are compared with the 'game' RGB values. I started off using the euclidean distance of the RGB vectors as the difference metric, but - with kid friendly values - it meant that you could sometimes match red to green (and green to blue etc.). I ended up requiring each colour be within a defined distance for a successful match.

When a match is detected we turn off interrupts, flash the LEDs and modulate the speaker sound. Then switch interrupts back on and assign a new colour to the system RGB LED.

It uses double buffered software PWM for the LEDs and standard PWM for the speaker.

The only other trick is that the random seed is stored in EEPROM and incremented each time the uC is booted up. The incremented seed is fed to srand and from there we just use the rand() function. This way the game sequence is different each time (well, different for 256 games in a row anyway).


#include <avr/eeprom.h>
/*
 * Use a variable stored in EEPROM to ensure the random color
 * sequence changes from one game to the next.
 */
void initRand()
{
    uint8_t vSeed = eeprom_read_word(0); // load last stored seed
    srand(++vSeed); // increment and use value as seed
    eeprom_write_word(0, vSeed); //store the new seed for next time
}

CharliePlexed LEDs

2010-02-27T23:21:00.001-08:00

There are quite a few things I've wanted to try out and post about as I've been learning them (it seems like a good way to remember them!). For example, I have a half-written post on AVR ADC (analogue to digital converter - for reading inputs like potentiometers and light dependent resistors), one on using pulse width modulation (PWM), one on using LEDs as light sensors...etc, etc. well, so I don't always get round to finishing what I've started. I'm not sure those posts would even be popular and I've concentrated on real/physical/entertaining projects instead. Of course now I have a load of half written posts for almost finished projects... aaaaannyway, onto the point.

I've heard a lot about charlieplexing since starting out on the electronics adventure & the idea of controlling lots of LEDs from only a few microcontroller pins is very appealing. I've been wanting to make some interesting ways to play with the glow-in-the-dark wall and this has lead me to my first practical use for charlieplexing. I thought that a controllable row of LEDs would open up a lot of possibilities: scan back and forth for a sine wave; all LEDs on for caligraphy; random flash for making star-scapes; POV style message writing; printing patterns - hearts, smileys etc.

So, the problem is that with an ATtiny, if you don't want to mess with the reset pin, you only have 5 I/O pins available. I want to use two pins as input - a potentiometer and a push button. This would leave me 3 pins for controllign LEDs... not much to play with really. That's where charlieplexing comes in. I can control 6 LEDs using these 3 uC pins.

The wikipedia article on charlieplexing is pretty good, so I won't repeat what's already been said. Take a look at the tri-state logic part to see what's going on here. There are a load of Instructables which cover charlieplexing - this one on the theory is worth a read.

In the code below the LEDs are numbered ~~slightly differently than~~ exactly the same as in the wikipedia diagram (I just soldered up a prototype and the wiring is much easier to route with the wikipedia numbering). The trick is that we switch two pins to output and one as a high-impedance input (this is the 'floating' pin that is effectively taken out of consideration). One input is set high (+Vcc) and one is low (0v). Current is sourced by the +Vcc output pin and sunk by the 0v output pin. So, for each LED we have different data direction (DDRxn) and port (PORTxn) register settings.

In order to control the 6 LEDs in the diagram above we use the following settings:

LED	PIN1	PIN2	PIN3
1	+Vcc	0v	Input
2	0v	+Vcc	Input
3	Input	+Vcc	0v
4	Input	0v	+Vcc
5	0v	Input	+Vcc
6	+Vcc	Input	0v

The code below is just an initial test set-up where we activate LEDs in a scanning pattern (classic 'cylon eye'). It has all the basics necessary to implement the more complex behaviours. Having the structure array hold the PORTB and DDRB values makes controlling individual LEDs very easy. I'm hoping this will scale up to allowing PWM, but I haven't put much thought into that yet.

Hopefully I'll get a chance to make the UV LED gizmo this week and post about the results.

You can download the source-code from code.google.com or use the cut and paste options in the top right of the code box below.

/*
* charlieplex_test.c
*
* Running on an ATtiny45.
*
* Here we control 6 LEDs through 3 pins (PB0:2).
*
* In order to illuminate each LED we do the following:
*
* LED1 - PB0 & 2 output PB2 input. PB0 sourcing, PB1 sinking. Pull-up on PB2
* LED2 - PB0 & 2 output PB2 input. PB1 sourcing, PB0 sinking. Pull-up on PB2
* LED3 - PB1 & 3 output PB0 input. PB1 sourcing, PB2 sinking. Pull-up on PB0
* LED4 - PB1 & 3 output PB0 input. PB2 sourcing, PB1 sinking. Pull-up on PB0
* LED5 - PB0 & 3 output PB1 input. PB0 sourcing, PB2 sinking. Pull-up on PB1
* LED6 - PB0 & 3 output PB1 input. PB2 sourcing, PB0 sinking. Pull-up on PB2
*
* This little ASCII diagram shows the wiring and orientation of the 6 LEDs.
* The hyphens ('-') identify the cathode pins of the LEDs.
*
* PB0 ----------------------
*        |   -      |      |
*        1   2      |      |
*        -   |      |      -
* PB1 --------      5      6
*        |   -      -      |
*        3   4      |      |
*        -   |      |      |
* PB2 ----------------------
*
* Only a single LED can be illuminated at any point in time.
*
* Distributed under Creative Commons 3.0 -- Attib & Share Alike
*
*  Created on: Feb 27, 2010
*      Author: PaulBo
*/
#include <avr/io.h>
#include <util/delay.h>

#ifndef F_CPU
#define F_CPU 1000000UL
#endif

#define DELAY_TIME 50
#define N_LED 6

// see class comments for pin setting explanation
// unused pins are set to input with pull-up resistors activated
struct leds {
uint8_t mDdrB;
uint8_t mPortB;
} ledData[] = {
{0b00011011, 0b11100101},
{0b00011011, 0b11100110},
{0b00011110, 0b11100011},
{0b00011110, 0b11100101},
{0b00011101, 0b11100011},
{0b00011101, 0b11100110}
};

int main()
{
uint8_t i;
for(;;)
{
for(i = 0; i < N_LED - 1; i++)
{
DDRB = ledData[i].mDdrB;
PORTB = ledData[i].mPortB;
_delay_ms(DELAY_TIME);
}
for(i = N_LED - 1;i > 0; i--)
{
DDRB = ledData[i].mDdrB;
PORTB = ledData[i].mPortB;
_delay_ms(DELAY_TIME);
}
}
}

RGB Night-lights

2010-02-07T23:21:00.000-08:00

My kids love lights; flashlights, LEDs, house lights, pen-lights, light-up teddy bears, the northern lights... you name it, they love it. I've been playing around with RGB LEDs for another project along with ping-pong ball diffusers and baby jar containers. It occurred to me that I could make a simple night-light with most of the same components & the girls were bound love 'em.

I put it all together on Saturday evening after the girls were in bed. I think I'm getting better at all this as I had the code working and 2 lights put together by midnight. The girls found them in the morning (unfortunately, very early...) and came into our bedroom to play with them. First off, they played some kind of colour matching game where they were shouting (yes, shouting, early, in bed...) "RED! I'm wearing red!", "Blue! My socks are blue!". After a bit of this they moved into their bedroom to make a 'tent' out of a couple of chairs and a duvet (comforter). They played with the lights in there for a while; I'm not sure what they were doing as I was drifting in and out of consciousness.

It's Sunday and I've just put the kids to bed. They wanted to go to bed with their lights right next to them. I declare them a success!

I apologise for the quality of this video. It was taken on an iPhone and I've not been able to get hold of them again to take a proper vid. I'm sure you get the idea though.

Ingredients:

ATtiny13
RGB LED (common anode)
8 pin DIP socket
switch (the ones I used were SPDT)
coin cell battery holder
coin cell battery
baby jar
hookup wire (I used stranded 24 AWG).
ping pong ball
neodymium magnet

I used the magnet to attach everything to the lid of the baby jar. I've not had much luck with hot-glue and lids (metal ones), so I figured this should work better. I decided to put this together free-form (i.e. no perfboard), mainly for space reasons - but also as I like the aesthetics of the free-form projects (like this advent wreath or this programmable led).

First off I realised that the DIP socket would fit nicely onto the side of my coin cell holders:

Then I added the neodymium magnet to the center of the holder:

This was actually a bad idea... these things are very strong and everything you're playing with at this point has some kind of ferrous metal involved. This thing attracted the soldering iron, the solder, cut off leads, pliers, the helping hand... If I do this again, I'd definitely wait until the end to attach the magnets.

Next step was to solder on the RGB LED:

You may notice that the socket has changed orientation. I was planning on attaching wire to the leads of the LED so that it'd be easily positionable. Then I realised that, since I only had a tiny amount of room in the jar, I could leave the LEDs leads in place and bend them to put the LED into the correct position. That meant re-orientating the DIP socket (as seen above).

The LEDs common anode has not been attached at this point. I added some heat-shrink tubing to this lead to insulate it from the others. It has to be bent forward and could easily touch one of the adjacent leads.

Also, I sanded the LED casing to diffuse the light. Without this step there are obvious areas of red/green/blue that shine on the ping pong ball from the LED.

Now all that's left is the final bit of wiring:

I attached the switch to Vcc and added a ground wire from the battery holder to the DIP socket. The wire is bent around the magnet and was, er... "fun" to solder in place. The soldering iron kept 'pinging' onto the magnet just as I was getting into position... like I said before, put the magnet on last!

I decided to house the lights in baby food jars. The only modification was to cut some holes for my switches (I used a Proxxon rotary tool for this).

Here's a few shots of them in working order:

Code:

I'm running the ATtiny at 8MHz. This requires setting the fuse bits because the default setting is to divide the clock by 8. This code uses the same software PWM as the firefly-jar-II I wrote about previously. No other tricks here, other than a hack (in the main method) to increase the duration of the RedToYellow transition. That's just personal taste though & (since I'm fickle) I may remove that section in the future.

Current code is available on code.google.com. Here's the code that's running in my kids bedroom at the time of posting:

/*
 * rgb_strobe.c
 *
 * Distributed under Creative Commons 3.0 -- Attib & Share Alike
 *
 *  Created on: Feb 6, 2010
 *      Author: PaulBo
 */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#ifndef F_CPU
    #define F_CPU 8000000UL
#endif

//Hardware definitions
#define RED_LED      PB2
#define GREEN_LED    PB1
#define BLUE_LED     PB0
#define ALL_LEDS    ((1 << RED_LED) | (1 << GREEN_LED) | (1 << BLUE_LED))

//Maximum value for led brightness
#define R_MAX 255
#define G_MAX 255
#define B_MAX 255

#define RED_INDEX   0
#define GREEN_INDEX 1
#define BLUE_INDEX  2

//Cycle States
#define RedToYellow     0
#define YellowToGreen   1
#define GreenToCyan     2
#define CyanToBlue      3
#define BlueToMagenta    4
#define MagentaToRed     5

//set red to max (we start in the RedToYellow state)
volatile unsigned char mRgbBuffer[] = {0,0,0};
unsigned char mRgbValues[] = {255,0,0};
unsigned char mState;

void init_timers()
{
    TIMSK0 = (1 << TOIE0);         // enable overflow interrupt
    TCCR0B = (1 << CS00);          // start timer, no prescale

    //enable interrupts
    sei();
}

void rgbCycle(){
    switch (mState) {
    case RedToYellow:
        mRgbValues[GREEN_INDEX]++;
        if (mRgbValues[GREEN_INDEX] == G_MAX)
            mState++;
        break;
    case YellowToGreen:
        mRgbValues[RED_INDEX]--;
        if (mRgbValues[RED_INDEX] == 0)
            mState++;
        break;
    case GreenToCyan:
        mRgbValues[BLUE_INDEX]++;
        if (mRgbValues[BLUE_INDEX] == B_MAX)
            mState++;
        break;
    case CyanToBlue:
        mRgbValues[GREEN_INDEX]--;
        if (mRgbValues[GREEN_INDEX] == 0)
            mState++;
        break;
    case BlueToMagenta:
        mRgbValues[RED_INDEX]++;
        if (mRgbValues[RED_INDEX] == R_MAX)
            mState++;
        break;
    case MagentaToRed:
        mRgbValues[BLUE_INDEX]--;
        if (mRgbValues[BLUE_INDEX] == 0)
            mState++;
        break;
    }

    //state should never advance beyond 5.
    //It wraps back to 0 when we reach 6
    mState %= 6;
}

int main(void){
    //Set LED pins to output
    DDRB |= ALL_LEDS;

    init_timers();

    while (1) {
        rgbCycle();
        _delay_ms(250);

        //I like the orange state and it only lasts for a second
        //so lets extend it a little bit more
        if(mState == RedToYellow)
        {
            _delay_ms(250);
            _delay_ms(250);
        }
    }
    return 0;
}

/*
 * Timer/Counter overflow interrupt. This is called each time
 * the counter overflows (255 counts/cycles).
 */
ISR(TIM0_OVF_vect)
{
    //static variables maintain state from one call to the next
    static unsigned char sPortBmask = ALL_LEDS;
    static unsigned char sCounter = 255;

    //set port pins straight away (no waiting for processing)
    PORTB = sPortBmask;

    //this counter will overflow back to 0 after reaching 255.
    //So we end up adjusting the LED states for every 256 interrupts/overflows.
    if(++sCounter == 0)
    {
        mRgbBuffer[RED_INDEX] = mRgbValues[RED_INDEX];
        mRgbBuffer[GREEN_INDEX] = mRgbValues[GREEN_INDEX];
        mRgbBuffer[BLUE_INDEX] = mRgbValues[BLUE_INDEX];

        //set all pins to low (remember this is a common anode LED)
        sPortBmask &=~ ALL_LEDS;
    }
    //this loop is considered for every overflow interrupt.
    //this is the software PWM.
    if(mRgbBuffer[RED_INDEX]   == sCounter) sPortBmask |= (1 << RED_LED);
    if(mRgbBuffer[GREEN_INDEX] == sCounter) sPortBmask |= (1 << GREEN_LED);
    if(mRgbBuffer[BLUE_INDEX]  == sCounter) sPortBmask |= (1 << BLUE_LED);
}

Jar-O-Fireflies (Mark II)

2010-02-02T23:53:00.000-08:00

I really enjoyed the process of making my first 'Jar-O-Fireflies' but I was a little disappointed with the performance (i.e. the software), especially the obvious flicker when the lights were pulsing on and off. I've learned a lot more about how to program the AVR uCs over the last few months (but still just the basics really). So, I decided to re-write the software and make a smaller, battery powered, version. I'm going to make another and put it in an empty Nuttela jar for the girls to use as a night light (I'm sure the girls will help me empty the jar).

The software took a little while to sort out but the hardware, on the other hand, only took about 2 hours to put together. Most of that was due to the fiddlyness of using magnet wire for the LED leads.

Below is a little video of it working. Yes, we have 'pet' ants at the moment - at least it was interested in what was going on...

The parts:

some magnet wire
coin cell holder (and coin cell to go with it)
perf board - I used a board with a semi breadboard layout (see picture below), but it wasn't much more help than a standard one other than having a common power and ground rail to connect everything to.
switch (one that fits onto a PCB/perf board)
8-pin dip
5 green LEDs (3mm)
ATtiny13

This is the layout I used (for the battery holder, DIP socket and switch):

The trickiest part was soldering the magnet wire onto the LEDs. I used a third-hand to hold all the pieces together. It helps that the magnet wire is quite stiff and bendable even though it's thin.

As you can see from the photo. After soldering on the wire I twisted the two strands together. After doing the 5 LEDs I realised that it'd be really nice to have 2 different colours of wire so that the positive and negative leads were obvious... oops. I ended up testing each pair of wires with my LED tester to determine which lead was positive and which was negative.

Then it's was just a matter of soldering on the LED leads to the board:

Then I glued everything onto the jar lid (using a hot glue gun):

Et voila!

Code:

I've just started using code.google.com as a code repository. The google site supports subversion source control (and there's a good plug-in for eclipse called subversive). I'd been going back and forth between computers and it was turning into quite a headache trying to get the code in sync. Now I can just push and pull from the code repository.

Here's the location of the firefly code:
http://code.google.com/p/pboardman-avr/source/browse/firefly_jar/firefly_jar.c

This may change in the future as I tinker a bit more, so I'm including below the version of the code that was running when I wrote this post. This version required setting the fuse bits for the ATtiny13 to make it run at 8MHz. I also wrote a better software PWM routine (see the Atmel technote: "Low-Jitter Multi Channel Software PWM". Warning: PDF link).

There are a few enhancements that I have in mind like actually using a random number generator for generating random numbers... The reason I didn't was that I had trouble coming up with a method for generating a seed (without a differing seed, the pseudo random number generator would give the same sequence each time the AVR was switched on). My latest project (post forthcoming) saves the seed in EEPROM and increments it each time the AVR is booted up - this way the random number generator produces a different sequence each time. Anyway, here's the code:


/*
 * firefly_jar.c
 *
 * Distributed under Creative Commons 3.0 -- Attib & Share Alike
 *
 *  Created on: Feb 2, 2010
 *      Author: PaulBo
 */
#import <util/delay.h>
#import <avr/io.h>
#import <avr/interrupt.h>

#ifndef F_CPU
    #define F_CPU 8000000UL
#endif

//LED pin definitions
#define LED1    PB0
#define LED2    PB1
#define LED3    PB2
#define LED4    PB3
#define LED5    PB4
#define N_LEDS  5
#define ALL_LEDS (1 << LED1) | (1 << LED2) | (1 << LED3) | (1 << LED4) | (1 << LED5)

//Max value for LED brightness
#define MAX     100

#define PULSE_UP   1
#define PULSE_DOWN 0

volatile unsigned char buffer[N_LEDS];

//counter for use in updateLedState() and pulseLeds()
unsigned char i;

//structure for storing data on each LED
struct ledData {
    unsigned char mBrightness;
    unsigned int  mTime;
    unsigned char mPin;
    unsigned char mPulseDirection;
};

//set up some initial values
struct ledData led_data[] = {
        {0, 1000,  LED1, PULSE_DOWN},
        {0, 10, LED2, PULSE_DOWN},
        {0, 500, LED3, PULSE_DOWN},
        {0, 50, LED4, PULSE_DOWN},
        {0, 150,  LED5, PULSE_DOWN}
};

//return a random time interval from 0 to 255
int getTime()
{
    return TCNT0;//just read the current timer/counter value
}

void updateLedState()
{
    for(i = 0; i < N_LEDS; i++)
    {
        switch(led_data[i].mBrightness)
        {
            case MAX://led is on
                if(--led_data[i].mTime == 0)
                {
                    //decrement the brightness, this puts the LED in a
                    //pulse state
                    led_data[i].mBrightness--;

                    //specify the "down" direction for pulsing
                    led_data[i].mPulseDirection = PULSE_DOWN;
                }
                break;
            case 0://led is off
                if(--led_data[i].mTime == 0)
                {
                    //increment the brightness,this puts the LED in
                    //a pulse state
                    led_data[i].mBrightness++;

                    //specify the "up" direction for pulsing
                    led_data[i].mPulseDirection = PULSE_UP;

                    //set the ON time
                    led_data[i].mTime = getTime() + 1;
                }
                break;
            default: //pulse state
                if(led_data[i].mPulseDirection == PULSE_UP)
                {
                    led_data[i].mBrightness++;
                }
                else
                {
                    if(--led_data[i].mBrightness == 0)
                    {
                        //set the OFF time - make this longer than the on time
                        led_data[i].mTime = (getTime() + 1) * 5;
                    }
                }
                break;
        }
    }
}

void init_timers()
{
    TIMSK0 = (1 << TOIE0);         // enable overflow interrupt
    TCCR0B = (1 << CS00);          // start timer, no prescale

    //enable interrupts
    sei();
}

void init_io()
{
    //set all LED pins as outputs
    DDRB |= ALL_LEDS;
    PORTB &= ~(ALL_LEDS); //off to start
}

void setup()
 {
    init_io();
    init_timers();
}

int main(void)
{
    setup();

    //infinite loop
    while(1)
    {
        updateLedState();
        _delay_ms(10);
    }
}

/*
 * Timer/Counter overflow interrupt. This is called each time
 * the counter overflows (255 counts/cycles).
 */
ISR(TIM0_OVF_vect)
{
    //static variables maintain state from one call to the next
    static unsigned char sPortBmask = ALL_LEDS;
    static unsigned char sCounter = 255;

    //set port pins straight away (no waiting for processing)
    PORTB = sPortBmask;

    //this counter will overflow back to 0 after reaching 255.
    //So we end up adjusting the LED states for every 256 overflows.
    if(++sCounter == 0)
    {
        for(i = 0; i < N_LEDS; i++)
        {
            buffer[i] = led_data[i].mBrightness;
        }
        //set all pins to high
        sPortBmask = ALL_LEDS;
    }
    //this loop is considered for every overflow interrupt.
    //this is the software PWM.
    if(buffer[0] == sCounter) sPortBmask &= ~(1 << led_data[0].mPin);
    if(buffer[1] == sCounter) sPortBmask &= ~(1 << led_data[1].mPin);
    if(buffer[2] == sCounter) sPortBmask &= ~(1 << led_data[2].mPin);
    if(buffer[3] == sCounter) sPortBmask &= ~(1 << led_data[3].mPin);
    if(buffer[4] == sCounter) sPortBmask &= ~(1 << led_data[4].mPin);
}

Glow-in-the-Dark sketch wall and LED pens

2010-01-12T23:40:00.001-08:00

I've finally realised one of my childhood dreams; I'm now the proud owner of a glow-in-the-dark wall - just don't tell the landlord!

I've had some glow-in-the-dark paint knocking around for quite a while and was inspired to do something with it when I saw this post on hackaday.com - "Record player display sans POV". I thought "the kids" would have a lot of fun using LED flashlights to write on something that was phosphorescent.

To start with I just coated some stiff card with the phosphorescent paint and hacked together a simple UV-LED flashlight. The flashlight design was taken from this Instructable - "Make A Mini LED Light". I found it while trying to find ways to make my own battery holders for a more standard flashlight, but this idea was so simple and small that I decided to go with it instead. All I did was to substitute a UV LED in place of a standard one.

After making the prototype I showed it off to "'er indoors" (this may not mean much to you if you didn't grow up watching "Minder" in the U.K.). Her response was a little unexpected - "Hmmm.... why don't we paint the wall with glow-in-the-dark paint? That way loads of kids can play at once!". So that's what we did :) We isolated a good amount of wall with painters tape, we just wanted it to be slightly taller than the kids. Then we put on 2 coats of white primer, 3 coats of the glow-in-the-dark paint and a couple of layers of varnish (so the kids didn't immediately scrape off the latex based glow paint). After removing the painters tape, I was pleasantly surprised to see that the wall didn't look much different.

Unfortunately, my night time camera skills leave a lot to be desired (i.e. they're crap), so I don't have many pictures of the kids playing with the wall. I can say that they were very excited and played with it for days & were very keen to get all their friends to play too whenever they came over. At one point we had a complete sea-scape covering the whole canvas with storm clouds, jellyfish, 'normal' fish and deep sea monsters. In the picture below I'm holding one of our home made light-sabers next to the wall in an attempt to allow the camera to focus (see this filthwizardry post for more lightsaber fun- "balloon and torch lightsabers").

I think one of the favourite activities, however, was with an old SLR camera flash. Get the kids up against the wall and blind them with the flash. If they recover (ok, you could just tell them to close their eyes) they'll get to see themselves glowing in silhouette form on the wall .

Hmm... ok, maybe it was one of my favourite activities as well.

After a couple of days playing, I ended up buying some LED keychain flashlights (like these from Amazon) as I quickly ran out of parts.

Here's a few in-production pictures of the ones I made:

I made 4 to begin with. All you need is a pushbutton, a UV LED, a coin cell battery and holder (and a soldering iron + solder for connecting it all up).

Connect the positive lead of the LED to the positive battery holder connector, cut off the rest of the lead so it doesn't get in the way, then attach the pushbutton to the negative battery holder connection and the negative LED lead. That's it!

Here's the first one working (nice purple glow). Some hot glue made for good protection and electrical tape wrapped around the base of the LED helped to focus the beam.

You should probably use a resistor to protect the LED... The datasheet for my LED stated that it required 3.2V to operate and the coin cell is only rated at 3V so I decided to leave the resistor out.

Important: Bright lights/UV lights can damage your eyesight. Do not shine the lights into anyone's eyes and make sure any kids playing with these are supervised and told to shine the light only at the wall. Extra care should be used when using UV light - the human eye can not detect it (i.e. you can't see it) which makes it easier to overexpose your retina as you don't have the same pain response as with intense light in the visible spectrum.

If you're nervous about this then the standard keychain lights work pretty well. The homemade UV ones just give a longer lasting glow.

Duplo Traffic Lights

2009-12-17T16:17:00.000-08:00

We've been playing with LEGO and DUPLO quite a lot at home recently (Lin's been doing some great work on expanding our LEGO possibilities - see these posts over on filthwizardry: "Lego and hole punching cards", "Festive card punching with more LEGO", "LEGO and DUPLO" and "LEGO car and DUPLO truck cardboard printables").

I thought it'd be really nice to be able to add some traffic lights (like these ones I made a while back) to the creative fun. Lin suggested I house some in a DUPLO block, so I set to work trying to figure out how to do it.

Ingredients: 3 LEDs (red, yellow, green), 3 resistors (I used 330 ohm), ATtiny13, 8 pin DIP socket, perf board, magnet wire (thin), switch, stranded wire (black and red), coin cell battery, DUPLO blocks (the 8 knobble variety, 1 standard and 2 thin).

Tools: soldering iron, dremel, hot glue gun, various dremel attachments and drill bits (depending on your LEDs and switch).

The three holes/cylinders on the underside of a standard DUPLO block are perfect for traffic light mimicry. I ended up using 3 blocks, one large and two thin. The large block houses the electronics and the switch, one thin piece has 3 holes drilled in it for the LEDs and the last piece is used on the back as a battery cover.

Here's a couple of pictures showing the carved out bricks. You have to leave some of the 'tubing' in the large brick in order for the other brick to still connect normally. I used a dremel to cut off the 4 middle bobbles from the thinner piece - leaving a hollow center, between the two pieces, for the electronics.

I haven't taken a picture of the remaining thin block, I hollowed that out in the same manner as the larger block, to make room for the coin cell battery. Again leaving enough of the innards so it'd still fit tightly on the back of the main block.

I drilled 3 holes in the front piece (the thin black one above) directly in the center of the three tubes; the holes need to be just the right size for the LEDs to fit snuggly (I messed this up with my first prototype). I also drilled a small hole in the center of the big block for the power wires to feed through later on. This way you can have all the electronics hidden in the main block and have the battery accessible on the back.

The main board is just a small bit of perf-board with the 8-pin DIP socket soldered on. I'm using the same code as last time, so the LEDs and resistors are attached to pins 5, 6 and 7 (PB0, PB1 and PB2 respectively). I used magnet wire to attach the LEDs as it's flexible and takes up very little room. I tried just soldering the LEDs directly onto the perf-board but that made it difficult to get a good fit later on. If you give this a go, remember to sand the insulation off the ends of the magnet wire before soldering.

Add a switch:

Then place it all inside the main block (feeding the power wires out of the hole in the back).

Then glue the LEDs into the holes of the front piece and close it all up. I'm probably going to have to glue it shut in the future to keep out fiddling fingers.

I didn't have a coin cell holder, so I scavenged some metal tabs from the innards of a happy meal toy and soldered these onto the ends of the power leads. Then I taped them tightly onto the coin-cell. Clip on the battery cover (3rd block) and it's all done. This would all be a bit cleaner if there was a coin cell holder attached to the back in some way (I'll give that a go next time).

Here's the lights in operation (with my first attempt on the right which has directly soldered LEDs and an ugly switch):

The kids really do seem to like them! The original lights have had to be repaired a few times from er... 'overly keen' play. Well, that and Ffion ripping them apart.

Next ideas are to make them easier to include with normal duplo play by attaching blocks to the top and bottom (may require some cutting and gluing). Another good addition would be to have lights on both sides of the block to control traffic in both directions (so when one side is green the other is red). If only I had more black duplo...

64-bit Windows 7 and the AVR ISP USB programmer

2009-11-22T23:36:00.000-08:00

Just a very quick note about this.

I upgraded my laptop to 64-bit Windows 7 a week or so ago and have just gotten round to setting it up for AVR programming. I thought for a while that I'd never get my USB programmer to work (AVRStudio couldn't auto detect my AVR ISP even after installing/reinstalling). After a little bit of searching I found this thread on avrfreaks.net. I followed the directions, allowed windows to discover the correct drivers at the end of the process and, badabing-badaboom, everything now works fine (other than the fact that I installed a 32 bit Eclipse that isn't happy...).

LED Tester Mark II

2009-11-03T12:15:00.000-08:00

Ok, so the last one I made had a serious flaw... it'd burn out any LED that couldn't take 3V... Oops! I recently bought a new soldering iron (variable temp, xytronics from allelectronics.com) and wanted to play with it, so I thought it was time to replace the LED burner with an LED tester.

Basic ingredients: wire, some resistors, an 8 pin DIP socket, a pushbutton and some perfboard. I treated myself to an automatic wire stripper the other day ($8 from Fry's), it's great! I've been using it quite a lot. No need for it in this project really, but I like to show off my toys.

Here's the basic wiring and soldering for the resistors and socket (this is what I messed up in the first iteration):

At midnight I ended up with the following "finished" product (I should have learned by now not to start late at night...):

The problem was that I'd completely wired the push button wrong. In the above wiring, the power lines are connected to the positive and negative rails on the DIP socket, which meant the LEDs lit up as soon as they came in contact with the DIP. On pushing the switch the LEDs would turn off because the positive and negative leads from the battery holder were shorted... bah!

A few days later, I came back and repaired it (button connects and disconnects +ve terminal, -ve terminal is wired directly):

A view from the top.

Single LED test. You can see the multi-LED test picture at the top of this post.

The soldering iron is much better than the Weller I'd bought (it was a bottom of the line weller min you). It heats up fast and the tip is noticeably better quality. The power cord, however, is very thick and reduced the maneuverability of the iron.

Flashing Bat Eyes

2009-11-01T15:13:00.000-08:00

Very simple project. You just need a 555 timer a couple of resistors, a capacitor, a couple of LEDs and a talented wife to provide a bat ;) I think she'll be adding a post on making the Halloween bats so I'll link to it once it's up.

I used the following online calculator to work out the values for R1, R2 and C1 for the standard astable 555 set up. I ended up with: R1 = 3K Ohm, R2 = 570 Ohm and C1 = 100uF (mainly because that was the combination of components that I had lying around and that gave an acceptable output wave). I didn't bother adding a switch to this one, I'm not sure why as it'd be very easy... here's the fully wired up project:

Did you notice the 9V battery clip onto an 2xAA holder? Weird eh? Useful though. I think I picked up the battery case at radioshack. You'll also have noticed that I decided to try a free-form (no perf-board) approach. It was a bit fiddly, but worked out ok. I still haven't found a combination of 3rd hand/clamp/foot/nose that works for me for these fiddly soldering projects...

Here's a couple of close-ups of the soldered 555 itself:

Most of the time I had the 555 held with a crocodile clip (on the 3rd hand). Unfortunately, I bought a really cheap 3rd hand from a market and the crocodile clips are not stable so everything kept moving around whilst I was trying to work on it... bah. At points I ended up jamming the chip into a corner of the 3rd hand base whilst pushing at it with the soldering iron. Not very elegant or skilled... any advice is greatly welcomed!

All that's left was to poke out some holes for the bats eyes and to mangle it all into the available space. I made the holes big enough for the dome of the LEDs to fit through but small enough to prevent the rest of the LED housing from pushing through.

And here it is outside our house (flashing on the opened door frame), waiting to welcome the trick-or-treaters :)

ATmega programming board

2009-10-31T17:45:00.001-07:00

Recently I've been playing with some projects that required more IO pins than the ATtiny has to offer. I bought a few ATmega8's from ebay and have about 3 of them installed in various breadboards at the moment. All the wiring was getting very frustrating, so I decided to make another programming board to reduce the clutter and to make my life a bit easier.

The process was almost identical to that for the ATtiny header board. There are only two real differences: 1) this is a board designed to fit the ATmega8 AVR chip so it has a 28 pin DIP socket and 2) I used a bad purchase (wide 28 pin dip socket) as the female headers for wiring up to the breadboard projects.

The wiring is practically the same as the ATtiny board. If you've ever wired an ATmega to a breadboard (or to anything else) you'll easily be able to work this out. There's more room to maneuver with the larger 28 pin board as well, which was nice.

Here's the 'bad purchase':

I mistakenly bought a few of these wide 28 pin sockets (as part of another allelectronics purchase). These have been sitting in a drawer all but forgotten. I noticed them whilst retrieving the narrow 28-pin socket for this board and figured these would be useful as female header rows if I just chopped them in half. It turns out they fit really well & look pretty good too.

LED Cube

2009-09-12T23:50:00.000-07:00

I've wanted to create one of these for ages. There are a ton of instructables out there for how to make various versions of these from 2x2x2 cubes to 8x8x8 monsters. I wanted to make something reasonable for a first attempt, but fun enough to look at. I figured a 3x3x3 is a good start.

There's also been quite a buzz the last few months around using LEDs as both light emitters and light detectors. I wondered if the LED cube could be made more interesting by also making it detect changes in ambient light. Perhaps that's a little too ambitious for the first iteration, but I can at least plan for this feature as a software (rather than a hardware) update later on. It turns out that there's nothing extra needed, hardware wise, for light detection with LEDs (check out this post on spritemods, which is a great example: minimalism; Jeroen also posts the source code, which I'm going to "borrow" from rather liberally when I get round to trying the light detection part). Don't expect any of the light detection fangling in this post - I'm only going to describe making and testing a 3x3x3 LED cube. I mention the light detection stuff because it's cool and I wanted to pressure myself into getting round to doing it by publicly announcing my intent :)

Anyway, first things first, lets get a working cube soldered and tested.

For the initial test set up I used the following: 9 LEDs (I chose all blue), an ATmega8, 12 breadboard jumper cables, 3 alligator clips (for the cathodes), a couple of breadboards and my regular USB AVR programer and associated paraphernalia.

To make the soldering process easier I created a jig from a plastic box in the recycling bin. I made a 3x3x3 grid of holes, spaced 25mm apart (just a little less than the length of the LED cathode leads). I marked out the holes with a sharpie and then blasphemed by melting the holes with my soldering iron...

I pushed in the LEDs into each hole with the anodes (long leads) facing outwards - we're going to be soldering all the anodes in a column together later on and it seemed sensible to have them on the outside of the cube, where they'll be easier to get at. Then I bent the cathodes down 90^o so that they touched the cathode of one of their neighbours.

Here's the jig with the first set of LEDs in place, ready to solder:

The middle LED only makes one connection, which makes it a weak point in the layer. I was tempted to add a couple of extra connections from it to make it more stable, but I figured that, after soldering the layers together it should be stable enough. I just added a bit more solder to that particular connection in order to strengthen it.

After soldering all the leads together, you gently pull each LED out of their hole. You can then pull the whole assembly away and marvel at your soldering skill ;). Then it's time to start over again...

Here's the full set of 3 layers all soldered nicely (still separate though):

The final step in creating the cube is to solder the layers together. There must be a better way than what I tried, but here it is: I placed one layer back in the jig, cut off a few small strips of sellotape, positioned the next layer on top so that the anodes from the lower layer overlapped enough to solder to the next layer and then secured the two layers together with the sellotape (synonym:scotch tape). I soldered the corners first to give some amount of stability to the emerging structure.

Whilst soldering the third layer I worked out that the best method was to position the lower anode lead on the outside of the upper LED, then bend about 2mm of the lower lead 90^o towards the upper lead and then solder them together. The bottome left LED column in the second picture below shows what I mean:

And here's the completed cube:

I'd not actually programmed an ATmega8 before, but it was fairly straight forward to modify my ATtiny setup. I just had to work out which pins to attach the programmer to (by looking at the atmega8 datasheet). The trickiest part ended up being getting the cube securely placed into the breadboards (I wish I'd given into a previous whim to buy one of the bigger boards now). The picture below shows my test current set-up with the cube installed.

I tried to come up with the simplest test I could imagine whilst ensuring I was addressing each LED correctly. So my first test just powered up each individual LED in order, one layer at a time.

Here's a video of it in action:

I've included the code below for those interested. Just bear in mind that this was specific to the way I wired up the cube. It's a shame 9 columns have to be used for this as it means using multiple registers for the LEDs, which means we have to specify which columns are on which registers. Maybe someone out there can show me a better way to do it?


/*
* led_cube.c
*
*  Created on: September 6th, 2009
*      Author: Paul
*/
#include <avr/io.h>
#include <avr/delay.h>

//define the cathode pins
//I just happened to connect them to these pins
#define LAYER1 PD1
#define LAYER2 PD0
#define LAYER3 PD2

//define which pin each column (anode) is connected to
uint8_t kColumnConfig[] = {PD3, PB7, PB3, PD4, PD6, PB2, PB6, PD7, PB1};
//store the layers in an array as well
uint8_t kLayerConfig[] = {LAYER1, LAYER2, LAYER3};

//this function switches a column on or off
//we have to know which port the column is a part of
//hence the switch statment:
// PORTD pins are at indices 0,3,4,7 in the kColumnConfig array
// PORTB pins are at indices 1,2,5,6,8 in the kColumnConfig array
void setColumn(uint8_t pVal, uint8_t pCol)
{
switch(pCol)
{
//portD pins
case 0:
case 3:
case 4:
case 7:
 if(pVal)
 {
  PORTD |= (1 << kColumnConfig[pCol]);
 }
 else
 {
  PORTD &= ~(1 << kColumnConfig[pCol]);
 }
 break;
case 1:
case 2:
case 5:
case 6:
case 8:
 // portB pins
 if(pVal)
 {
  PORTB |= (1 << kColumnConfig[pCol]);
 }
 else
 {
  PORTB &= ~(1 << kColumnConfig[pCol]);
 }
 break;
}
}

int main(void)
{
uint8_t i = 0;
uint8_t j = 0;

DDRB = 0xFF; // all set to output
DDRD = 0xFF; // all set to output
//swich off all layers by applying voltage to the cathode pins thereby preventing current flow
PORTD |= (1 << LAYER1) | (1 << LAYER2) | (1 << LAYER3);
while(1)
{
 //loop through each layer
 for(i = 0; i < 3; i++)
 {
  //set the output value for this cathode layer to '0'
  //this allows current to flow in this layer
  PORTD &= ~(1 << kLayerConfig[i]);
  for(j = 0;j < 9; j++)
  {
   //turn on the LED in column j
   setColumn(1, j);
   _delay_ms(250);
   //trun off the LED in column j
      setColumn(0, j);
  }
  //set the output value for this cathode layer to '1'
  //this prevents current flow for this layer
  PORTD |= (1 << kLayerConfig[i]);
 }
}
return 1;
}

PVC Pipe Marshmallow gun

2009-09-07T23:40:00.001-07:00

This post is a bit of a diversion from the normal electronic fangling, but it's such an easy and fun project that I wanted to share.

I was flicking through a recent purchase, "The best of instructables (volume 1)" , and I landed on page 232 - "The marshmallow shooter". It's labour day (sorry: "labor day") which means that we were having a lazy Monday at home so we decided to take a trip to Lowes to pick up the necessary bits to make a few shooters.

That's all you need (and some marshmallows). The pipe is 1/2" schedule 40 PVC, it was 89c for about 5 feet of the stuff (enough for 3 shooters). I also picked up a few different fittings: three way junctions, four way junctions, elbows (with different angles), caps and some couplings (to use as mouthpieces). I also picked up a pipe cutter; I've experienced the "joy" of using a hacksaw for cutting pipes (those ones get a brief mention on filthwizardry: music tree) . This time I decided on an easier option.

First off we cut up the pipe into various lengths, short pipe for the handles and longer ones for the main body. We washed all the bits thoroughly.

Here's all the parts that went into our first three guns:

Next up I showed the girls how all the parts fit together. I helped to tighten the parts, but that was all the intervention necessary. It's all very easy and simple. I think I'm going to get a load more of the piping and fittings and just let the kids play with it free-style sometime soon.

After getting all the parts together, they decided their creations needed to be decorated before we could use them :) We had a strange coincidence here: before heading to Lowes we popped into the local Savers (they were having a labor day sale) and what did we find in the book section? A book on making marshmallow guns (here's the Amazon link)! Very weird! Being from Savers, it didn't come with any of the piping, but it did have most of the stickers left (not anymore though!).

Time to try out the beautified guns on Lin.

They had a great time blasting (and eating) the mini marshmallows. The great thing about using marshmallows is that, strangely, there was no mess to clean up afterwards...

Toy Traffic Lights

2009-08-30T20:59:00.000-07:00

This is something I've been meaning to make for ages. My kids love toy cars (ok, lets face it, all kids love toy cars!). There's been lots of car related fun in our household (some of which has been documented on filthwizardry: "Toy cars and trucks from recycling", "shower curtain village playmat" and "home made toy carwash") and one of the kids favourite pastimes in the car is to shout "RED means STOP!" and "GREEN: GO!" (as loudly as humanly possible). I figured it was about time I used this as an excuse to spend some time in the garage making something with flashing LEDs :)

Between Lin and myself we've managed to amass quite a bit of cheap 'junk' that can be hacked together for something like this. I was going to make something flimsy using a battery pack and a drinking straw, but I was persuaded to make something a bit more kid-proof using a dollar store wooden box, an Altoids tin and the tube from a black felt-tip pen. Here's a picture of all the bits (there are three 150 ohm resistors are missing):

The plastic domes are the discarded remnants of 25c kids toys purchased from a vending machine in our local Taqueria, they looked like they'd make good LED covers (and they were used as wheels in another crafty distraction: "Toy cars and trucks from recycling"). The chip is an ATtiny13.

First up was to drill some holes: two in the box, one on the side for the switch and one on the top for the pen tube; one in the base of the altoids tin (again, for the pen tube) and three in the back of the tin for the LEDs.

Then I painted it black.

The wiring for the base/box is pretty simple, just an AA battery pack wired to a switch with the main wires threaded out of the hole in the top of the box. I stuck the pen casing in at this point and threaded the wires through to the top.

Now it's time for the wiring.

First off, I hot glued the base to the Altoids tin. Then I glued the LEDs into their holes with the cathodes all facing in one direction so I could solder them together to form a ground rail.

I soldered on three, 150 ohm, resistors to an 8-pin dip socket (pins 5, 6 and 7), soldered the positive lead from the base to pin 8 on the socket. Then I connected the LEDs to the resistors and finally connected the ground pin (pin 4) to the ground rail. That's it!

When I was writing the code I didn't think ahead about which pins were going to be connected where in the final project and ended up with the red and green pins mixed up (in software), so the initial sequence was backwards; but then that's why I used a socket rather than directly soldering the uC ;). Easy to fix with a quick software update.

Here's the final working project (yes, the yellow works too, I just didn't take a picture of it):

I've included the code below. As always, it's pretty simple:

### code starts here ###
(I found a nice way of displaying code in blogger. I talk about setting it up here)


/*
* trafflic_lights.c
*
*  Created on: Aug 29, 2009
*      Author: Paul
*/
#include <avr/io.h>
#include <avr/delay.h>

#define RED_LED PB2
#define YELLOW_LED PB1
#define GREEN_LED PB0

#define RED_DELAY 10
#define YELLOW_DELAY 3
#define GREEN_DELAY 15

uint8_t i = 0;
uint8_t j = 0;
void delay_seconds(uint8_t pSecs)
{
  for(i = 0; i < pSecs; i++)
  {
      for(j = 0; j < 4; j++)
          _delay_ms(250);
  }
}

int main(void)
{
  DDRB = 0xFF;//set all to output

  //start traffic light sequence
  while(1)
  {
      PORTB = (1 << RED_LED);
      delay_seconds(RED_DELAY);
      PORTB = (1 << YELLOW_LED);
      delay_seconds(YELLOW_DELAY);
      PORTB = (1 << GREEN_LED);
      delay_seconds(GREEN_DELAY);
  }
}

Led camp fire

2009-08-25T22:05:00.000-07:00

A few days ago I came home from work and was rather surprised to find a, full-sized, indoor camp-out taking up the living room... you have to see it to believe it (the original was bigger than the version above!):- filthwizardry.blogspot.com. Well, the kids loved it and my lovely lady inspired me to make a flame free campfire to add to the fun. I figured it'd be easy to do with a uC and a few red/orange LEDs -all of which I had lying around the place.

To get the basic set-up I cannibalized the innards of the glow in the dark balls project and jammed a few LEDs in the right places; this let me start messing with the code. In the second image you can see my test set-up. I ended up using my LED tester to provide power to the breadboard and my ATtiny header board for quickly cycling the code on the chip. I was happily surprised that both of these worked and were useful - I've been getting frustrated jamming frayed power leads into the breadboard and it'd only just occurred to me that I could use the LED tester.

All I wanted the code to do was randomly switch the LEDs on and off fast enough to mimic flickering flames. I messed around with the speed of flickering a bit until I was happy.

For those who are interested, I've included the code at the bottom of the page. It's a pretty simple affair. I take no credit for the random number generator, in the past I've just used library code for this, but I happened across that nice bit of code online and fancied using it (I think this is the original source but I found it here). The code is in a slightly incomplete state as I was also messing around with altering the delay between each set of LED updates. Shorter delays give the impression of an angry/quick burning fire and longer delays give rise to a soothing fire. I quite like the idea of having a random drift for the delay to make the fire more interesting, but got tired at around midnight and decided to simplify.

Lin suggested housing everything in the top section of a solar garden light case (which had been destroyed during a particularly energetic play-date). All that needed modifying was to add a small hole for the switch. I also cut down the LEDs so they took up less space and were more secure:

Then I added some protection to the top and a cardboard base to keep the innards in place (I used a hot-glue gun to secure both parts).

And that's it! Very simple.

Here's the contraption hidden in the kids camp fire waiting to be discovered:

and a little video of it in action:

p.s. anyone notice the freaky kiddie scarecrow in the first image? Have a look at the whole filthwizardry post, that thing freaks me out on a daily basis! I think it's the eyes... "she's got the cold dead eyes of a killer" ;)

### code starts here ###


/*
 * candle.c
 *
 *  Created on: Aug 21, 2009
 *      Author: Paul
 */
#include <avr/io.h>
#include <avr/delay.h>

/*
 * pseudorandom
 * return the next pseudo-random number (PRN) using a standard maximum
 * length xor-feedback 16-bit shift register.
 * This returns the number from 1 to 65535 in a fixed but apparently
 * random sequence.  No one number repeats.
 */
uint16_t randreg = 10;

static uint16_t pseudorandom16 (void)
{
    uint16_t newbit = 0;

    if (randreg == 0) {
        randreg = 1;
    }
    if (randreg & 0x8000) newbit = 1;
    if (randreg & 0x4000) newbit ^= 1;
    if (randreg & 0x1000) newbit ^= 1;
    if (randreg & 0x0008) newbit ^= 1;
    randreg = (randreg << 1) + newbit;
    return randreg;
}

int main(void)
{
 uint8_t i = 0;
 uint16_t j = 0;
 uint8_t delay = 20;
 DDRB = 0xFF;

 while(1)
 {
  j = pseudorandom16();
  for(i=0;i<5;i++)
  {
   if(pseudorandom16() > j)
   {
    PORTB ^= (1<<i);
   }
  }
  _delay_ms(delay);
 }
}

Home cooked PCB etching - part 1

2009-08-10T22:45:00.000-07:00

I saw this excellent Instructables on easy PCB etching and have been itching to give it a try ever since. I popped into the local Radioshack to pick up the bits, but was dissapointed that they had neither the ferric chloride solution nor the copper boards. So, when we were up in Santa Rosa for the mini Maker's Fair (see Lin's blogpost for more on that) I ran into the Radioshack up there and was lucky (they'd only just restocked them). Tonight, after the battle of the bed-times, I thought I'd give it a test run. For a proper run, I'm going to have to decide on a board to make, get some transfer paper and print out the design at work (no laser printer at home).

The instructable mentioned that a sharpie should be enough to mask the board, so I drew out a test pattern:

Imaginative, eh? I guess I could have gone computer programing 101 and used "Hello World!" instead.

So, next step was to add ferric chloride solution to a sponge and get scrubbing. The only plastic gloves we've got in the house are 'small' so I figured I'd risk it and just try keeping my fingers out of the way as much as possible. I used a dollar store, sponge on a stick, dabbed on a small amount of ferric chloride solution and got scrubbing.

About 5 minutes later, nothing had happened. A bit of an anti-climax from the promised '"1-minute etch" but I persevered for a little while longer and added a bit more solution to the sponge. I couldn't tell if the black liquid that was forming was to do with the etching process, or if it was just me scrubbing off the sharpie marks...

Another 5 mins of scrubbing and a few more dabs of solution yielded a glimmer of hope:

You can clearly see some of the copper being cleared from the top of the board. A few more minutes and most of the board was clear. Being impatient, I stopped there and used a "Mr Clean magic eraser" to clean off the remaining sharpie marks (no nail polish remover in our house, but plenty of need for powerful grime removal ;) ).

Sweet! It works! Time to create something more functional!

I've got glow-in-the-dark balls

2009-07-16T23:32:00.000-07:00

Yeah, you heard me right!

I recently got very excited at the local Home-Despot when I found out they sold glow in the dark paint! I've painted a few things with it (including various parts of the kids - which was more their doing than mine!) but nothing really stood out until I realised I could coat ping-pong balls with the stuff, drill holes in them and insert LEDs where er... "the sun don't shine". I figured, periodic pulses from the LEDs should be sufficient to charge up the paint on the balls and make them glow.

One of the things that took the longest out of all of this was painting the ping-pong balls & getting them to dry without all the paint oozing off or collecting at one spot. The best technique I could come up with was to dip my balls in the paint and then dance around the room waggling them in the air (this was after connecting the LEDs). Ok, ok, this is getting too much, I'll be serious now. Unfortunately, that really was my technique for getting the paint to dry evenly. I'd tried just painting them with a brush and leaving them on some paper, but all the paint oozed down to the bottom and glued the balls to the paper, but left only a really thin coat on them. Bah. I think I'll look for spray on paint for any future project involving curved surfaces.

The parts list for this is pretty small: an ATTiny13, 5 LEDs, some perf-board, wire, 8 pin socket, some female header pins (single-row), some snappable male header pins (also single row), a battery pack (I used a 2AA pack) and some ping pong balls.

The circuit was easy, now that I've got the hang of soldering. I decided I'd make something a little more modular than normal, so the LEDs weren't soldered directly onto the board. First, I soldered the LEDs onto some wire (cut in pairs to a few different lengths). Then I soldered on header pins to the other end of the wires.

For the circuit board, I soldered on the IC socket and added some female headers. I included a row for all the ground pins as well as sockets for all the active uC ports (no need for the reset pin to have a header and I could have left off pin 8's header too). I used one of the cut-off LED leads to create a ground wire to easilly connect all the ground pins.

I wired up the power leads first - and completely forgot to include a power switch!

I drilled small holes in the ping-pong balls and hot-glue'd the LEDs in place. Then it was just a matter of connecting up the LED/balls to the correct pins. I had marked all the ground leads with a black ring at the base. I've used all wire of the same colour so that, if I make something interesting out of them, the wires won't stand out too much.

Solar powered fairy lights

2009-07-08T13:12:00.000-07:00

Yes, I'm going through a solar powered phase right now. I'll have used up the parts I bought from allelectronics.com soon enough & will have to move onto pastures new.

My lovely lady suggested it'd be nice to have some twinkling fairy lights in the kitchen; ideally, ones that didn't need to be plugged in to the mains. The simplest solution would have been to use a battery pack, but our kitchen gets a fair bit of light &, like I said, I'm in a solar powered gadgetry phase right now...

My ebay habit has brought me some colour changing LEDs (before I knew exactly what they did). These look like normal LEDs (two leads) but cycle through a few colours over the course of 15 seconds or so. I figured these would be perfect for the project, so I dug out 4 working ones (using the LED tester I posted about previously).

There are very few components for this (if you count the solar-panel/charger as a single component): 1 solar charging circuit, 4 colour changing LEDs, an Altoids tin, some wire and I used a couple of neodymium magnets to secure the tin onto the curtain rail in our kitchen.

The first thing to do is to cut the LED leads from the solar-charging circuit, this is where we'll attach the wires for our own lights. I also cut down the plastic 'pins' which hold the circuit board in place; this was to make the assembly fit nicer in the tin (and as an excuse for me to try out some new cutting disks for the Proxxon).

I then cut two strands of wire (about 1 1/2' each of red and black), marked where I wanted to place the LEDs/lights on the wires and striped away the insulation around these points. I ended up melting the insulation away with a soldering iron and then using a knife to scrape off the excess plastic. There must be a much better way of doing it.

Soldering the LEDs onto the wires was a little awkward, especially since I cut the LED leads down to about 1/3 cm to keep them close the the wires. I'm glad I decided to only put on 4 for this prototype! Hmmm... thinking about it now, I should have left the leads on and bent them around the other wires to hold them in place whilst soldering them, doh!

After soldering the LEDs, I drilled a couple of small holes in the Altoids tin, threaded in the two wires and soldered them onto the solar charging unit.

Slide everything into place and there we go:

My better half has been making lots of playdough for some lovely projects (see: Dinosaur Island and playdough rain table) as a result, we've used up a lot of food colouring. It turns out the bottles make quite good LED diffusers. The picture below shows the Fairy Lights in front of our kitchen window. I used two magnets to make the tin secure (the magnets are on the inside of the tin). I also ended up taking the lid off the tin and securing the solar panels in-place with a couple of elastic bands.

Personal empowerment through skill acquisition (or how I fixed a Vtech Tote 'n Go)

2009-07-04T22:11:00.000-07:00

Phew, what a poncy title! Well, that's me through and through :) But what I wanted to post about was how empowering learning something pretty simple like soldering has been for me.

The kids have been playing with various incarnations of Vtech laptops (ones that play 'learning' games to do with letters and numbers). Their first laptop, the Vtech Tote 'n Go, broke about 6 months ago, the speaker stopped working as did the mouse button. Normally, that'd mean landfill for this big bit of plastic, but, having learned a little bit of electronics, I took it apart to see if I could figure out what was wrong.

It turns out that the speaker wires had broken off and the small push button inside the mouse had broken completely. I got the speaker wire soldered back in place the same day, but the button fix had to wait a while. I was tempted to hack together some Frankenstein creation using the huge push buttons I bought ages ago, but decided against it (I'm sure the kids would have loved it though).

I recently found allelectronics.com (see the solar power upgrade to the fireflies) and, as part of the initial order, I bought some small push buttons which were exact matches for the one in the kids laptop. So I took a second stab at fixing it. I couldn't successfully de-solder the original button, so I just clipped it off, trimmed the leads of the replacement and soldered it in place.

All very simple stuff. I left the laptop out somewhere I knew the kids would find it and the next morning I hear our youngest waking up our oldest by crying "Carys! Carys! Come see! Come see! The monkey laptop! It's working!". It was lovely.

The shocking part of this is that our friends have the same laptop and it's mouse button has stopped working as well. I'll fix that one too, but it must mean that loads of these things become landfill just because a single button breaks...

LED tester

2009-07-04T20:17:00.000-07:00

I have to be honest, I've not been very er... meticulous when it comes to keeping my LEDs in check. Let's be frank, I have a big mess of them and I've no idea which ones work or what colour they are. I'm about to start on a solar powered fairy lights project and realised I'd be spending a lot of time working out which LEDs were the ones I wanted (hence the subject of this post).

To date, I've been using a torn down dollar store hand fan for testing; I'll take a picture to show you what I mean:

It's not the easiest to use, but it outputs ~3V, has a switch and two leads (not obvious which one is positive and which one is ground though since they're both red). I ended up getting frustrated whilst holding the ends of the wires onto the LEDs and then switching over wondering if the batteries were dead, the LED was dead or if I was just crap at getting a decent connection between the leads.

Anyway, what all this blathering is getting to is that I wanted something simpler and more reliable to use. You know, something that doesn't make me want to throw it against the wall in frustration... I'd been messing with 8 pin IC sockets and perf board for other projects and realised that they are perfect for this as well. So I got together the old battery pack from the JarOFireflies prototype (which is why it has a magnet still glued on top), a small bit of perfboard, an 8 pin IC socket and 4, 330 ohm, resistors.

I soldered the resistors and socket onto the board at the same time.

I used the wires from the last resistor to solder all the connections on each side together forming two rails (positive and ground):

Then I soldered in the wires from the battery pack, connecting one to each rail, and voila!

The nice thing about this is that it's easy to check a single led without messing much with it's leads (since there's 4 holes a side, there's plenty of room) and it'll also accommodate, up to, 4 LEDs at a time:

This took about 20 mins to put together including frequent interruptions from the kids wondering what I was doing by myself in the garage.

UPDATE (2009-09-19): The resistor set-up I created is obviously crazy, I'm not sure what I was thinking (or not) at this point... The resistors should be separating pins 1 - 4 from the positive rail.

Solar powered fireflies

2009-06-17T22:25:00.000-07:00

I've been wanting to make something solar powered for some time & figured the firefly kit would be perfect to upgrade to solar power.

I just came across some cheap, second hand, solar powered light fixtures from allelectronics, which is a great place to pick up bits and bats for your electronic projects. Here's the actual solar lights I bought - solar-cell w/charging circuit. As the description says, they come with two solar panels, an LDR, a charging circuit (including - old - batteries) and some LEDs (one LED with this particular one and three with a different product).

As you can see from the pictures, all the components are easily acessible; these seemed perfect for hacking.

My first attempt was pretty simple, I just de-soldered the battery wires from my old JarOFireflies project, snipped the leads to the LED on the solar light kit and soldered the two kits together (the leads to the LED actually have a + and - designation printed on the board).

The LED wires are solid core and quite thick so there's no worry about them snapping under the strain and it made positioning the firefly board easier too. Speaking of which, I cut down the board to a more reasonable size for this project.

I didn't know if the batteries on the solar kit were duff so I left the hybrid out in the sunshine for a full day to charge then brought it indoors to see if it works:

And it does! What a pleasant surprise for something to work first time!

I think I'll cut a hole in the original jar's lid and place the kit in it more securely. Might be nice just to put it out in the garden to confuse the next door neighbours cats who seem to prefer our back yard to their own...

555 noisemaker

2009-06-06T14:18:00.000-07:00

When I started off on the electronics journey I bought the solar powered theramin kit (heliophone) from the makershed I thought it'd be a fun thing for the kids and would be a good starting point for learning to solder. The heliophone uses a solar panel to generate power and produces a clicking noise (the frequency of clicks varies with the intensity of ambient light).

The noisemaker I wanted to make sounds pretty similar but runs off a battery and uses a 555 timer to generate pulses which drive the speaker. Like with the heliophone kit, we alter the frequency of the 'clicks' with changes in ambient light intensity. In this case, it uses the standard "astable" set-up for the 555 and switches R1 for an LDR.

This is a pretty simple set-up and it makes a horrendously annoying noise; so it's perfect for the kids :) My inspiration for this came from this hack-a-day post on tiny-optical-theramins.

I'd already bought a few 555s and LDRs (again due to my eBay issues) so it seemed daft not to make something out of them, especially if the kids were likely to enjoy it.

Here's the final kit. I still want to house it in an interesting way, but I'll have to employ my lady's creative talent to produce something attractive. Maybe I'll paint an alien face on the tin with the LDR sticking through as it's mouth and get the kids to 'feed' it light.

Here's a little test run I did with Ffion, she got distracted pretty quickly by stuff going on in the next room...

ATtiny header board

2009-05-18T08:30:00.000-07:00

I've been programming my AVRs using the SparkFun set-up since I started. This is fine for the odd bit of tinkering, but it's a pain having all those wires poked into the programming cable and getting in the way on the breadboard. With an 8-pin dip, there's not a lot of room around the chip for my fat fingers to add wires.

I'd seen these breadboard headers over at Tinkerlog.com and fancied having a go at making my own using the components I'd got lying around (well, ok, I bough the male/female header pins from eBay).

First a rough idea of how I thought it should look:

Then I tried to figure out where the wires should go based on my original set-up (pic of wire mess above) and the ATtiny13 datashet.

Finally I gave a little thought as to where the physical wires were going to go on the perfboard. I decided to swap the position of the 6-pin programming header to make the wiring a little easier. I'm sure there's a better solution, but I was impatient and wanted to get on with it.

Then it was a matter of soldering everything together. I am not an accomplished solderer - this is only my 3rd real soldering project and I'm sure most people wouldn't even consider the ones I've done so far 'projects'.

First off I soldered the headers, push switch (cannibalized from a broken kids toy) and IC socket. This is pretty much how the finished project looks from the top.

Then I realise that I could bridge pins 1 and 8 using the 10K resisitor and have the resistor out of the way of the rest of the wires by having it on the front of the board.

After that it all got a little messy... I need to give myself more time to figure out wiring/routing! I guess this is all a learning experience :)

I kept the insulation on the long wires to prevent short circuits, unfortunately I also ended up melting a lot of the plastic which caused a few issues around pin 5 of the IC socket hence the blackened mess and excess solder around there... I think I managed to sort out my technique a bit better after than and the remaining solder bridges are ok (tips on creating these gratefully received!).

Here it is in action (note that I have to bring in power from the breadboard with my particular programmer).

Basic AVR IO

2009-05-09T15:20:00.000-07:00

I found this very confusing when I started to program my ATtiny13. I read a bunch of different sites/blogs/datasheets to get a feel for it (and am still slightly confused tbh). So, I thought I'd give a brief overview of the basics in a way that makes sense to me. I'm not going to cover input here, just output; but it's a good start.

Here's the key concepts:

AVR uCs are 8-bit devices.
Every AVR has at least some pins which can act as either Input or Output (I/O) devices.
The voltage on the pins can be sensed or controlled via software.
Because of 1. physical pins are logically grouped in sets of 8 as I/O ports. For my ATtiny13 there is only one port (port B) as there are only 8 pins.
Each I/O port has 3 registers associated with it: DDRx, PINx and PORTx (more on this later), where x represents the port (in my case there's only BBRB, PINB and PORTB available).
I/O pins exists as registers inside the processor. It's the software controlled contents of these registers that controls the state and operation of the I/O ports and pins.
The registers are 8-bits in size. Each bit in the register determines the operation of the corresponding number pin (0-7).

DDRx
This register the direction (input/output) of the pins on port x. Again, for the ATtiny13 there is only a port B so we only have DDRB available but on other AVRs there can be many ports (e.g. the atmega168 has 3 ports B, C and D controlling 23 programmable I/O pins) .

A '0' bit makes that port pin act as input.
A '1' bit makes that port pin act as output.

PORTx
This register contains the output state of the pins on port x.

A '0' bit is considered LOW (~0V)
A '1' bit is considered HIGH (~Vcc)

PINx
This register contains the input state of the pins on port x.

A '0' bit indicates that the port pin is LOW (~0V).
A '1' bit indicates that the port pin is HIGH (~Vcc).

So let's take a quick look at the simple code I posted in "Starting with the AVR uC":

1:  #include 
2:  #include 
3:
4:  //LED is wired into pin 7 (PB2)
5:  #define LED PB2
6:
7:  int main(void){
8:   //set data direction register for pin 7 to output
9:   DDRB |= _BV(DDB2);
10:
11:  //infinite loop
12:  while (1) {
13:   //turn on the LED
14:   PORTB |= _BV(LED);
15:   //wait for 1/4 of a second
16:   _delay_ms(250);
17:   //turn off the LED
18:   PORTB &= ~_BV(LED);
19:   //wait for 1/4 second
20:   _delay_ms(250);
21:  }
22: }

5: define LED as PB2. This is just a convenience to allow us to refer to pin 7 as the variable LED. I have the LED wired into pin 7 and this pin is called PB2 according to my datasheet (this can be different for different uCs). PB2 is actually another variable which has been defined thanks to the avr/io.h import statement. I could have used the number 7 instead but I decided to use the name of the pin from the datasheet.

9: This sets bit 7 of DDRB to '1' without affecting any of the other bits in the register. This is the data direction register (DDR), setting a pin in this register to a '1' makes that pin act as an output. I think I should have used the LED variable (defined earlier) rather than DDR2, just for clarity. Ok, next time.

14: Here we manipulate the bits in the PORTB register. This statement sets bit 7 to '1' without affecting any of the other bits in the register. Assigning a '1' to bit 7 of PORTB sets pin 7 to HIGH (~Vcc). This allows current to flow through our LED, lighting it up (or burning it out if you've not added a resistor in serial with it).

18: This statement sets bit 7 of the PORTB register to '0' without affecting any of the other bits. Pin 7 is now LOW, no current flows through the LED (so we've turned it off).

Now, here's a little nugget of info that didn't click until my trip to Noisebridge and a chat with Mitch Altman: I/O pins, by their very nature, are ambivalent towards the direction of current flow. Let me say that again as it's something I didn't realise to begin with and it has an impact on programming LEDs with the AVR. I/O pins don't care which way current flows through them. So, if you have an LED attached to an I/O port (via a resistor) then it can be orientated in either direction (i.e. connected to ground or Vcc, it doesn't matter), the only difference will be whether or not a '1' or a '0' on the corresponding PORTB pin switches it on or off. If the LED is connected to ground, then a '1' in the PORTB register will turn it on; on the other hand, if it's connected to Vcc, then a '0' will switch the LED on.

I know I laboured that last point, but it was non-obvious to me (as a beginner) so I wanted to share. It also meant that those common cathode RGB LEDs I bought aren't as useless as I thought - I was under the wrong impression that I'd only be able to program them using 3 transistors attached to the AVR as switches, because I thought you could only turn on LEDs [with an AVR] by placing a '1' in the PORTB register... doh!

Jar o' Fireflies

2009-05-02T11:34:00.000-07:00

I've seen a few good examples of micro controller controlled fireflies "in a jar" and I wanted to try this for myself. This is by no means a new idea (just take a look at this youtube search and you'll see tons of examples) but I like the idea and I'd already got the basic set-up (see my previous post on AVR programming). All I needed to do was work out the programming (the wiring seems pretty obvious - wire LEDs to uC, wire uC to battery).

What I wanted to do was use all the ATtiny13's 6 output pins to control 6 "fireflies". I'd be happy with just randomly pulsing green LEDs, but I thought it was important to have the LEDs pulse on and off rather than just switch on an off. Here's a youtube video showing fireflies in New York as an example of how the real thing looks. I have a very fond memory of sitting out on a boulder with my brother in Nepal and looking out at a hillside with thousands of fireflies blinking away; we stayed there for ages captivated by the hypnotic display.

So, the standard way to create pulses with an AVR seems to be with pulse width modulation (PWM). Unfortunately mine only has 2 PWM outputs and I wanted to use the parts on hand. A quick search brought up a few possible solutions, but this post on Kevin Mehall's blog was the winner for me. I ended up implementing a software PWM solution based on the code Kevin made public - thanks, Kevin! I've not quite worked out the best way to post code on blogger, when I do I'll post the actual code.

Here's an overview of the parts that went into the project:

The jar was found in the local Savers, the perf board was bought on eBay as were the IC socket, uC, green LEDs and battery pack (all in batches of 10 or more). The wire on the bottom left was scavenged from a broken kids princess wand. The hair clip was an interloper.

My lovely missus decided to improve my project by drawing a few fireflies on shrinkydinks so that I could glue them onto the LEDs after the project was finished:

Here's some photo pr0n of the project in various stages of completion:

And here's something we bought to scare the fireflies:

We got these from Lowes; I think the kids enjoy the venus fly traps much more than the fireflies... c'est la vie.

And, finally, a little video. The flicker isn't actually as bad in real life as it appears in the video, hopefully I'll find a way to remove it completely.

Starting with the AVR microcontroller

2009-04-26T21:51:00.000-07:00

I thought it'd be fun to do some microcontroller (uC) programming. I've been following the Make blog (and a few others) for a while & love the idea of interactive electronics or even something just a little more complicated than vibrating yogurt pots and wired up LEDs. I can program already, so it seemed like the logical next step.

Well, firstly I spent a fair bit of time being confused by the huge amount of choice (Arduino, BASIC stamp, PIC, AVR etc.). The Arduino platform is featured heavily in the Maker community, but it seems a bit heavyweight for what I've been thinking about and besides, if you want to make a few "objects of interest" each one would require their own Arduino board which, at $35 a pop and multiple kids on the rampage, could get very expensive. PIC and BASIC stamp are both good choices but I decided on the AVR series of uCs for a number of reasons:

They're cheap ($1.50 upwards) and readily available.
You can program them in C (one of the languages I understand).
The compiler and programmer software is available free (I'm using WinAVR, the GNU toolchain is available from the Atmel website).
There's a large and active community of users (e.g. AVRFreaks).
There's an Eclipse plug-in for AVR programming (Eclipse is my favourite IDE).

Unfortunately, in my rush to dive in, I didn't do quite enough reading and ended up buying a batch of 10 ATtiny13s (from eBay). These are great because they have 8 pins (small size), but the problem I found was that they only have two PWM (pulse width modulation) outputs - more on that in a later post though.

So, on top of the software and the chip themselves you also need a way to program the chips. There are dedicated boards available for this, but I chose to use a USB ISP (In-System Programmer). With these you can have the chip already placed on a breadboard with the project all wired up, program the chip and see what the effects are immediately. With the dedicated board, you'd have to program the chip, take it out and place it in the project before you could see the effects. I made another mistake when buying the USB ISP; in my love of eBay I ended up buying an STK500 copy rather than something genuine from DigiKey (e.g. AVAVRISP2); my knock-off has some compatibility issues with the Eclipse AVR plug in which has meant that I now program and build in Eclipse but use AVR Studio to send the program to the chips. Ah well, you live and learn.

Anyway, onto the obligatory "hello world" for micro-controllers; the blinking LED!

Firstly, rather than re-iterate what others have said very well, just do what I did and follow the first couple of sessions of the sparkfun tutorials. I love how ghetto it looks having the wires poked into the programming cable and then into the breadboard; I love it so much that I still have it set-up this way. The only differences are where to attach the leads to the chip, you can work it out by looking at the ATtiny13 datasheet and comparing the pin layout with that of the ATmega8 used by sparkfun.

The picture below shows what I ended up with. I'd already added the power supply suggestion from the first lesson, which is the purpose of all the electronics at the head of the breadboard, but I'm using a 9v battery rather than an ac adapter.

Here's the code to make the single LED blink:


#include <avr/io.h>
#include <avr/delay.h>

//LED is wired into pin 7 (PB2)
#define LED PB2

int main(void){
 //set data direction register for pin 7 to output
 DDRB |= _BV(DDB2);

 //infinite loop
 while (1) {
  //turn on the LED
  PORTB |= _BV(LED);
  //wait for 1/4 of a second
  _delay_ms(250);
  //turn off the LED
  PORTB &= ~_BV(LED);
  //wait for 1/4 second
  _delay_ms(250);
 }
}

Compile (Project->Build in Eclipse), upload to chip (using AVR Studio) and voila! A blinking LED... not particularly amazing, but it's a good start.

Update: Whilst writing this post I figured out how to get Eclipse to program the uC as well! AVR Studio can autodetect your programmer, apparently I have an AVR ISP V2. AVR Studio will also tell you what port it's connected on (is there a way to get the Eclipse plugin to autodetect this?). In Eclipse I had to open up Project->Properties->AVR->AVRDude->Programmer and edit the configuration. I set the programmer to "Atmel AVR ISP V2" and overrode the default port (first dialogue box below the programmer list) to com3 - which is the one reported by AVR Studio for my set-up.

Drawing Vibrobots

2009-04-26T12:57:00.000-07:00

This was one of my first excursions into building a useful or interesting electronic thing for the kids to play with. The idea is really simple, use the vibrations from a motor to shake a yogurt pot with pens on it. The result should be some interesting patterns drawn on paper (and probably the floor).

I sourced the motors from some dollar store fans and a Nintendo rumble pack (found for $1.50 in a thrift store). The fan motors were great as the were already wired up to a switch and all I had to do was solder on a battery pack. I glued the battery pack on the insides of the pots and poked some holes in the top to attach the wires to the motors. I then weighted one of the fan blades with glue to set up a weight offset and increase the amplitude of vibration.

We made a mistake with the first plastic pot in that we glued on the pen legs to the pot, which meant that they weren't easily changeable (not for kids anyway). I say "we" because the gluing was done by my wife, who is far more adept with a glue gun that I am. 'er indoors also had the idea of putting in some motion activated flashing lights scavenged from various kiddie toys and gluing them onto the inside of the pots. That was a nice touch; thanks love!

For the second pot we glued on the pen lids instead:

For some reason this larger one reminds me of those ships in Tron...

It turns out that the results from the drawing actually makes for some good wrapping paper! Bonus!

And, finally, a little video:

NoiseBridge

2009-04-26T11:04:00.001-07:00

My better half, reminded me about Noisebridge a few weeks back. I heard about it when they first set-up but then promptly forgot. Noisebridge is a hackerspace located in the Mission district of San Francisco (much like NYC-Resistor; see Hackerspaces.org for a comprehensive list).

As well as being a general space for people to go and work on projects, they also offer a few tutorials/courses to the general public. I decided to head along to one of the "Circuit Hacking Mondays" to meet the crew, hone my soldering skills and make something interesting. This session was hosted by Mitch Altman (of Brain Machine and tvbgone fame - gizmodo with tvbgone at CES2009), who gave an easy to follow introduction to general electronics and some tips on soldering.

Mitch got out a load of examples of the kits he'd bought with him for people to make. I chose to make a "Trippy RGB Waves" kit (also available at the makershed), but was tempted by the Mini POV kit and, of course, the TV-B-Gone kit. I think I may go again just to make another kit in an easygoing environment with some interesting people.

Putting the kit together was pretty simple, I did get off to a slightly shaky start as Mitch decided to use me as the "demo bunny", I'm glad I'd soldered before so I didn't look like too much of a tool ;) After the initial intro, people just got stuck into soldering their kits. It was a lot of fun. Great to meet such a diverse group of people as well - there were Noisebridge regulars popping in and out all the time to work on their personal projects or just to see who was around.

I'd definitely recommend popping by to anyone who lives nearby! Another interesting evening is the Machine Learning get together every Wednesday night. I managed to make it to a couple of the neural net themed ones, and am planning on heading back soon. I got quite a kick out of coding up a perceptron in the first tutorial.

LED Power Meter

2009-04-26T09:28:00.000-07:00

For one of the kids playdates, my lovely wife requested I make a power meter (the playdate was electricity themed). Well, this was my first foray into electronics, so it took me a while to pick up the basics (maybe that should be a separate post), then I had to learn how to solder, buy some components (mainly from RadioShack and eBay) and finally design the circuit and put it all together... phew.

Well that was a great journey, which I heartily recommend!

I have to admit that I didn't come up with the design from scratch. I googled for ideas and settled on a simple chained diode approach. With this design you connect a set of diodes in series with LEDs forking off to from the anode of each. Each diode creates a voltage drop of ~1V (depending on your choice of diode), so, as you increase the input voltage, you light up more LEDs. Genius ;)

I put together a couple of prototypes on a breadboard (bough from eBay) to make sure I was getting it right and then soldered everything together on a prototype PCB board (another eBay purchase).

To make it more interesting for the kids, I decided to use 3 different colour LEDs: red for "DANGER - low power!"; orange for "medium power"; and green for "WOOT!".

The result? Voila!

The extra diodes at the base create a bridge-rectifier; I needed this as I was powering the circuit from a re-purposed hand-crank torch which I'd bought for $2 from savers.

The "who can light up the most LEDs" game turned out to be quite popular :) Having just two green LEDs at the high end made for quite a challenge; only the "big kids" managed to light them up. Below is a couple of pictures of the finished product in action:

Yes, that's a "Stand Back! I'm going to try Science!" t-shirt, from xkcd.