Multiplexer (MUX) entmystifiziert: Die Verkehrssteuerung für Daten

Kurz gesagt: Ein Multiplexer wählt mit einem $n$-Bit-Auswahlcode einen von $2^n$ Dateneingängen. Für einen 4-zu-1-MUX gilt $Y=\overline{S_1}\overline{S_0}D_0+\overline{S_1}S_0D_1+S_1\overline{S_0}D_2+S_1S_0D_3$. Konstante Werte an den Dateneingängen machen einen MUX zur Umsetzung einer Wahrheitstabelle, während echte FPGA-LUTs gespeicherte Konfiguration mit architekturspezifischer Auswahlschaltung verbinden.

Multiplexer wählen Operandenquellen in Prozessoren, Antworten in Verbindungsnetzen und konfigurierte Signale in programmierbarer Logik aus. Analoge und Video-Schalter lösen ein verwandtes Weiterleitungsproblem, ihr elektrisches Verhalten geht jedoch über das eines digitalen Ein-Bit-MUX hinaus. Dieser Leitfaden behandelt die boolesche Grundlage, den Aufbau auf Gatterebene, die Kaskadierung und die Eigenschaft als Funktionsgenerator.

Was ist ein Multiplexer?

Ein Multiplexer ist eine kombinatorische Schaltung, die einen von mehreren Dateneingängen auswählt und ihn an eine einzige Ausgangsleitung weitergibt. Die Auswahl steuert ein separates Bündel von Auswahlleitungen, das eine binäre Adresse für den gewünschten Eingang codiert.

Für einen vollständig belegten MUX mit einer Zweierpotenz von Eingängen gilt:

$n$ Auswahlleitungen können aus $2^n$ Dateneingängen wählen.

Eine Auswahlleitung adressiert zwei Eingänge, zwei adressieren vier und drei adressieren acht. Schnittstellen ohne Zweierpotenz können Codes ungenutzt lassen oder einen Standardpfad festlegen; viele praktische Bausteine besitzen zusätzlich ein Enable- oder Strobe-Signal.

Ein 4-zu-1-Multiplexer: Zwei Auswahlleitungen wählen zwischen vier Eingängen. Der gewählte Eingang erscheint am Ausgang.

Der 2-zu-1-MUX: Der einfachste Datenselektor

Der 2-zu-1-MUX ist der grundlegende Baustein. Er hat 2 Dateneingänge ($D_0$, $D_1$), 1 Auswahlleitung ($S$) und 1 Ausgang ($Y$).

Der boolesche Ausdruck ist unkompliziert. $D_0$ soll durchgelassen werden, wenn $S=0$ ist, und $D_1$, wenn $S=1$ ist:

$Y = \overline{S} \cdot D_0 + S \cdot D_1$

Eine kanonische Umsetzung mit Grundgattern verwendet:

• Ein NICHT-Gatter zur Erzeugung von $\overline{S}$
• Zwei UND-Gatter: Eines berechnet $\overline{S} \cdot D_0$, das andere $S \cdot D_1$
• Ein ODER-Gatter, das beide UND-Ausgänge zum Endergebnis zusammenführt

Ein 2-zu-1-MUX aus UND-, ODER- und NICHT-Gattern. Bei S=0 wird $D_0$ durchgeleitet; bei S=1 wird $D_1$ durchgeleitet.

Der 4-zu-1-MUX: Boolescher Ausdruck und Entwurf auf Gatterebene

Ein 4-zu-1-MUX hat 4 Dateneingänge ($D_0$ bis $D_3$) und 2 Auswahlleitungen ($S_1$, $S_0$). Die Auswahlleitungen bilden eine 2-Bit-Binäradresse, die bestimmt, welcher Eingang den Ausgang erreicht.

Jede Zeile dieser Tabelle entspricht einem Produktterm, bei dem die Auswahlleitungen genau einen Dateneingang „freigeben“. Der vollständige boolesche Ausdruck für den 4-zu-1-MUX lautet:

$Y = \overline{S_1}\,\overline{S_0}\,D_0 + \overline{S_1}\,S_0\,D_1 + S_1\,\overline{S_0}\,D_2 + S_1\,S_0\,D_3$

Dieser Ausdruck zeigt genau, welche Hardware wir brauchen:

• 2 NICHT-Gatter zur Erzeugung von $\overline{S_1}$ und $\overline{S_0}$
• 4 UND-Gatter mit drei Eingängen, die jeweils einen Dateneingang mit der passenden Auswahlkombination verknüpfen
• 1 ODER-Gatter mit vier Eingängen, das alle vier UND-Ausgänge zusammenführt

Die direkte boolesche Zeichnung enthält zwei Invertierungen, vier Produktterme und eine ODER-Reduktion. „Sieben Gatter“ setzt voraus, dass beliebige Gatter mit drei bzw. vier Eingängen jeweils als eins zählen; eine physische Bibliothek oder ein FPGA kann die Funktion anders abbilden.

4-zu-1-MUX mit Funktionstabelle und Skalierungsmuster. $n$ Auswahlleitungen wählen aus $2^n$ Eingängen.

Einen 4-zu-1-MUX auf digisim.io bauen

Befolge diese Schritte, um einen 4-zu-1-MUX aus einzelnen Gattern zu bauen:

1. Die Auswahlleitungen platzieren. Ziehen Sie zwei INPUT_SWITCH-Komponenten auf die Arbeitsfläche und beschriften Sie sie mit $S_1$ und $S_0$.
2. Die Komplemente erzeugen. Platzieren Sie zwei NICHT-Gatter. Verbinden Sie $S_1$ mit dem einen und $S_0$ mit dem anderen, sodass $\overline{S_1}$ und $\overline{S_0}$ entstehen.
3. Die Dateneingänge platzieren. Fügen Sie vier INPUT_SWITCH-Komponenten hinzu und beschriften Sie diese mit $D_0$, $D_1$, $D_2$ und $D_3$.
4. Das UND-Netzwerk erstellen. Platzieren Sie vier UND-Gatter mit jeweils drei Eingängen:
   • UND-0: Die Eingänge sind $\overline{S_1}$, $\overline{S_0}$ und $D_0$
   • UND-1: Die Eingänge sind $\overline{S_1}$, $S_0$ und $D_1$
   • UND-2: Die Eingänge sind $S_1$, $\overline{S_0}$ und $D_2$
   • UND-3: Die Eingänge sind $S_1$, $S_0$ und $D_3$
5. Die Ergebnisse zusammenführen. Platzieren Sie ein ODER-Gatter und verbinden Sie damit alle vier UND-Ausgänge. Der ODER-Ausgang ist der endgültige Ausgang $Y$.
6. Visualisierung hinzufügen. Verbinden Sie $Y$ mit einem OUTPUT_LIGHT.

Betätigen Sie die Auswahlschalter, um unterschiedliche Dateneingänge zum Ausgang zu leiten. In einem stabilen, gültigen Auswahlzustand ist nur der gewählte Produktterm aktiviert; sein Datenwert bestimmt Y.

MUXe kaskadieren: Einen 8-zu-1-MUX aus 4-zu-1-Einheiten bauen

Eine wesentliche Eigenschaft von Multiplexern ist ihre Kaskadierbarkeit für eine größere Anzahl von Eingängen. Sie müssen einen 8-zu-1-MUX nicht vollständig neu entwerfen, sondern können ihn aus kleineren Einheiten aufbauen.

Ein 8-zu-1-MUX benötigt 3 Auswahlleitungen ($S_2$, $S_1$, $S_0$) und 8 Dateneingänge ($D_0$ bis $D_7$). So wird er aus zwei 4-zu-1-MUXen und einem 2-zu-1-MUX aufgebaut:

1. Erste Stufe (zwei 4-zu-1-MUXe):
   • MUX-A verarbeitet $D_0$-$D_3$; $S_1$ und $S_0$ dienen ihm als Auswahlleitungen.
   • MUX-B verarbeitet $D_4$-$D_7$; $S_1$ und $S_0$ dienen ihm als Auswahlleitungen.
2. Zweite Stufe (ein 2-zu-1-MUX):
   • Der Ausgang von MUX-A wird mit $D_0$ des abschließenden MUX verbunden.
   • Der Ausgang von MUX-B wird mit $D_1$ des abschließenden MUX verbunden.
   • $S_2$ dient als Auswahlleitung für diesen abschließenden MUX.

Wenn $S_2 = 0$ ist, gibt der abschließende MUX das Ergebnis von MUX-A weiter (Eingänge $D_0$-$D_3$). Wenn $S_2 = 1$ ist, gibt er das Ergebnis von MUX-B weiter (Eingänge $D_4$-$D_7$). Die unteren Auswahlleitungen $S_1$ und $S_0$ bestimmen, welcher der vier Eingänge innerhalb der gewählten Gruppe den Ausgang erreicht.

Dieser hierarchische Ansatz skaliert auf jede Größe. Ein 16-zu-1-MUX kann aus zwei 8-zu-1-MUXen und einem 2-zu-1-MUX aufgebaut werden oder aus vier 4-zu-1-MUXen, die einen 4-zu-1-MUX der zweiten Ebene speisen.

Ein 8-zu-1-MUX mit 3 Auswahlleitungen. Er kann aus zwei 4-zu-1-MUXen und einem 2-zu-1-MUX aufgebaut werden.

Der MUX als universeller Funktionsgenerator

Ein $2^n$-zu-1-MUX kann jede boolesche Funktion von n Variablen implementieren, indem diese Variablen mit den Auswahlleitungen verbunden und die Dateneingänge mit Konstanten aus der Wahrheitstabelle verdrahtet werden. Der MUX ist selbst Logik; dies ist daher eine strukturelle Umsetzung – keine Logik „gratis“.

Betrachten Sie beispielsweise eine Funktion mit drei Variablen $F(A, B, C)$. Für einen 8-zu-1-MUX gilt:

1. Verbinden Sie $A$, $B$ und $C$ mit den Auswahlleitungen $S_2$, $S_1$ und $S_0$.
2. Für jede Zeile der Wahrheitstabelle adressiert die Auswahlkombination einen Dateneingang. Verdrahten Sie diesen Eingang mit 1, wenn für die Zeile $F=1$ gilt, andernfalls mit 0.

Der MUX-Ausgang bildet dann die Wahrheitstabelle nach. FPGA-Lookup-Tabellen nutzen gespeicherte Konfigurationsbits und Auswahlschaltungen, um dieselbe von außen sichtbare Fähigkeit bereitzustellen: jede Funktion, die in die LUT-Eingangsanzahl passt. Die interne Struktur und dedizierte Kaskadenressourcen sind jeweils von der Gerätefamilie abhängig.

Sie können auch einen kleineren MUX verwenden, indem Sie eine Eingangsvariable anstelle der Auswahlleitungen auf die Datenleitungen legen. Eine Funktion mit drei Variablen lässt sich beispielsweise mit einem 4-zu-1-MUX und nur zwei Auswahlleitungen realisieren: Verbinden Sie $A$ und $B$ mit den Auswahlleitungen und verdrahten Sie die einzelnen Dateneingänge je nach Bedarf mit 0, 1, $C$ oder $\overline{C}$.

Durchgerechnetes Beispiel: Eine Mehrheitsfunktion implementieren

Die Mehrheitsfunktion mit 3 Eingängen gibt 1 aus, wenn zwei oder mehr Eingänge 1 sind. Ihre Wahrheitstabelle lautet:

Mit einem 8-zu-1-MUX: Verbinden Sie $A$, $B$ und $C$ mit $S_2$, $S_1$ und $S_0$. Verdrahten Sie die Dateneingänge $D_0$ bis $D_7$ entsprechend der F-Spalte: $D_0=0$, $D_1=0$, $D_2=0$, $D_3=1$, $D_4=0$, $D_5=1$, $D_6=1$, $D_7=1$. Außer dem MUX und den Konstantquellen sind keine externen Logikgatter erforderlich.

Mit einem 4-zu-1-MUX (reduzierte Form): Verbinden Sie $A$ und $B$ mit $S_1$ und $S_0$. Gruppieren Sie die Zeilen der Wahrheitstabelle nach $AB$:

• $AB=00$: Für $C=0$ und $C=1$ gilt $F=0$. Verdrahten Sie $D_0 = 0$.
• $AB=01$: Bei $C=0$ gilt $F=0$, bei $C=1$ gilt $F=1$. Verdrahten Sie $D_1 = C$.
• $AB=10$: Bei $C=0$ gilt $F=0$, bei $C=1$ gilt $F=1$. Verdrahten Sie $D_2 = C$.
• $AB=11$: Für $C=0$ und $C=1$ gilt $F=1$. Verdrahten Sie $D_3 = 1$.

Damit wird dieselbe Funktion mit einem kleineren MUX umgesetzt, wobei $C$ direkt mit zwei Dateneingängen verbunden ist.

Signallaufzeit und Timing-Aspekte

Wie jede physische kombinatorische Schaltung hat ein MUX eine Signallaufzeit. In der direkten Summe-der-Produkte-Zeichnung kann ein Wechsel der Auswahl über einen Inverter, einen Produktterm und die ODER-Reduktion laufen:

Dies ist lediglich eine topologische Abschätzung. Die tatsächliche Signallaufzeit hängt von Zellwahl, Eingangsslewrate, Last, Verdrahtung, Versorgungsspannung, Temperatur sowie davon ab, ob der betrachtete Pfad an einem Daten- oder Auswahleingang beginnt. Eine kaskadierte Auswahl fügt logische Ebenen hinzu; zugleich kann auch ein physisch breiter Ausdruck mit nur einer Ebene aufgrund hohen Fan-ins und langer Verbindungen langsam sein. Verwenden Sie die Timing-Analyse des Zielbausteins, anstatt aus der logischen Topologie pauschale Geschwindigkeitsverhältnisse abzuleiten.

Beim Wechsel der Auswahl kann ein vorübergehender Ausgangsimpuls entstehen, wenn sich alter und neuer Dateneingang unterscheiden und interne Signalpfade unterschiedliche Laufzeiten aufweisen. Übernehmen Sie das Ergebnis beim Übergang über eine synchrone Grenze in ein Register, halten Sie die Auswahl während des erforderlichen Zeitintervalls stabil und verwenden Sie einen nicht qualifizierten MUX-Ausgang weder als Taktsignal noch als asynchronen Schreibimpuls. Die funktionale Simulation validiert die Auswahllogik, bildet physikalische Hazards und Laufzeiten jedoch möglicherweise nicht ab.

Der allgemeine boolesche Ausdruck für einen $N$-zu-1-MUX

Wir können den booleschen MUX-Ausdruck auf jede Größe verallgemeinern. Für einen $2^n$-zu-1-MUX mit Auswahlleitungen $S_{n-1}, S_{n-2}, \ldots, S_0$ und Dateneingängen $D_0, D_1, \ldots, D_{2^n - 1}$:

$Y = \sum_{i=0}^{2^n - 1} \left( D_i \cdot m_i \right)$

wobei $m_i$ der $i$-te Minterm der Auswahlvariablen ist. Jeder Minterm ist ein Produkt aller Auswahlvariablen, die abhängig von der Binärdarstellung von $i$ jeweils in wahrer oder komplementierter Form auftreten. Beispielsweise lautet in einem 8-zu-1-MUX der Minterm für $i=5$ (binär 101) $S_2 \cdot \overline{S_1} \cdot S_0$.

Diese Formulierung macht deutlich, dass ein MUX buchstäblich eine Hardware-Umsetzung der kanonischen Summe-von-Mintermen-Form ist. Jede boolesche Funktion besitzt einen eindeutigen Summe-von-Mintermen-Ausdruck, und ein MUX kann ihn direkt implementieren, indem seine Dateneingänge mit den passenden konstanten Werten verdrahtet werden.

Der Enable-Eingang

Viele kommerzielle MUX-ICs besitzen einen Enable- oder Strobe-Pin, häufig aktiv-low. Das Verhalten im deaktivierten Zustand ist bausteinspezifisch: Ein Ausgang kann auf Low, auf High oder – in einer anderen Geräteklasse – auf hohe Impedanz gezwungen werden. Für ein abstraktes aktiv-hohes Enable E, das Y im deaktivierten Zustand auf Low zwingt:

$Y = E \cdot \left(\overline{S_1}\,\overline{S_0}\,D_0 + \overline{S_1}\,S_0\,D_1 + S_1\,\overline{S_0}\,D_2 + S_1\,S_0\,D_3\right)$

Ein Enable kann die Kaskadierung und Kontrollqualifizierung vereinfachen, ist aber nicht für jede MUX-Hierarchie erforderlich. Ein Push-Pull-MUX-Ausgang darf nicht mit einem Tri-State-Bustreiber verwechselt werden.

Beim Aufbau kaskadierter Multiplexer auf digisim.io können Sie die Freigabefunktion nachbilden, indem Sie zwischen dem letzten ODER-Ausgang und einem Freigabeschalter ein UND-Gatter einfügen.

Alltagsanalogie: TV-Eingangswähler

Stellen Sie sich vier Videoquellen (Spielkonsole, Kabelreceiver, Blu-ray-Player und Streaming-Stick) sowie ein Fernsehgerät vor. Ein MUX entspricht dem Eingangswähler: Die Taste auf der Fernbedienung (Auswahlleitungen) bestimmt, welche Quelle auf dem Bildschirm (Ausgang) erscheint. Die Videodaten liegen kontinuierlich an allen vier Eingängen an, doch der MUX leitet nur die ausgewählte Quelle zum Ausgang weiter.

TV-Eingangswähler als MUX: Auswahlleitungen bestimmen, welche Eingangsquelle auf dem Fernseher erscheint.

Der Demultiplexer (DEMUX)

Das Gegenstück zu einem MUX ist ein Demultiplexer (DEMUX). Während ein MUX einen von vielen Eingängen auswählt und zu einem einzigen Ausgang leitet, nimmt ein DEMUX einen Eingang und leitet ihn anhand der Auswahlleitungen zu einem von vielen Ausgängen weiter.

Die booleschen Ausdrücke für einen 1-zu-4-DEMUX lauten:

$Y_0 = D \cdot \overline{S_1} \cdot \overline{S_0}$ $Y_1 = D \cdot \overline{S_1} \cdot S_0$ $Y_2 = D \cdot S_1 \cdot \overline{S_0}$ $Y_3 = D \cdot S_1 \cdot S_0$

Beachten Sie, dass ein DEMUX strukturell einem Decoder mit Freigabeeingang entspricht. Wenn der Dateneingang $D$ als Freigabesignal dient, bestimmt die „Adresse“ auf den Auswahlleitungen, welcher Ausgang das Signal erhält.

Ein 1-zu-4-DEMUX: Ein Eingang wird anhand von 2 Auswahlleitungen zu einem von vier Ausgängen geleitet.

Anwendungen von Multiplexern

Multiplexer kommen auf jeder Ebene des Entwurfs digitaler Systeme vor. Hier sind die wichtigsten Anwendungen, mit genügend Details, um zu verstehen, warum MUXe unverzichtbar sind.

CPU-Registerdatei

In einer kleinen Registerbank aus diskreten Flipflops kann jeder asynchrone Leseport als wortbreiter MUX modelliert werden, der durch einen Registerindex ausgewählt wird. Eine Lehr-Registerbank mit acht Registern zu je acht Bit würde pro Leseport acht parallele 8-zu-1-Bitauswahlen verwenden. Physische ASIC- und FPGA-Registerdateien können stattdessen Speichermakros, dekodierte Wortleitungen, Bitleitungen, dedizierte RAM-Ressourcen oder verteilte Logik nutzen. Das MUX-Modell beschreibt die von außen sichtbare Auswahl, nicht eine zwingende Transistortopologie.

Auswahl der ALU-Eingänge

Die Operanden der ALU kommen nicht immer aus Registern. Manchmal ist ein Operand eine in der Instruktion eingebettete unmittelbare Konstante oder ein aus dem Speicher gelesener Wert. Ein MUX an jedem ALU-Eingang ermöglicht der Steuereinheit die Wahl der Operandenquelle: Registerdateiausgang, unmittelbarer Wert oder Speicherdatenregister. Dieser einzelne MUX pro ALU-Eingang verleiht der CPU die Flexibilität, Register-Register-, Register-Unmittelbar- und Speicher-Register-Instruktionen mit derselben ALU-Hardware auszuführen.

Dekodierung von Speicheradressen und Bus-Arbitrierung

Wenn mehrere Ziele Daten zurückgeben können, kann ein MUX die Antwort auswählen, die zu einer dekodierten Anfrage gehört. Wenn mehrere Master eine Ressource anfordern, entscheidet ein Arbiter über die Zuteilung, und Weiterleitungs-MUXe geben Adresse, Daten und Steuersignale des ausgewählten Masters weiter. Der MUX implementiert weder Fairness noch den Request/Grant-Handshake; er leitet ausschließlich entsprechend dem Arbitrierungsergebnis weiter.

FPGA-Lookup-Tabellen

Ein übliches FPGA-Logikprimitive ist eine Lookup-Tabelle (LUT). Ihr Konfigurationszustand speichert Werte der Wahrheitstabelle, und die Logikeingänge wählen den passenden Wert. Eine konzeptionelle LUT mit k Eingängen verhält sich daher wie eine von k Eingängen ausgewählte Wahrheitstabelle mit $2^k$ Einträgen. Tatsächliche FPGA-Familien verwenden architekturspezifische LUT-Schaltungen, Fracturing-Modi, dedizierte Kaskadenmultiplexer und Routing; ein „64-zu-1-MUX“ ist deshalb ein nützliches Funktionsmodell, aber kein universelles physisches Schaltbild.

Praktische Übungen

Bauen Sie diese Schaltungen im digisim.io-Editor auf, um Ihr Verständnis zu festigen:

1. Bauen Sie einen 2-zu-1-MUX aus zwei UND-Gattern, einem ODER-Gatter und einem NICHT-Gatter auf. Prüfen Sie alle vier Eingangskombinationen.
2. Erweitern Sie die Schaltung zu einem 4-zu-1-MUX mithilfe des obigen booleschen Ausdrucks. Messen Sie den Ausgang für jede stabile Auswahlkombination.
3. Kaskadieren Sie zwei 4-zu-1-Multiplexer und einen 2-zu-1-Multiplexer zu einem 8-zu-1-Multiplexer. Prüfen Sie, ob alle acht Eingänge einzeln adressierbar sind.
4. Implementieren Sie eine boolesche Funktion mit einem MUX. Wählen Sie eine beliebige Funktion mit drei Variablen aus einer Wahrheitstabelle und konfigurieren Sie einen 8-zu-1-MUX dafür, indem Sie die Dateneingänge fest verdrahten.
5. Bauen Sie einen DEMUX, um die Weiterleitungsrichtung umzukehren: Leiten Sie ein Signal zu einem von vier Ausgängen.

Lesen Sie anschließend Decoder und Encoder über den strukturellen Verwandten des DEMUX, untersuchen Sie die Zuführung der ALU durch Multiplexer im Fetch-Decode-Execute-Zyklus, oder öffnen Sie die Komponentenreferenz zum UND-Gatter – dem grundlegenden Baustein jedes MUX.

Referenz

• Texas Instruments: Produktdokumentation zum SN74HC151 8-zu-1-Datenselektor/Multiplexer