Bity w elektronice
Konwerter kodu BCD na kod Aikena


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

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:


cyfra 0 1 2 3 4 5 6 7 8 9
BCD 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001

 

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 4cyfrowa liczba dziesiętna 2158 zostanie zakodowana w kodzie BCD jako 4 słowa kodowe:

2158(10) = 0010 0001 0101 1000(BCD)

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

 

cyfra 0 1 2 3 4 5 6 7 8 9
Kod Aikena 0000 0001 0010 0011 0100 1011 1100 1101 1110 1111

 

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:

 

cyfra 0 1 2 3 4 5 6 7 8 9
BCD 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001
Kod Aikena 0000 0001 0010 0011 0100 1011 1100 1101 1110 1111

 

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:

 

8421 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
BCD 0 1 2 3 4 5 6 7 8 9 niewykorzystane
Kod Aikena 0 1 2 3 4 niewykorzystane 5 6 7 8 9

 

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.


Określenie funkcji logicznych

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:

 

Cyfra BCD Aiken
d c b a D C B A
0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 1
2 0 0 1 0 0 0 1 0
3 0 0 1 1 0 0 1 1
4 0 1 0 0 0 1 0 0
5 0 1 0 1 1 0 1 1
6 0 1 1 0 1 1 0 0
7 0 1 1 1 1 1 0 1
8 1 0 0 0 1 1 1 0
9 1 0 0 1 1 1 1 1

 

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
D1 = ca
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
D2 = cb
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
D3 = d

 

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
C1 = ca
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
C2 = cb
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
C3 = d

 

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
B1 = cba
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
B2 = cb
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
B3 = d

 

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
A = a

 

Podsumujmy otrzymane wyniki:

 

 

Testowy program w języku C++

Za pomocą prostych przekształceń Algebry Boole'a otrzymaliśmy wzory funkcji logicznych wyjść A, B, C i D, w których występują jedynie funkcje NAND - pozwoli to zrealizować układ kodera za pomocą jednorodnych układów scalonych. Najpierw jednak napiszemy program testujący wyznaczone funkcje logiczne:

 

// Symulacja sieci konwertera kodu BCD na kod Aikena
// (C)2007 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main()
{
  bool we[4],wy[4];
  int i,j,m;
    
  cout << "CYFRA   BCD     AIKEN\n"
          "------d-c-b-a--D-C-B-A\n";
  for(i = 0; i < 10; i++)
  {

// obliczamy kod BCD kolejnej cyfry

    for(m = 8, j = 3; m; j--, m >>= 1) we[j] = (i & m) > 0 ;

// kod BCD -> kod Aikena

    wy[0] = we[0];    
    wy[1] = !(!(we[2] && !we[1] && we[0]) && !(!we[2] && we[1]) && !we[3]);
    wy[2] = !(!(we[2] && !(we[0] && !we[1])) && !we[3]);
    wy[3] = !(!(we[2] && !(!we[0] && !we[1])) && !we[3]);

// prezentujemy wyniki

    cout << "  " << i << "   ";
    for(j = 3; j >= 0; j--) cout << we[j] << " ";
    cout << " ";
    for(j = 3; j >= 0; j--) cout << wy[j] << " ";
    cout << endl;
  }

  cout << endl;
  return 0;
}
CYFRA   BCD     AIKEN
------d-c-b-a--D-C-B-A
  0   0 0 0 0  0 0 0 0
  1   0 0 0 1  0 0 0 1
  2   0 0 1 0  0 0 1 0
  3   0 0 1 1  0 0 1 1
  4   0 1 0 0  0 1 0 0
  5   0 1 0 1  1 0 1 1
  6   0 1 1 0  1 1 0 0
  7   0 1 1 1  1 1 0 1
  8   1 0 0 0  1 1 1 0
  9   1 0 0 1  1 1 1 1
Cyfra BCD Aiken
d c b a D C B A
0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 1
2 0 0 1 0 0 0 1 0
3 0 0 1 1 0 0 1 1
4 0 1 0 0 0 1 0 0
5 0 1 0 1 1 0 1 1
6 0 1 1 0 1 1 0 0
7 0 1 1 1 1 1 0 1
8 1 0 0 0 1 1 1 0
9 1 0 0 1 1 1 1 1

Symulacja sieci logicznej

Otrzymane w programie wyniki dokładnie odpowiadają tabeli konwersji kodów. Zatem możemy przystąpić do konstrukcji sieci z bramek NAND.

 

 

Zestawienie elementów

Obciążenia wnoszone przez poszczególne wejścia: a - 3,  b - 2, c - 3,  d - 1,

 

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.