The Nixie Clock - A Journey Through Time, Voltage, and Obsolete Tech

The Spark of an Idea

Back in 2016, long before the world became as complicated as it is today, I managed to acquire a batch of beautiful IN-12 Nixie tubes from a supplier in Ukraine. I'd always been captivated by the warm, nostalgic glow of Nixie displays and decided it was time to finally build my own clock.

The principle seemed simple enough: a Nixie tube is essentially a cold-cathode display where a high voltage, usually a few hundred volts, is applied to one of several cathodes shaped like numerals. The gas around the energized cathode glows, lighting up the number. With six tubes, a bit of high-voltage wizardry, and some imagination, you have a clock. How hard could it be?

The Engineering Challenges

As with any project worth doing, the "simple" idea presented a few interesting hurdles:

The High Voltage: The tubes require around $200 V$ DC to operate. Where do you safely get that from a standard low-voltage supply?
High-Voltage Control: You can't just connect an Arduino pin to a $200 V$ line. I needed specific components capable of switching these higher voltages reliably.
The Brains: How do you control the logic, keep accurate time, and manage the display?
User Interface: How do you set the time without a mess of buttons and dials?

The Build: From Parts to Pulses

1. Sourcing the Power

I'll admit, I cheated on the first challenge. Instead of designing a boost converter from scratch, I found a ready-made $200 V$ module on eBay from a seller in Poland. This, combined with my recent Ukrainian tube purchase, resulted in my PayPal account being temporarily locked for "suspicious international activity." An unexpected, but amusing, bump in the road!

2. Taming the Voltage: The Multiplexing Strategy

To control 60 individual digits (10 per tube) plus a few decimal points, you'd need an impossible number of controller pins. The solution is multiplexing. I designed a $6 \times 11$ matrix, where the 6 columns represent the individual tubes (anodes) and the 11 rows represent the cathodes (0-9 digits and a decimal point).

The Cathode Driver (Low-Side Switch): For the "bottom" of the array, I reached back to the 1970s and used a classic 74141 BCD to Decimal Decoder/Driver IC. This brilliant chip takes a 4-bit binary input and grounds the corresponding output pin. While it's only officially rated for $60 V$ , it works perfectly. In the 'on' state, the voltage drop across the Nixie tube and its current-limiting ballast resistor means the IC never sees the full supply voltage.
The Anode Driver (High-Side Switch): For the "top" of the array, I needed to switch the main $200 V$ supply to each tube in sequence. I created a driver circuit for each tube using a pair of high-voltage transistors: an MPSA42 (NPN) and an MPSA92 (PNP). A low-voltage signal from the microcontroller switches on the NPN transistor, which in turn switches on the PNP transistor, connecting its emitter to the $200 V$ supply and illuminating the selected tube.

3. A Professional Finish with a Custom PCB

To elevate the project from a tangle of wires into something truly polished, I designed a custom printed circuit board (PCB) using the online tool EasyEDA. This platform made it straightforward to lay out the schematic and design a compact, two-layer board to house all the components neatly. Once the design was complete, I had it manufactured and shipped for less than £20. The result was a professional-grade foundation that made the final assembly clean, reliable, and, if I do say so myself, somewhat stunning. It truly transformed the project's look and feel.

4. The Controller and Timekeeper

The brains of the operation is an Arduino Pro Mini. It's small, cheap, and more than powerful enough for this task. For timekeeping, I coupled it with a DS1307 Real-Time Clock (RTC) module.

For the initial design, I wanted a clean, modern way to set the time. I integrated an 868MHz IoT radio module that allowed me to send serial commands to the Arduino. This meant I could not only set the time remotely but also push other data to the clock, like the outdoor temperature from a separate wireless weather station.

The Software: Giving it Life

While I'm a fan of Arduino hardware, the standard IDE can feel a bit basic. I opted for Visual Studio with the VisualMicro plugin. This gave me a professional development environment with powerful features like IntelliSense and seamless debugging tools, making the coding process much smoother.

After including a few essential libraries and writing about 430 lines of code, the clock flickered to life.

Libraries Used:

#include <Wire.h> // For I2C communication with the RTC
#include <EEPROM.h> // For storing settings
#include <LLAPSerial.h> // For the original Ciseco radio link
#include <TimerOne.h> // For creating the precise interrupts needed for flicker-free multiplexing
#include <TimeLib.h> // A robust timekeeping library
#include <DS1307RTC.h> // To interface with the RTC module

Evolution and Afterthoughts

The project wasn't without its flaws. In hindsight, the DS1307 RTC module was a poor choice; it seemed to gain about three seconds every hour. Luckily, my IoT radio link provided a perfect mitigation. I simply programmed the system to automatically re-sync the clock every hour, correcting the drift.

A few years later, the IoT radio vendor ceased trading, rendering my remote control obsolete. It was time for an upgrade. The 868MHz radio was replaced with an ESP8266 module running Tasmota. This modern WiFi-enabled device allowed me to send serial data over MQTT, effectively mimicking the old radio link's function but over my home network.

Today, the clock sits on my desk, a testament to a fun and challenging project. It's a functional piece of art, blending glowing, obsolete Soviet-era tech with a modern IoT backbone. And every time I look at it, I'm reminded of the journey—from Ukrainian tubes and Polish power supplies to the satisfying glow of a completed project.