Nixie Tube Display
nixie

Nixie tubes have always interested me since I first saw a nixie tube clock in college in 2014. I wanted to make my own nixie tube display, but either with 7-segment or 14-segment tubes. All I found on eBay were numbered tubes from former Soviet Countries and VFD tubes. I gave up looking and moved on with my degree.

 

Last year, I came across the Burroughs-B7971, a US made 14-segment nixie tube that was once used to make stock tickers on Wallstreet. Before I even had a plan to use them, I’d purchased 12. By the end, I’d purchased 4 more and made a full 16 tube display that I use as a clock and news crawler.

Examining the Tube

The tubes have 15 cathodes, one for each of the 14 segments to display an alphanumeric character and one for an underline. The anode is the grid that covers the entire front end of the tube. The space is filled with neon. When about 170v is placed across the anode and one of the cathode segments, the neon by the segment undergoes glow-discharge illuminating the segment.

I bought a small boost converter so that I could test the tubes. First, I wanted to determine the pin order. There was a helpful specsheet which numbered the segments, but it didn’t have current pin information. It did tell me that I needed a 1.8kΩ resister series with the anode to help regulate the voltage. I also took this time to take measurements of the tube. I did measure the pin locations as well just in case I decided I wanted to solder either the tubes or sockets to a yet to be designed circuit control board. However, I ultimately decided against doing that.

Control Chip

The tubes have 15 cathodes, one for each of the 14 segments to display an alphanumeric character and one for an underline. The anode is the grid that covers the entire front end of the tube. The space is filled with neon. When about 170v is placed across the anode and one of the cathode segments, the neon by the segment undergoes glow-discharge illuminating the segment.

I attached a couple of buttons to the control lines and pull up and pull down resistors so that I could test shifting in data. I also hooked up a tube in parallel with the LEDs by tying the cathodes together. This was mostly fine. Either they were being pulled down the ground by the chip or it was left floating. The 170v driving voltage on the anode most certainly exceeded the reverse voltage of the LEDs. While the whole voltage was never dropped across them, they did slowly die one by one over the course of the week.

Despite the early death of the LEDs, this configuration proved perfect. Each HV5122 chip could control two tubes. One tube would start at output 1 and the second at output 17. This way, a single 16-bit integer could represent a single tube with one of the bits optionally controlling a light between the tubes. The chips had a data-out pin as well as data-in, so that could be could be chained. This meant I could control an arbitrary number of tubes with just a few control signals, shifting the data bits from chip to chip.

Powering the Tubes

At this point, I had decided that I wanted my overall design to be modular, every 4 tubes controlled as a set. A single nixie control board would have two HV5122 chips in series and a boost converter. Each board on one side would take as inputs all the control signals, a logic voltage supply, and a boost converter voltage supply. The other side of the board would output buffered control signals and pass through the voltage supplies. While I could’ve had the boost converter off board and passed it through just as the other voltages, I liked the idea of having a self-contained control board as well as the safety aspect of not passing around the high voltage. This would mean the number of tubes I could control would be limited by the amount of current I could pass through the power traces on the boards, either that or periodically run additional power cables. This ended up not being a problem for four boards.

Instead of designing my own boost converter, I decided to use one that I found from a different nixie tube project, albeit one powering much smaller and fewer tubes. It used a MAX1771, a simple boost converter control chip that dynamically changes its switching frequency. Using this circuit ultimately ended up being a mistake, as powering four tubes was just at its limit and caused it to make an audible whine when really being stressed. That being said, it still gets the job done.

Instead of designing my own boost converter, I decided to use one that I found from a different nixie tube project, albeit one powering much smaller and fewer tubes. It used a MAX1771, a simple boost converter control chip that dynamically changes its switching frequency. Using this circuit ultimately ended up being a mistake, as powering four tubes was just at its limit and caused it to make an audible whine when really being stressed. That being said, it still gets the job done.

Decoding

Before designing the pcb, I need to develop and verify the control and decoding scheme for the nixie tubes. I connected an Arduino to my previous LED & tube combo set up to test some basic code that shifted single bits through the control chip.

Ultimately, the goal would be to decode ASCII into a stream of bits to turn on and off individual tube segments. Most printable ASCII characters can be displayed using 14-segments, so all I needed was create a table of ASCII codes to bitmaps. I used the original numbering of the segments from the specsheet as the bit order with the LSB for segment 1. I then sketched out what each character should look like, indexed the segments that would be lit, then coded the bitmap as hexadecimal.

Each bitmap was nicely git in a 16-bit integer for easy use in a lookup table in C or C++. In the table, index 0 corresponded to ASCII code 0x20, as nothing before that was printable. I decided to map all lowercase characters to their uppercase versions, as not all could readily be converted.

Designing the Board

I designed a custom PCB that could power and control four tubes. Each board would house two HV5122 shift registers in series and one boost converter. The board would take the control signals and voltage supplies from one side and output either buffered or passed through versions on the other so that boards could be daisy chained. The data out pin came from the second shit register.

I found sockets for the Burroughs-B7971 tubes. They were quite large and would’ve made the board very large, so I decided to mount them separately and connect them via a ribbon cable.

I used Diptrace to create the schematic and board layout. Placing the parts on the board wasn’t that difficult, nor was hand routing most of the traces. Getting the control signals from one side of the board to the other was a fun exercise. I think I kept the number of vias to a reasonable minimum.

Debugging the Board

The boost converter on Revision A was horribly unstable and produced 400V, which was very undesirable and unsafe. At first I thought it was my choice of inductor, which was much larger than the originally suggested one. I tried replacing it with the original inductor by hacking it on the board, but that didn’t prove fruitful either.

Instead of trying again with the original inductor on another revision of the full board, I made a smaller board that was just the boost converter. This also didn’t work, so I went back to soldering components together manually on a surface mount prototype board. Now it was working.

Despite the prototype circuit looking much messier than the printed one, there was one key difference. All the components were on the same side on the protype board, and I had placed the surfacemount power-fet on the backside of the PCB for heat dissipation purposes and passed the gate signal from the MAX1771 through a via. I had also put the inductor on that side because of size constraints. To test this theory without having to wait for another revision to be fabbed, I made my own board at home. And it worked!

custom_boost_4

I made the next revision of the board with all the power components on the same side, and sent it to the fab. While I waited for it to arrive, I decided I’d take Rev. A and power it externally so that I could make progress on testing the rest of the control circuitry, which ended up working just fine.

Connecting the Tubes

The tube sockets I found could were readily surface mounted. Keeping in line with the control board, I decided to use a rectangular piece of plexiglass on which to mount four tube sockets. Each mounting board would be connected to a control board via offsets. I had 16 tubes total, so that meant I had to assemble four boards in total. All the boards would be attached to two rails of aluminum.
Each tube socket had 16 active pins, 15 for the cathode segments and one for the anode. I soldered one board first to perform tests board design and software tests.

Nixie Protocol

I designed and implemented a simple command line protocol that an Arduino or other small microcontroller could parse. It could read simple commands over serial, decode them, and shift the bits out via SPI to the control boards. For the most part, the serial command line interface would take the text verbatim and decode the ASCII. I also added an ability to parse ASCII coded inline hexadecimal and binary to display arbitrary characters on the tubes.

Final Assembly

Now that I was certain that I could power and control an entire board’s worth of nixie tubes, I was ready to assemble the display. I now had Rev. C of the control board. Rev B. did work, but there were a couple of improvements I wanted to make, including better isolation of the power and digital ground planes. The HV5122 chips were neither plentiful nor cheap, so I harvested them from previous revisions of the boards for use on the final ones.

Using my measurements of the sockets, I designed a simple mounting board with four large holes for the sockets and a dozen or so smaller holes for screws. I fabricated them using my personal power tools. Soldering ribbon cables to 16 sockets with 16 pins each was incredibly tedious.

After assembling and testing all four control boards, I was able to make the final assembly. I connected all of the boards together and inserted the tubes into the sockets. I now had 16 nixie tube display with basic command line capabilities. It still required an external 12v supply and serial command, but I’d take care of that later. The next step was to write a more complex program that could display the time, a news ticker, or fun lights display.

board_full_bottom