Can this 4 bit adder be further simplified?

  • Thread starter Psinter
  • Start date
  • #1
259
786

Main Question or Discussion Point

Hello, I'm new to logic circuits and I was making a 4 bit binary adder and I thought I could maybe simplify it. However, I can't find anything simpler than what I already got. What I wanted to know is: is my circuit already in its most simple form or am I making something wrong in my attempts to simplificate it (meaning it can still be simplificated)?

The circuit works as follows:

We have the 1st 4 bit number: ABCD
We have the 2nd 4 bit number: EFGH

The total sum with one bit at a time would be: (D + H) and (C + G) and (B + F) and (A + E). In other words:
ABCD
EFGH
---------
XXXX

where, (D + H) is the only one that doesn't receive any carry because it's the initial point.

So I need 4 outputs with their respective carries as illustrated:

eyXQH.png


As you can see the pattern of circuits start at the second sum. Meaning, (C + G), (B + F), and (A + E) are the same circuits. I tried to simplify 1 of them so I could simplify the rest of the adder. However, I can't find any way to simplify it any further. When I look at the Karnaugh Map I made out of the Truth Table of the circuit that repeats I don't know what to do from there because I don't have any mapping groups there.


Truth Table: [tex]((C \oplus G) \oplus CARRY) \wedge CARRY[/tex]
\begin{array}{|c|c|c|c|}
\hline
C & G & CARRY & F1 \\ \hline
0 & 0 & 0 & 0 \\ \hline
0 & 0 & 1 & 1 \\ \hline
0 & 1 & 0 & 0 \\ \hline
0 & 1 & 1 & 0 \\ \hline
1 & 0 & 0 & 0 \\ \hline
1 & 0 & 1 & 0 \\ \hline
1 & 1 & 0 & 0 \\ \hline
1 & 1 & 1 & 1 \\
\hline
\end{array}


Karnaugh Map: [tex]((C \oplus G) \oplus CARRY) \wedge CARRY[/tex]
\begin{array}{|c|c|c|c|c|c|}
\hline
& G \wedge CARRY & 00 & 01 & 11 & 10 \\ \hline
C & & & & & \\ \hline
0 & & & 1 & & \\ \hline
1 & & & & 1 & \\
\hline
\end{array}

Does all this mean that I cannot simplify my adder any further?
 

Answers and Replies

  • #2
259
786
This is wrong, never mind, this adder is wrongly designed. This is not an adder. It says that 0 + 0 = 1 with carry 1 if the previous sum has a carry of 1. We know that this is not true so this is wrong.
 
  • #3
667
4
I confirm it's wrong, because each pair of bits must enter an AND gate. The XOR doesn't suffice.

If you like circuitry, you can give a look at carry propagation and anticipation, both for adders and counters.
 
  • #4
1,754
52
How do you want to simplify it - by reducing the number of ICs? One way to simplify it would be to replace all the ICs with a PROM. Use the address lines as inputs and the data lines as outputs. For every combination of inputs (all addresses) program the correct output. You could even have one of the output lines designated as a carry out and one of the inputs as carry in. That way they could be cascaded.
 
  • #5
667
4
http://www.physics.wisc.edu/undergrads/courses/fall2012/623/ds/74LS283.pdf
http://en.wikipedia.org/wiki/Adder_(electronics)
http://www.google.de/search?q="4+bit+adder"&hl=en&client=firefox-a&hs=MlE&rls=org.mozilla:fr:official&prmd=imvnsfd&tbm=isch&tbo=u&source=univ&sa=X&ei=EUN1UMXNDsbZsgbDpYHoCQ&ved=0CB4QsAQ&biw=1200&bih=1728

Beware that what was a "simple" design with TTL gates isn't "simple" with present-day CMOS, and a "simple" breadboard isn't a "simple" chip design - a simple breadbord would buy a 4-bit full adder chip...

Especially, CMOS can make good XOR gates with 3 inputs, as well as good majority logic gates (= at least 2 inputs of 3 are logical 1).
http://book.huihoo.com/design-of-vlsi-systems/ch06/ch06.html

Interesting : the LS283 computed the carry over 4 bits directly to save time, despite it takes more gates. Again, many-inputs-Nand fit LS very well, and heavy output loading was a small penalty ; different story with CMOS.

Carry lookahead saves time by splitting the 1-bit adder carry signal into a "generate carry" and "propagate carry" (if one carry is input to this bit). These two signals can enter the lookahead unit which, for with words, is a tree.
Depicted here as a binary tree:
http://net.pku.edu.cn/~course/cs101/2007/resource/Intro2Algorithm/book6/chap29.htm
but normally it would be a radix-four tree:
http://pages.cs.wisc.edu/~jsong/CS352/Readings/CLAs.pdf [Broken]

Carry lookahead exist for counters as well but are easier because a counter passes through FC and FE before attaining FF, giving more time.
 
Last edited by a moderator:

Related Threads for: Can this 4 bit adder be further simplified?

  • Last Post
Replies
10
Views
10K
Replies
6
Views
5K
Replies
2
Views
3K
Replies
1
Views
1K
Replies
15
Views
4K
Replies
3
Views
1K
  • Last Post
Replies
7
Views
33K
  • Last Post
Replies
4
Views
4K
Top