Nixie Tube Driver Library Command Guide – version 1

#include <NixieDriver.h>

Whenever you are using the Nixie tube driver library, you must include it at the top of your sketch. This allows the IDE to recognise commands from the library.

#include <NixieDriver.h>

nixie nixie(data, clock, optional: output_enable, optional: strobe);

Parameters:

int data - Pin which the data line is connected to

int clock - Pin which the clock line is connected to

int output_enable - Pin which the output enable line is connected to (OPTIONAL)

int strobe - Pin which the strobe line is connected to (OPTIONAL)

To begin using the library you must first define the class, in this case, ‘nixie’, but you could call it anything. The pins you are connecting to the Nixie tube driver with must be specified in the data and clock fields. The output_enable and strobe fields are optional connections, but we recommend connecting them to access the full functionality of the library.

//Pin assignments
const int data = 8;
const int clock = 9;
const int oe = 10;

//Create instances of class - Strobe not used
nixie nixie(data, clock, oe);

/* * * * OR * * * */

//Create instance of class with custom name - Strobe and OE not used
nixie myName(data, clock);

From now on all commands must start with your class name, then a dot. This links the command to the library, and without it the sketch will not be able to compile.

display(numberToDisplay);

Parameters:

float / int / long numberToDisplay - The number you wish to display

Returns:

None

The display function is the most useful function of the library; it takes an input number, which takes an integer, a long integer, or a floating point number (see https://www.arduino.cc/en/Reference/HomePage for info on data types) and displays it on the tubes. For a floating point number, the decimal point position is calculated and implemented automatically, though this will require IN12B tubes to display.

float numberToDisplay = 3.14159;
nixie.display(numberToDisplay);    //Displays pi on the tubes

setDecimalPoint(segment, state);

Parameters:

int segment - The segment of the decimal point you wish to alter (indexed from 0)

boolean state - The state of the decimal point

Returns:

None

Should you wish to control the decimal point yourself, this command allows you to manually turn on or off the decimal points. Note: Segments are indexed from 0 (i.e. the first digit is segment 0, the second segment 1 etc.)

nixie.setDecimalPoint(3, 1);     //Turns on the 3rd segment decimal point

blank(state);

Parameters:

boolean state - TRUE for blank, FALSE for not blanked

Returns:

None

nixie.blank(1);    //Blanks the display
nixie.blank(0);    //Unblanks the display

Clock mode is a convenient mode included with the library, which allows the display to be used quickly and easily as a clock or timer. The tubes will display all numbers in 3 groups of two, as shown: HH.MM.SS with a decimal point between each group.

setClockMode(state);

Parameters:

boolean state - TRUE for clock mode enabled, FALSE for clock mode disabled

Returns:

None

nixie.setClockMode(1);    //Enables clock mode. 
nixie.setClockMode(0);    //Disables clock mode.

The following commands only function when clock mode is enabled:

setTime(hours, minutes, seconds);

Parameters:

int hours - The hours to set

int minutes - The minutes to set

int seconds - The seconds to set

Returns:

None

All inputs to this function are in integer form.

nixie.setTime(13, 27, 00);    //Sets the time to 27 minutes past 1.

setHours(hours);

Parameters:

int hours - The hours to set

Returns:

None

nixie.setHour(11);    //Sets the hours to 11

setMinutes(minutes);

Parameters:

int minutes - The minutes to set

Returns:

None

nixie.setMinutes(23);    //Sets the minutes to 23

setSeconds(seconds);

Parameters:

int seconds - The seconds to set

Returns:

None

nixie.setSeconds(58);    //Sets the seconds to 58

updateTime();

Parameters:

None

Returns:

boolean - TRUE for successful update, FALSE for error

Updates the time physically displayed on the tubes to the current time held in memory.

nixie.updateTime();    //Updates the time displayed on the tubes

The nixie library includes a comprehensive backlight controller, which allows smooth blending of colours between fades, custom colour loops, and user controllable durations, all in the background of the sketch. The backlight controller functions as a completely independent sub-library, and therefore requires its own initialisation.

backlight rgb(redPin, greenPin, bluePin);

Parameters:

int redPin - the Arduino pin which the red line is connected to

int greenPin - the Arduino pin which the green line is connected to

int bluePin - the Arduino pin which the blue line is connected to

//Pin assignments for backlight pins
const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;

//Create instance of background class
backlight rgb(redPin, greenPin, bluePin);

To begin using the backlight controller you must first define a separate class, in this case, ‘rgb’, but you could call it anything. The pins you are connecting to the backlight LEDs with must be specified in the redPin, greenPin and bluePin segments.

setColour(colour);

Parameters:

int colour[] - a 3 element array detailing the colour, in {R,G,B} format. The elements can have values from 0-255

Returns:

None

This function changes the colour of the backlight to whatever colour is specified, in the example it is yellow.

rgb.setColour(rgb.yellow);     //Sets the backlight to display yellow

You can use one of our included colours, specified in the list below, or input your own colour using this format:

int myColour[3] = {red, green, blue}

int myColour[3] = {100, 40, 255};
rgb.setColour(myColour);

Amounts of each colour can vary from 0 to 255.

To use the colours included with the library already, simply write the name of a colour, preceded by your library object name (in our case 'rgb').

Included colours:

• white
• red
• green
• blue
• yellow
• dimWhite
• magenta
• aqua
• purple

crossFade(startColour, endColour, duration);

Parameters:

int startColour[] - a 3 element array detailing the start colour

int endColour[] - a 3 element array detailing the end colour

int duration - the duration in which the fade should take place

Returns:

None

This function allows seamless blending of two colours, over a specified time. The colours must be predefined, or part of our included set.

rgb.crossFade(rgb.red, rgb.blue, 1000);     //Fade from red to blue with a duration of 1s.

fadeIn(colour, duration);

Parameters:

int colour[] - a 3 element array detailing the colour to fade in to

int duration - the duration in which the fade should take place

Returns:

None

This function fades a colour in from black over a specified time period.

rgb.fadeIn(rgb.aqua, 3000);    //Fade in to aqua over 3s.

fadeout(duration);

Parameters:

int duration - the duration in which the fade out should happen

Returns:

None

This function fades a colour out to black over a specified time period.

rgb.fadeOut(500);    //Fade out over half a second.

The library has features that allow you to set up a colour fade, and start it cycling in the background of your code.

To do this you need to set up the colour cycle first, before you begin the fade.

Setting up a colour cycle:

The following format applies for setting up a cycle. First, you must make an integer array, of dimension ‘CYCLETYPE’; this is a custom definition to the library. You can then specify colours and their respective durations (note: this is the duration of the fade from one colour to the next, it will not remain on the specified colour for that time. Should you wish to remain on a single colour for a period of time you should put 2 of the same colour sequentially).

There can be a maximum of 16 colours in a colour cycle, before the ENDCYCLE.

int colourCycle[CYCLETYPE] = {

{COLOUR1, Duration},

{COLOUR2, Duration},

{…},

{COLOURN, Duration},

{ENDCYCLE}

};

For example:

int cycle1[CYCLETYPE] = {
    { RED,     1000 },    //Fade from red to yellow in 1s
    { YELLOW,  4000 },    //Fade from yellow to green in 4s
    { GREEN,   5000 },    //Fade from green to blue in 5s
    { BLUE,    8000 },    //Fade from blue to pink in 8s
    { MAGENTA, 1000 },    //Fade from pink to red in 1s
    { ENDCYCLE      }
};

The colours must be specified in capitals from the following list:

• BLACK
• WHITE
• RED
• GREEN
• BLUE
• YELLOW
• DIMWHITE
• AQUA
• MAGENTA
• PURPLE

Should you wish to specify your own colours you should do so using a definition, rather than a variable. This should be done at the top of your code, after #include <NixieDriver.h>. This does not need a type and this line should not end with a semi-colon.

#define MYCOLOUR 100, 40, 255

Starting/Stopping your colour cycle:

setFade(colourCycle);

Parameters:

int colourCycle[CYCLETYPE] - the colour cycle you wish to begin

Returns:

None

This will begin fading through the cycle specified in the background of the code.

rgb.setFade(cycle1);    //Start fading cycle1

stopFade(duration);

Parameters:

int duration - the duration in which you wish the colour cycle to stop cycling and fade out

Returns:

None

This will stop the cycle wherever it currently is and fade it to black over the time period specified.

rgb.stopFade(3000);    //Stops the cycle and fades out over 3s.