Kod BCD (ang. Binary Coded Decimal - Dziesiętny Kodowany Binarnie) jest powszechnie stosowany w przemyśle przy sterowaniu różnych wyświetlaczy cyfrowych - kasy, czujniki temperatury, wskaźniki itp. W kodzie BCD kodujemy binarnie poszczególne cyfry liczby dziesiętnej. Ponieważ cyfr jest 10, to każda z nich jest kodowana przy pomocy 4 bitów:

Zwróć uwagę, iż kod BCD jest zwykłym, okrojonym kodem binarnym 8421. Wartość słówka kodowego odpowiada bezpośrednio wartości reprezentowanej przez niego cyfry. Pozostałe kombinacje bitów (1010, 1011, 1100, 1101, 1110 i 1111) nie są w kodzie BCD używane (można je wykorzystać do reprezentacji innych obiektów niż cyfry: kropka dziesiętna, minus, plus itp.). Na przykład 4-cyfrowa liczba dziesiętna 2158 zostanie zakodowana w kodzie BCD jako 4 słowa kodowe:

Więcej na temat kodu BCD znajdziesz tutaj.

Howard Hathaway Aiken

Howard Hathaway Aiken (ur. 8-03-1900, zm. 14-03-1973) był amerykańskim matematykiem, pionierem komputeryzacji, twórcą jednego z pierwszych komputerów Mark I. Opracował on kod binarny do zapisu cyfr liczb dziesiętnych, który nazwano kodem Aikena (dzisiaj posiadający tylko znaczenie dydaktyczne):

W kodzie Aikena bity posiadają kolejno wagi 2 4 2 1, co bardzo łatwo sprawdzić na podstawie powyższej tabelki. Jeśli porównamy ze sobą kod BCD i kod Aikena:

to zauważymy, iż dla cyfr 0,1,2,3 i 4 są one takie same. Różnica powstaje dopiero od cyfry 5. Jeśli rozpiszemy wszystkie kolejne kombinacje 4-bitów, to otrzymamy następujące położenia słówek kodujących cyfry dziesiętne w obu kodach:

Począwszy od cyfry 5 słowa wartości słówek kodowych kodu Aikena są przesunięte o 6 pozycji w stosunku do słówek kodu BCD.

Po tym krótkim wstępie przejdźmy do projektu - naszym zadaniem jest zaprojektowanie sieci logicznej, która konwertuje kody cyfr BCD na kody cyfr w kodzie Aikena. Zdefiniujmy sygnały wejściowe i wyjściowe naszego transkodera:

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

Do minimalizacji funkcji wykorzystamy mapy Karnaugha (ponieważ nasz koder nie wykorzystuje wszystkich kombinacji bitów wejściowych, stan X oznacza dowolną wartość bitu wyjściowego w zależności od potrzeb) :

Sygnał D

Obszar D1 00 01 11 10 00 0 0 0 0 01 0 1 1 1 11 X X X X 10 1 1 X X	Obszar D2 00 01 11 10 00 0 0 0 0 01 0 1 1 1 11 X X X X 10 1 1 X X	Obszar D3 00 01 11 10 00 0 0 0 0 01 0 1 1 1 11 X X X X 10 1 1 X X

Sygnał C

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

Sygnał B

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

Sygnał A

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

Wszystkie funkcje sprowadziliśmy do zanegowanych koniunkcji, aby do budowy sieci można było zastosować bramki uniwersalne NAND.

Podsumujmy otrzymane wyniki:

Przyjrzyj się otrzymanym wzorom. Do realizacji funkcji dla sygnałów wyjściowych A, B, C i D potrzebujemy następujących sygnałów wejściowych:

Rozpoczynamy od sygnałów wejściowych:

Teraz przystępujemy do budowy sieci na podstawie funkcji:

Numerujemy bramki:

Określamy sieć połączeń:

Program tworzy sygnały a, b, c i d odpowiadające cyfrom 0...9 w kodzie BCD. Na wyjściu powinniśmy otrzymać kody tych cyfr w kodzie Aikena.

// Symulacja sieci logicznej
// transkodera BCD na kod Aikena
// (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/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,YB12,YB13;

  // Licznik pętli/cyfra BCD
  int i;

  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++)
  {
    // Wyodrębniamy bity kodu BCD cyfr
    a = (i & 0x1);
    b = (i & 0x2) > 0;
    c = (i & 0x4) > 0;
    d = (i & 0x8) > 0;

    // Symulacja sieci
    YB1  = NAND2(a,1);
    YB2  = NAND2(b,1);
    YB3  = NAND2(c,1);
    YB4  = NAND2(d,1);
    YB5  = NAND2(YB3,b);
    YB6  = NAND3(a,YB2,c);
    YB7  = NAND2(a,YB2);
    YB8  = NAND2(YB2,YB1);
    YB9  = NAND3(YB5,YB6,YB4);
    YB10 = NAND2(c,YB7);
    YB11 = NAND2(c,YB8);
    YB12 = NAND2(YB10,YB4);
    YB13 = NAND2(YB11,YB4);
    A    = a;
    B    = YB9;
    C    = YB12;
    D    = YB13;

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

Bity kodu BCD ustawiasz kliknięciami w kwadratowe przyciski. Bity słowa kodu Aikena odczytujesz z okrągłych wskaźników. Kolor czarny oznacza stan 0, kolor czerwony oznacza stan 1.

Obciążenia wnoszone przez poszczególne wejścia sieci są następujące:

Sieć wykorzystuje 1 opornik 1kΩ oraz 13 bramek: 11 bramek NAND 2-wejściowych oraz 2 bramki NAND 3-wejściowe:

SN7400 × 3

SN7410 × 1