Tagged: Arduino

IN-3 Matrix is nearly there

It’s been a long time since I wrote any updates about my IN-3 matrix project. Whilst I haven’t had much chance to work on it it has come a long long way from the original 4×4 tester.

I built an oak frame, machined an mdf board and attached 128 bulbs. Then I started the long process of wiring up each bulb to the PWM driver boards. In hindsight, I should have designed some kind of PCB strip to connect the bulbs to. This would have saved many hours of labour and been a lot neater. As it is each row of 16 bulbs takes about 1 hour to wire. Very boring so next time I know what to do!

I opted to buy a high(ish) voltage supply from eBay, the display can draw a lot of power when fully lit so despite having literally hundreds of high voltage driver boards for my IN-9 kit I figured to play it safe!

I am still only running some test code to make sure the bulbs light up and in the right order. I’m using an Arduino and the Adafruit Adafruit_PWMServoDriver library to communicate with the PCA9685 PWM drivers. Once I find a couple of hours to finish off the last two rows I’ll focus on what to use as a controller (probably the Teensy I’ve had laying about for 3 years) and actually write some proper firmware.

I’ve also now added a Github repo with all the hardware design files (DesignSpark PCB) for the driver boards and arduino sketches. I’ll continue to add to it as I progress.


Inductor coil winder

For the last few years, I have repeatedly and frequently needed to wind a wire around a thing. From making RFID antenna to transformers. I switched job about 6 months ago and naively thought my winding days were over. However, I was wrong. By some freak accident, I’m back winding wire onto ferrite rods. This time though I need to make some whopping 1H inductors. I’m not going to sit here and wind a thousand turns by hand, not while I have a stepper motor, a microcontroller and a makespace next door.

After a couple of hours on Fusion360 I had a design and I was off to laser cut it. Doesn’t look too bad. The rest of the parts should arrive tomorrow when I can finish this beast.


Nixie Matrix prototype ready

It was a pretty straightforward task to assemble the bits into a functioning 4×4 nixie matrix. The tubes are mounted on spray painted black MDF with the PWM driver mounted on the back. They are each held in place with a small square of double sided foam tape. Wires soldered on the back to the tubes create a small nest and will be more neatly managed of the bigger version. I programmed an Arduino with the Adafruit pwmtest example and it all works fine. In fact, it works much better than I expected and I think I’m ready to go full scale, with no real modifications. All seems too easy.

I did a measurement of power consumption and the 4×4 uses a power of 1.8W, so will need about 15W for going full scale. Not too bad really for 128 tubes.



Running a PWM test.


IN-3 Nixie Matrix

I recently bought a few (200) IN-3 nixie bulbs. Unlike the familiar numeric tubes or the bargraphs I’m fond of, these are just little bulbs. They have commonly been used as dots between digits in clocks and alike. Not content to make just another run of the mill Nixie project I decided to build a Nixie matrix, much like an LED matrix but with the lovely orange glow. My eventual aim is an 8×16 matrix, enough to display basic numbers and graphics. Though I’m starting with a simpler 4×4. This does provide the first challenge, how to drive so many tubes? The common way is multiplexing, however, since this is a one-off build and additional electronics isn’t too important (I’m not trying to optimise a BOM and a bit of extra work is fine) I have opted to directly drive each IN-3 tube. Not only drive each tube on and off but with a PWM signal. This should allow nice brightness variations and fading effects across the matrix. Pretty sexy. So now I just need 128 PWM channels… For ease I’ve gone for a 16 channel LED PWM driver (PCA9685). There’s even a nice Adafruit library for quick Arduino testing. It’s I2C so I intend the chain 8 of them together, these are driving mosfets that switch the high voltage tubes. (I’m also putting together an IN-9 driver kit (watch out Kickstarter…) so I have an abundance of high voltage supplies.)

So far I’ve fully soldered up 4 boards and tested one with 16 tubes. All working nicely. Today I’ve cut out a small 4×4 MDF board to make up a little test board to get everything right before I go full scale. So far, it’s all be smooth sailing. Wonder how long that’ll last.


Dead bug LDC1000 inductance to digital shield

I needed to make a data logger to measure the inductance of a coil over time. The coil is flexible and so will distort while in operation. I wanted to know how much this would change the inductance in order to account for it.

I found a nice IC from Texus Instruments, the LDC1000 inductance to digital converter. However it comes in an annoying SON-16 package, so time to whip out the fine tip soldering iron and practice my dead bug wiring. (For various reasons I thought logical at the time (though probably not) I opted not to use the handy eval board.)

So I superglued it onto an arduino protoshield, added a few caps and it was done. To measure the inductance the LDC1000 needs to be clocked, which is what the green board kapton taped to it is doing. This is a breakout I made for the Freescale/NXP KL03 cortex M0+, clocking the LDC1000 at 3MHz. You might ask why am I using the arduino for the logging and the KL03 to clock. Well. Whatever.

I plugged in an Adafruit datalogging shield and a few simple lines of code later I was logging inductance data. Sweet.

dead bug.png

Finished nixie weather station

weather station

I decided to make people Christmas presents last year, and thought I’d make my Dad a weather station. That’s the kind of thing parents like. I wanted to make something a bit nicer looking than an ugly circuit board so had the idea of attaching the wires to a piece of wood. In the end I had to make it in about a day, just before Christmas, and so it didn’t end up as neat as I would have liked. However, I think the result is still pretty nice/interesting. Something I will definitely try again, perhaps with more time and planning.

The heart of the actual weather station is an Atmega328 with an arduino uno bootloader. For the sensing I use an MPL115A2 pressure and temperature sensor, conveniently broken out by Adafruit. For the humidity I use an DHT22 temperature and humidity sensor. Though since I already have a temp sensor I ignore this one.

It is pretty straight forward to get the arduino and sensors talking and displaying the humidity, temperature and pressure on screen. To display it on the weather station I decided on 3 nixie IN-9 bargraphs, as previously used on my clock project. These need a 140v supply which I bought as a small board (visible on the bottom right). To control the height of the plasma the current through each tube needs to be controlled. To achieve this I map the humidity, temp and pressure values to 3 PWM outputs and pass through a low pass filter, with a time constant of about 1 second. This gives a pretty good DC voltage. This is then fed into the base of a high voltage transistor. This then controls the current through the tube. Much simpler than it might sound. Check out my clock instructable for how to control the nixie tubes with an arduino.

So, why is this all 10 months late. Well I did all of the above in about a day. I wired the whole thing up with copper wire and glued onto a wood backing. An old piece of laminate flooring! However, I never actually got round to making scales for the different tubes. As any young scientist knows, without labelling the axes it means nothing! The problem was I could never think of a nice way of doing it, until now. Playing around at the Hackspace I decided to laser cut them. I tried a few materials, wood being the obvious choice, but opted in the end for black acrylic. After a little tweaking, I cut the scales and stuck them on. Now it really is finished and looking pretty good. An instructable may follow…

weather station close up


So while waiting (and waiting) for the eventual arrival of the last remaining parts for the Luminous Loafers I have been filling my time with new projects. After seeing an excellent POV globe at the Brighton Maker Faire I decided I wanted to do that! Also it would be a good way to learn a few new things too.

So here is my first experiment with POV. Very simple, just an Arduino nano clone, 595 shift register and 7 white LEDs. The first step on my way to building the full volumatric 3D POV display I want!


The result of me waving my phone around wildly hoping for a good pic…

Pendulum wave using the LOL shield

I have had a lol shield laying around for quite a while now and never really used it beyond the example sketches. It’s a great little glowy shield, especially as I love anything involving leds.

So I decided to write up a quick sketch to make something interesting to light up my desk as I work. Being a physicist I decided on a pendulum wave. It’s a nice demonstration of simple harmonic motion and pretty hypnotic to watch. Here’s a nice youtube video of a real one in action: Pendulum Wave.

For my sketch, each vertical column of leds represents my mass on a spring, and each column will have a shorter string. This is simply modelled and a nice derivation is given here. So it was just a quick job of writing up a sketch and here we go! Enjoy the video (apologies for the poor quality).



Here’s the sketch if you want to have a go:

#include <Charliplexing.h>

void setup() {
LedSign::Init(); //Initilizes the LoL Shield

int p = 0, Hled[15];
int N = 50; // N is the number of oscillations individual oscillations on the first pendulum until the whole wave repeats
int period = 20000; // each time step is an interger incremented each loop
double amplitude[15]; // amplitude of each pendulum colomn

void loop() {

for(int x = 0; x < 14; x++){
for(int y = 0; y < 9; y++){
if(y == Hled[x]){

for(int z = 0; z < 15; z++){
amplitude[z] = (4.5*(0.85+cos((2*3.141*(N+z))/(period)*p)))+0.5; // calculates the amplitude of each colomn
Hled[z] = int(amplitude[z]);