Serwis Edukacyjny
w I-LO w Tarnowie
obrazek

Materiały dla uczniów liceum

  Wyjście       Spis treści       Wstecz       Dalej  

Autor artykułu: mgr Jerzy Wałaszek

©2020 mgr Jerzy Wałaszek
I LO w Tarnowie

Bity w elektronice

1-bitowy sumator

SPIS TREŚCI
Podrozdziały

Opis

obrazek

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:

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

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

obrazek

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.

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
Na początek:  podrozdziału   strony 

Określenie funkcji logicznych

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:

Na początek:  podrozdziału   strony 

Budowa sieci logicznej

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.

Na początek:  podrozdziału   strony 

Symulacja sieci w języku C++

Numerujemy bramki:

Definiujemy sieć połączeń:

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

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

Na początek:  podrozdziału   strony 

Symulacja interaktywna

Symulator
Na początek:  podrozdziału   strony 

Spis elementów

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

SN7400 × 3
obrazek
SN7404 × 1
obrazek

Sumatory wielobitowe

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

obrazek

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.

obrazek 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

obrazek

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
obrazek  obrazek

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
obrazek  obrazek
Na początek:  podrozdziału   strony 

Zespół Przedmiotowy
Chemii-Fizyki-Informatyki

w I Liceum Ogólnokształcącym
im. Kazimierza Brodzińskiego
w Tarnowie
ul. Piłsudskiego 4
©2020 mgr Jerzy Wałaszek

Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone
pod warunkiem podania źródła oraz niepobierania za to pieniędzy.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.