Close
0%
0%

Modular Nixie Display

Modular nixie display board based on the soviet Russian IN-12A cold-cathode tubes.

Similar projects worth following
Just a simple little two digit IN12A display with colon. The display is modular, so you can create displays for clocks with 2, 4, 6, or 8 digits (if you're a little crazy).

FOR SOME REASON I DON'T GET NOTIFIED ABOUT COMMENTS YOU LEAVE, SORRY IF IT TAKES A WHILE FOR ME TO RESPOND.

The main objective for this project is to design a modular nixie display board containing two IN12A's and two neon indicators (colon) that can be strung along to create 2, 4 or 6 digit clocks. The idea is, tubes can be individually controlled via SPI. I explored different methods of driving nixies, such as using the common SN74141 BCD to Decimal decoder driver clones called the K155ID1 along with 74HC595 8-bit shift registers. Also shift-registers with high-voltage transistors on the outputs. These methods were ok, but I later changed my design to include the HV5530 instead. The HV5530 is a shift register with high-voltage open-drain outputs and are still being manufactured.

Modular IN12A Driver Rev1.zip

Gerbers and NC drill files

x-zip-compressed - 54.05 kB - 01/17/2018 at 03:08

Download

Adobe Portable Document Format - 305.92 kB - 01/16/2018 at 03:05

Preview
Download

  • 2 × V2/V3 - IN12A Nixie Tube
  • 2 × V1/V4 - INS-1 Neon Indicator Bulb
  • 1 × U1 - HV5530PG-G 44PQF
  • 1 × C1 - 100nF 50V 0805
  • 1 × C2 - 10uF 25V 1206

View all 7 components

  • Test Code

    Johnny01/16/2018 at 03:58 0 comments

    /*
     * Test File for Modular IN12A Nixie Display Boards
     * Works with Arduino Uno.
     * 
     * By: Johnny Izzard
     */
    
    #include <SPI.h>
    
    #define LD 10
    #define CLK 13
    #define SDO 11
    #define PWM 9
    
    #define tube_off 10
    #define ind_off 3
    
    uint16_t decimal_lookup[11] = {0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0000}; // decimal_lookup[0]...decimal_lookup[9] outputs corresponding nixie number. decimal_lookup[10] is off.
    uint8_t ind_lookup[4] = {0x01, 0x02, 0x03, 0x00}; // ind_lookup[0] is top indicator, ind_lookup[1] is bottom indicator, ind_lookup[2] is both, ind_lookup[3] is off.
    
    uint32_t data1 = 0; // Used to store data to be shifted
    uint32_t data2 = 0;
    uint32_t data3 = 0;
    
    uint8_t  tube1 = 0; // Value to display on the corresponding tube.
    uint8_t  tube2 = 0;
    uint8_t  tube3 = 0;
    uint8_t  tube4 = 0;
    uint8_t  tube5 = 0;
    uint8_t  tube6 = 0;
    
    uint8_t indicator1 = 0; // Value to display on the corresponding indicator. 
    uint8_t indicator2 = 0;
    uint8_t indicator3 = 0;
    
    
    void setup() {
      
      pinMode(LD,OUTPUT);  // LD is pin 10 (active high)
      pinMode(CLK,OUTPUT); // CLK is pin 13
      pinMode(SDO,OUTPUT); // SDO is pin 11
      pinMode(PWM,OUTPUT); // PWM (Blank) is pin 9 (active low)
      digitalWrite(LD,LOW);
      digitalWrite(CLK,LOW);
      digitalWrite(SDO,LOW);
      digitalWrite(PWM,HIGH);
      SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE1));
    
      /* Reset Values/Blank The Display */
      tube1 = tube_off;
      tube2 = tube_off;
      tube3 = tube_off;
      tube4 = tube_off;
      tube5 = tube_off;
      tube6 = tube_off;
      indicator1 = ind_off;
      indicator2 = ind_off;
      indicator3 = ind_off;
      update_disp();
    }
    
    void loop() {
    
      indicator1 = 2; // Both indicators on
      indicator2 = 2;
      indicator3 = ind_off;
      for(uint8_t i = 0; i<10; i++){
        tube1 = i;
        tube2 = i;
        tube3 = i;
        tube4 = i;
        tube5 = i;
        tube6 = i;
        update_disp();
        delay(500);
      }
    
      /* Reset Values/Blank The Display */
      tube1 = tube_off;
      tube2 = tube_off;
      tube3 = tube_off;
      tube4 = tube_off;
      tube5 = tube_off;
      tube6 = tube_off;
      indicator1 = ind_off;
      indicator2 = ind_off;
      indicator3 = ind_off;
      update_disp();
      delay(500);
    
      tube1 = 9;
      update_disp();
      delay(500);
    
      tube1 = tube_off;
      tube2 = 9;
      update_disp();
      delay(500);
    
      tube2 = tube_off;
      indicator1 = 0;
      update_disp();
      delay(500);
    
      indicator1 = 1;
      update_disp();
      delay(500);
    
      indicator1 = 2;
      update_disp();
      delay(500);
    
      indicator1 = ind_off;
      tube3 = 9;
      update_disp();
      delay(500);
    
      tube3 = tube_off;
      tube4 = 9;
      update_disp();
      delay(500);
    
      tube4 = tube_off;
      indicator2 = 0;
      update_disp();
      delay(500);
    
      indicator2 = 1;
      update_disp();
      delay(500);
    
      indicator2 = 2;
      update_disp();
      delay(500);
    
      indicator2 = ind_off;
      tube5 = 9;
      update_disp();
      delay(500);
    
      tube5 = tube_off;
      tube6 = 9;
      update_disp();
      delay(500);
    
      tube6 = tube_off;
      indicator3 = 0;
      update_disp();
      delay(500);
    
      indicator3 = 1;
      update_disp();
      delay(500);
    
      indicator3 = 2;
      update_disp();
      delay(500);
    
      indicator3 = ind_off;
      update_disp();
      delay(500);
    
      // All On
      tube1 = 9;
      tube2 = 9;
      tube3 = 9;
      tube4 = 9;
      tube5 = 9;
      tube6 = 9;
      indicator1 = 2;
      indicator2 = 2;
      indicator3 = 2;
      update_disp();
    
      // Fade Out
      for(uint8_t i = 150; i!=0; i-=1){
        analogWrite(PWM,i);
        delay(40);
      }
    
      // Fade In
      for(uint8_t i = 0; i!=150; i+=1){
        analogWrite(PWM,i);
        delay(40);
      }
      digitalWrite(PWM,HIGH);
    
      
    }
    
    void update_disp(void){
      data1 = 0x00000000;
      data1 |= ((uint32_t (decimal_lookup[tube1]))&0x000003FF);
      data1 |= ((uint32_t (decimal_lookup[tube2])<<10)&0x000FFC00); 
      data1 |= ((uint32_t (ind_lookup[indicator1])<<20)&0x00300000);
    
      data2 = 0x00000000;
      data2 |= ((uint32_t (decimal_lookup[tube3]))&0x000003FF);
      data2 |= ((uint32_t (decimal_lookup[tube4])<<10)&0x000FFC00); 
      data2 |= ((uint32_t (ind_lookup[indicator2])<<20)&0x00300000);
    
      data3 = 0x00000000;
      data3 |= ((uint32_t (decimal_lookup[tube5]))&0x000003FF);
      data3 |= ((uint32_t (decimal_lookup[tube6])<<10)&0x000FFC00); 
      data3 |= ((uint32_t (ind_lookup[indicator3])<<20)&0x00300000); 
    
     digitalWrite(LD,HIGH);
    ...
    Read more »

  • INS-1

    Johnny12/17/2015 at 08:05 1 comment

    I'm trying out the INS-1 indicator bulbs to replace the generic ones I use.

    Datasheets are still in Russian, but google translate to the rescue!

    DesignatorElectrode Type
    1 - The smaller cylinderAnode
    2 - The larger cylinderCathode

    See the dark dot in the pinout diagram? This matches a dot on the envelope of the indicator (image below). The dot is next to the anode pin. Another way of tell the anode from the cathode, as the table above suggests, is finding the pin that connects to the smaller cylinder.

    Parameter NameMinimumMaximum
    Firing Voltage, in V6590
    Sustaining Voltage, in V-55

    Recommended current, providing sufficient brightness is 0.5mA.

    Because the sustain voltage is about 55V, I'm using a 180V power supply and 0.5mA is required, about 270K current limiting resistor is used.

  • 6 Digits + Brightness

    Johnny12/01/2015 at 06:22 0 comments

  • 4 Digits

    Johnny11/27/2015 at 11:20 0 comments

  • Module Test

    Johnny11/27/2015 at 09:30 0 comments

  • PCBs

    Johnny11/27/2015 at 07:13 0 comments

    PCBs arrived. I populated one and gave it a test program. All works well.

  • Better Driving Solution

    Johnny11/05/2015 at 03:06 0 comments

      Came across this component the other day:

      It's a 32-bit serial-in parallel-out shift-register with open drain outputs designed for driving high voltage loads, perfect for nixie tubes. The shift-register has typical 'Data In', 'Clock' and 'Data Out' pins. The active-low 'Latch Enable' pin is used to latch/save the data stored in the shift register to the buffer/output register, which in turn, turns on the appropriate output MOSFET. The 'LE' pin should be kept at logic-high in rest state, then send a logic-low pulse to latch. The active-low 'Polarity' pin can be used to invert the outputs on logic-low and the active-low 'Blanking' pin will turn off the outputs on logic-low (this doesn't change the buffer value and note the polarity function has higher priority). The 'BL' pin can be used to change the displays brightness using PWM. The HV5530 shifts data anticlockwise around the IC, where it's brother, the HV5630 shifts clockwise. This is useful for different PCB layouts. But in truth you could just change to shifting order from MSB to LSB or vice-versa in your program. If you plan on using SPI with the HV5530, note that MODE1 or MODE2 should be used with MSB first. MODE1 or MODE2 are used because the HV5530 and HV5630's shift-register latches data on the falling edge of the 'CLK' pin.

      The voltage requirements for this device are a bit of a downer, as it's not 5V CMOS compatible (technically). 12V logic is specified by the datasheet, but in practice I've used 5V logic fine. In my case 12V is needed for my SMPS to produce 180V for the nixies; so the 12V here can be used in conjunction with a level shifting circuit to convert 5V signals to 12V signals.

      The real positives for this device are:

      1. It's still being manufactured, unlike the SN74141 and K155ID1.
      2. Replaces many components and number of tracks, resulting in a much more compact board.

      Cons:

      1. 12V CMOS logic
      2. Costly at about $6USD each

      My original driving solution using the K155ID1 with 73HC595 resulted in a design that looked like this:

      The new design using the HV5530 looks like this:

  • Driving the IN-12A

    Johnny11/15/2014 at 12:46 0 comments

    The IN-12A nixie tubes are operated at very high voltages, and microcontrollers can't handle voltages much higher then their VCC voltage. So that the IN-12A's can be controlled by digital logic circuitry, it is required that we have some sort of device that can drive these nixies, but also be able to interface with a microcontroller. The easiest method is a driver that can pull individual cathodes (numbers) to ground. Traditionally a SN74141 BCD(binary coded decimal)-TO-DECIMAL driver/decoder is used. This part is very rare these days, and if you do find one on ebay, it most likely will be second hand, and will cost you an arm and a leg.

    An alternative to the SN74141 is the K155ID1, a SN74141 clone made in Russia in the late 80s. The K155ID1 is not as expensive as the SN74141 but, is still quite expensive, at about $2US a piece when purchased in lots of 6 and above. With that in mind, that's about $12US for six nixie drivers when making a six digit clock. As the K155ID1 stopped being manufactured long ago, and the NOS (new old stock) will eventually run dry, prices will go even higher. Because of this I will show an alternative options in a later project log.

    The K155ID1 is a BCD-TO-DECIMAL driver/decoder. How this works is, when a binary value is placed on the A-D (A is the least significant bit or bit 0) input pins, a corresponding output pin with the decimal value name will go LOW. That means that the K155ID1 has ACTIVE LOW outputs. The output pins of the K155ID1 are open collector, so they can pull to ground (LOW), but cannot produce a logic HIGH output. Instead, when a output pin is not LOW, the output is high impedance. Open collector TTL ICs like these are designed to drive loads, not for digital communication.

    A useful feature of the K155ID1 is, when the binary input goes higher than the decimal range (9), all the outputs become high impedance. This is useful for blanking (turning off) the nixie tube.

  • The IN-12A

    Johnny11/13/2014 at 07:58 0 comments

    The IN-12A is a relatively cheap 80s cold cathode tube made is Soviet Russia and is by far the most common nixie found on ebay. Price is around $20US for a lot of six (new old stock).

    The IN-12A has 12 pins. Pin 1 is the anode. This pin is tied to 170-200V DC. Pins 2-11 are the individual number cathode pins. When you want to illuminate a particular number, place 0V on the corresponding cathode pin (be sure to include a current limiting resistor on the anode pin, seen further in the log). Please refer to the image and table below.

    The IN-12A has a strike voltage of about 170V, that is the voltage at which conduction between the anode and cathode can begin so the number can illuminate. For conduction to start, it takes time, as the nixie's gas needs an ionized path from anode to cathode. Once conducting, the anode to cathode voltage will drop and current will increase. Both will reach a steady state in about 100us.

    Like the test circuit seen above, 180V from a boost converter was applied to the nixie tube's anode through a series 15K current limiting resistor and GND was applied to the number three cathode. After conduction, the anode to cathode voltage dropped to about 143V. This is below the strike voltage now, but don't worry, the ionized gas path will remain, this is normal... The current through the nixie tube ended up at about 2.5mA, which is the nominal value for the IN-12A.

    Anode to Cathode Voltage at Switch Closed O-Scope Reading

    The oscilloscope trace above is an example of testing a cathodes step response (number three cathode). The trace may vary slightly for different number cathodes, as the anode to cathode distance and cathode surface area varies. Analyzing the oscilloscope trace, it can been seen that it takes about 80us for the number three cathode to reach steady-state. A comparison between cathode settling times needs to be taken into consideration if I wish to use PWM to effect the brightness of the display.

  • PrototypeVideo

    Johnny07/17/2014 at 07:37 0 comments

    This is the proof of concept board. This will be re-designed for fab-house manufacturing. Two layer, and much smaller.

View all 10 project logs

Enjoy this project?

Share

Discussions

takeiryou926 wrote 06/18/2018 at 16:37 point

Hey could you please add your INS-1 .lbr file? I trying to make the lib by my self but I cannot find the dimensions  of INS-1.  

Thanks!!

  Are you sure? yes | no

simeon.larrea wrote 03/06/2018 at 11:30 point

Great work Johhny. I am gettting some boards printed! Do you have a component list to save me trawling through electronics catalogues to get the correct size components? That would be super helpful. I will be driving 6 IN-14s and 4 IN-8s to make a custom display and your driver boards are just what i have been looking for.

Thanks in advance!

  Are you sure? yes | no

Johnny wrote 03/08/2018 at 03:42 point

Hey Simeon,

I added a components list. I forgot to do that :). Have fun.

  Are you sure? yes | no

simeon.larrea wrote 03/08/2018 at 08:32 point

Legend!!!! Thanks so much.

  Are you sure? yes | no

nexxo00 wrote 03/30/2018 at 09:22 point

You are awesome for sharing all this. I'll be making my own board for four IN-14 tubes, and want to drive the two decimal points inside each tube rather than drive separate neon lamps for the colons. I imagine this has some implications for the code?

  Are you sure? yes | no

Johnny wrote 03/31/2018 at 13:17 point

Hey nexxo00,

Yeah, if I was to redesign this, I'd include the internal decimal points for the INA12B. The boards I designed won't allow you to use the internal decimal points, just not enough outputs.

  Are you sure? yes | no

nexxo00 wrote 06/08/2018 at 07:08 point

That's OK; I am redesigning the board slightly to reroute the output that went to the neon decimal point bulbs to the IN-14 nixie tube instead.

  Are you sure? yes | no

Frederic L wrote 02/22/2018 at 22:07 point

Amazing work. And thank you for sharing, it's helping me a lot designing my own board for Nixies and Arduino. I have noted the following through my research :

When you switch any tube OFF, your code sends ---0b0000000000--- to the HV5530. This I believe will disconnect all cathodes from ground for the targeted tube. According to this site (https://threeneurons.wordpress.com/nixie-power-supply/) I quote :

"DO NOT blank, by turning all cathodes OFF. Especially, when using cathode drivers like a 74141 (or its Russian equivalent). If you attempt this with these devices, they will see over ~100V, and will conduct thru more than one cathode at a time. This will look similar to ghosting.  These devices are leaky, so at least one cathode should be ON at all times."

That being said, I don't know what convenient way there would be to switch the tube OFF, besides cutting power to the anode I guess ? Or decreasing brightness to that specific tube... but then one HV5530 would be required per tube which isn't convenient...

  Are you sure? yes | no

Johnny wrote 03/03/2018 at 00:45 point

Hey Frederic, 

good to hear you got something out of it :). Yeah, a zero sent to a pin makes it high impedance, so all 0s will blank the display. You could also use the BL pin to do this. Leakage shouldn't cause you any problems with the HV5530. The datasheet says maximum is 10uA, all outputs high and SWS in parallel (not sure what sws is? All outputs tied together?). Anyway, I haven't experienced any ghosting.

You making a clock? Should put your progress up on hackaday.io, I'm keen to see what you've come up with.

Cheers, Johnny.

  Are you sure? yes | no

Johnny wrote 03/03/2018 at 00:54 point

Also yes you could use anode switching to blank these with a PNP transistor, I did this on my earlier version. The HV5530 has spare pins left over, you could drive the PNP with that. Because I haven't had any real issues with just the HV5530, I'd just use that and blank in software.

  Are you sure? yes | no

Alex Ganov wrote 07/21/2016 at 15:01 point

Great project man, the way you are able to chain the modules is awesome. As I can see you found a way to change the brightness of the IN-12 tubes with the HV5530 which is just great. I'm trying to archive this with 74141 and 74HC595 but with no success... I hope you'll share the project files someday.

  Are you sure? yes | no

Johnny wrote 01/16/2018 at 02:54 point

Hey Alex, 

sorry about the really late reply! Life got busy and I haven't been on this site in a long time. I'll see if I can dish out some files and add it to the page.

John.

  Are you sure? yes | no

nexxo00 wrote 01/18/2018 at 20:03 point

Thank you very much! I'm looking for something like this (adapted slightly to use IN-14 tubes) for my steampunk computer build: three IN-14 digit tubes and one IN-19 symbol tube to display temperature and flow of the water cooling.

  Are you sure? yes | no

karesz25 wrote 06/28/2016 at 13:05 point

Hi!

Nice project!

Can you share / sell pcb files?

Thanks.

  Are you sure? yes | no

Johnny wrote 01/16/2018 at 02:54 point

Hey,

sorry about the really late reply! Life got busy and I haven't been on this site in a long time. I'll see if I can dish out some files and add it to the page.

John.

  Are you sure? yes | no

brian wrote 05/31/2016 at 17:36 point

Hi Johnny, would you be amenable to sharing your schematic and board files? I love the way you make this work and would like to learn from your work so I can finish my own :)

  Are you sure? yes | no

Johnny wrote 01/16/2018 at 02:55 point

Hey Brian,

sorry about the really late reply! Life got busy and I haven't been on this site in a long time. I'll see if I can dish out some files and add it to the page.

John.

  Are you sure? yes | no

Phill wrote 02/02/2016 at 05:30 point

Loving this ! 

What code are you using to drive the clock ?

  Are you sure? yes | no

Johnny wrote 02/02/2016 at 10:51 point

Thanks Phill. The code sends values to the shift register/drivers which then drive the tubes. The code can be a little awkward in the beginning because numbers aren't expressed in binary, they are in decimal (i.e. bit 0 is '0' on the tube and bit 1 is '1', ... etc), also each tube takes up 10bits out of 32. Therefore a lookup table is first needed to convert each tube value to decimal, before combining the two tube values to make up 20bits. Then the last two bits are the colon. 22bits in all. Sending data over SPI is often in 8bit packets, so the last step is to shift out the 22bit value in 8bit chunks (32bits in total). I think I'll post my code.

  Are you sure? yes | no

Phill wrote 02/02/2016 at 10:55 point

Sweet... I would love to see it !

  Are you sure? yes | no

jmspswny wrote 12/22/2015 at 15:40 point

Are you planning on publishing your PCB files? will you be selling blank PCBs?  

  Are you sure? yes | no

Johnny wrote 12/22/2015 at 22:00 point

Yes to publishing Gerber files and image of schematic. And maybe to selling PCBs. I'll start looking into it.

  Are you sure? yes | no

Johnny wrote 12/02/2015 at 02:17 point

Thanks, I wasn't planning to. I guess if the demand is high enough I will.

  Are you sure? yes | no

Rivers wrote 12/01/2015 at 15:01 point

great project are you selling these

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates