Multiplekser (selektor danych) jest układem cyfrowym posiadającym n wejść danych, jedno wyjście y oraz wejścia adresowe. Na wyjściu y pojawia się stan wejścia danych, którego numer (adres) podany został na wejścia adresowe. Przykładowy projekt dotyczy układu z czterema wejściami danych D0, D1, D2, D3, z jednym wyjściem Y oraz dwoma wejściami adresowymi A i B.

Poniższa tabelka definiuje stan wyjścia w zależności od sygnałów wejściowych.

Na podstawie tabelki stanów układamy tablice Karnaugha:

Obszar Y1 00 01 11 10  0  0  0  0 0 0 0 0  0  0  0  1 0 0 1 0  0  0  1  1 0 0 1 1  0  0  1  0 0 0 0 1  0  1  1  0 0 1 0 1  0  1  1  1 0 1 1 1  0  1  0  1 0 1 1 0  0  1  0  0 0 1 0 0  1  1  0  0 1 1 0 0  1  1  0  1 1 1 1 0  1  1  1  1 1 1 1 1  1  1  1  0 1 1 0 1  1  0  1  0 1 0 0 1  1  0  1  1 1 0 1 1  1  0  0  1 1 0 1 0  1  0  0  0 1 0 0 0

Obszar Y2 00 01 11 10  0  0  0  0 0 0 0 0  0  0  0  1 0 0 1 0  0  0  1  1 0 0 1 1  0  0  1  0 0 0 0 1  0  1  1  0 0 1 0 1  0  1  1  1 0 1 1 1  0  1  0  1 0 1 1 0  0  1  0  0 0 1 0 0  1  1  0  0 1 1 0 0  1  1  0  1 1 1 1 0  1  1  1  1 1 1 1 1  1  1  1  0 1 1 0 1  1  0  1  0 1 0 0 1  1  0  1  1 1 0 1 1  1  0  0  1 1 0 1 0  1  0  0  0 1 0 0 0

Obszar Y3 00 01 11 10  0  0  0  0 0 0 0 0  0  0  0  1 0 0 1 0  0  0  1  1 0 0 1 1  0  0  1  0 0 0 0 1  0  1  1  0 0 1 0 1  0  1  1  1 0 1 1 1  0  1  0  1 0 1 1 0  0  1  0  0 0 1 0 0  1  1  0  0 1 1 0 0  1  1  0  1 1 1 1 0  1  1  1  1 1 1 1 1  1  1  1  0 1 1 0 1  1  0  1  0 1 0 0 1  1  0  1  1 1 0 1 1  1  0  0  1 1 0 1 0  1  0  0  0 1 0 0 0

Obszar Y4 00 01 11 10  0  0  0  0 0 0 0 0  0  0  0  1 0 0 1 0  0  0  1  1 0 0 1 1  0  0  1  0 0 0 0 1  0  1  1  0 0 1 0 1  0  1  1  1 0 1 1 1  0  1  0  1 0 1 1 0  0  1  0  0 0 1 0 0  1  1  0  0 1 1 0 0  1  1  0  1 1 1 1 0  1  1  1  1 1 1 1 1  1  1  1  0 1 1 0 1  1  0  1  0 1 0 0 1  1  0  1  1 1 0 1 1  1  0  0  1 1 0 1 0  1  0  0  0 1 0 0 0

  Funkcje wyjścia Y sprowadzamy do postaci NAND:

Rozpoczynamy od sygnałów wejściowych. Sygnały adresowe A i B muszą być dostępne w wersji zwykłej i zanegowanej.

Teraz realizujemy etapami funkcję wyjścia Y.

Zwróć uwagę, że druga część wzoru ma taką samą strukturę jak pierwsza.

Zwróć uwagę, iż główna sieć logiczna multipleksera zbudowana jest z trzech identycznych podsieci:

Realizują one funkcję logiczną:

Numerujemy bramki:

Określamy sieć połączeń:

Na wejście sieci będziemy podawali sygnały:

// Symulacja sieci logicznej
// multipleksera 4-bitowego
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

// Funkcje bramek

int NOT(int a)
{
  return !a;
}

int NAND(int a, int b)
{
  return !(a && b);
}

int main()
{
  // Stany wejściowe oraz stany wyjściowe
  int D0,D1,D2,D3,A,B,Y;

  // Stany wyjściowe bramek
  int YB1, YB2, YB3, YB4, YB5, YB6, YB7, YB8, YB9, YB10,YB11;

  int a,d;

  // W pętli generujemy adresy od 0 do 3
  for(a = 0; a < 4; a++)
  {
    cout << "ADRES = " << a << endl
         << " D0 D1 D2 D3  B  A | Y" << endl;

    // Wydzielamy bity adresu
    B = (a & 0x2) > 0;
    A = a & 0x1;

    // Generujemy bity danych
    for(d = 0; d < 16; d++)
    {
        D0 = d & 0x1;
        D1 = (d & 0x2) > 0;
        D2 = (d & 0x4) > 0;
        D3 = (d & 0x8) > 0;

        // Symulujemy sieć
        YB1  = NOT(B);
        YB2  = NOT(A);
        YB3  = NAND(YB1,D0);
        YB4  = NAND(B,D2);
        YB5  = NAND(YB1,D1);
        YB6  = NAND(B,D3);
        YB7  = NAND(YB3,YB4);
        YB8  = NAND(YB5,YB6);
        YB9  = NAND(YB7,YB2);
        YB10 = NAND(YB8,A);
        YB11 = NAND(YB9,YB10);
        Y    = YB11;

        // Wyniki
        cout << " " << D0 << " "
             << " " << D1 << " "
             << " " << D2 << " "
             << " " << D3 << "  "
             << " " << B << " "
             << " " << A << " | " << Y << endl;
    }
    cout << endl;
  }
  cout << endl;
  return 0;
}

Dane wejściowe obejmują wszystkie kombinacje stanów wejściowych. Na wyjściu Y pojawia się stan wejścia Dn o adresie n. Pozostałe stany wejść D nie wpływają na stan wyjścia Y.

Obciążenia wnoszone przez poszczególne wejścia:

A - 2, B - 3, D0 - 1, D1 - 1, D2 - 1, D3 - 1

SN7400 × 3

SN7404 × 1

Scalone multipleksery

Ponieważ funkcje spełniane przez multipleksery są bardzo popularne w urządzeniach cyfrowych, przemysł elektroniczny produkuje je w postaci pojedynczych układów scalonych średniej skali integracji - MSI.

Typowy scalony multiplekser posiada określoną liczbę wejść danych (16, 8, 4 lub 2), wejścia adresowe, wyjście danych Y, wyjście zanegowane Y i wejście strobujące S.

Linie adresowe wybierają jedno z wejść danych o numerze odpowiadającym adresowi. Stan wybranego wejścia przenoszony jest na wyjście Y  (a w postaci zanegowanej na wyjście Y). Wejście strobujące S umożliwia blokowanie multipleksera. Jeśli podamy na nie stan niski (kółeczko na wejściu oznacza, iż stan niski jest stanem aktywnym, czyli włączającym funkcję strobowania), to na wyjściu Y pojawi się stan wejścia, którego numer podano na wejścia adresowe. Przy stanie wysokim na wyjściu mamy zawsze 0 bez względu na stany wejść. Jest to pomocne przy łączeniu multiplekserów do wybierania sygnałów z większej liczby linii wejściowych (np. 32 lub 64).

Po lewej stronie przedstawiamy typowy symbol multipleksera, stosowany na schematach układów cyfrowych. Poniżej prezentujemy cztery popularne układy scalone, zawierające różne multipleksery.

SN74150
szesnastowejściowy multiplekser

Układ SN74150 posiada 16 wejść danych D0...D15, cztery wejścia adresowe A, B, C, D, wejście strobujące S oraz wyjście Y. Adres wybiera jedno z wejść D0...D15. Stan wybranego wejścia pojawia się w postaci zanegowanej na wyjściu Y.

SN74151
ośmiowejściowy multiplekser

Układ SN74151 posiada 8 wejść danych D0...D7, trzy wejścia adresowe A, B, C, wejście strobujące S oraz dwa komplementarne wyjścia Y i Y. Adres wybiera jedno z wejść D0...D7. Stan wybranego wejścia pojawia się na wyjściu Y oraz w postaci zanegowanej na wyjściu Y.

SN74153
dwa czterowejściowe multipleksery
o wspólnym adresowaniu

Układ SN74153 zawiera dwa czterowejściowe multipleksery - bardzo podobne w działaniu do multipleksera, który stworzyliśmy w tym projekcie. Multipleksery posiadają wspólne wejścia adresowe - zatem wejścia są wybierane parami. Wewnętrznie wejścia adresowe są buforowane i wnoszą obciążenie 1. Niezależne są natomiast sygnały strobujące.

SN74157
cztery dwuwejściowe multipleksery
o wspólnym adresowaniu i strobowaniu

Układ SN74157 zawiera cztery multipleksery, z których każdy posiada dwa wejścia danych D0, D1, jedno wyjście Y, jedno wspólne wejście adresowe A oraz jedno wspólne wejście strobowania S. Wewnętrznie adres i strobowanie są buforowane i wnoszą obciążenie równe 1.