Home CPSC 305

Build a CPU Part 1

Due: April 10

Objective

To implement hardware components necessary to build a CPU.


Overview

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.


Arithmetic Logic Unit

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:

  1. The first argument which is a 16-bit value.
  2. The second argument which is also a 16-bit value.
  3. The operation code, or "opcode" which selects which of its operations the ALU should perform on the arguments. The opcodes are given below:
OpcodeOperationMeaning
0Andoutput = in1 & in2
1Oroutput = in1 | in2
2Xoroutput = in1 ^ in2
3Notoutput = ~in1
4Addoutput = in1 + in2
5Subtractoutput = in1 - in2
6Multiplyoutput = in1 * in2
7Set less thanoutput = (in1 < in2) ? 1 : 0
8Shift leftoutput = in1 << in2
9Shift rightoutput = in1 >> in2
10-output = in1
11-output = in1
12-output = in2
13-output = 1
14Equal Zero?output = (in1 == 0)
15Not 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 0) 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.


Register File

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:

  1. The clock signal, so that the writes can be synchronized with the rest of the CPU. Note that this must be a pin, and not an actual clock.
  2. A clear signal, which can be used to set all 16 registers back to 0.
  3. The write data, which is a 16-bit value.
  4. The write address, which is a 4-bit value which determines which of the 16 registers we are writing.
  5. A write enable signal, which is a single bit and determines whether we are doing a write this clock cycle. If 0, nothing is written. If 1, then the write happens when the clock goes from low to high.
  6. Read address 1, which is a 4-bit value determining which of the registers to read for the first read value.
  7. Read address 2, which is a 4-bit value determining which of the registers to read for the second read value.

The register file has only two outputs:

  1. Read 1 value, which is a 16-bit value giving the first read value.
  2. Read 2 value, which is a 16-bit value giving the second read value.

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.


Screen Memory

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:

  1. The clock signal, so that the writes can be synchronized with the rest of the CPU.
  2. A clear signal, which can be used to turn off all pixels at once.
  3. The write data, which is a 16-bit value. Each write will be for an entire row.
  4. The write address, which is a 4-bit value which determines which of the 16 screen rows we are writing.
  5. A write enable signal, which is a single bit and determines whether we are doing a write this clock cycle. If 0, nothing is written. If 1, then the write happens when the clock goes from low to high.

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.


Submitting

When you feel sure that your three components work as required, email the .circ file to ifinlay@umw.edu.

Copyright © 2018 Ian Finlayson | Licensed under a Creative Commons Attribution 4.0 International License.