Adderare

Från Wikipedia
Hoppa till: navigering, sök

En adderare är en grundläggande digital komponent för beräkningar i digitala konstruktioner. I en dator sitter adderarna i ALU:n. En en-bits-adderare utan minnessiffra består bara av endast en xor-grind.

En tvåbitsadderare från en datorlaboration.

Det finns olika typer av adderare:

  • Halvadderare - tar inte hänsyn till ingående minnessiffra, har två utgångar:

en minnessiffra, en summa. Kan realiseras med hjälp av en AND-grind (minnessiffran) och en XOR-grind.

  • Heladderare - tar hänsyn till ingående minnessiffra och kan realiseras med hjälp av två halvadderare och en OR-grind.

Halvadderare[redigera | redigera wikitext]

En halvadderare (eng. half adder) är en digital krets som utför en addition av två binära siffror (bitar). Halvadderaren skiljer sig från heladderaren i att halvadderaren inte har någon ingång för en möjlig minnessiffra.

Logisk funktion[redigera | redigera wikitext]

Kretsschema för en halvadderare

Halvadderaren har två ingångar, bit A och bit B, samt en bit för summan S och en bit för minnessiffran från additionen, C (från eng. carry).

Summabiten bestäms genom XOR-funktionen medan carrybiten bestäms genom AND-funktionen. Funktionsvärdena illustreras i tabellen nedan.

Ingång Utgång
A B C S
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0

Ifall båda in-bitarna är 0, blir både summan och minnessiffran 0. Då endast en av bitarna är 1, blir summan 1 och minnessiffran 0. Om båda in-bitarna är 1, blir summan 0 och minnessiffran 1. Situationen där båda in-bitarna är 1 kan jämföras med en addition i talsystemet med basen 10, där summan blir större än 10 och en minnessiffra tas i bruk.

Heladderare[redigera | redigera wikitext]

En heladderare uppbyggd med logiska grindar

En heladderare (kort FA, från engelska Full Adder) är en digital komponent för addition av två (egentligen tre) bitar. Eftersom den är en digital komponent kan den bara arbeta med de diskreta värdena 1 och 0. Heladderaren tar tre insignaler x, y och cin (carry in), som den adderar, och lämnar två utsignaler s ((entals)summan) och cout (carry out, minnessiffra (som är 2-värd)).

Heladderaren kan kopplas ensam eller i kedja av flera adderare för att kunna addera två binära tal som består av fler än 1 bitar vardera. För att addera två tal med n stycken bitar, krävs n stycken heladderare. Då används cin och cout för att hålla koll på minnessiffrorna.

Logisk funktion[redigera | redigera wikitext]

Funktionstabell:

in ut
x y cin s cout
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1

Funktionen hos en heladderare kan beskrivas med funktionstabell (till höger) eller med de logiska uttrycken för utsignalerna:

S = (A \oplus B) \oplus C_{in}
C_{out} = (A \cdot B) + (C_{in} \cdot (A \oplus B)) = (A \cdot B) + (C_{in} \cdot B) + (C_{in} \cdot A)

Heladderare används ofta för att addera två tal, längre än en 1 bit vardera. För att addera talen X = <x1, x2, x3, ... , xn> och Y = <y1, y2, y3, ... , yn> behövs n stycken heladderare (FA1, FA2, FA3, ... , FAn), kopplade i en kedja.

Ripple-Carry-adderare[redigera | redigera wikitext]

För att addera stora tal måste lika många heladderare som talens längd i bitar, kopplas i kedja. En minnessiffra måste då rippla genom varje heladderare i tur och ordning. Eftersom kretsen är parallell betyder det att summorna för varje adderare förändras hela tiden. En tidsperiod måste därför passera innan totalsumman kan kontrolleras.

Denna typ av adderare benämns Ripple-Carry-adderare.

4 st seriekopplade heladderare till en 4-bitars (Ripple-Carry) adderare

Fördröjning[redigera | redigera wikitext]

X och Y kommer in parallellt (samtidigt) till kedjan av heladderare på så sätt att xi och yi kopplas till ingångarna x och y på FAi. De ligger alltså där och väntar på att carry-in ska sättas. När carry-in har satts måste signalerna igenom två stycken grindar, man säger att heladderaren har grinddjup två.

Om det tar 5 ms för en signal att gå genom en grind, kommer det ta 5 ms * 2 * n för n stycken heladderare att beräkna summan av två n-bitars tal. Detta är ofta för långsamt för längre tal, och därför finns det tekniker för att snabba upp uträkningen.

Carry-Look-Ahead-adderare[redigera | redigera wikitext]

För att addera långa tal utan att varje beräkning måste utföras i sekvens används ofta Carry-Look-Ahead-adderare. I denna beräknar varje adderare om den ska emittera två signaler eller inte: Propagate-signalen, om en carrybit kommer in på ingången, kommer adderaren att skicka en carry-bit till nästa adderare. Den propagerar alltså vidare en eventuellt inkommande carrybit. Detta realiseras med en XOR-grind mellan de två ingångarna.

Generate-signalen, om denna aktiveras kommer adderaren att skicka en carry-bit. Detta realiseras med en AND-grind.

Alla Propagate och Generate signalerna går in i en carry-accelerator, som egentligen bara består av ett antal AND-grindar, dessa skickar tillbaka en carry-bit till varje adderare där acceleratorn beräknat att carry-biten ska gå hög. Detta sker parallellt och ökar hastigheten rejält på adderarkonstruktionen.

Dubbelberäkning[redigera | redigera wikitext]

En annan teknik för att beräkna en addition snabbare är att man delar upp heladderarkedjan i två delar (förslagvis lika stora delar). Sedan börjar man addera båda delarna var för sig samtidigt. Den första och mindre signifikanta halva beräknas som vanligt, men den andra halvan beräknas både som om carry-in vore 1 och som om den vore 0. På detta sätt har man två versioner av halva uträkningen klar samtidigt som den första halvan av uträkningen är klar. Då kan man med hjälp av den Carry-out välja vilken av de andra uträkningarna som ska användas, och vilken som var felaktig och ska kastas.