Bity w elektronice
Bramka sterowana OR - AND - EXOR - NAND


Bramki logiczne
Cyfrowe układy scalone TTL i CMOS
Zasilanie układów TTL i CMOS
Zjawisko hazardu w sieciach logicznych
  Projekty
Bramka sterowana OR - AND - EXOR - NAND
Czytnik klawiatury numerycznej
Konwerter kodu 8421 na kod Gray'a
Konwerter kodu Gray'a na kod 8421
8-bitowy generator bitu parzystości
Konwerter kodu BCD na kod Aikena
Konwerter kodu Aikena na kod BCD
Sterowanie wyświetlaczem kostki do gry
Sterowanie wyświetlaczem cyfrowym LED
Konwerter kodu BCD na kod 1 z 10
Sterownik wskaźnika postępu z 10 diod LED
4-bitowy multiplekser
4-bitowy demultiplekser
1-bitowy sumator

Opis

Bramka sterowana realizuje różne funkcje logiczne na sygnałach wejściowych a i b w zależności od stanu wejść sterujących s1 i s2. Tego typu układy występują w procesorach w tzw. jednostce arytmetyczno-logicznej, która, w zależności od odczytanego z pamięci rozkazu, wykonuje różne operacje arytmetyczne lub logiczne.

 

Określenie funkcji logicznych

Na początek zdefiniujmy zachowanie się naszej bramki. Będzie ona posiadała dwa wejścia danych a i b, dwa wejścia wyboru funkcji s1 i s2 oraz jedno wyjście danych y:

 

 

Na wyjściu y bramki pojawia się stan logiczny będący funkcją stanów na wejściach a i b. Rodzaj funkcji określają wejścia sterujące s1 i s2 zgodnie z poniższą tabelką:

 

s1 s2 Realizowana
funkcja
Nazwa funkcji
0 0 y = a+b Alternatywa - OR
0 1 y = ab Koniunkcja - AND
1 0 y = a Å b Suma modulo 2 - EXOR
1 1 y = ab Zanegowana koniunkcja - NAND

 

Zadanie rozwiążemy wykorzystując do minimalizacji funkcji logicznej mapy Karnaugha. W tym celu rozpiszmy wszystkie argumenty i wyniku funkcji. Dane zbierzemy w poniższej tabelce:

 

a b y s1 s2 Funkcja
0 0 0 0 0 OR
0 1 1 0 0
1 0 1 0 0
1 1 1 0 0
0 0 0 0 1 AND
0 1 0 0 1
1 0 0 0 1
1 1 1 0 1
0 0 0 1 0 EX-OR
0 1 1 1 0
1 0 1 1 0
1 1 0 1 0
0 0 1 1 1 NAND
0 1 1 1 1
1 0 1 1 1
1 1 0 1 1

 

Na podstawie tych danych tworzymy mapę Karnaugha. Z sygnałów wejściowych tworzymy dwie grupy współrzędnych mapy: ab oraz s1s2. Pierwsze współrzędne zapisujemy w kodzie Graya po lewej stronie mapy, drugie współrzędne zapisujemy również w kodzie Graya u góry mapy:

 

 

Współrzędne wyznaczają pola na mapie Karnaugha. W polach wpisujemy wartości funkcji y odczytane z tabelki:

 

 

Pola zawierające 1 łączymy w prostokątne obszary - pamiętamy, iż wymiary tych obszarów muszą być potęgami liczby 2 (1,2,4,8...):

 

 

Otrzymaliśmy 6 obszarów zawierających po dwa pola mapy. Rozpiszmy funkcje logiczne dla poszczególnych obszarów.

 

y1 = as1s2
y2 = bs1s2
y3 = abs1
y4 = abs1
y5 = as1s2
y6 = abs1
y =  y1 + y2 + y3 + y4 + y5 + y6
y = as1s2 + bs1s2 + abs1 + abs1 + as1s2 + abs1

 

Otrzymana funkcja nie jest jeszcze dla nas wygodna. Funkcje przekształcimy tak, aby można było w niej zastosować tylko bramki uniwersalne NAND. Najpierw, stosując zasady Algebry Boole'a, dokonamy kilku uproszczeń:

 

y = as1s2 + bs1s2 + abs1 + abs1 + as1s2 + abs1
y = as1(s2 + b) +bs1s2 + abs1 + as1s2 + abs1
y = as1(s2 + b) +bs1(s2 + a) + as1s2 + abs1
y = as1(s2 + b) +bs1(s2 + a) + a(s1s2 + bs1)

 

Wyrażenia w nawiasach negujemy podwójnie (nie zmienia to wartości logicznej wyrażenia). Zgodnie z prawami DeMorgana otrzymamy w nawiasach funkcję NAND:

 

 

Całość funkcji ponownie poddajemy podwójnej negacji:

 

 

Wynikowa funkcja zawiera jedynie negacje koniunkcji - zatem da się przedstawić w postaci sieci zbudowanej tylko z bramek NAND.

 

Testowy program w języku C++

Aby sprawdzić działanie sieci przed jej budową, przygotowałem prosty program symulacyjny w C++. Program wypisuje dane i wyniki zgodnie z podaną powyżej tabelką stanów logicznych.

 

// Symulacja sieci logicznej bramki sterowanej
// (C)2006 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main()
{
  int s1,s2,a,b,y;

  cout << "a b y 1 2\n";
  for(s1 = 0; s1 <= 1; s1++)
    for(s2 = 0; s2 <= 1; s2++)
      for(a = 0; a <= 1; a++)
        for(b = 0; b <= 1; b++)
        {
          int xx = !(!a && s1 && !(!s2 && !b));
          int yy = !(b && !s1 && !(s2 && !a));
          int zz = !(a && !(!(!s1 && !s2) && !(!b && s1)));
          y = !(xx && yy && zz);
          cout << a << " " << b << " " << y << " " << s1 << " " << s2 << endl;
        }
  cout << endl;
  return 0;
}
a b y 1 2
0 0 0 0 0
0 1 1 0 0
1 0 1 0 0
1 1 1 0 0
0 0 0 0 1
0 1 0 0 1
1 0 0 0 1
1 1 1 0 1
0 0 0 1 0
0 1 1 1 0
1 0 1 1 0
1 1 0 1 0
0 0 1 1 1
0 1 1 1 1
1 0 1 1 1
1 1 0 1 1
a b y s1 s2 Funkcja
0 0 0 0 0 OR
0 1 1 0 0
1 0 1 0 0
1 1 1 0 0
0 0 0 0 1 AND
0 1 0 0 1
1 0 0 0 1
1 1 1 0 1
0 0 0 1 0 EX-OR
0 1 1 1 0
1 0 1 1 0
1 1 0 1 0
0 0 1 1 1 NAND
0 1 1 1 1
1 0 1 1 1
1 1 0 1 1

Symulacja sieci logicznej

Wartości generowane przez program zgadzają się z tabelką, zatem możemy na podstawie wyprowadzonej funkcji zbudować sieć z bramek NAND.

 

 

Zestawienie elementów

Obciążenia wnoszone przez poszczególne wejścia: a - 2,  b - 2,  s1 - 3,  s2 - 2

 

SN7400 x 2

SN7404 x 1

SN7410 x 1

   

 



List do administratora Serwisu Edukacyjnego Nauczycieli I LO

Twój email: (jeśli chcesz otrzymać odpowiedź)
Temat:
Uwaga: ← tutaj wpisz wyraz  ilo , inaczej list zostanie zignorowany

Poniżej wpisz swoje uwagi lub pytania dotyczące tego rozdziału (max. 2048 znaków).

Liczba znaków do wykorzystania: 2048

 

W związku z dużą liczbą listów do naszego serwisu edukacyjnego nie będziemy udzielać odpowiedzi na prośby rozwiązywania zadań, pisania programów zaliczeniowych, przesyłania materiałów czy też tłumaczenia zagadnień szeroko opisywanych w podręcznikach.



   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie

©2017 mgr Jerzy Wałaszek

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.