This lab should be done with a partner of your choosing.
[~]$ setup31 labs/03 tdanner1Once the script finishes, Tejas (tdanner1) should run
[~]$ setup31 labs/03 mdanner1
For the next step only one partner should copy over the starting code
[~]$ cd ~/cs31/labs/03 [03]$ cp -r ~adanner/public/cs31/labs/03/* ./ [03]$ ls part1.circ alu.circNow push the changes to your partner
[03]$ git add *.circ [03]$ git commit -m "lab 3 start" [03]$ git pushYour partner can now pull the changes. In this case if Tejas wishes to get files Molly pushed, he would run
[~]$ cd ~/cs31/labs/03 [03]$ git pull
Using git, you should be able to submit only part1.circ for your checkpoint this week, and only alu.circ for your full solution next week. We will only look at your part1.circ for the checkpoint, and we will only look at alu.circ for the full solution, even if they are both submitted this week and next.
$ logisim # start a new session $ logisim alu.circ # run on an existing circuit fileHere are a few other suggestions on where to begin. You don't have to do these all, but I suggest you do some of them:
$ logisim part1.circEdit the text at the top of this file to list your and your partner's names.
Sign extension is an common operation performed inside a CPU. It is used when combining a value(s) of types smaller than the registers holding the values. Create a circuit (Project→Add Circuit) that takes a 2-bit 2's complement number and performs sign extension so that the output is an equivalent 4-bit 2's complement number. Name this circuit something like signext2to4. Be sure to label each of your input and output values. Your input should be labeled so that the least significant input bit is a0 and the most significant input bit is a1. Following the same pattern, label your output bits b0 through b3.
Create a 1-bit full adder as a new circuit (Project→Add Circuit). Name this circuit fulladder. Your full adder should take 3 inputs (X, Y, CarryIn) and yield two outputs (Sum, CarryOut).
Start with the truth table for $$X + Y + C_{\mathrm{in}} = \mathrm{Sum}, C_{out}$$ and then translate this into a circuit using basic gates only. (i.e. there is an adder circuit in logisim, you cannot use that to solve this problem, you have to build your own).
Once built, test out your cicuit for all possible input values.
Add a new circuit fulladder4 that takes 2 4-bit input values, x and y, and 1 1-bit input value, carry-in, and produces a 4-bit sum output value, and a 1-bit carry-out value. To build this circuit you should use four copies of your 1-bit adder to add each digit. The two 4-bit input values can be represented as a single input of size 4 and then you can use a splitter to get the value of each bit.
You do not need to worry about overflow, but you should add a probe to the carry out bit wire to see when it is 0 or 1.
Test out your 4-bit adder for differnt input values.
NOTE: The 4-bit adder you are building adds two 4-bit numbers, whether they are unsigned or 2's complement. The only difference has to do with overflow -- which you aren't dealing with in this question -- the addition is the same either way.Test out your resulting cirucit for different input values. Use the poke tool to change the bits of an input value. Do NOT hook up a clock and a counter to this circuit's input; the 3 input values x, y, and carry_in should come from the input. You can use a counter for testing, but the version you submit should not have this.
In this part of the lab, you will implement part of an arithmetic logic unit. Your answer will be stored in alu.circ. The ALU is the part of the processor that performs mathematical and logical operations. Your ALU should use components from Logisim whenever possible. For example, do not build a 8-bit adder -- simply use the 8-bit adder that is already part of Logisim.
To use an 8-bit adder, open the Arithmetic folder and select Adder. The default Adder has "Data Bits" set to 8. That is an 8-bit adder. The inputs to an 8-bit adder are also 8-bits, so you need to hook up an 8-bit input pin. The output is 8-bits, so you need to hook up an 8-bit output pin. The carry-in and carry-out bits are only 1-bit each.
Your ALU will perform 8 arithmetic functions on two 8-bit inputs, producing one 8-bit output, and five 1-bit ouputs (condition code flags). In addition it will have one 3-bit input, the opcode, which will select which of the 8 arithmetic functions to perform. Implement this in your circuit using a multiplexor with 8 inputs, one for each function result, and 3 select lines. (In Logisim, be sure to change "Include Enable?" from "Yes" to "No".) The function you perform will depend on the value of the 3 select lines. Assuming the inputs are called X and Y, you will perform:
Remember that the ALU does not know, nor does it care, if the operands are signed or unsigned values. It will set the OF and the CF flags to 0 or 1 on every addition or subtraction.
Your final ALU circuit should look like this when you use it as part of a larger circuit:
If your circuit layout does not match this, then right-click on your alu circuit in circuit menu and Choose Edit Circuit Appearance. Then move your input and ouput to the corresponding locations to match those above.
I suggest that you test your ALU curcuit as you go; add a little functionality, stop and test that functionality by trying out different input values using the poke tool, once that part works, then add a little more functionality ...
You may also want to add a tester circuit into which you can plop a copy of your alu, and from which you can do more extesive testing on your entire circuit. You could use counters and clocks here to cycle through a set of values if you'd like. You can also use input values stored in 3 ROMs: one for op; one for x; and one for y. Then use a counter and clock to feed addresses into the three ROMS to get the next set of x, y, and opcode input to test.
Logisim hint: If you have an 8-bit number and you want to access just the bits individually, you can use the Splitter located under Wiring. If you set "Fan Out" to 8 and "Bit Width In" to 8, you'll be able to turn any 8-bit input into 8 1-bit outputs. You can also do the reverse by simply connecting 8 1-bit inputs to one side of the splitter and getting 1 8-bit output back out.
To submit your code, simply commit your changes locally using git add and git commit. Then run git push while in the labs/03 directory. Only one partner needs to run the final push, but make sure both partners have pulled and merged each others changes. See the section on using a shared repo on the git help page.