Serwis Edukacyjny
w I-LO w Tarnowie
obrazek

Materiały dla uczniów liceum

  Wyjście       Spis treści       Wstecz       Dalej  

Autor artykułu: mgr Jerzy Wałaszek

©2020 mgr Jerzy Wałaszek
I LO w Tarnowie

Bity w elektronice

4-bitowy multiplekser

SPIS TREŚCI
Podrozdziały

Opis

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.

obrazek

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

B A D0 D1 D2 D3 Y
0 0 0 X X X 0
0 1 X 0 X X 0
1 0 X X 0 X 0
1 1 X X X 0 0
0 0 1 X X X 1
0 1 X 1 X X 1
1 0 X X 1 X 1
1 1 X X X 1 1
Na początek:  podrozdziału   strony 

Określenie funkcji logicznych

Na podstawie tabelki stanów układamy tablice Karnaugha:
Obszar Y1
obrazek 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
obrazek 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
obrazek 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
obrazek 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:

Na początek:  podrozdziału   strony 

Budowa sieci logicznej

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ą:

Na początek:  podrozdziału   strony 

Symulacja sieci w języku C++

Numerujemy bramki:

Określamy sieć połączeń:

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

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

D0 D1 D2 D3 B A Y
0 X X X 0 0 0
1 X X X 0 0 1
X 0 X X 0 1 0
X 1 X X 0 1 1
X X 0 X 1 0 0
X X 1 X 1 0 1
X X X 0 1 1 0
X X X 1 1 1 1

X oznacza wartość dowolną, 0 lub 1

C++
// 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;
}
Wynik:
ADRES = 0
D0 D1 D2 D3 B A | Y
 0  0  0  0 0 0 | 0
 1  0  0  0 0 0 | 1
 0  1  0  0 0 0 | 0
 1  1  0  0 0 0 | 1
 0  0  1  0 0 0 | 0
 1  0  1  0 0 0 | 1
 0  1  1  0 0 0 | 0
 1  1  1  0 0 0 | 1
 0  0  0  1 0 0 | 0
 1  0  0  1 0 0 | 1
 0  1  0  1 0 0 | 0
 1  1  0  1 0 0 | 1
 0  0  1  1 0 0 | 0
 1  0  1  1 0 0 | 1
 0  1  1  1 0 0 | 0
 1  1  1  1 0 0 | 1

ADRES = 1
D0 D1 D2 D3 B A | Y
 0  0  0  0 0 1 | 0
 1  0  0  0 0 1 | 0
 0  1  0  0 0 1 | 1
 1  1  0  0 0 1 | 1
 0  0  1  0 0 1 | 0
 1  0  1  0 0 1 | 0
 0  1  1  0 0 1 | 1
 1  1  1  0 0 1 | 1
 0  0  0  1 0 1 | 0
 1  0  0  1 0 1 | 0
 0  1  0  1 0 1 | 1
 1  1  0  1 0 1 | 1
 0  0  1  1 0 1 | 0
 1  0  1  1 0 1 | 0
 0  1  1  1 0 1 | 1
 1  1  1  1 0 1 | 1

ADRES = 2
D0 D1 D2 D3 B A | Y
 0  0  0  0 1 0 | 0
 1  0  0  0 1 0 | 0
 0  1  0  0 1 0 | 0
 1  1  0  0 1 0 | 0
 0  0  1  0 1 0 | 1
 1  0  1  0 1 0 | 1
 0  1  1  0 1 0 | 1
 1  1  1  0 1 0 | 1
 0  0  0  1 1 0 | 0
 1  0  0  1 1 0 | 0
 0  1  0  1 1 0 | 0
 1  1  0  1 1 0 | 0
 0  0  1  1 1 0 | 1
 1  0  1  1 1 0 | 1
 0  1  1  1 1 0 | 1
 1  1  1  1 1 0 | 1

ADRES = 3
D0 D1 D2 D3 B A | Y
 0  0  0  0 1 1 | 0
 1  0  0  0 1 1 | 0
 0  1  0  0 1 1 | 0
 1  1  0  0 1 1 | 0
 0  0  1  0 1 1 | 0
 1  0  1  0 1 1 | 0
 0  1  1  0 1 1 | 0
 1  1  1  0 1 1 | 0
 0  0  0  1 1 1 | 1
 1  0  0  1 1 1 | 1
 0  1  0  1 1 1 | 1
 1  1  0  1 1 1 | 1
 0  0  1  1 1 1 | 1
 1  0  1  1 1 1 | 1
 0  1  1  1 1 1 | 1
 1  1  1  1 1 1 | 1

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.

Na początek:  podrozdziału   strony 

Symulacja interaktywna

Symulator
Na początek:  podrozdziału   strony 

Spis elementów

Obciążenia wnoszone przez poszczególne wejścia: A - 2,  B - 3, D0 - 1,  D1 - 1, D2 - 1, D3 - 1

SN7400 × 3
obrazek
SN7404 × 1
obrazek

Scalone multipleksery

obrazek

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
obrazek

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.

Adres S Y
D C B A
X X X X 1 1
0 0 0 0 0 D0
0 0 0 1 0 D1
0 0 1 0 0 D2
0 0 1 1 0 D3
0 1 0 0 0 D4
0 1 0 1 0 D5
0 1 1 0 0 D6
0 1 1 1 0 D7
1 0 0 0 0 D8
1 0 0 1 0 D9
1 0 1 0 0 D10
1 0 1 1 0 D11
1 1 0 0 0 D12
1 1 0 1 0 D13
1 1 1 0 0 D14
1 1 1 1 0 D15

SN74151 - ośmiowejściowy multiplekser
obrazek

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.

Adres S Y Y
C B A
X X X 1 0 1
0 0 0 0 D0 D0
0 0 1 0 D1 D1
0 1 0 0 D2 D2
0 1 1 0 D3 D3
1 0 0 0 D4 D4
1 0 1 0 D5 D5
1 1 0 0 D6 D6
1 1 1 0 D7 D7

SN74153 - dwa czterowejściowe multipleksery o wspólnym adresowaniu
obrazek

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.

Adres S Y
B A
X X 1 0
0 0 0 D0
0 1 0 D1
1 0 0 D2
1 1 0 D3

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

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.

Adres S Y
A
X 1 0
0 0 D0
1 0 D1
Na początek:  podrozdziału   strony 

Zespół Przedmiotowy
Chemii-Fizyki-Informatyki

w I Liceum Ogólnokształcącym
im. Kazimierza Brodzińskiego
w Tarnowie
ul. Piłsudskiego 4
©2020 mgr Jerzy Wałaszek

Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone
pod warunkiem podania źródła oraz niepobierania za to pieniędzy.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.