Bity w elektronice
1-bitowy sumator


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

Sumator (ang. adder) jest układem cyfrowym realizującym operację dodawania. Tabliczka dodawania w systemie dwójkowym jest szczególnie prosta:


0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 0 i przeniesienie do następnej kolumny.


Przeniesienie (ang. carry) powstaje wtedy, gdy wynik dodawania nie mieści się w jednym bicie. W takim przypadku oprócz dodawania cyfr, w następnej kolumnie musimy dodać jeszcze jedynkę z przeniesienia. Zasady te są identyczne jak w systemie dziesiętnym. Dokładniejsze omówienie operacji arytmetycznych w systemie dwójkowym znajdziesz w artykule o binarnym kodowaniu liczb.

Uwzględniając przeniesienie z poprzedniej pozycji możemy rozszerzyć podane reguły dodawania. Oznaczmy indeksem 1 przeniesienie z poprzedniej pozycji (w pierwszej kolumnie przeniesienie to po prostu wynosi 0), które musimy dodać do wyniku dodawania cyfr na bieżącej pozycji, a indeksem 2 przeniesienie do następnej pozycji. Otrzymamy następujące reguły dodawania pojedynczych bitów:

 

0 + 0 + 01 = 0 i 02
0 + 1 + 01 = 1 i 02
1 + 0 + 01 = 1 i 02
1 + 1 + 01 = 0 i 12
0 + 0 + 11 = 1 i 02
0 + 1 + 11 = 0 i 12
1 + 0 + 11 = 0 i 12
1 + 1 + 11 = 1 i 12

 

Według powyższego schematu dodaje się dowolnie długie ciągi bitów:

 

  1 0 1 1
+ 0 1 1 0
        1
Dodawanie rozpoczynamy od ostatniej kolumny. Postępujemy zgodnie z podanymi regułami dodawania z przeniesieniem. Na początku przeniesienie wynosi 0, zatem:

1 + 0 + 01 = 1 i 02

      0  
  1 0 1 1
+ 0 1 1 0
      0 1
Przeniesienie 0 zapisujemy w następnej kolumnie małą cyferką. Wykonujemy dodawanie:

1 + 1 + 01 = 0 i 12

    1 0  
  1 0 1 1
+ 0 1 1 0
    0 0 1
Przeniesienie 1 zapisujemy w następnej kolumnie małą cyferką. Wykonujemy dodawanie:

0 + 1 + 11 = 0 i 12

  1 1 0  
  1 0 1 1
+ 0 1 1 0
  0 0 0 1
Przeniesienie 1 zapisujemy w następnej kolumnie małą cyferką. Wykonujemy dodawanie:

1 + 0 + 11 = 0 i 12

1 1 1 0  
  1 0 1 1
+ 0 1 1 0
1 0 0 0 1
Przeniesienie 1 zapisaliśmy w kolumnie, w której nie ma już cyfr. Brakujące cyfry możemy zastąpić cyframi 0. W takim przypadku wykonamy ostatnie dodawanie:

0 + 0 + 11 = 1 i 02

Cyfry się skończyły, przeniesienie do następnej kolumny wynosi 0, zatem dodawanie jest wykonane.

 

Sprawdźmy, czy otrzymaliśmy poprawny wynik:

 

1011(2) + 0110(2) = 10001(2)

1011(2) = 1 + 2 + 8 = 11(10)
0110(2) = 2 + 4 = 6(10)
10001(2) = 1 + 16 = 17(10)

11 + 6 = 17 - zgadza się.

 

Określenie funkcji logicznych

Celem projektu jest stworzenie jednobitowego sumatora. Określmy sygnały wejściowe i wyjściowe:

 

 

Sumator będzie posiadał dwa wejścia danych A i B, na które podajemy bity do zsumowania. Na wejście C1 podajemy przeniesienie z poprzedniej pozycji. Na wyjściu Y otrzymujemy wynik sumowania bitów A, B oraz C1. Na wyjściu C2 otrzymujemy przeniesienie do następnej pozycji.

Funkcje logiczne dla sygnałów wyjściowych Y i C2 otrzymamy na podstawie reguł dodawania z przeniesieniem. W tym celu układamy tablice Karnaugha:

 

Obszar Y
0 1
0  0 0 1
0  1 1 0
1  1 0 1
1  0 1 0

Obszar C2A
0 1
0  0 0 0
0  1 0 1
1  1 1 1
1  0 0 1

Obszar C2B
0 1
0  0 0 0
0  1 0 1
1  1 1 1
1  0 0 1

Obszar C2C
0 1
0  0 0 0
0  1 0 1
1  1 1 1
1  0 0 1


Podsumujmy:

 

 

Testowy program w języku C++

Wyprowadzone funkcje logiczne sprawdzamy w programie testowym:

 

// Test funkcji dla 1 bitowego sumatora
//-------------------------------------------
// (C)2007 mgr Jerzy Wałaszek I-LO w Tarnowie
//-------------------------------------------

#include <iostream>

using namespace std;

int main()
{
  int A,B,C1,C2,Y;
  
  cout << " A B C1 | Y C2\n"
          "--------+-----\n";
  for(C1 = 0; C1 <= 1; C1++)
    for(A = 0; A <= 1; A++)
      for(B = 0; B <= 1; B++)
      {
        Y = !(!(C1&&!(!(!A&&!B)&&!(A&&B)))&&!(!C1&&!(!(!A&&B)&&!(A&&!B))));
        C2 = !(!(A&&B)&&!(!(!A&&!B)&&C1)); 
        cout << " " << A << " " << B << "  " << C1 << " | " << Y << "  " << C2 << endl;
      }
  cout << endl;
  return 0;
}
 A B C1 | Y C2
--------+-----
 0 0  0 | 0  0
 0 1  0 | 1  0
 1 0  0 | 1  0
 1 1  0 | 0  1
 0 0  1 | 1  0
 0 1  1 | 0  1
 1 0  1 | 0  1
 1 1  1 | 1  1
0 + 0 + 01 = 0 i 02
0 + 1 + 01 = 1 i 02
1 + 0 + 01 = 1 i 02
1 + 1 + 01 = 0 i 12
0 + 0 + 11 = 1 i 02
0 + 1 + 11 = 0 i 12
1 + 0 + 11 = 0 i 12
1 + 1 + 11 = 1 i 12

 

Otrzymaliśmy zgodność wyników z regułami dodawania, zatem funkcje dla wyniku dodawania Y i przeniesienia do następnej pozycji C2 są poprawne.

 

Symulacja sieci logicznej

Zestawienie elementów

Obciążenia wnoszone przez poszczególne wejścia: A -3,  B - 3, C1 - 3

 

SN7400 x 3

SN7404 x 1

 

Sumatory wielobitowe

Sumator jednobitowy można łączyć w większe jednostki. Poniżej przedstawiamy przykład sumatora 4 bitowego:

 

 

Podane rozwiązanie posiada pewne wady. Mianowicie sygnały wyjściowe Y1...Y3 ustalą się dopiero po propagacji przeniesień przez wszystkie sumatory. Z tego powodu sumator tego typu może być nieefektywny dla większej liczby bitów. Problem ten rozwiązuje się przez zastosowanie specjalnych sieci logicznych generujących przeniesienia równolegle a nie szeregowo.

 

Scalony sumator

Układ scalony SN7483 jest czterobitowym sumatorem dwójkowym z przeniesieniami równoległymi (szybsze działanie w porównaniu do przeniesień szeregowych, patrz powyżej). Poniżej przedstawiamy definicję wyprowadzeń układu SN7483.

 

Układ SN7483 posiada 9 wejść danych:

A1...A4 - bity pierwszej liczby
B1...B4 - bity drugiej liczby
C0 - przeniesienie początkowe z poprzedniej pozycji

oraz 5 wyjść:

C4 - przeniesienie wyjściowe z 4-tej pozycji
∑1...∑4 - bity wyniku sumowania bitów A i B

 

Sumator można wykorzystywać na wiele różnych sposobów. Wyposażając go w kilka dodatkowych elementów uzyskujemy wiele ciekawych układów cyfrowych.

 

4 bitowy układ dodający lub odejmujący

Na wejścia A1...A4 i B1...B4 podajemy bitu sumowanych lub odejmowanych liczb. Jeśli wejście +/- znajduje się w stanie niskim, to bramki EX-OR przenoszą w stanie niezmienionym bity B1...B4 na wejścia B sumatora SN7483 - układ realizuje zwykłe dodawanie.

Jeśli wejście +/- znajduje się w stanie wysokim, to bramki EX-OR dokonują inwersji bitów B1...B4 na wejściu sumatora. Jednocześnie wejście przeniesienia C1 zostanie ustawione w stan wysoki, co spowoduje dodanie jedynki do wyniku. Jeśli do inwersji bitów dodamy jedynkę, to otrzymamy liczbę przeciwną w kodzie U2. Dodanie liczby przeciwnej jest równoważne wykonaniu odejmowania. Więcej na ten temat znajdziesz w artykule o binarnym kodowaniu liczb.

 

Konwerter kodu BCD na kod z nadmiarem 3 i na odwrót

Kod z nadmiarem 3 (ang. excess 3 binary ceded decimal, XS-3) jest systemem przedstawiania cyfr dziesiętnych za pomocą 4 bitów, wykorzystywanym w przeszłości przez niektóre systemy komputerowe. Słowa kodowe otrzymujemy ze słów kodowych BCD przez dodanie do nich liczby 3. W odwrotną stronę otrzymamy kody BCD odejmując od kodów XS-3 liczbę 3 (dodając uzupełnienie U2 liczby 3).

Cyfra BCD XS-3
0 0000 0011
1 0001 0100
2 0010 0101
3 0011 0110
4 0100 0111
5 0101 1000
6 0110 1001
7 0111 1010
8 1000 1011
9 1001 1100
 

 

Konwerter kodu BCD na kod Aikena i na odwrót

Wyrazy kodu Aikena powstają z wyrazów kodu BCD przez dodanie 6 do wyrazów większych od 4. W odwrotną stronę wyrazy kodu BCD otrzymujemy z wyrazów kodu Aikena odejmując 6 (dodając uzupełnienie U2 liczby 6) od wyrazów, w których ustawiony jest najstarszy bit. Reguły te pozwalają zaprojektować proste konwertery kodów Aikena na BCD i na odwrót, wykorzystując sumator SN7483.

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

 



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.