To implement hardware components necessary to build a CPU.
This is first part of a two-part project in which you will build a simple, but complete computer in Logisim. For this part, you will build three components that will be key parts of the overall computer design.
Each of these components should be created as separate circuits. For this assignment, you should use the "main" circuit to test the three components. In part 2 of this assignment, you will build the complete computer which will incorporate the components from this assignment, with some additional logic.
The first of three components is an Arithmetic Logic Unit (ALU) which is a circuit which can perform multiple operations on input values. The ALU should have three input pins:
| Opcode | Operation | Meaning |
| 0 | And | output = in1 & in2 |
| 1 | Or | output = in1 | in2 |
| 2 | Xor | output = in1 ^ in2 |
| 3 | Not | output = ~in1 |
| 4 | Add | output = in1 + in2 |
| 5 | Subtract | output = in1 - in2 |
| 6 | Multiply | output = in1 * in2 |
| 7 | Set less than | output = (in1 < in2) ? 1 : 0 |
| 8 | Shift left | output = in1 << in2 |
| 9 | Shift right | output = in1 >> in2 |
| 10 | - | output = in1 |
| 11 | - | output = in1 |
| 12 | - | output = in2 |
| 13 | - | output = 1 |
| 14 | Equal Zero? | output = (in1 == 0) |
| 15 | Not Equal Zero? | output = (in1 != 0) |
The ALU should contain a single output pin which is a 16-bit value containing the result of the operation as described above.
The blank operations will be used for operations such as memory accesses that do not use the ALU. Each of the outputs just passes along an input (or 1) which will make wiring it slightly simpler.
In order to build the ALU, you should route the arguments through circuits which compute each of the results, and route those into a multiplexer (under the "Plexers" menu). Use the opcode as the selector input of the multiplexer.
To implement the comparison operations, use a "Comparator" circuit. Because our CPU will support negative numbers, you should use 2's complement comparisons.
For this reason, the right shift operation should be done using an "arithmetic right shift", which maintains the sign bit as it shifts, as opposed to a "logical right shift" which does not.
The comparators output a single bit. In order to extend this to the 16-bit result, you can use a "bit extender" to zero extend the value (pad some number of zeroes to the end).
To test your ALU, create one in main, and connect pins for the inputs and the opcode, and connect the output to an output pin. Check that each opcode works as described above on a few inputs each.
The register file is a very small memory that contains the working set of values used by our computer. The register file stores just 16 registers, each of which is 16 bits large. The register file supports two reads and a write at the same time.
The register file should take the following inputs:
The register file has only two outputs:
To create the register file, add 16 registers from the "memory" section and set them to store a 16-bit value. Connect all of the clear inputs to the incoming clear signal, and all of the clock inputs to the incoming clock signal.
To allow data to be stored in the register file, connect the write data to the data port of each register. You must ensure that data is only written to each register when the incoming write enable input is true, and also when the write address matches the register in question. You should use a "decoder" for this purpose (under the Plexers menu). The decoder will transform the 4-bit address into 16 1-bit selection lines. You should change the decoder's "disabled output" to "zero" instead of "floating".
To allow the register file to be read, you should connect each of the register output values into a multiplexer, and use the read address input as the multiplexer's selector signal. The output of the multiplexer would then give you the value of the register being read. You will need to to this twice: once for each of the two values we can read.
To test your register file, create one in main and connect pins to it. It should store values which you can later retrieve using the read and write inputs.
Our CPU is going to have a screen somewhat like the Game Boy Advance in mode 3 in that the pixel values are mapped to a section of memory. Writing into this memory will update the screen. To support this, you should create a screen memory component.
The screen memory is similar to the register file in that it will store 16 values which are each 16-bits. Our computer's screen will be 16 rows by 16 columns, and be monochrome - each pixels is either on or off. Each of the 16 registers represents one row, and each bit position represents one column.
The screen memory will be write only, but will show all of its rows onto a graphics display. It should have the following input pins:
The screen memory will have an 16 output pins, each of which is 16 bits. These will provide each of the 16 rows and will be fed into the actual screen of the computer.
To test the screen memory, create one in main, and try to store and retrieve values. If you want to see how it will work when connected to a screen, you can add an "LED Matrix" from the Input/Output section, and set it to be 16 by 16, and set the Input Format to be Rows. Then connect the 16 row outputs of the screen memory to the 16 inputs to the LED screen.
When you feel sure that your three components work as required, submit the .circ file to the assignment on Canvas.