Bramka sterowana realizuje różne funkcje logiczne na sygnałach wejściowych a i b w zależności od stanu wejść sterujących s₁ i s₂. 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 s₁ i s₂ 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 s₁ i s₂ zgodnie z poniższą tabelką (dla funkcji logicznych będziemy używać notacji stosowanej w elektronice, ponieważ jest bardziej czytelna):

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:

Na podstawie tych danych tworzymy mapę Karnaugha. Z sygnałów wejściowych tworzymy dwie grupy współrzędnych mapy: ab oraz s₁s₂. 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.

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

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, s₁ i s₂:

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:

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:

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

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

// 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;
}

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.

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

SN7400 × 3

SN7410 × 1