P-001 / Technische Dokumentation
Aufbau, Zeitführung, Anzeigeansteuerung und Software einer DCF77-synchronisierten NIXIE-Uhr.
Überblick
Diese Seite beschreibt Aufbau und Funktionsweise der DCF77-NIXIE-Uhr sowie das Zusammenwirken von Hardware und Software. Die folgenden Abschnitte ordnen die Funktionsgruppen technisch ein und erläutern die wesentlichen Entwurfsentscheidungen.
Die Uhr verbindet historische Anzeigetechnik mit klassischer Digitaltechnik und moderner Mikrocontrollersteuerung in einem praktisch erprobten Aufbau.
Fertige Uhr
Vor der Beschreibung der einzelnen Baugruppen wird zunächst die fertig aufgebaute Uhr gezeigt. An ihr werden die Anordnung der Röhren, die sichtbare Leiterplatte und die konstruktive Verbindung von Anzeige, Elektronik und Gehäuse unmittelbar erkennbar. Das betriebsbereite Gerät im Acrylgehäuse verwendet die Leiterplattenversion V3; die nachfolgenden Aufbauaufnahmen dokumentieren die weiterentwickelte Version V4.
Die NIXITRON-Uhr wurde im Jahr 2009 ursprünglich im Rahmen eines Ausbildungsprojekts konzipiert und danach schrittweise weiterentwickelt. Die heutige Dokumentation beschreibt das daraus entstandene Gerät als technisches Projekt und ordnet seine Funktionsgruppen nachvollziehbar ein.
Die Dokumentation ist nicht als vollständige Schritt-für-Schritt-Bauanleitung angelegt. Ihr Schwerpunkt liegt auf dem Schaltungsprinzip und dem Zusammenwirken von Hardware und Software. Hinweise zu Aufbau, Störfestigkeit und elektrischer Sicherheit werden dort ergänzt, wo sie für die fachliche Einordnung wesentlich sind. Am Ende der Seite folgen Hinweise zur praktischen Implementierung.
| Projektcharakter — Die Konstruktion wurde mehrfach erfolgreich aufgebaut. Die Dokumentation beschreibt daher ein praktisch erprobtes Schaltungskonzept und keine rein theoretische Entwurfsstudie. |
|---|
Eine Uhr eignet sich als Projektgegenstand, weil ihr Betriebszustand unmittelbar sichtbar ist und mehrere Funktionsgruppen zu einem vollständigen elektronischen System zusammenwirken. Zugleich lassen sich Bauteile und Schaltungsprinzipien aus unterschiedlichen Entwicklungsepochen miteinander kombinieren.
Die Anzeige ist bewusst auf Stunden und Minuten beschränkt. Auf eine Sekundenanzeige wurde verzichtet, da der fortlaufende Ziffernwechsel die ruhige Wirkung der Röhren verändern würde. Zusätzliche Unterleuchtungen oder andere optische Effekte sind nicht vorgesehen.
Zwei dauerhaft leuchtende LEDs bilden den Doppelpunkt zwischen Stunden und Minuten. Alternativ wären hierfür Glimmlampen möglich gewesen. Erfahrungen aus dem langjährigen Betrieb zeigten jedoch, dass einzelne Glimmlampen schneller alterten als die NIXIE-Röhren und dadurch Unterschiede in Farbe und Helligkeit entstanden. Farblich angepasste LEDs erwiesen sich deshalb als beständigere Lösung.
Der Aufbau der Uhr und die in ihr verwendeten Komponenten haben einen technikhistorischen Bezug, weil sie mehrere Entwicklungsstufen der Elektronik auf einer Leiterplatte zusammenführen. Sichtbar wird dies besonders in der vertikalen Gliederung der Baugruppen: oben die NIXIE-Röhren als historische Anzeige, darunter die Logik- und Treiberbausteine der klassischen Digitaltechnik, unten die moderne Mikrocontrollersteuerung.
Die NIXIE-Anzeige mit ihren gasgefüllten Glimmröhren geht bis in die 1950er Jahre zurück. Damals waren solche Röhren eine verbreitete Technik für numerische Anzeigen in Messgeräten, Zählern und frühen elektronischen Steuerungen. Ab den 1960er Jahren wurden sie zunehmend durch LED-, LCD- und Fluoreszenzanzeigen verdrängt. In einzelnen Messgeräten und militärischen Geräten des Ostblocks blieben NIXIE-Anzeigen jedoch noch lange im Einsatz, teilweise bis in die 1980er Jahre.
Für die Konstruktion der Uhr werden sowjetische Röhren des Typs IN-12 verwendet. Die Unterscheidung zwischen IN-12a und IN-12b ist für diese Anwendung nicht wesentlich. Die IN-12 ist kompakt, gut ablesbar und heute noch vergleichsweise gut erhältlich, weil sie in großen Stückzahlen hergestellt wurde. Eine auffällige Besonderheit ist die fehlende eigene Ziffer 5: Stattdessen wird ein um 180 Grad gedrehtes Kathodenblech der Ziffer 2 verwendet. Diese Lösung verweist auf die material- und fertigungstechnischen Randbedingungen, unter denen viele Bauteile im früheren Ostblock entwickelt und produziert wurden.
Auch die Ansteuerung der Röhren trägt zu dieser Einordnung bei. Die Uhr kombiniert westliche CMOS-Logik, TTL-nahe NIXIE-Treiber und sowjetische Anzeigeröhren mit einem modernen Mikrocontroller. Die konkrete elektrische Funktion dieser Baugruppen wird in den folgenden Fachabschnitten beschrieben; an dieser Stelle steht vor allem die historische Schichtung der Technik im Vordergrund.
Die Tabelle zeigt die wichtigsten Prämissen zur Konstruktion der Uhr. Die Schaltung bleibt trotz ihres historischen Anzeigeprinzips bewusst überschaubar: Der Mikrocontroller übernimmt die Zeitführung und die Anzeigelogik, während RTC und Hochspannungsversorgung als fertige, klar spezifizierte Module eingebunden werden.
Für die Anzeige wurde eine statische Ansteuerung gewählt. Jede Röhre besitzt damit ihren eigenen Treiberpfad und leuchtet ohne zeitliches Multiplexing. Diese Lösung benötigt mehr Treiberbausteine als eine Multiplexanzeige, vermeidet aber Flimmern, Ghosting, impulsartig erhöhte Röhrenströme und zusätzliche hochfrequente Schaltvorgänge im Umfeld des DCF77-Empfängers.
Die Zeitbasis ist dreistufig ausgelegt. Vorrangig wird das DCF77-Zeitzeichen verwendet. Bei fehlendem oder gestörtem Empfang hält ein DS3231-RTC-Modul die Uhrzeit lokal weiter vor. Ist auch diese Quelle nicht verfügbar, bleibt die interne Softwarezeit des Mikrocontrollers als Rückfallebene erhalten. Zur manuellen Einstellung stehen Taster für Stunden und Minuten zur Verfügung.
| Bereich | Festlegung |
|---|---|
| Mikrocontroller | ATmega328P in Minimalbeschaltung, Entwicklung mit der Arduino-IDE |
| Anzeige | Vier Stellen im Format HH:MM, 24-Stunden-Betrieb, keine Sekundenanzeige |
| Röhren | IN-12-NIXIE-Röhren, statische Ansteuerung |
| Zeitquellen | DCF77 als externe Referenz, DS3231 als lokale Zeitbasis, interne Softwarezeit als Rückfallebene |
| Bedienung | Je ein Taster für Stunden und Minuten |
| Anzeigelogik | Zwei kaskadierte CD4094 mit Ausgangslatches und vier 74141/K155ID1 |
| Module | Marktgängige Baugruppen für RTC und Hochspannung |
| Störfestigkeit | Keine Multiplexanzeige; räumliche und elektrische Trennung empfindlicher und störender Baugruppen |
Die Uhr zeigt die Uhrzeit im Format HH:MM an. Als Zeitreferenz wird vorrangig das DCF77-Zeitzeichen verwendet. Die RTC (basierend auf dem IC DS3231) hält die Uhrzeit auch bei gestörtem Empfang und bei ausgeschalteter Uhr. Der ATmega328P verarbeitet die Zeitinformation und überträgt die vier Ziffern seriell an zwei Schieberegister. Vier BCD-Treiber schalten anschließend die Kathoden der NIXIE-Röhren.
Die Schaltung arbeitet mit zwei deutlich getrennten Spannungsebenen. Die digitale Elektronik wird mit 5 V versorgt. Für die NIXIE-Röhren erzeugt ein externes Hochspannungsmodul ungefähr 170 V Gleichspannung. In der Implementierung sollten diese Bereiche räumlich und elektrisch so weit wie möglich getrennt werden. Dadurch sinkt sowohl das Risiko einer Gefährdung des Niederspannungsbereichs als auch die Wahrscheinlichkeit störender Einkopplungen aus dem Schaltwandler.
Der 5-V-Bereich versorgt Mikrocontroller, CD4094, DCF77-Modul, RTC-Modul und LEDs. Puffer- und Abblockkondensatoren reduzieren Versorgungseinbrüche und hochfrequente Störungen. In einem realen Aufbau sind 100-nF-Keramikkondensatoren unmittelbar an den Versorgungspins jedes Digital-ICs zweckmäßig. In der konkreten Umsetzung der Uhr wird auf einzelne 100-nF-Abblockkondensatoren an den langsam schaltenden Logikbausteinen verzichtet; bei Stabilitätsproblemen wäre diese Bestückung jedoch die naheliegende Ergänzung.
Die Hochspannungsversorgung führt vom Ausgang des Wandlermoduls über die Anodenwiderstände und die NIXIE-Röhren zu den Kathodenausgängen der 74141/K155ID1. Der jeweils aktive Treiberausgang zieht die ausgewählte Kathode auf ein Potential nahe Masse. Anodenwiderstand und gezündete Röhre nehmen dabei den größten Teil der Versorgungsspannung auf. Nicht aktive Kathodenausgänge können dagegen erhöhte Potentiale annehmen und müssen die auftretende Sperrspannung sicher beherrschen. Die Logikeingänge der Treiber arbeiten unabhängig davon mit 5-V-Pegeln.
Die volle Versorgungsspannung von etwa 170 V liegt auf der Leiterplatte nur zwischen dem oberen Steckplatz des Hochspannungsmoduls und den Anodenwiderständen an. Im leitenden Strompfad fällt anschließend ein Teil der Spannung am Anodenwiderstand und der größere Teil als Brennspannung an der gezündeten Röhre ab. Der obere Leiterplattenbereich ist deshalb bewusst ohne Kupferflächen ausgeführt. Dies verbessert die Isolation und vermindert zugleich die kapazitive Kopplung in benachbarte Schaltungsteile.
Die folgende Tabelle fasst diese Spannungsverteilung überschlägig zusammen. Sie ersetzt keine Messung am konkreten Aufbau, zeigt aber die Größenordnung der Spannungen und Spannungsabfälle.
| Bereich / Messpunkt | Typische Spannung gegen Masse | Einordnung |
|---|---|---|
| Ausgang Hochspannungsmodul und Leiterzug bis zu den Anodenwiderständen | ca. +170 V DC | Hier liegt die eingespeiste Hochspannung nahezu vollständig an. Dieser Bereich bestimmt die Anforderungen an Isolation, Abstand und Verzicht auf unnötige Kupferflächen. |
| Anodenwiderstand, z. B. 10 kΩ bei ca. 3 mA Röhrenstrom | Spannungsabfall ca. 30 V | Der Widerstand begrenzt den Strom der Glimmentladung. Rechnerisch gilt U = R · I = 10 kΩ · 3 mA = 30 V. |
| Gezündete NIXIE-Röhre | ca. 140 V Brennspannung | Die genaue Brennspannung ist röhren- und stromabhängig. Sie ergibt sich hier überschlägig aus 170 V Versorgung minus 30 V am Anodenwiderstand. |
| Aktiver Kathodenausgang des 74141/K155ID1 | nahe 0 V, zuzüglich geringer Restspannung des leitenden Ausgangs | Der Treiber schaltet die ausgewählte Kathode gegen Masse und führt den Röhrenstrom. Die Logikeingänge des Treibers bleiben davon getrennt und arbeiten mit 5-V-Pegeln. |
| Nicht aktive Kathodenausgänge des Treibers | abhängig vom Röhrenzustand und der internen Treiberstruktur | Diese Ausgänge müssen Sperrspannungen aus dem Röhrenkreis verkraften. Der Treiberbereich ist deshalb weiterhin als Teil der Hochspannungsumgebung zu betrachten. |
| Sicherheit — 170 V sind berührungsgefährlich. Hochspannungsbereiche müssen mechanisch abgedeckt, ausreichend isoliert und nach dem Abschalten entladen werden. Messungen dürfen nur mit geeigneten Messleitungen und Messgeräten erfolgen. Änderungen an der Schaltung sind grundsätzlich spannungsfrei durchzuführen. |
|---|
Der ATmega328P ist für dieses Projekt ausreichend leistungsfähig und zugleich überschaubar. Er besitzt typische Mikrocontrollerfunktionen wie digitale Ein- und Ausgänge, Timer, externe Interrupts, I²C und SPI. Die Nutzung der Arduino-IDE vereinfacht Programmierung und Bibliothekseinbindung, ohne dass ein vollständiges Arduino-Board erforderlich ist.
Ein externer 16-MHz-Quarz mit zwei Lastkondensatoren bestimmt die Prozessoraktfrequenz. Der Reset-Eingang wird über einen Pull-up-Widerstand auf HIGH gehalten. Ein LOW-Pegel löst einen definierten Neustart aus.
Die ISP-Schnittstelle nutzt MOSI, MISO, SCK und RESET. Über sie können Bootloader, Fuse-Einstellungen und Anwenderprogramm direkt in den Mikrocontroller übertragen werden.
Das grundsätzliche Verhalten des Mikrocontrollers wird durch die Hardwarekonfiguration und die Software bestimmt. Die Fuse-Bits legen grundlegende Parameter fest, insbesondere Taktquelle, Startverhalten, Bootbereich und gegebenenfalls Brown-out-Überwachung. Der Bootloader ist dagegen ein kleines Programm im Flash-Speicher, das das Laden eines Anwenderprogramms über eine serielle Schnittstelle ermöglicht. Er ist nicht erforderlich, wenn die Programmierung über ISP erfolgt. Der Arduino-Core stellt anschließend Funktionen wie pinMode(), digitalWrite() und shiftOut() sowie die verwendeten Bibliotheksschnittstellen bereit.
Die korrekte Konfiguration der Fuse-Bits und die erstmalige Programmierung erfordern einige vorbereitende Schritte. Mit der Arduino-IDE lässt sich dieser Vorgang vereinfachen: Wird eine zum verwendeten ATmega328P passende Arduino-Nano-Konfiguration gewählt und der Bootloader über einen ISP-Programmer übertragen, setzt die IDE zugleich die zugehörigen Fuse-Bits. Der Mikrocontroller besitzt anschließend weitgehend die für ein Arduino-Nano-Board erwartete Konfiguration und kann in dieser Entwicklungsumgebung programmiert werden.
| Präzisierung — Fuse-Bits, Bootloader und Arduino-Core erfüllen unterschiedliche Aufgaben: Fuses definieren die grundlegende Hardwarekonfiguration, der Bootloader stellt einen optionalen Programmierweg bereit, und der Arduino-Core bildet die Laufzeit- und Bibliotheksumgebung. |
|---|
Die RTC mit DS3231 als Zeitreferenz ist eine batteriegepufferte Echtzeituhr mit temperaturkompensiertem Quarzoszillator. Die Kommunikation erfolgt über I²C mit den Leitungen SDA und SCL. Das Modul hält die Uhrzeit bei unterbrochener Hauptversorgung weiter vor und reduziert die Gangabweichung gegenüber einer reinen Softwarezeit.
DCF77 überträgt die gesetzliche Zeit Deutschlands auf 77,5 kHz im Langwellenbereich. Das DCF-2-Modul übernimmt Empfang und Demodulation. Der Mikrocontroller wertet die Impulsdauern aus und setzt bei einem gültigen Zeittelegramm sowohl die interne Zeit als auch den DS3231.
| Priorität | Quelle | Funktion |
|---|---|---|
| 1 | DCF77 | Externe Referenz; synchronisiert Systemzeit und RTC. |
| 2 | DS3231 | Kontinuierliche lokale Zeitbasis bei fehlendem oder gestörtem DCF77-Empfang. |
| 3 | Interne Softwarezeit | Rückfallebene, wenn weder DCF77 noch RTC verfügbar sind. |
Eine manuelle Einstellung über die beiden Taster wird ebenfalls in die RTC geschrieben. Dadurch bleibt die korrigierte Zeit nach einer Unterbrechung der Stromversorgung erhalten.
Das verwendete DCF-2-Modul der Firma ELV besitzt einen Open-Collector-Ausgang. Der Ausgangstransistor kann die Signalleitung aktiv nach Masse ziehen, erzeugt aber keinen eigenen HIGH-Pegel. R6 arbeitet deshalb als Pull-up-Widerstand auf der Seite der Uhr. Bei gesperrtem Ausgangstransistor entsteht dort ein definierter HIGH-Pegel, bei leitendem Transistor ein LOW-Pegel.
Der Open-Collector-Ausgang ermöglicht es, den Pull-up-Widerstand auf der Seite der auswertenden Uhr anzuordnen und den HIGH-Pegel dort lokal zu bilden. Dies ist bei längeren Verbindungen günstiger als ein unmittelbar vom Empfangsmodul ausgegebener Spannungssignalpegel, macht die Leitung jedoch nicht unempfindlich gegen eingekoppelte Störungen.
Das Hochspannungsmodul erzeugt in seiner Umgebung elektrische und magnetische Störungen, die den DCF77-Empfang beeinträchtigen können. Im vorliegenden Aufbau kann ein Abstand von etwa 30 cm zwischen Uhr und DCF77-Empfänger bereits ausreichen. Dieser Wert ist jedoch nur ein Erfahrungswert; der erforderliche Abstand hängt von der Empfangsfeldstärke, der Ausrichtung der Ferritantenne und der konkreten Einbausituation ab.
Auch bei einer Open-Collector-Anbindung können längere Verbindungsleitungen Störungen aufnehmen. Dabei werden vor allem kurze, höherfrequente Störanteile eingekoppelt, die die Auswertung des DCF77-Signals erschweren können. Ein passiver RC-Tiefpass dämpft solche Impulse, verringert jedoch zugleich die Flankensteilheit des Nutzsignals. Zu langsame oder durch Störungen überlagerte Signalübergänge können an einem gewöhnlichen Digitaleingang zu mehrfachen Pegelwechseln führen.
Eine weitergehende Ausführung könnte deshalb einen Schmitt-Trigger hinter dem Tiefpass vorsehen, um eindeutige Signalflanken wiederherzustellen. Im konkreten Aufbau ist die Zeitkonstante des Tiefpasses so gewählt, dass die DCF77-Impulse nur geringfügig verändert werden. Auf einen zusätzlichen Schmitt-Trigger konnte daher nach praktischer Erprobung verzichtet werden.
R9 = 6,8 kΩ und C4 = 100 nF bilden einen Tiefpass, der sehr kurze Störimpulse dämpft. Die Zeitkonstante beträgt:
τ = R · C = 6,8 kΩ · 100 nF = 680 µs
Die Grenzfrequenz beträgt näherungsweise:
f₍g₎ = 1 / (2πRC) ≈ 234 Hz
Die DCF77-Nutzimpulse dauern etwa 100 ms beziehungsweise 200 ms und werden deshalb nur unwesentlich verändert. Kurze hochfrequente Störimpulse werden dagegen deutlich abgeschwächt.
Die Uhr verarbeitet überwiegend langsam veränderliche Signale. Für die elektromagnetische Verträglichkeit bleiben dennoch zwei Baugruppen wesentlich: der empfindliche DCF77-Empfänger und der schaltende Hochspannungswandler. Elektrische und magnetische Störfelder des Wandlers können den Empfang beeinträchtigen; zusätzlich sind kapazitive Einkopplungen aus dem Hochspannungsbereich möglich. Für Aufbau und Leitungsführung sollten deshalb folgende Punkte berücksichtigt werden:
Ein Taster erhöht die Stunde, ein zweiter die Minute. Externe Widerstände erzeugen definierte Ruhepegel. Die Software entprellt die Kontakte, damit ein mechanischer Tastendruck nicht als Folge mehrerer Betätigungen interpretiert wird.
| Anzeige | Bedeutung |
|---|---|
| LED1 blinkt | DCF77-Synchronisation ist aktuell. |
| LED1 aus | Betrieb mit gültiger RTC-Zeit, aber ohne aktuelle DCF77-Synchronisation. |
| LED1 dauerhaft an | Weder aktuelle DCF77-Synchronisation noch gültige RTC-Zeit. |
| LED2 + LED3 | Dauerhaft leuchtender Doppelpunkt zwischen Stunden und Minuten. |
Eine NIXIE-Röhre enthält eine gemeinsame Anode und mehrere in Ziffernform ausgeführte Kathoden. In einer Edelgasfüllung entsteht bei ausreichender Spannung eine Glimmentladung in unmittelbarer Nähe der ausgewählten Kathode. Dadurch erscheint die Form der betreffenden Ziffer leuchtend.
Nach dem Zünden besitzt die Glimmentladung eine vergleichsweise geringe dynamische Impedanz. Ohne Vorwiderstand würde der Strom stark ansteigen. Der Anodenwiderstand begrenzt deshalb den Betriebsstrom.
Für eine angenommene Brennspannung von 140 V und einen Vorwiderstand von 10 kΩ gilt:
Uᵣ = 170 V − 140 V = 30 V
I = Uᵣ / R = 30 V / 10 kΩ = 3 mA
Pᵣ = I² · R = 0,09 W
Ein Widerstand mit 0,25 W Belastbarkeit ist rechnerisch ausreichend; 0,5 W bietet zusätzliche thermische Reserve. Die reale Brennspannung ist röhren- und stromabhängig, weshalb der Strom im Aufbau überprüft werden sollte.
Der 74141 beziehungsweise sein sowjetischer Verwandter K155ID1 übernimmt in der NIXIE-Uhr eine doppelte Aufgabe. Einerseits dekodiert der Baustein einen vierbitigen BCD-Code in genau einen von zehn Dezimalausgängen. Andererseits ist seine Ausgangsstufe dafür ausgelegt, die Kathoden einer NIXIE-Röhre gegen Masse zu schalten. Damit verbindet der IC die 5-V-Logikebene der digitalen Steuerung mit dem Hochspannungskreis der Anzeige.
Ein BCD-Code besteht aus vier Leitungen. Die Werte 0000 bis 1001 entsprechen den Dezimalziffern 0 bis 9. Der Treiber aktiviert jeweils denjenigen Ausgang, der zur angelegten Ziffer gehört. In der Schaltung bedeutet dies: Die gemeinsame Anode der Röhre liegt über einen Vorwiderstand an der Hochspannung, während der ausgewählte Kathodenanschluss durch den Treiber auf ein niedriges Potential gezogen wird. Nur an dieser Kathode kann sich dann die Glimmentladung ausbilden; die entsprechende Ziffer wird sichtbar.
Die Ausgänge sind nicht als gewöhnliche Logikausgänge zu verstehen. Sie arbeiten sinngemäß als offene Kollektorausgänge beziehungsweise als stromsenkende Ausgänge. Der aktive Ausgang liefert also keine positive Spannung, sondern stellt einen leitenden Pfad nach Masse bereit. Diese Betriebsweise passt gut zur NIXIE-Röhre, weil deren Ziffernkathoden einzeln gegen Masse geschaltet werden müssen. Die Strombegrenzung erfolgt nicht im Treiber-IC, sondern über den Anodenwiderstand der Röhre.
Für ungültige BCD-Codes oberhalb von 9, also 1010 bis 1111, geben Datenblatt und Vergleichsangaben ein besonderes Verhalten an: Bei 74141/K155ID1 werden die Ausgänge typischerweise abgeschaltet. Dieses Verhalten kann zur Dunkelschaltung einer Röhre genutzt werden, etwa beim Ausblenden führender Nullen. Es sollte jedoch nicht unkritisch als sicherheitsrelevante Abschaltung verstanden werden, da reale Röhren, Leckströme und Varianten einzelner Hersteller das sichtbare Verhalten beeinflussen können.
Die vorliegende Uhr verwendet für die Stunden-Zehnerstelle dennoch keine ungültige Pseudotetrade zur Dunkeltastung, sondern einen eindeutig dekodierten Wert mit nicht angeschlossener Kathode. Die konkrete Umsetzung wird in Abschnitt 13 beschrieben.
Schaltungstechnisch erklärt der Einsatz dieser Bausteine den vergleichsweise klaren Aufbau der Uhr. Pro Röhre werden nur vier digitale Steuerleitungen benötigt, während zehn Kathoden selektiv geschaltet werden können. Ohne einen solchen Dekoder wären entweder zehn einzelne Schalttransistoren pro Röhre oder eine zusätzliche Dekoderlogik mit nachgeschalteten Hochspannungstransistoren erforderlich. Der 74141/K155ID1 fasst diese beiden Funktionsgruppen in einem Baustein zusammen und reduziert damit Bauteilzahl, Leiterbahnführung und Fehlermöglichkeiten.
Bei den Zehnerstellen werden nicht alle Dezimalziffern benötigt. Die Stunden-Zehner können nur 1 oder 2 anzeigen; die Minuten-Zehner nur 0 bis 5. Nicht benötigte Kathodenleitungen können unbeschaltet bleiben. Dies reduziert den Routing-Aufwand und wird bei der Stunden-Zehnerstelle gezielt zur Dunkeltastung genutzt.
Technikhistorisch steht der 74141 für eine Übergangsphase der Elektronik. NIXIE-Röhren stammen aus einer Zeit, in der numerische Anzeigen noch häufig mit gasgefüllten Kaltkathodenröhren realisiert wurden. Die Logik zur Ansteuerung wanderte jedoch bereits in integrierte TTL-Schaltungen. Der Baustein verbindet daher zwei technische Generationen: die sichtbare Anzeige als Röhre und die digitale Verarbeitung als integrierte Halbleiterlogik. Genau dieser Übergang macht ihn für eine NIXIE-Uhr besonders interessant. Die Anzeige wirkt historisch, die Ansteuerung ist aber bereits eindeutig Teil der integrierten Digitalelektronik.
Der K155ID1 ist in diesem Zusammenhang ebenfalls bemerkenswert. Er ist funktional eng mit dem westlichen 74141 verwandt und wurde vor allem im Umfeld sowjetischer beziehungsweise osteuropäischer TTL-Logik eingesetzt. Da viele NIXIE-Röhren und passende Treiberbausteine aus diesem technischen Umfeld stammen, treffen auf einer solchen Uhr westliche CMOS- und Mikrocontrollertechnik, TTL-Logik und osteuropäische Anzeigetechnik unmittelbar aufeinander. Das ist kein rein dekorativer Effekt, sondern spiegelt reale Entwicklungslinien der Elektronikgeschichte wider.
Für die vorliegende Uhr ist der Baustein daher nicht nur eine praktische Lösung, sondern auch ein technisch passendes Bauteil. Er löst genau das historische Schnittstellenproblem, das bei NIXIE-Anzeigen entsteht: Eine niedrige digitale Logikspannung muss einzelne Elektroden in einem deutlich höheren Anzeigespannungskreis zuverlässig auswählen.
Bei der BCD-Codierung wird jede Dezimalziffer einzeln als vierstellige Binärzahl dargestellt. Die Eingänge A, B, C und D besitzen die Stellenwerte 1, 2, 4 und 8:
Ziffer = A · 1 + B · 2 + C · 4 + D · 8
| Dezimal | D | C | B | A |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 1 | 0 | 0 | 0 | 1 |
| 2 | 0 | 0 | 1 | 0 |
| 3 | 0 | 0 | 1 | 1 |
| 5 | 0 | 1 | 0 | 1 |
| 9 | 1 | 0 | 0 | 1 |
Die Uhrzeit wird in vier Ziffern zerlegt: Stunden-Zehner, Stunden-Einer, Minuten-Zehner und Minuten-Einer. Weil die Wertebereiche eingeschränkt sind, werden nicht für jede Stelle vier Leitungen benötigt.
Die vier NIXIE-Röhren werden nicht direkt vom Mikrocontroller angesteuert. Jede Röhre besitzt einen BCD-Treiber, der vier Eingangssignale benötigt. Bei vier Röhren ergäbe sich daraus ein Bedarf von bis zu 16 digitalen Ausgangsleitungen. Für einen Mikrocontroller wäre das zwar grundsätzlich möglich, es würde aber viele Anschlüsse binden, das Leiterplattenlayout vergrößern und spätere Erweiterungen erschweren. Die Uhr verwendet deshalb eine seriell-parallele Datenübertragung mit zwei kaskadierten CD4094-Schieberegistern.
Bei einer parallelen Datenübertragung liegen mehrere Bits gleichzeitig auf getrennten Leitungen an. Der Vorteil besteht darin, dass ein vollständiger Datenwert sofort verfügbar ist. Der Nachteil ist der hohe Leitungsbedarf. Werden beispielsweise 16 Steuerbits parallel übertragen, müssen auch 16 Signalleitungen vom Mikrocontroller zu den nachfolgenden Schaltungsteilen geführt werden.
Bei einer seriellen Datenübertragung werden die Bits dagegen nacheinander über eine gemeinsame Datenleitung übertragen. Zusätzlich wird ein Taktsignal benötigt, das festlegt, wann ein Bit übernommen wird. Der Leitungsbedarf ist deutlich geringer, dafür muss der Empfänger die nacheinander eintreffenden Bits zwischenspeichern und wieder als paralleles Signal bereitstellen.
Genau diese Aufgabe übernimmt der CD4094. Er ist ein 8-stufiges Schiebe- und Speicherregister mit seriellem Eingang und parallelen Ausgängen. Das Datenblatt beschreibt den Baustein als Register, bei dem die Daten seriell eingeschoben und anschließend über ein Speicherregister auf parallele Ausgänge übernommen werden. Damit eignet er sich unmittelbar für die Umwandlung weniger Mikrocontrollerleitungen in mehrere gleichzeitig verfügbare Steuersignale.
Der CD4094 besitzt funktional zwei Ebenen. Die erste Ebene ist das Schieberegister. Dort werden die Bits nacheinander mit jeder Taktflanke aufgenommen. Die zweite Ebene ist das Ausgangslatch beziehungsweise Speicherregister. Erst wenn das Strobe-Signal aktiviert wird, wird der zuvor eingeschobene Registerinhalt auf die parallelen Ausgänge übernommen.
Diese Trennung ist für die Anzeige wichtig. Während die 16 Bits nacheinander eingeschoben werden, dürfen sich die sichtbaren Ziffern nicht bei jedem einzelnen Bitwechsel verändern. Die bisherigen Ausgangszustände bleiben deshalb während des Schiebevorgangs erhalten. Erst nach vollständiger Übertragung wird mit dem Strobe-Impuls der gesamte neue Zustand übernommen. Dadurch wechseln alle BCD-Signale praktisch gleichzeitig. Sichtbare Zwischenziffern oder kurzzeitige Fehldekodierungen werden vermieden.
Der Ablauf besteht damit aus drei einfachen Signalvorgängen: DAT legt das nächste serielle Datenbit fest, mit jeder CLK-Flanke wird dieses Bit in die Registerkette übernommen, und STR übernimmt nach 16 Takten beide Registerinhalte gleichzeitig in die Ausgangslatches.
Ein einzelner CD4094 stellt acht parallele Ausgänge bereit. Für die vier BCD-Treiber der Uhr werden insgesamt 16 Steuerbits benötigt. Daher werden zwei CD4094 hintereinandergeschaltet. Der serielle Ausgang des ersten Bausteins speist den seriellen Eingang des zweiten. Die Daten laufen also bitweise durch das erste Register hindurch und weiter in das zweite Register.
Nach 16 Takten sind beide Register vollständig geladen. Anschließend übernimmt ein gemeinsamer Strobe-Impuls beide Registerinhalte in die Ausgangslatches. Aus Sicht der NIXIE-Treiber entstehen dadurch 16 parallele Signale, obwohl der Mikrocontroller nur wenige Steuerleitungen benötigt.
Die Uhr verwendet drei wesentliche Signale:
Damit wird die Steuerung der vier Röhren von bis zu 16 direkten Mikrocontrollerleitungen auf drei Steuerleitungen reduziert. Die 16 Ausgangsbits bleiben dennoch als parallele BCD-Signale für die vier 74141/K155ID1-Treiber verfügbar.
Das Minutenregister liegt näher am Mikrocontroller, das Stundenregister folgt in der Kette. Deshalb werden zuerst die Stunden und anschließend die Minuten übertragen. Das zuerst geschobene Byte wird durch das erste Register hindurch bis in das zweite weitergereicht.
shiftOut(PIN_DRV_DAT, PIN_DRV_CLK, MSBFIRST, hourByte);
shiftOut(PIN_DRV_DAT, PIN_DRV_CLK, MSBFIRST, minuteByte);Das folgende Oszillogramm zeigt diesen Übertragungsvorgang an den drei Steuersignalen. CLOCK taktet die Bits in die Schieberegister, DATA führt die Bitfolge für Stunden- und Minutenregister, und STROBE übernimmt den vollständig eingeschobenen Registerinhalt erst am Ende in die Ausgangslatches. Dadurch bleiben die sichtbaren Ausgangssignale während des Schiebens stabil.
Die gewählte Architektur ist für diese Uhr besonders passend, weil die Anzeige keine hohe Datenrate benötigt. Die Uhrzeit ändert sich nur langsam. Selbst wenn die Register regelmäßig neu beschrieben werden, sind 16 serielle Takte gegenüber den zeitlichen Anforderungen einer Uhr vernachlässigbar. Der Geschwindigkeitsnachteil serieller Übertragung spielt daher praktisch keine Rolle.
Der Vorteil ist dagegen erheblich: Die Zahl der Mikrocontrollerleitungen sinkt deutlich, das Leiterplattenlayout wird übersichtlicher, und die Trennung zwischen Logiksteuerung und Anzeigetreibern bleibt klar.
Die Lösung ist damit kein Kompromiss aus Mangel an Anschlüssen, sondern eine sachgerechte Architekturentscheidung. Für eine statische NIXIE-Uhr mit vier Ziffern sind wenige Steuerleitungen, stabile Ausgangszustände und eine klare Registerstruktur wichtiger als eine parallele Direktanbindung aller BCD-Eingänge.
Ein zusätzlicher Entwurfsaspekt ergibt sich aus der Kombination unterschiedlicher Logikfamilien. Der CD4094 gehört zur CMOS-Logik, während die Eingänge der 74141/K155ID1-Treiber klassisch TTL-orientiert sind. Beide Schaltungsteile können zwar mit 5 V betrieben werden, daraus folgt aber nicht automatisch in jedem Fall eine uneingeschränkte Pegelkompatibilität.
TTL-Logik bewertet Eingangsspannungen nach anderen Schwellen als CMOS-Logik. Klassische TTL-Eingänge erkennen einen niedrigen Pegel typischerweise sicher unterhalb von etwa 0,8 V und einen hohen Pegel oberhalb von etwa 2,0 V. CMOS-Eingänge und -Ausgänge orientieren sich dagegen stärker an der jeweiligen Versorgungsspannung. Bei 5 V Versorgung liefern CMOS-Ausgänge im unbelasteten Zustand meist nahezu 0 V beziehungsweise nahezu 5 V. Damit können sie TTL-Eingänge grundsätzlich gut ansteuern, solange die Ausgangsbelastung gering bleibt und die Versorgungsspannungen sauber definiert sind.
Problematisch kann die Schnittstelle werden, wenn Bausteine verschiedener Hersteller, abweichende Versorgungsspannungen, lange Leitungen, zusätzliche Lasten oder ungünstige Eingangsbeschaltungen zusammenkommen. Auch das Einschaltverhalten ist zu beachten: Während Versorgungsspannungen ansteigen, können undefinierte Pegel entstehen, die bei Dekoder- und Anzeigeschaltungen kurzzeitig sichtbare oder elektrisch unerwünschte Zustände verursachen.
Für die NIXIE-Uhr ist die Kombination dennoch nachvollziehbar. Die CD4094-Ausgänge treiben nur die Logikeingänge der NIXIE-Treiber und keine hohen Lastströme. Bei gemeinsamer 5-V-Versorgung und kurzen Leiterbahnen auf derselben Platine ist die Pegelsituation beherrschbar. Trotzdem ist diese Stelle eine echte Schnittstelle zwischen Logikfamilien und sollte nicht nur als beliebige digitale Verbindung verstanden werden.
Als Alternative kommen CMOS-Schieberegister aus der 74HCT-Familie in Betracht. Ihre Eingänge besitzen TTL-kompatible Schaltschwellen, was insbesondere dann relevant ist, wenn TTL-Ausgänge ein CMOS-Register ansteuern. In der vorliegenden Uhr verläuft die betrachtete Signalrichtung jedoch vom Register zu den TTL-Eingängen der NIXIE-Treiber. Hier sind vor allem die garantierten HIGH- und LOW-Ausgangspegel sowie die Ausgangsbelastbarkeit des Registers unter den tatsächlichen Betriebsbedingungen maßgeblich. Ein HCT-Schieberegister ist daher nicht automatisch die bessere Lösung, kann die Einbindung in ein gemischtes Logiksystem aber erleichtern, sofern Registerfunktion, Zeitverhalten und Anschlussbelegung zur Schaltung passen.
Für diese Uhr bleibt der CD4094 jedoch eine sachgerechte Wahl, sofern die praktische Beschaltung geprüft ist: gemeinsame 5-V-Logikversorgung, kurze Leiterbahnen, stabile Versorgung, definierte Reset- beziehungsweise Einschaltzustände und keine nennenswerte Zusatzlast an den Registerausgängen.
Auch technikhistorisch passt der CD4094 gut in die Schaltung. Die CD4000-Familie steht für CMOS-Logik mit geringem Ruhestrom, weitem Versorgungsspannungsbereich und vergleichsweise einfacher Verschaltung. Während die 74141/K155ID1-Treiber die spezifische Schnittstelle zur NIXIE-Röhre bilden, übernimmt der CD4094 eine typische digitale Hilfsfunktion: Er erweitert die Anzahl nutzbarer Ausgänge, ohne die Mikrocontrollerseite unnötig zu belasten.
Damit kombiniert die Uhr mehrere Logikgenerationen und Funktionsprinzipien: moderne Mikrocontrollersteuerung, CMOS-Schieberegister, TTL-nahe NIXIE-Treiber und gasgefüllte Kaltkathodenanzeigen.
| Bit | CD4094-Ausgang | Funktion |
|---|---|---|
| 0 | Q1 | Stunden-Zehner A |
| 1 | Q2 | Stunden-Zehner B |
| 2 | Q3 | Stunden-Einer A |
| 3 | Q4 | Stunden-Einer B |
| 4 | Q5 | Stunden-Einer C |
| 5 | Q6 | Stunden-Einer D |
| 6 | Q7 | unbenutzt |
| 7 | Q8 | unbenutzt |
Die Software bildet das Byte nach dem Prinzip:
hourByte = (Stunden-Zehner & 0x03) | ((Stunden-Einer & 0x0F) << 2);
| Bit | CD4094-Ausgang | Funktion |
|---|---|---|
| 0 | Q1 | Minuten-Zehner A |
| 1 | Q2 | Minuten-Zehner B |
| 2 | Q3 | Minuten-Zehner C |
| 3 | Q4 | Minuten-Einer A |
| 4 | Q5 | Minuten-Einer B |
| 5 | Q6 | Minuten-Einer C |
| 6 | Q7 | Minuten-Einer D |
| 7 | Q8 | unbenutzt |
Die Software bildet das Byte nach dem Prinzip:
minuteByte = (Minuten-Zehner & 0x07) | ((Minuten-Einer & 0x0F) << 3);
Bei Uhrzeiten unter 10 Uhr soll keine führende Null erscheinen. Die Software gibt deshalb an der Stunden-Zehnerstelle den BCD-Code 3 aus:
D C B A = 0 0 1 1
Der 74141 aktiviert damit den Ausgang für die Ziffer 3. Diese Kathode ist an der Stunden-Zehnerröhre bewusst nicht angeschlossen. Es entsteht kein Strompfad, und die Röhre bleibt dunkel. Die Lösung benötigt weder einen zusätzlichen Transistor noch einen speziellen Blank-Eingang.
| Hardware-Software-Kopplung — Die Dunkeltastung entsteht erst durch das koordinierte Zusammenwirken von Softwarecode und absichtlich unbeschalteter Kathodenleitung. Sie ist ein anschauliches Beispiel dafür, dass sich eine Funktion häufig nicht allein der Hardware oder allein der Software zuordnen lässt. |
|---|
Zur Versorgung der NIXIE-Röhren ist eine geeignete Hochspannungsquelle erforderlich. Grundsätzlich kann sie selbst aufgebaut oder als fertiges Modul eingebunden werden, sofern Ausgangsspannung, Leistung, Sicherheit und Störemissionen zur Schaltung passen. Für diese Uhr wurde ein fertiges Modul gewählt, weil Hochspannungswandler zwar gut beherrschbar, im Detail aber anspruchsvoll auszulegen sind.
Zum Einsatz kommen Miniatur-Hochspannungsnetzteile von Taylor Electronics. Sie sind für diese Anwendung gut geeignet, weil sie dokumentierte technische Daten besitzen, die Ausgangsspannung über einen Widerstand festgelegt wird und sich die Module in vergleichbaren NIXIE-Aufbauten praktisch bewährt haben.
R11 = 47 kΩ ist mit RADJUST verbunden und stellt das Modul auf ungefähr 170 V ein; das Datenblatt nennt für diesen Wert rund 170,4 V.
Das verwendete Taylor-Hochspannungsmodul gehört zur Reihe 1363/1364/1554 HVPS. Das Datenblatt beschreibt diese Module als Miniatur-Flyback-Aufwärtswandler für Eingangsspannungen von 2 V bis 16 V DC. Die Standardausführung stellt eine Ausgangsspannung im Bereich von etwa 150 V bis 200 V DC bereit. Die Einstellung erfolgt nicht über ein Potentiometer, sondern über den Anschluss RADJUST, der mit einem Widerstand gegen Masse beschaltet wird.
Für die NIXIE-Uhr ist diese Art der Einstellung vorteilhaft, weil die Hochspannung reproduzierbar über einen festen Widerstandswert festgelegt werden kann. Für eine Ausgangsspannung von ungefähr 170 V nennt das Datenblatt als rechnerischen Wert 48,9 kΩ. Mit Standardwerten aus der E-Reihe ergeben sich laut Datenblatt 47 kΩ = 170,4 V beziehungsweise 51 kΩ = 169,5 V. Der in der Uhr verwendete Wert von 47 kΩ ist damit eine datenblattkonforme Wahl.
Ein besonders wichtiger Hinweis betrifft den Enable-Eingang. Das Datenblatt weist ausdrücklich darauf hin, dass dieser Eingang bei angelegter Versorgung nicht offen bleiben darf. Ein undefinierter Enable-Pegel kann zu undefiniertem Betrieb führen und das Modul beschädigen. Der Enable-Eingang muss daher immer aktiv beschaltet werden. Für den Abschaltzustand nennt das Datenblatt einen Bereich von 0 V bis 0,45 V; als eingeschaltet gilt der Bereich ab etwa 1,20 V bis zur jeweiligen Eingangsspannung VIN. Zwischen diesen Bereichen liegt ein undefinierter Zustand.
Das Modul kann über den Enable-Eingang grundsätzlich durch eine Logikschaltung oder einen Mikrocontroller geschaltet werden. Dabei ist aber zu beachten, dass das Datenblatt ein schnelles wiederholtes Ein- und Ausschalten über längere Zeit ausdrücklich nicht vorsieht. Als Richtwert wird eine minimale Einschaltzeit von etwa 10 s genannt. Für die NIXIE-Uhr ist dies unkritisch, solange die Hochspannung nur zum bewussten Ein- und Ausschalten der Anzeige verwendet wird, etwa für eine Nachtabschaltung. Der Enable-Eingang sollte dagegen nicht zur schnellen Helligkeitsregelung oder zum Multiplexbetrieb der Hochspannung verwendet werden.
Auch die Eingangsbeschaltung ist nicht beliebig. Da es sich um einen Flyback-Wandler handelt, entnimmt das Modul der Niederspannungsversorgung gepulste Ströme. Das Datenblatt empfiehlt einen Eingangskondensator von 330 µF / 16 V, wenn das Modul weiter von der Hauptpufferung der Schaltung entfernt sitzt. In einem kompakten Aufbau mit gemeinsamer Leiterplatte kann die vorhandene Pufferung ausreichen; trotzdem sollte die Versorgung niederimpedant geführt und lokal ausreichend gestützt werden.
Die Leistungsbilanz passt zur Anwendung in der Uhr. Bei vier IN-12-Röhren mit jeweils ungefähr 3 mA Anodenstrom ergibt sich ein Hochspannungsstrom von etwa 12 mA. Bei 170 V entspricht das einer Ausgangsleistung von rund 2 W. Damit bleibt die Anwendung im Bereich, für den das Modul vorgesehen ist. Dennoch sollte die thermische Situation im fertigen Gerät beachtet werden, weil Wirkungsgrad, Eingangsspannung, Luftzirkulation und Einbaulage die Erwärmung beeinflussen.
Das Datenblatt enthält außerdem einen wichtigen mechanischen Hinweis zum Transformatorbereich. Leitfähige Materialien in unmittelbarer Nähe des Transformators, etwa metallische Gehäuseteile, Kühlkörper, große Kupferflächen oder auch berührbare leitfähige Flächen, können magnetisch oder kapazitiv Energie aus dem Wandler auskoppeln. Dies kann die Effizienz verschlechtern und hörbares Schwingen begünstigen. Für den Leiterplattenentwurf bedeutet dies, dass der Transformatorbereich freigehalten und nicht unnötig mit Kupferflächen oder leitfähigen Gehäuseteilen gekoppelt werden sollte.
Für die Uhr ist außerdem die räumliche Anordnung gegenüber empfindlichen Baugruppen relevant. Der Hochspannungswandler arbeitet als Schaltnetzteil und kann elektrische sowie magnetische Störungen erzeugen. Der DCF77-Empfänger mit Ferritantenne sollte daher räumlich vom Modul getrennt werden. Kurze Leitungen im Hochspannungsbereich, eine saubere Masseführung, ausreichende Abstände und eine lokale Eingangspufferung vermindern die Gefahr störender Einkopplungen.
Zusammengefasst ist das Taylor-Modul für die NIXIE-Uhr gut geeignet, wenn seine Randbedingungen beachtet werden: definierter Enable-Pegel, feste Spannungseinstellung über RADJUST, keine offene Enable-Leitung, keine schnelle Dauer-Taktung des Enable-Eingangs, ausreichende Eingangspufferung, keine Verpolung der Eingangsspannung, mechanische Freihaltung des Transformatorbereichs und angemessene Hochspannungsabstände.
Das Programm verbindet die Zeitquellen, die Bedienung und die Anzeigeansteuerung. Die Hauptschleife ist bewusst einfach aufgebaut und wiederholt zyklisch die folgenden Schritte:
| Signal | ATmega-/Arduino-Pin | Funktion |
|---|---|---|
| DCF | 2 / INT0 | DCF77-Eingang |
| SET-MIN | 3 | Minutentaster |
| SET-HOUR | 4 | Stundentaster |
| CLK | 5 | Schiebetakt CD4094 |
| STR | 6 | Übernahmeimpuls |
| DAT | 7 | Serielle Daten |
| STATUS | 13 | Betriebszustands-LED |
| SDA | A4 / 18 | I²C-Daten |
| SCL | A5 / 19 | I²C-Takt |
Die Leiterplatte übernimmt nicht nur die elektrische Verbindung der Baugruppen, sondern bestimmt zugleich deren sichtbare technische Ordnung. Röhren, Treiber-ICs, Schieberegister und Mikrocontroller sind so angeordnet, dass sich Signalweg und Funktionsgruppen auch am aufgebauten Gerät nachvollziehen lassen. Die folgenden Aufnahmen zeigen den Übergang von der unbestückten Leiterplatte über die schrittweise Bestückung bis zum Versuchsaufbau vor dem Einbau in das Gehäuse.
Zum Steuerprogramm liegt eine separate Programmdokumentation vor. Sie beschreibt den Arduino-Sketch DCF_Clock_V4a.ino im Zusammenhang mit der NIXIE-Uhr und verfolgt den Weg vom DCF77-Zeittelegramm über die interne Zeitverwaltung bis zur Ausgabe der vierstelligen Anzeige.
Behandelt werden unter anderem Softwarearchitektur, Priorität der Zeitquellen DCF77, DS3231 und TimeLib, Pinbelegung, Bibliotheken, Programmstart und Selbsttest, Bildung der NIXIE-Anzeigedaten, Ablauf der Hauptschleife, Bedienung, Statusanzeige, typische Grenzfälle sowie Hinweise zu Diagnose, Inbetriebnahme und späterer Erweiterbarkeit.
Programmdokumentation DCF_Clock_V4a als PDF öffnen
Der vollständige Quellcode ist zusätzlich als Datei verfügbar und kann in der folgenden Code-Box direkt gelesen oder durch Markieren kopiert werden.
Quellcode DCF_Clock_V4a.ino öffnen
// ============================================================================
// NIXIE CLOCK V4a
// DCF77-synchronized controller for a four-digit HH:MM display
// (c) Thomas Liebe, 2026
// ============================================================================
//
// Target hardware:
// - ATmega328P / Arduino Nano compatible board at 16 MHz
// - Two cascaded CD4094 shift/latch registers
// - Four 74141 BCD-to-decimal Nixie drivers
// - DS3231 real-time clock
// - Active-low DCF77 receiver input
// - Separate hour and minute adjustment switches
//
// Timekeeping:
// - TimeLib holds the active system clock.
// - A valid DS3231 refreshes the system clock once per displayed second.
// - A valid DCF77 telegram corrects both the system clock and the RTC.
//
// Status LED:
// - Blinking: valid DCF77 update received within the last two minutes
// - Off : no recent DCF77 update, but valid RTC time is available
// - On : system-clock fallback without valid RTC or recent DCF77 data
//
// The LED and Nixie startup test is always executed. Serial initialization is
// included only when ENABLE_SERIAL_DEBUG is nonzero.
//
// Author: Thomas F. Liebe
// Version: 4a
// Documentation revision: 2026-08-03
// ============================================================================
// ---------------------------------------------------------------------------
// Section 1: Included Libraries
// ---------------------------------------------------------------------------
#include "DCF77.h"
#include "Time.h"
#include <ezButton.h>
#include <RTClib.h>
#include <Wire.h>
// ---------------------------------------------------------------------------
// Section 2: Compile-Time and Hardware Configuration
// ---------------------------------------------------------------------------
// Optional serial interface. The release default is disabled. It can also be
// enabled externally with the compiler option -DENABLE_SERIAL_DEBUG=1.
#ifndef ENABLE_SERIAL_DEBUG
#define ENABLE_SERIAL_DEBUG 0
#endif
// External interrupt 0 is fixed to digital pin 2 on ATmega328P.
constexpr uint8_t DCF_INTERRUPT = 0;
// ---------------------------------------------------------------------------
// Section 3: Pin Definitions
// ---------------------------------------------------------------------------
constexpr uint8_t PIN_DCF_INPUT = 2; // Open-collector DCF77 signal
constexpr uint8_t PIN_STATUS_LED = 13; // System-state LED
// Three-wire interface to both cascaded CD4094 registers.
constexpr uint8_t PIN_DRV_CLK = 5; // Shift clock
constexpr uint8_t PIN_DRV_STR = 6; // Output-register strobe
constexpr uint8_t PIN_DRV_DAT = 7; // Serial data
// Wire automatically uses the fixed ATmega328P I2C pins:
// A5 / digital pin 19 = SCL, A4 / digital pin 18 = SDA.
constexpr uint8_t PIN_BUTTON_HOUR = 4;
constexpr uint8_t PIN_BUTTON_MINUTE = 3;
// ---------------------------------------------------------------------------
// Section 4: Timing and Status Constants
// ---------------------------------------------------------------------------
// The visible startup test is intentionally always enabled.
constexpr uint8_t STARTUP_LED_BLINKS = 30;
constexpr unsigned long STARTUP_LED_DELAY_MS = 80UL;
// Keep the DCF state valid across one delayed or missed minute telegram.
constexpr unsigned long DCF_SYNC_TIMEOUT_MS = 2UL * 60UL * 1000UL;
// ---------------------------------------------------------------------------
// Section 5: Runtime State
// ---------------------------------------------------------------------------
// RTC reachability and RTC time validity are intentionally separate states.
// DCF age is measured with millis(), so manual or RTC time corrections cannot
// make a recent DCF update appear older or newer.
time_t lastDisplayedSecond;
unsigned long lastDcfSyncMillis = 0; // Monotonic DCF update time
bool dcfEverSynchronized = false;
bool rtcIsPresent = false;
bool rtcTimeIsValid = false;
// ---------------------------------------------------------------------------
// Section 6: Peripheral Objects
// ---------------------------------------------------------------------------
RTC_DS3231 rtcModule;
// false selects the active-low DCF77 pulse polarity used by the PCB.
DCF77 dcfReceiver = DCF77(PIN_DCF_INPUT, DCF_INTERRUPT, false);
// Keep INPUT: this exact setting is verified on the existing hardware.
// With this ezButton polarity, isReleased() represents the physical
// HIGH-to-LOW edge that occurs when a switch is pressed.
ezButton buttonHour(PIN_BUTTON_HOUR, INPUT);
ezButton buttonMinute(PIN_BUTTON_MINUTE, INPUT);
// ============================================================================
// Section 7: Nixie Display Control
// ============================================================================
//
// Register bit assignment:
//
// hourByte
// Bits 1..0 : hour tens
// Bits 5..2 : hour ones
// Bits 7..6 : unused
//
// minuteByte
// Bits 2..0 : minute tens
// Bits 6..3 : minute ones
// Bit 7 : unused
//
// Hours are shifted first so they pass through the first CD4094 into the
// second register. Minutes are shifted afterwards and remain in the first.
// ---------------------------------------------------------------------------
// 7.1 Transfer Both Register Bytes
// ---------------------------------------------------------------------------
// STR remains LOW while shifting, so intermediate bit patterns never reach
// the visible outputs. The final HIGH-to-LOW pulse updates all tubes together.
void shiftNixieBytes(uint8_t hourByte, uint8_t minuteByte) {
digitalWrite(PIN_DRV_STR, LOW);
shiftOut(PIN_DRV_DAT, PIN_DRV_CLK, MSBFIRST, hourByte);
shiftOut(PIN_DRV_DAT, PIN_DRV_CLK, MSBFIRST, minuteByte);
digitalWrite(PIN_DRV_STR, HIGH);
digitalWrite(PIN_DRV_STR, LOW);
}
// ---------------------------------------------------------------------------
// 7.2 Convert HH:MM into the Register Bit Pattern
// ---------------------------------------------------------------------------
// This function uses explicit values and does not modify the system clock.
// The startup display test can therefore use it without changing the time.
void writeNixieDisplay(uint8_t displayHour, uint8_t displayMinute) {
uint8_t hourByte = 0;
uint8_t minuteByte = 0;
// Hour tens need only two bits. For hours below 10, code 3 selects an
// unconnected decoder output and blanks the leading-zero tube.
if (displayHour > 9) {
hourByte |= ((displayHour / 10) & 0x03);
} else {
hourByte |= 0x03;
}
// Hour ones use a full four-bit BCD value in bits 5..2.
hourByte |= ((displayHour % 10) & 0x0F) << 2;
// Minute tens require three bits for values 0 through 5.
minuteByte |= ((displayMinute / 10) & 0x07);
// Minute ones use a full four-bit BCD value in bits 6..3.
minuteByte |= ((displayMinute % 10) & 0x0F) << 3;
shiftNixieBytes(hourByte, minuteByte);
}
// ---------------------------------------------------------------------------
// 7.3 Update the Display from One Time Snapshot
// ---------------------------------------------------------------------------
void updateNixieDisplay(time_t displayTime) {
writeNixieDisplay(hour(displayTime), minute(displayTime));
}
// ---------------------------------------------------------------------------
// 7.4 Force a Defined Dark Display
// ---------------------------------------------------------------------------
// The tens positions select unconnected decoder outputs. The ones positions
// use invalid BCD code 15, which switches off every 74141 cathode output.
void blankNixieDisplay() {
constexpr uint8_t blankHourByte = 0x3F;
constexpr uint8_t blankMinuteByte = 0x7F;
shiftNixieBytes(blankHourByte, blankMinuteByte);
}
// ============================================================================
// Section 8: Arduino Setup
// ============================================================================
void setup() {
// -------------------------------------------------------------------------
// 8.1 Optional Serial Interface
// -------------------------------------------------------------------------
#if ENABLE_SERIAL_DEBUG
Serial.begin(57600);
#endif
// -------------------------------------------------------------------------
// 8.2 RTC Detection
// -------------------------------------------------------------------------
// A reachable RTC is not necessarily a valid time source. The Lost-Power
// flag is therefore stored independently from module presence.
rtcIsPresent = rtcModule.begin();
if (rtcIsPresent) {
rtcTimeIsValid = !rtcModule.lostPower();
}
// -------------------------------------------------------------------------
// 8.3 Pin Initialization
// -------------------------------------------------------------------------
pinMode(PIN_STATUS_LED, OUTPUT);
pinMode(PIN_DCF_INPUT, INPUT);
pinMode(PIN_DRV_CLK, OUTPUT);
pinMode(PIN_DRV_STR, OUTPUT);
pinMode(PIN_DRV_DAT, OUTPUT);
// Establish defined driver levels and blank the always-enabled outputs
// before any visible startup delay can expose random register contents.
digitalWrite(PIN_DRV_CLK, LOW);
digitalWrite(PIN_DRV_STR, LOW);
digitalWrite(PIN_DRV_DAT, LOW);
blankNixieDisplay();
// Preserve the hardware-tested button configuration.
pinMode(PIN_BUTTON_HOUR, INPUT);
pinMode(PIN_BUTTON_MINUTE, INPUT);
// -------------------------------------------------------------------------
// 8.4 Mandatory LED and Nixie Self-Test
// -------------------------------------------------------------------------
for (uint8_t i = 0; i < STARTUP_LED_BLINKS; i++) {
digitalWrite(PIN_STATUS_LED, !digitalRead(PIN_STATUS_LED));
delay(STARTUP_LED_DELAY_MS);
}
// Display all hour and minute values without changing system time.
for (uint8_t h = 0; h < 24; h++) {
writeNixieDisplay(h, 0);
delay(100);
}
for (uint8_t m = 0; m < 60; m++) {
writeNixieDisplay(23, m);
delay(100);
}
// -------------------------------------------------------------------------
// 8.5 Fallback Time and DCF77 Start
// -------------------------------------------------------------------------
// Use a deterministic fallback until RTC or DCF77 supplies valid time.
setTime(0, 0, 0, 1, 1, 2000);
updateNixieDisplay(now());
delay(1500);
// DCF reception begins after the intentionally blocking startup test.
dcfReceiver.Start();
// Record the current second to avoid an immediate duplicate update.
lastDisplayedSecond = now();
}
// ============================================================================
// Section 9: Main Program Loop
// ============================================================================
void loop() {
// Keep the hardware-tested input sampling interval.
delay(100);
// -------------------------------------------------------------------------
// 9.1 Process a New DCF77 Time
// -------------------------------------------------------------------------
// getTime() returns zero until a newly validated telegram is available.
time_t dcfTime = dcfReceiver.getTime();
if (dcfTime != 0) {
setTime(dcfTime);
lastDcfSyncMillis = millis();
dcfEverSynchronized = true;
if (rtcIsPresent) {
rtcModule.adjust(DateTime(dcfTime));
rtcTimeIsValid = true;
}
}
// -------------------------------------------------------------------------
// 9.2 Process Manual Hour and Minute Adjustment
// -------------------------------------------------------------------------
buttonHour.loop();
buttonMinute.loop();
// isReleased() intentionally represents the physical press edge here;
// see the button-object comment in Section 6.
if (buttonHour.isReleased()) {
const time_t buttonTime = now();
const uint8_t newHour = (hour(buttonTime) + 1) % 24;
setTime(newHour, minute(buttonTime), second(buttonTime),
day(buttonTime), month(buttonTime), year(buttonTime));
if (rtcIsPresent) {
const time_t adjustedTime = now();
rtcModule.adjust(DateTime(adjustedTime));
rtcTimeIsValid = true;
}
}
if (buttonMinute.isReleased()) {
const time_t buttonTime = now();
const uint8_t newMinute = (minute(buttonTime) + 1) % 60;
setTime(hour(buttonTime), newMinute, 0,
day(buttonTime), month(buttonTime), year(buttonTime));
if (rtcIsPresent) {
const time_t adjustedTime = now();
rtcModule.adjust(DateTime(adjustedTime));
rtcTimeIsValid = true;
}
}
// -------------------------------------------------------------------------
// 9.3 Synchronize RTC, Update Display, and Set Status LED
// -------------------------------------------------------------------------
// One snapshot supplies all fields used during this update cycle.
time_t currentTime = now();
// RTC status and time are read at most once per new system second.
if (lastDisplayedSecond != currentTime) {
if (rtcIsPresent && rtcTimeIsValid) {
if (rtcModule.lostPower()) {
rtcTimeIsValid = false;
} else {
const DateTime rtcTime = rtcModule.now();
setTime(rtcTime.hour(), rtcTime.minute(), rtcTime.second(),
rtcTime.day(), rtcTime.month(), rtcTime.year());
currentTime = now();
}
}
updateNixieDisplay(currentTime);
lastDisplayedSecond = currentTime;
// Unsigned subtraction remains valid when millis() rolls over.
const unsigned long currentMillis = millis();
const bool dcfIsRecent =
dcfEverSynchronized &&
(currentMillis - lastDcfSyncMillis < DCF_SYNC_TIMEOUT_MS);
// LED: blinking = recent DCF, off = RTC, on = fallback only.
if (!dcfIsRecent) {
if (rtcTimeIsValid) digitalWrite(PIN_STATUS_LED, LOW);
else digitalWrite(PIN_STATUS_LED, HIGH);
} else {
digitalWrite(PIN_STATUS_LED, second(currentTime) % 2);
}
}
}