Demultiplekser jest elementem cyfrowym, który przesyła dane z wejścia na jedno z wyjść, którego numer określa stan wejść adresowych. Pełni on zatem rolę przeciwną do multipleksera, który utworzyliśmy w poprzednim projekcie. Teraz stworzymy prosty demultiplekser, który będzie posiadał jedno wejście danych G, cztery wyjścia Y0, Y1, Y2, Y3 oraz dwa wejścia adresowe A i B.

Dla każdego wyjścia możemy bezpośrednio napisać funkcję logiczną, która będzie iloczynem adresu i wejścia danych:

Funkcje przekształcamy w funkcje NAND, aby zastosować bramki standardowe.

Budowę sieci rozpoczynamy tradycyjnie od sygnałów wejściowych. Będą nam potrzebne sygnały adresowe A, B wraz z ich zaprzeczeniami A i B oraz sygnał G.

Teraz realizujemy kolejne funkcje wyjść:

Sieć jest gotowa.

Numerujemy bramki:

Określamy sieć połączeń:

Na wejścia sieci będziemy podawać sygnały zgodne z poniższą tabelką:

// Symulacja sieci logicznej
// demultipleksera 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, int c)
{
  return !(a && b && c);
}

int main()
{
  // Stany wejściowe oraz stany wyjściowe
  int G,A,B,Y0,Y1,Y2,Y3;

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

  int i;

  // W pętli generujemy stany wejściowe
  cout << " G  B  A | Y0 Y1 Y2 Y3" << endl;
  for(i = 0; i < 8; i++)
  {
    // Wydzielamy stany wejściowe
    G = (i & 0x4) > 0;
    B = (i & 0x2) > 0;
    A = i & 0x1;

    // Symulujemy sieć
    YB1 = NOT(B);
    YB2 = NOT(A);
    YB3 = NAND(YB2,YB1,G);
    YB4 = NAND(A,YB1,G);
    YB5 = NAND(YB2,B,G);
    YB6 = NAND(A,B,G);
    YB7 = NOT(YB3);
    YB8 = NOT(YB4);
    YB9 = NOT(YB5);
    YB10 = NOT(YB6);
    Y0 = YB7;
    Y1 = YB8;
    Y2 = YB9;
    Y3 = YB10;

    // Wyniki
    cout << " " << G << " "
         << " " << B << " "
         << " " << A << " | "
         << " " << Y0 << " "
         << " " << Y1 << " "
         << " " << Y2 << " "
         << " " << Y3 << " " << endl;
  }
  cout << endl;
  return 0;
}

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

A - 3, B - 3, G - 4.

SN7404 × 1

SN7410 × 2

Scalone demultipleksery

SN74154
szesnastowyjściowy demultiplekser

Układ SN74154 posiada dwa wejścia danych G1 i G2 (jedno z nich można traktować jako wejście strobujące - stan wysoki na nim blokuje wyjścia demultipleksera). Zwróć uwagę, iż wejścia te pracują w logice ujemnej - świadczy o tym kółeczko na symbolu demultipleksera. Oznacza to, iż sygnał wejściowy jest negowany, a stanem aktywnym wejścia jest stan niski 0. Aby na wybranym wyjściu demultipleksera otrzymać stan niski, oba wejścia G1 i G2 muszą również znajdować się w stanie niskim. Wejścia adresowe D, C, B i A służą do wyboru jednego z 16 wyjść Y0 ... Y15. Wyjścia są również zanegowane, jednakże z powodu zanegowania wejść, stan wyjścia wybranego adresem odpowiada sygnałowi wejściowemu na G1 i G2. Poniżej umieściliśmy tabelkę stanów demultipleksera SN74154.

SN74155
dwa demultipleksery z dwóch linii na cztery linie

Układ scalony SN74155 zawiera dwa demultipleksery z dwóch linii na cztery linie. Dzielą one wspólne wejścia adresowe B i A - nie można zatem adresować niezależnie wyjść demultiplekserów - pracują one zawsze w parze. Pierwszy demultiplekser posiada zanegowane wejście danych, co powoduje jego odmienne działanie.

Każdy z demultiplekserów zawiera jedno wejście danych C, jedno wejście strobowania G, dwa wspólne wejścia adresowe B i A, które wybierają aktywne wyjście oraz cztery wyjścia Y0 ... Y3. Poniżej umieściliśmy tabelki stanów dla obu demultiplekserów.