Question

Design a 4-bit ALU with the truth table above. In this design A and B are two 4-bit binary inputs, s0, s1, s2, s3 and Cin are control signals. There is no need to draw the internal circuits of MUX & Full adders but I need the logic gates drawn out.

S3 S2 s1 Cin Operation 0 A 0 0 0 1 A+1 0 0 1 10 A+B 0 1 1 A+B+1 A+B 0 0 0 0 0 A+B'+1 0 1 1 A-1 0 1 1 1 0 0 АЛВ 1 0 1 A vB 0 АӨВ 1 X 0 1 1 X A' 1 X X X SHR 1 1 X X SHL SO

Answer 1

The ALU—Arithmetic Logic Unit
A CPU consists of three main sections: memory for variables (registers), control circuitry (microcode), and the ALU. The ALU (Arithmetic Logic Unit) is the part of a CPU that actually does calculations and condition testing.

For example, if you wish to add two binary numbers, it is the ALU that is responsible for producing the result. If your program needs to execute some code if two values are equal it is the ALU that performs the comparison between the values and then sets flags if the condition is met or not.

as many of the IBM mainframe computers) were actually built with discrete 4000 and 7400 series chips.

This means that you can build a CPU at home! So why not?

This project will be a discrete 4-bit ALU that will be constructed with 4000 series and 7400 series chips.

Project Prerequisites
Because this project is rather complex you will need the following:

Basic understanding of boolean concepts
Basic understanding of logic gates

Binary Addition
Two fundamental ALU operations are addition and subtraction.

The Theory
Adding binary digits (individual bits) is rather easy and is shown in the list below (all the possible combinations):
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10 (This is also 0 + carry bit)
But how do we add binary numbers that are more than one digit long? This is where the carry bit comes into play and we need to use long addition.

Carry bits are used as shown below where "0(c)" means "no carry bit" and "1(c)" means "carry bit".

0 + 0 +0(c) = 0
0 + 1 +0(c) = 1
1 + 0 +0(c) = 1
1 + 1 +0(c) = 10
0 + 0 +1(c) = 1
0 + 1 +1(c) = 10
1 + 0 +1(c) = 10
1 + 1 +1(c) = 11
If we wish to add 10 and 10 in binary form, we would start by writing them down in the form of long addition. We add the bits up in columns using the rules above starting from the far right and moving to the left. When we have a carry from a bit addition, we move it one column to the left, where it gets included in the addition as a bit.

Carry> 0 1 0 1 1 0 0 0 1 11 o0 Word A Word B Result Right to left Add Down Long addition of binary numbers

The Circuit
The half adder has two inputs and two outputs as shown in the diagram below. The two inputs represent two individual bits, the Sum output represents the sum of the two bits in the form of a single bit and the Carry output is the carry bit from the addition.

Half Adder A- SUM B Carry Half adder circuit, which uses an AND gate and an exclusive-OR (XOR) gate A B Sum Carry 0 0 0 0 1 1 1 0 1 1 1 0 1 Truth table for half adder

Full Adder Carry In Half Adder Half Adder A Sum Sum A A Sum B Carry B B Carry Carry Out A full adder made by using two half adders and an OR gate

Binary Subtraction
The Theory
Now that we can add two 4-bit numbers, how do we subtract binary numbers? To do this, we will implement a binary system called “two’s complement”. The system has a few rules:

To negate a number (e.g., change 5 into -5), flip all the bits and add 1.
A number is negative if the MSB (most significant bit) is 1. For example:
10010 is negative
00010 is positive
Note that by following rule 1 you can determine the value of a negative binary number:

0001 = 1: Negate this = (1110 + 1 = 1111) = -1
1001 = -7: Negate this = (0110 + 1 = 0111) = 7
0110 = 6: Negate this = (1001 + 1 = 1010) = -6
The two’s complement technique is beneficial because it allows us to perform both addition and subtraction using the same adder circuit. So if we wish to turn our 4-bit adder into a 4-bit adder/subtractor, we just need to incorporate a single 4070 IC (quad XOR). We feed the binary number inputs into one input of each XOR gate, use the other XOR input as an add/subtract line, and then feed this same line into the carry in of the adder.

When we wish to subtract B from A, we make the subtract line high. This does two things:

Flips all the incoming bits on input B
Adds one to the adder

4 Bit Adder /Subtractor 4008 4 Word A A Result SUM 4 B Cout OverFlow BO B0 Cin B1 B1 When (ADD / SUB) 1 Result A B B2 B2 When (ADD SUB) = 0 Result A+ B B3 B3 ADD SUB The complete 4-bit adder/subtractor Word B

The final circuit will also use a 74HC125 quad buffer on the output so that the adder/subtractor unit can be connected to a common data bus for the output. The buffer also has an enable line that allows us to choose the output from the adder/subtractor.

With the adding/subtracting unit done, it's time to look at the logical functions.

Logical Functions
Logical functions are useful when bit manipulation is needed. Imagine a microcontroller that has an 8-bit port, and you use the lower 4 bits to read from a 4-bit data bus. When you read from the port you will need to remove the upper four bits, as those bits can affect program execution. So to remove these bits, you can mask them out with a logical AND function.

This function will AND bits from one word (the port) with another number (the number that will remove the upper four bits). If we AND the port with 0x0F (0b00001111), we preserve the lower four bits (because x AND 1 = x) and remove the upper four bits (because x AND 0 = 0).

AND is used to remove bits
NOT is used when you need to flip all the bits (0000 will become 1111)
OR is used to merge bits (0110 OR 0001 is 0111)
XOR is used to flip selected bits (0101 XOR 0100 is 0001)
The logical units in our ALU are AND, OR, XOR, and NOT gates connected to buffers. An enable line feeds into each bus buffer for each logical unit so that each unit can be selected individually.

4081 - Quad AND gate
4070 - Quad XOR gate
4071 - Quad OR gate
4049 - Hex NOT gate
74HC125 - Output buffers (for bus isolation)

AND Operation A Output B OR Operation Output XOR Operation A Output NOT Operation Output A Logic gates showing the four logical functions of our AL U AB B