Nixie Pipe – Modern Day LED Nixie Tube

December 14, 2016

Nixie Pipe is my interpretation of a modern day Nixie Tube – the cold-cathode vacuum gas-filled tubes from the 1960s.

The project came about when I decided to make a clock for my kitchen, with specific requirement for an egg timer function! I’ve always wanted to make a Nixie Tube clock but having completed a Nixie Tube project recently and one pipe failing after around 6,000 hours, I wanted to come up this something better. Something that didn’t require high voltages, special driving circuitry, could be easily interfaced and was modular, but which maintained the unique visual depth of a Nixie Tube.

At around the same time, my dad showed me the above from an old telephone exchange. It’s a 70s way of displaying digits by using engraved light pipes, lit by channeling emission from filament bulbs within. Putting the two together, Nixie Pipe is the design I came up with. I’ve called it Nixie Pipe because it uses light pipes. Each Nixie Pipe contains ten individually controlled RGB LEDs, which sit below channelled layers of acrylic acting as light pipes. By laser engraving the acrylic layers, the piped light diffracts, creating controlled illumination.

Nixie Pipes are modular and can be chained together to form displays. A Master module features an AVR Atmega328p microcontroller allowing it to drive Slave units, which only features LEDs. The pipes connect via three pins and inter-locking nodes on the rear. It means the pipes are constrained enough to require no further fixing. The Master also features a USB serial converter and I2C breakout, allowing a host computer or chip to drive the Nixie Pipe array with dynamic content – using either the Python package , Node.js module or Electron GUI I developed. The LEDs are WS2812B, which operate on the single wire interface so Slaves can be directly driven by any external microcontroller such as an Arduino.

You might be wondering what the pills on the front are for. They are touch buttons on the Master pipe, which allow control of the clock for instance or just incrementing or decrementing the display. My main design requirement was an egg timer after all and without a means to set and start a timer the design would not be self-contained.

Using the Atmega328p lead to me create a fully compatible Arduino library API for controlling the Nixie Pipe, either for creating custom Master firmware for external driving with another microcontroller; I did much of my development using an Arduino connected via the three input wires to Nixie Pipes for ease of programming – a key stage in developing products is having an easy to use test bed.

Design Development


  • Use engraved light pipe technique from telephone exchange module but using LEDs. The space saved would allow lighting directly from the button without any bending and a much more complex form.
  • Modular design 0-9 per module allowing display of any number size.
  • Self-contained with no requirement for external driver.
  • Single module with microcontroller driving dumb modules.
  • Symbols as well as digit.
  • User IO on the main module.


The development took around 4 months on and off before coming to my final design. There were lots of small refinements mechanically and electronically along the way, but below is a brief summary.

Basic Feasibility

First thing I did was cut some layers, engraved them, then lit them from below. The basic principle worked so I went ahead.


My initial design was enclosure based with the layers ‘wedged’ inside on top of a PCB. It was all a bit bulky, cumbersome and not very elegant. I ditched the sides, tooth/dent construction and went for a design whereby the layers are clamped together, with slots to suspend the PCB below. The mechanical design remained largely untouched after that, other than addition of strain relief around the slotting and the inter-locking nodes.


I had four PCB iterations before coming to my final design. Mostly small functional changes other than adding the forgotten zero LED.
I had four PCB iterations before coming to my final design. Mostly small functional changes other than adding the forgotten zero LED.
  1. PCB 1.0: The design worked great with only one issue…I forgot a zero!! Funny how double checking the design a million times one misses the obvious. My mind was obviously still in binary clock mode, assuming off would be zero – I quickly realised that wouldn’t be obvious enough and just looked like I’d forgotten a zero…
  2. PCB 1.1: I got rid of the QFN package because I was hand-soldering prototypes and added one more LED for zero. 45deg skew on the QFP actually made the routing easier due to space in the middle.
  3. PCB 1.2: Regulator on-board went (not sure what I was thinking) and since the current was low (< 500mA) I opted for micro USB connector rather than terminal block. This made connection and power availability much more friendly.
  4. PCB 1.3: With the USB interface, why not add USB serial so that the display can be set via a host? On went an FTDI FT230XS USB serial. 1.2 did actually have USB D+/- going to INT. pins on the Atmega328p as I had intention of using VUSB rather an a USB serial. Once I got a basic firmware enumerating however, I decided the additional development time and potential driver issues weren’t worth the saving over using a USB serial converter IC.


I got quite carried away with the software side and ended up developing four code projects! They came in logical phases:

1. Hardware Driver

I started with an Arduino compatible C++ Nixie Pipe class. Time spent being thorough here proved invaluable when it came to developing the high language APIs.

The class uses the FastLED library to manage the daisy chained WS2812B on each Nixie Pipe PCB. The LEDs are split into ‘pipes’ using pointer offset addressing of 10 LEDs. Each pipe can then index the correct LED index for the current number to be displayed. The class manages the current display number and colour for easy updating.

Pipes are set (display number, colour changed) prior to manipulation of the LED array using write. Reasoning behind this is to allow an array of pipes to be setup prior to the FastLED array changing. This allows fading and rainbow effects on the complete pipe array.

2. Python Package

For quick scripting I made a Python class that interfaces with the firmware using SYS_EX like commands. I actually developed the interrupter firmware and Python package in parallel so you could call that five code projects!

import nixiepipe

# Create pipe object from nixiepipe class. Will auto find serial port using device descriptor
pipe = nixiepipe.pipe()

pipe.setNumberUnits(0) # Set number of Nixie Pipe Unit modules
pipe.setColour(0,0,255) # Set array colour blue
pipe.setNumber(9999) # Set array number to 9999

# Write and show new settings

3. Node Module

I started looking at making a GUI as most people I showed the Nixie Pipes to loved it but had no knowledge of programming. Electron caught my eye and having first considering using it with a Python backend, I decided against mixing the two and so ported my Python class to Node. My Node was a bit rusty having not developed with it for a few years so it ended up being the perfect refresher.

var pipes = new NixiePipe();

pipes.once("connected", function() {
pipes.setNumber(9999); // Set array number 9999
pipes.setColour(0,0,255); // Set blue; // Write and set new settings
pipes.getNumber( function() { console.log(pipes.number); }); // Return display number

4. Electron App

I put this app together over a weekend to trial Electron development. I’ll be using it again in the future.

With the Node module developed, I went to work making an Electron app – having not used Electron before I saw it as the project as the perfect test bed. The experience only took a couple of days as I’m familiar with web design methods and Javascript. Overall I was impressed with Electron and would use it again.

Demo Video

Thanks for reading. If you like the Nixie Pipes, I’m selling a limited number through my shop. I’m currently making them myself but if interest is high may run a Kickstarter to outsource production. If you know what you’re doing, you can download the project files and build one yourself. All aspects of the project are licensed under GPL 3.0.