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:

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

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ę.

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. Funkcje sprowadzamy do postaci NAND i NOT, aby można było zastosować standardowe bramki logiczne.

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:

Rozpoczynamy standardowo od sygnałów wejściowych i ich zaprzeczeń:

Przystępujemy do realizacji funkcji wyjścia Y. Zwróć uwagę, iż niektóre jej elementy są również wykorzystywane w funkcji wyjścia C2. Uprości to nieco sieć logiczną.

Zwróć uwagę na dwie rzeczy. Sumator, podobnie jak opisany wcześniej multiplekser, składa się z powtarzalnych elementów:

Realizują one funkcję logiczną:

Dodatkowo przeniesienie C2 do następnej pozycji nie korzysta wcale z wyniku sumowania, lecz z wartości sumowanych argumentów. Pozwala to przyspieszać sumowanie liczb wielobitowych.

Numerujemy bramki:

Definiujemy sieć połączeń:

Na wejście sieci będziemy podawać sygnały zgodne z poniższą tabelką:

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

C++ // Symulacja sieci logicznej // sumatora 1-bitowego // (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 oraz stany wyjściowe int A,B,C1,Y,C2; // Stany wyjściowe bramek int YB1, YB2, YB3, YB4, YB5, YB6, YB7, YB8, YB9, YB10; int YB11,YB12,YB13,YB14; int i; // W pętli generujemy stany wejściowe cout << " A B C1 | Y C2" << endl; for(i = 0; i < 8; i++) { // Wydzielamy stany wejściowe C1 = (i & 0x4) > 0; A = (i & 0x2) > 0; B = i & 0x1; // Symulujemy sieć YB1 = NOT(A); YB2 = NOT(B); YB3 = NOT(C1); YB4 = NAND(YB1,YB2); YB5 = NAND(A,B); YB6 = NAND(YB1,B); YB7 = NAND(A,YB2); YB8 = NAND(YB4,YB5); YB9 = NAND(YB6,YB7); YB10 = NAND(YB4,C1); YB11 = NAND(YB8,C1); YB12 = NAND(YB9,YB3); YB13 = NAND(YB10,YB5); YB14 = NAND(YB11,YB12); Y = YB14; C2 = YB13; // Wyniki cout << " " << A << " " << " " << B << " " << " " << C1 << " |" << " " << Y << " " << " " << C2 << endl; } cout << endl; return 0; }

Wynik:

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

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

SN7400 × 3

SN7404 × 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

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