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

// 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, 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;
}

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