W poprzednim rozdziale zaprojektowaliśmy sieć logiczną, która przekształcała kod BCD na kod Aikena. Teraz zaprojektujemy sieć realizującą zadanie odwrotne - przekształcanie kodu Aikena na kod BCD. Na początek, jak zwykle, określimy sygnały wejściowe i wyjściowe naszego transkodera:

Na wejścia abcd transkodera podajemy słowo kodu Aikena. Na wyjściach ABCD otrzymujemy odpowiednik w kodzie BCD. Na podstawie poniższej tabelki zamian wyrazów kodowych określimy funkcje logiczne dla poszczególnych wyjść A, B, C i D:

Na podstawie tabelki układamy tablice Karnaugha dla poszczególnych wyjść transkodera. Wszystkie funkcje sprowadzamy do postaci NAND, aby można było użyć bramek standardowych:

Sygnał D

Obszar D 00 01 11 10 00 0 0 0 0 01 0 X X X 11 0 0 1 1 10 X X 0 X

Sygnał C

Obszar C1 00 01 11 10 00 0 0 0 0 01 1 X X X 11 1 1 0 0 10 X X 1 X	Obszar C2 00 01 11 10 00 0 0 0 0 01 1 X X X 11 1 1 0 0 10 X X 1 X

Sygnał B

Obszar B1 00 01 11 10 00 0 0 1 1 01 0 X X X 11 1 1 0 0 10 X X 0 X	Obszar B2 00 01 11 10 00 0 0 1 1 01 0 X X X 11 1 1 0 0 10 X X 0 X

Sygnał A

Obszar A 00 01 11 10 00 0 1 1 0 01 0 X X X 11 0 1 1 0 10 X X 1 X

Podsumujmy otrzymane funkcje logiczne:

Tworzenie sieci logicznej rozpoczynamy od wejść. Jeśli przyjrzysz się wzorom:

to zauważysz, iż używane są w nich wejścia: a, b, b, c, c, d, d. Zaprzeczenia zrealizujemy za pomocą inwerterów NOT.

Realizujemy kolejne funkcje:

 

 

 

 

 

 

 

Sieć logiczna jest gotowa

Numerujemy bramki w sieci w kolejności przetwarzanych przez nie sygnałów:

Określamy sieć połączeń:

Program będzie tworzył na wejściach a, b, c i d kolejne wyrazy kodu Aikena. Na wyjściach sieci powinniśmy otrzymać kolejne słowa w kodzie BCD wg poniższej tabelki:

// Symulacja sieci logicznej
// transkodera z kodu Aikena na BCD
// (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/wyjściowe
  int a,b,c,d,A,B,C,D;

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

  // Licznik pętli i cyfra Aikena
  int i,ca;

  cout << "Cyfra | d c b a | D C B A\n"
          "------+---------+--------"
       << endl;

  // W pętli generujemy kody cyfr 0-9
  for(i = 0; i < 10; i++)
  {
    ca = i;
    if(i > 4) ca += 6;

    // Wyodrębniamy bity kodu Aikena
    a = (ca & 0x1);
    b = (ca & 0x2) > 0;
    c = (ca & 0x4) > 0;
    d = (ca & 0x8) > 0;

    // Symulacja sieci
    YB1  = NOT(d);
    YB2  = NOT(c);
    YB3  = NOT(b);
    YB4  = NAND(c,b);
    YB5  = NAND(YB2,d);
    YB6  = NAND(c,YB3);
    YB7  = NAND(YB1,b);
    YB8  = NAND(d,YB3);
    YB9  = NOT(YB4);
    YB10 = NAND(YB5,YB6);
    YB11 = NAND(YB7,YB8);
    A    = a;
    B    = YB11;
    C    = YB10;
    D    = YB9;

    // Wyświetlamy wyniki
    cout << "  " << i << "   | "
         << d << " " << c << " "
         << b << " " << a << " | "
         << D << " " << C << " "
         << B << " " << A << endl;
  }
  cout << endl;
  return 0;
}

W symulatorze kod Aikena ustawiasz z lewej strony na kwadratowych przyciskach. Kliknięcie w przycisk zmienia jego stan na przeciwny. Kolor czarny oznacza stan niski 0, kolor czerwony to stan wysoki 1. Kod BCD odczytujemy z okrągłych wskaźników po prawej stronie. Pamiętaj, iż sieć poprawnie działa tylko dla prawidłowych kodów Aikena. Jest to konsekwencją uproszczenia funkcji logicznych.