I’m pretty happy with how this turned out, and I can finally say the nixie clock project is finished. I definitely learned a lot for the next clock – like use the RTC with an onboard crystal! I’m thinking of perhaps making a wordclock.

You can check out the Inkscape files I sent to Ponoko for manufacture here (they are released under CC BY-SA 3.0 if you are interested).

In unrelated news, design on revision four of my motor controller is nearing completion, so hopefully the thing will be flying soon!

Everyone has to make a nixie clock at some time, and as I had 12 IN-14 type tubes lying around for quite a while after ordering them from Russia, I decided I should go ahead and make one. PCBs were designed in due course and sent off to Gold Phoenix for manufacture, and eventually I got back a whole load of PCBs and fabbed up the clock.

There are three main parts: the power supply unit, the control board, and one driver board per two nixie tubes.

Power Supply
I borrowed heavily from http://desmith.net/NMdS/Electronics/NixiePSU.html in both the schematic and PCB layout, as I don’t have much experience in fast or high voltage layout and didn’t want to make any crucial mistakes. I did make a few modifications to suit what components I could get and in a few cases routings I thought could reduce via count or otherwise shorten traces. The design works very well, and successfully drives the nixies at sufficient brightness.

The power supply takes around 12V DC input and converts it to around 220V DC output in a switch mode design. Essentially, the microchip opens the FET, current flows through the inductor and then through the FET to ground, then the FET closes. As the current in the inductor still has a kind of ‘momentum’ (the magnetic field it created tries to keep the current moving) but nowhere to go the voltage rises and goes through the fast diode to charge the capacitor. Once the voltage reaches the desired level, the FET is switched back to ground again and the process repeats. The output is a relatively smooth DC. (NB: this description could be very wrong, it’s just how I believe it works – please leave a comment to correct me!)

Control
The control PCB contains an ATmega168, the DS1307 real time clock IC and a whole load of buttons used for setting the time. The RTC IC is set with a time once and then keeps it as accurately as it can, using the onboard battery backup to provide a tiny amount of power when the mains electricity is removed. The buttons make setting the time fairly easy; you just hold down the time item you want to change (hour/min/sec/day/month/year) and press the up or down button to adjust, holding it down to make large changes.

Driver
The driver PCB contains two nixie tubes, two old 7414N logic chips (actually I used Russian equivalents) and an 8bit shift register. The control board shifts out BCD (binary coded decimal) to the shift registers, four bits per display digit. The shift registers then output this to the 7414Ns which decode it and pull one of their ten outputs to ground. That output is connected to one of the numerals in the nixie tube, causing it to light up.

Overall, I’ve found it to be a really neat clock. I plan to make a nice case for it at some point in the future, but making nice cases is not a strong point for me, so I’m not sure when exactly this will happen. For the moment, the clock sits on a shelf next to my desk where I can easily see it from anywhere in the room. The digits are bright enough to see clearly, but the clock turns off the display between 00:00 and 07:00 so I can get to sleep! Turning off the tubes also helps extend their lifetime. Just before turnoff, each tube cycles through all of its digits for a few minutes to prevent cathode poisoning, where little emissions from lit numbers coat the unlit numbers and make them dimmer. Finally, clock accuracy leaves a little to be desired – it is routinely out by a minute or two every couple of weeks. It is easy to adjust and a minute isn’t that big a deal, but I would have hoped the crystal would be more accurate.

At the end of the day though, it’s a fun clock and is my favourite for checking the time!

All the Eagle files as well as PNGs of the PCBs are available here: https://randomskk.net/projects/nixie_clock and more photos are available on Flickr here.

I’ve been trying to make electronic fireflies for ages now, and most of my previous attempts involved RGB LEDs, and one of them per ATtiny13 with code to flash a random colour now and again. This was always going to be a pretty expensive method, but after seeing http://www.instructables.com/id/Jar-of-Fireflies/ I realised it would be a much better idea to have one ATtiny13 control /many/ LEDs.

I wanted the first one to be in a jar, but in future I plan to have much longer wires so that I get one controller PCB and 12 fireflies extending off to cover a corner of a room, or part of a ceiling, etc. I could even add an LDR so it can detect dark, possibly by using pin 1 (so the chips couldn’t easily be reprogrammed).

The circuit schematic is kind of odd: I took a normal 2×3 matrix, where PB0 and PB1 control the two columns (as they can do PWM, so all LEDs can be PWM controlled), and added another LED for each position but in reverse. Since all the ouputs can tri-state (where effectively they act as though they were not connected), I can light up any LED I want individually.

While I could easily extend this to a full charlieplexing scheme, that would mean losing the hardware PWM for every LED. I could easily add another two LEDs between PB0 and PB1, but it’s really not worth the added complexity – 12 is plenty!

Each LED is an 0603 green LED soldered to two very thin wires, which run to a home made PCB at the top of the jar. The battery holder is a standard kind of cell holder from Rapid, and on the other side of the PCB is the ATtiny13 (soldered to the solder-side directly) and two 180 ohm resistors. The entire thing is through-the-hole because I don’t have any surface mounted ATtiny13s lying around and did have loads of 180 ohm through the hole resistors.

The code is fairly simple: in an infinite loop it chooses one LED at random, lights it up following a rough sine wave (actually modeled on a real firefly flash!) and then might repeat it once or twice, then waits a random amount of time before doing the whole thing again.

Each time the thing is turned on, a value is read from 0×00 in the internal EEPROM memory and used as the seed for the PRNG, then incremented and stored – giving 255 different patterns, more than enough that you can’t see any repetition!

By far the most difficult part of this was soldering all the tiny LEDs – if it wasn’t for that, this would be a particularly easy project to pull off. Using normal through-the-hole LEDs is an option, or even LED holders which would solder to the PCB and an LED just slots in. Surface mount ones are small enough to be less noticable and look better when lit up, though.

Eagle schematic and PCB file, C source code and compiled hex file available at: http://randomskk.net/projects/fireflies_in_jar all files are released under CC BY-SA-NC license

This device analyses the music it picks up via the electret microphone, then flashes the LEDs in time to the music. It’s encased in the box SparkFun sent me the microphones in, since the box was just begging to be used as a case for something! I’m sure that was intentionally designed.

Getting a bit more technical:

The microphone picks up the noise and sends this to the LM386 amp, which amplifies it about 200x before it’s read by the ATtiny13′s ADC at 8-bit resolution. The ATtiny13 then keeps a running average of the noise level, and flashes the LEDs if the current volume exceeds the average by a scalar amount.

As a result, the LEDs flash on when the music hits a peak, and are off otherwise – no matter what volume.
The brightness of the LEDs is also somewhat correlated to the loudness of the peak, since a louder peak will generally keep the LEDs on for longer.

Check out the video of it in action:

Download the schematic, PCB layout, code:
https://randomskk.net/projects/lightstrip/ (all files released under Creative Commons BY-SA-NC 3.0).

I recently ordered 100 blue LEDs from eBay for a measly £1 (plus p&p of something like £3). To my surprise, they are both bright and all functioning!

However, I hadn’t really thought through what to do with them.

This was when I found a link to the charlieplexing instructable again, and decided to whip it together on a piece of protoboard. This turned out to be an absolute nightmare of wiring things up, hidden shorts, melting wire, all that fun stuff. In the end, I got most of the LEDs working fine, and a few are a bit screwed up. They can each be individually controlled using just five pins on the little ATtiny13 in the middle there, and it even has five input buttons (one per pin)!

This is a pretty neat use of tiny amounts of IO pins.

Unfortunately the back of the thing looks like this:

and I never quite got the courage to get the last few working.

I plan to instead make a PCB for them! Of course, the wiring there will no doubt be equally nightmaric, but at least the manufacturing should be easy.

Mother’s Day was coming up and I’d just got the hang of making PCBs at home, along with a new Dremel that could cut and drill them.
Making some kind of project seemed the obvious answer. I took inspiration from an Instructable on a similar subject here, but didn’t have any fluorescent acrylic so had the LEDs illuminate the board directly.
It’s also etched with normal ferric chloride, unfortunately.

I’d just picked up some new surface mount button-cell holders, and while I was tempted to use a 555 to make a quick pulse that drives the LEDs, a simpler circuit could be made with an ATtiny13, and I just so happened to have ten of them sitting around. A little breadboarding and I’d got the general idea working, although PWM still wasn’t working – the LEDs simply flashed on and then off 12 seconds later, with no fading.

I documented most of the manufacture with my camera, so I’ll go through it with pictures. Here goes…

First, the circuit had to be designed. I do this in Eagle, since it’s free and runs on Linux. The design has to be single sided (I’ve only got single sided boards, for one thing), and I figured the thicker tracks would make it more resistant to any problems with the toner transfer. It didn’t take too long to come up with an acceptable design that doesn’t have any jumper wires.

Next, I tried using photo paper to print and transfer the toner. This basically failed miserably – the paper got too hot before the toner was too hot, and the paper bubbled up underneath, ruining it. I tried all six circuits that I printed and none worked.
However, the photos showing the manufacture are the same as for transparencies, so I’ll go through them anyway.

The iron’s heated up to “Wool” for transparencies

Boards are scrubbed clean with a scrubber and also rinsed, I didn’t bother with soap later on and it worked fine. Faux-steel brushes would probably be even better, or perhaps sandpaper. The key thing is to get a clean copper surface that’s slightly scratched up to help the toner stick.

The chosen design is cut out.

And stuck down to the board, toner side down.

You then put tissue paper over it to stop the iron sticking to the paper, and heat it for ~5min.

Sadly, every try with photo paper came out pretty badly.

I got some transparencies printed. These worked a lot better!

Transparency is stuck toner-side down. You can tell which way this is because the circuit should look the right way around when the transfer is stuck down.

It did take a second try to get the temperature right, but this is much better!
There are still one or two small issues – nothing that stops the board working, but a few tracks lost a little toner. This is easily fixed with a standard permanent marker.

I cut out the PCBs using a cutting disk on the Dremel (in this case the one-clic cutting disks which I believe are fibreglass-reinforced ones). This wasn’t too easy since the edge of the dremel somewhat restricts how deep the cut can be into the material, but I was just able to get them both cut out nicely.
Then I sanded them down at the edges to make them nice and smooth.

I then etched both boards in ferric chloride. This is a fairly poor, but easily available etchant that doesn’t give off nasty fumes. It does stain everything, so I’m wearing gloves here. I have a plastic tray of etchant placed in a larger plastic tray of hot water, which heats the etchant and catches any spills. I constantly swirl the board around in the etchant, which makes a big difference in etching time.
In this photo, you can just see the copper starting to be etched away in the corners.

The boards are now fully etched, the only copper left is hopefully under the toner!
The toner is non conductive and can’t be soldered to, so we need to strip it off the copper tracks.

I usually let the boards soak in acetone for ten minutes and then scrub hard to remove the toner. I’m also removing the toner from the non-etched board so it can be reused.
In retrospect, I noticed a few things:
1) There really wasn’t any need to remove toner from the top PCB, since it won’t be soldered to and toner may have even made the sign stand out better. However, the copper does look fairly nice.
2) Toner could also be used as something of a solder stop, so potentially I could have only removed it from pads that had to be soldered too. This may have been risky later on with the copper heating up, though.
3) Paint stripper probably would have worked better.

The PCBs are then drilled: a 3mm hole for the 4-40 thread screws, and 0.8mm holes for everything else. I’m using HSS drill bits in my Dremel at 33k RPM, the boards are FR2 so there’s not so much need for tungsten carbide drill bits.

Both boards are now drilled.

Components get soldered on. Soldering the LEDs was a real pain, but luckily you can’t see the solder when the thing is closed up. In the future, I’d probably use surface mounted LEDs. The battery holder doesn’t seem to fit the batteries very well, so I use two batteries instead – this is not only a much better contact, but also drives up the LED’s brightnesses.

I ended up using two stand-offs taped together, instead of just one, to give the LEDs more space to diffuse. This made a big difference. It also let me cover the outsides with tape, which makes the whole thing look a lot more solid.

Finally, here it is in all its glory!

The ATtiny13 has a fairly simple program that just turns on the LEDs through a transistor for 12s when the button is pressed, and goes to sleep (power-down mode) otherwise. I wanted to have the LEDs fade in and out using PWM, but I wasn’t able to figure out how to do proper PWM with the IC’s counters in time, and software PWM took up too much space when the code was compiled, for some reason. Having some kind of on/off mode might have been a neat idea too, although this way the two batteries should last a lot longer.

I hope you enjoyed reading through the project! I’ve attached the Eagle files below if anyone wants to try printing one, although since Mother’s Day has passed I’d suggest changing the message :p

Eagle Board

Eagle Schematic