Die Numitron – Etwas Retro muss sein

 Numitron = Vakuumröhre?

Numitrons sind Mehrfadenglühlampen. In einer kleinen Vakuumglasröhre befinden sich mehrere Glühfäden in Form einer 7-Segment-Anzeige. Diese werden wie bei einer kleinen Glühlampe durch Stromfluß durch den Glühfaden zum Leuchten gebracht.  Es handelt sich dabei jedoch nicht um eine typische Elektronenröhre, da hier keine Elektronen von einer Kathode zu einer Anode sausen. Die Anzeige ähnelt den deutlich bekannteren Nixieröhren. Sie benötigen jedoch keine Hochspannung von bis zu 150V. Die von mir gewählten relativ preiswerten russischen Numitrons IV-9 (NB-9) sind für rund 3 US-$ per Stück über diverse Internet-Shops erhältlich und besitzen eine 10 mm hohe und 6 mm breite 7-Segment ähnliche Ziffernanzeige sowie eine Art Dezimalpunkt rechts unten. Die Röhren selbst haben einen Durchmesser von 11mm und eine Höhe von etwa 35mm.

Eben noch in Osteuropa, nachfolgend bereits die Ansicht frisch aus der Verpackung und auf meinen Tisch.

Technische Daten der Numitron

Die Betriebsspannung dieser Numitron IV-9 beträgt typisch 3,15V (2,8V bis max. 4,5V allerhöchstens). Jedes Segment benötigt etwa 20mA (17mA bis max. 22mA), zumindest sofern ich das kyrillische Datenblattfragment richtig interpretiert habe.

Numitrons lassen sich leider nicht so ohne weiteres multiplexen wie die Nixies oder 7-Segment LED-Anzeigen, da die Glühfäden zu träge sind und außerdem in beiden Spannungsrichtungen betrieben werden können. Bei Multiplexbetrieb müssen daher die einzelnen Segmentleitungen zumindest durch Dioden getrennt werden. Bei den von mir angedachten 6 Stellen mit je 7 Segmenten machen das also allein 42 Dioden aus, sollen die Dezimalpunkte mit angesteuert werden, sind es sogar 48 Dioden.  Um hier möglichst flexibel zu bleiben und ggf. auch andere Numitrons mit höheren Strömen einsetzen zu können, werde ich mich vermutlich zu 6 Treiberbausteinen für die  Ansteuerung der Segmente entschließen. Eine finale Entscheidung, ob in dem anstehenden Projekt nun ULN2003 Treiberbausteine oder Schieberegister wie MAX7219, 74HC595, 4094, MAX6921 oder Konstantstromtreiber wie A6278EA-T oder vielleicht auch eine traditionelle Kombination aus 7490 und 74141 oder 7447 und 74HCT164 o. ä. eingesetzt werden oder vielleicht auch irgendeine andere Lösung, ist bis jetzt noch nicht gefallen. Eine weitere Option wäre ganz auf die Treiber zu verzichten und tatsächlich nur die 48 Segmente über Dioden zu entkoppeln und die gemeinsamen Com-Anschlüsse über Transistoren mit einer Betriebsspannung knapp unterhalb der typischen 3,15V zu versorgen. So bliebe die Stromaufnahme jedes Segmentes garantiert unterhalb der vom Arduino Atmega328 möglichen Treiberströme von jeweils 20mA. Dieses sind nur  einige der möglichen Optionen, die erst einmal in die engere Wahl gekommen sind. Es werden sicherlich noch weitere hinzukommen.

In Kurzform die technischen Daten (unter Vorbehalt)

Betriebsspannung:                          3,15V    (2,8V bis max. 4,5V)
Stromaufnahme je Filament:         19,5mA                (17mA bis max. 22mA)
7-Segmentanzeige:                       10 * 6mm
Abmessungen:                                35mm hoch, 11mm Durchmesser

Überlegungen zur Stromaufnahme

Werden alle 7 Segmente und auch der Dezimalpunkt bei voller Helligkeit gleichzeitig angesteuert, so ergibt sich je Numitron eine Stromaufnahme von etwa 20mA * 8 = 160mA, bei 6 Röhren macht das bereits 960mA!

Um den Retroeffekt zu unterstützen, ist die Idee unter jeder der verwendeten Numitrons noch eine RGB-LED zu montieren um diese damit zu unterleuchten.  Da hier sicher keine volle Helligkeit der LED benötigt wird, sollten etwa 10mA je RGB-LED vermutlich ausreichen. Wenn dem so ist, kämen hier weitere 60mA hinzu. Die Stromaufnahme des Controllers und der Ansteuerelektronik veranschlagen wir großzügig in der gleichen Größenordnung und kommen damit in einen Bereich von deutlich über 1A Gesamtstromaufnahme!

Erfreulicherweise werden in der Regel jedoch nicht immer alle Segmente zur Anzeige benötigt. Auch eine volle Helligkeit ist nicht wirklich notwendig. Die Stromaufnahme sollte daher im Mittel deutlich unter 1A liegen.

Für einen ersten Test habe ich eine der Numitrons an ein 74HC595 Schieberegister angeschlossen. Die einzelnen Segmente der Numitron werden synonym an die Ausgänge  Qa bis Qh angeschlossen.

Pin/Ansicht von unten	Anschluss
1	Gemeinsamer Anschluss
2	rechter Dezimalpunkt
3	Segment (b)
4	Segment (c)
5	Segment (a)
6	Segment (f)
7	Segment (g)
8	Segment (d)
9	Segment (e)

Der nachfolgende Sketch erlaubt nicht nur die Darstellung von Ziffern. Auch einige Buchstaben können damit dargestellt werden.

/*********************************************************************************/
/* Numitron test sketch. Displays digits 0 to 9 and the decimal point via serial shift register
* 74HC595 to one Numitron tube.
* Origin Author:        Olaf Meier
* Hardware connection:  Please see below within the sketch
*/
/*********************************************************************************/
/*********************************************************************************/
/***  Declare constants and variables for the optional serial monitor for debugging  ***/
int debug                         =  1;            // Debug counter; if set to 1, will write values via serial
const unsigned int baudRate       =  9600;         // Baud rate for the serial monitor
/***  Declare constants and variables for the Numitron test sketch  ***/
/*** Control pin shift register 74HC595. Connect all pin 10 = MR to Vcc and pin13 = OE to GND  ***/
/*** In case of daisy chaining, connect serial out pin 9 with pin 14 serial data in of the next 74HC595  ***/
/*** Connect pin 15 Q0/QA with segment DP, pin 1 Q1/QB with segment g, pin 2 Q2/QC with segment f etc.  ***/
const byte shiftClockPin          =  4;            // CLock pin 11 of the 74HC595, connect further 74HC595 here
const byte storagePin                 =  5;            // Storage pin 12 of the 74HC595, connect further 74HC595 here
const byte dataPin                         =  6;            // Serial Data pin 14 to the 74HC595
/***  Declare 7+DP-segments: a,b,c,d,e,f,g,DP  –  Inverted logic! Means 0 = filament is on ***/
byte segmente[28][8] = {
0,0,0,0,0,0,1,1,                                 // Display number 0 (O)
1,0,0,1,1,1,1,1,                                 // Display number 1
0,0,1,0,0,1,0,1,                                 // Display number 2
0,0,0,0,1,1,0,1,                                 // Display number 3
1,0,0,1,1,0,0,1,                                 // Display number 4
0,1,0,0,1,0,0,1,                                 // Display number 5
0,1,0,0,0,0,0,1,                                 // Display number 6
0,0,0,1,1,1,1,1,                                 // Display number 7
0,0,0,0,0,0,0,1,                                 // Display number 8
0,0,0,0,1,0,0,1,                                 // Display number 9 (g)
1,1,1,1,1,1,1,0,                                 // Display decimal point
0,0,0,1,0,0,0,1,                                 // Display character A
1,1,0,0,0,0,0,0,                                 // Display character b
0,1,1,0,0,0,1,1,                                 // Display character C
1,0,0,0,0,1,0,1,                                 // Display character d
0,1,1,0,0,0,0,1,                                 // Display character E
0,1,1,1,0,0,0,1,                                 // Display character F
0,0,0,0,1,0,0,1,                                 // Display character g (9)
1,0,0,1,0,0,0,1,                                 // Display character H
1,1,1,1,0,0,1,1,                                 // Display character I
1,0,0,0,0,1,1,1,                                 // Display character J
1,1,1,0,0,0,1,1,                                 // Display character L
0,0,0,0,0,0,1,1,                                 // Display number O (0)
0,0,1,1,0,0,0,1,                                 // Display number P
0,1,0,0,1,0,0,1,                                 // Display number S
1,0,0,0,0,0,1,1,                                 // Display number U
1,0,0,0,1,0,0,1,                                 // Display number Y
1,1,1,1,1,1,1,1};                               // Blank
/*********************************************************************************/
/*********************************************************************************/
void setup() {
/***  Optional Debug routine via serial monitor  ***/
if (debug) {                                     // If you want to see some values for debugging in general…
/***  Start class Serial with function/method begin(9600)  ***/
/***  Instance variable .dot operator. method  ***/
Serial.begin(baudRate);        // …set up the serial output
Serial.println(„Debugging activated“);
}                                                           // End of debug
/***  Show software release  ***/
Serial.println();
Serial.print (sketchname);
Serial.print(„\t“);
Serial.print(revision);
Serial.println();
Serial.print(author);
Serial.print(„\t“);
Serial.println(date);
Serial.println();
/*********************************************************************************/
/***  Prepare the 74HC595 shift register  ***/
pinMode(shiftClockPin, OUTPUT);
pinMode(storagePin, OUTPUT);
pinMode(dataPin, OUTPUT);
reset595();                                     // Reset all needed pins of the 74HC595
}                                                            // End of void setup()
/*********************************************************************************/
/*********************************************************************************/
void loop() {
/***  Optional Debug routine via serial monitor  ***/
if (debug) {                                      // If TRUE
debug += 1;                                    // Increment the debug counter
if (debug > 100)                            // Print only each 1xx loop
{
debug = 1;                                       // Reset the counter
/***  Display your debug values here  **/
/*
Serial.print(„abc „);
Serial.println(variable);            // Display value of the ADC where the buttons are connected
*/
}
}                                                               // End of if (debug)
/***  End of optional Debug routine via serial monitor  ***/
/***  Show all defined digits  ***/
for(int i = 0; i <28; i++){
sendData(segmente[i]);            // Send data of the selected digit to be displayed
delay(500);
}
}                                                              // End of void loop()
/*********************************************************************************/
/*********************************************************************************/
/***  Function to send data in a serial manner to the shift register  ***/
void sendData(byte num[]){
for(int i = 0; i < 8; i++){
reset595();
digitalWrite(dataPin, num[i]);
//    delay(1);                                    // Only in case of trouble, add some delay
digitalWrite(shiftClockPin, HIGH);
//    delay(1);                                    // Only in case of trouble, add some delay
}
digitalWrite(storagePin, HIGH);
}                                                             // End of void sendData()
/*********************************************************************************/

/***  Function to reset all pins of the shift register  ***/
void reset595(){
digitalWrite(shiftClockPin, LOW);
digitalWrite(storagePin, LOW);
digitalWrite(dataPin, LOW);
}                                                             // End of void reset595()
/***  End of functions  ***/
/*********************************************************************************/
/*********************************************************************************/

Beim rüberkopieren des Sketches in die Arduino IDE ist unbedingt auf korrekte Zeilenumbrüche zu achten!