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

Bramka sterowana OR - AND - EXOR - NAND

SPIS TREŚCI
Podrozdziały

Określenie funkcji logicznych

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.

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:

obrazek

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ą (dla funkcji logicznych będziemy używać notacji stosowanej w elektronice, ponieważ jest bardziej czytelna):

s1 s2 Realizowana
funkcja
Nazwa funkcji
0 0 y = a+b Alternatywa OR
0 1 y = ab Koniunkcja AND
1 0 y = ab 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:

obrazek

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

obrazek

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...):

obrazek

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). Zgodnie z prawami DeMorgana otrzymamy w nawiasach funkcję NAND:

Całość funkcji ponownie poddajemy podwójnej negacji, aby pozbyć się alternatyw:

Wynikowa funkcja zawiera jedynie negacje koniunkcji - zatem da się przedstawić w postaci sieci zbudowanej tylko z bramek NAND. Teraz krok po kroku pokażemy, jak na podstawie wzoru funkcji otrzymać jej sieć logiczną z bramek NAND.

Rozpoczynamy od sygnałów wejściowych: a, b, s1 i s2:

We wzorze funkcji sygnały wejściowe występują w postaci normalnej i zanegowanej. Negacji dokonamy za pomocą bramek NAND w konfiguracji bramki NOT:

Dołączenie wejścia bramki poprzez opornik 1k do napięcia zasilania Vcc jest równoważne podaniu stanu 1 na to wejście. W takiej konfiguracji na wyjściu bramki panuje stan przeciwny do stanu drugiego jej wejścia, czyli otrzymujemy negator NOT.

Teraz realizujemy funkcje występujące wewnątrz wzoru:










Na początek:  podrozdziału   strony 

Testowy program w języku C++

Sieci logiczne możemy w prosty sposób testować za pomocą programu w języku C++ (lub dowolnym innym). Symulacja polega na podaniu na wejścia sieci kolejnych stanów logicznych, a następnie badaniu stanów na wyjściu. Jeśli będą zgodne z założeniami, to sieć jest poprawna logicznie. Pokażemy teraz, jak dokonać takiej symulacji dla naszej sieci.

Numerujemy bramki w sieci. Numerację wykonuje się w kolejności przetwarzania sygnałów przez poszczególne bramki.

W następnym kroku określamy sieć połączeń, tzn. z czym łączą się wejścia poszczególnych bramek oraz skąd będzie pobierany sygnał wyjściowy. Wyjścia bramek oznaczymy jako Yn, gdzie n jest numerem bramki. Wszystkie bramki wykonują funkcję NAND:

Y1 = NAND(1,a)
Y2 = NAND(1,b)
Y3 = NAND(1,s1)
Y4 = NAND(1,s2)
Y5 = NAND(Y1,s2)
Y6 = NAND(Y2,s1)
Y7 = NAND(Y3,Y4)
Y8 = NAND(Y2,Y4)
Y9 = NAND(b,Y3,Y5)
Y10 = NAND(Y6,Y7)
Y11 = NAND(Y8,s1,Y1)
Y12 = NAND(a,Y10)
Y13 = NAND(Y9,Y12,Y11)
y = Y13

Na wejście sieci podajemy sygnały zgodnie z tabelką:

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 wyjściu powinniśmy otrzymać stany y, jeśli zaprojektowana przez nas sieć działa prawidłowo. Sprawdźmy, program jest następujący

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

#include <iostream>

using namespace std;

// Funkcje bramek

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

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

int main( )
{
  // Stany wejściowe oraz stan wyjściowy
  int s1,s2,a,b,y;

  // Stany wyjściowe bramek
  int Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,Y9,Y10,Y11,Y12,Y13;

  int c = 0; // Zlicza wiersze

  cout << "a  b  y s1 s2" << endl
       << "-------------" << endl;

  // Generujemy stany wejściowe
  for( s1 = 0; s1 <= 1; s1++ )
    for( s2 = 0; s2 <= 1; s2++ )
      for( a = 0; a <= 1; a++ )
        for( b = 0; b <= 1; b++ )
        {
          Y1 = NAND2(1,a);
          Y2 = NAND2(1,b);
          Y3 = NAND2(1,s1);
          Y4 = NAND2(1,s2);
          Y5 = NAND2(Y1,s2);
          Y6 = NAND2(Y2,s1);
          Y7 = NAND2(Y3,Y4);
          Y8 = NAND2(Y2,Y4);
          Y9 = NAND3(b,Y3,Y5);
          Y10 = NAND2(Y6,Y7);
          Y11 = NAND3(Y8,s1,Y1);
          Y12 = NAND2(a,Y10);
          Y13 = NAND3(Y9,Y12,Y11);
          y = Y13;
          cout << a << "  " << b << "  " << y << "  " << s1 << "  " << s2 << endl;
          c++;
          if (c == 4)
          {
              c = 0;
              cout << "-------------" << endl;
          }
        }
  cout << endl;
  return 0;
}
Wynik:
a  b  y s1 s2
-------------
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
Na początek:  podrozdziału   strony 

Symulacja sieci logicznej

Wartości generowane przez program zgadzają się z tabelką, zatem możemy na podstawie wyprowadzonej funkcji zbudować sieć z bramek NAND. Poniżej znajduje się symulacja tej sieci. Stany wejść zmieniasz klikając w kwadratowe pola. Stan wyjścia obrazuje pole okrągłe.

Symulator
Na początek:  podrozdziału   strony 

Zestawienie elementów

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

a = 2
b = 2
s1 = 3
s2 = 2
SN7400 × 3
 obrazek
SN7410 × 1
 obrazek
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.