A Simple and Affordable TTL Processor for the Classroom

Dave Feinberg
The Harker School
500 Saratoga Ave
San Jose, CA 95129
(408) 249-2510
davef@harker.org

ABSTRACT way to study computer hardware, we believe there is greater value

This paper presents a simple 4-bit computer processor design that in working with physical hardware, which provides the most
may be built using TTL chips for less than $65. In addition to convincing means for students to internalize the subtle interplay
describing the processor itself in detail, we discuss our experience between software and hardware.
using the lab kit and its associated machine instruction set to teach
computer architecture to high school students. 2. LAB KIT REQUIREME#TS
In setting out to find a hardware lab kit, we identified three key
Categories and Subject Descriptors requirements. The kit must (1) be understandable, (2) require
C.1.m [Processor Architectures]: Miscellaneous minimal assembly time, and (3) be purchased at minimal cost.
Striving to keep the processor as simple as possible naturally lead
to meeting all three requirements. To achieve a simple design,
General Terms however, it was necessary to give up many features of more
Design, Languages serious processors. As long as our processor's instruction set
comprised a universal programming language, we were willing to
Keywords sacrifice the ability to run large or even useful programs.
Architecture, Processor, Education Optimizations such as caching and pipelining would only obscure
the core computer science concepts we wished to illuminate.

1. I#TRODUCTIO# Like MIT's MAYBE, nearly all university hardware lab kits
In the fall semester of 2005, eighteen high school students at The and numerous amateur-designed processors feature the TTL chip
Harker School successfully connected TTL chips on solderless set. Although TTL has stringent voltage requirements, its ability
breadboards to build their own computer processors. Most of the to withstand static charge made it ideal for our course. Because
students had no practical electronics experience, beyond a basic TTL chips typically come in 4-bit packages, MIT's 8-bit MAYBE
understanding of serial and parallel circuits. We created this processor required 2 ALU chips, 2 counter chips, etc. Students
computer architecture course to complement the high-level assembling MAYBE kits frequently found themselves working
software focus of the AP computer science course these students through the night to complete their wiring. As this level of time
had already completed. Our primary goals for the course were: commitment is unacceptable for a high school class, we settled on
a 4-bit datapath for our processor. We feel certain that students
• to explore what a computer is can learn as much from building a 4-bit processor as an 8-bit one,
and a 4-bit processor means half as much time spent wiring and
• to examine the interplay between hardware and software
debugging, half as much money spent on chips, and a solderless
• to link machine code to high-level program constructs breadboard of half the size and cost.
As an undergraduate, the author was among the last of MIT's A search through simple processor designs used in various
6.004 Computation Structures students to use the MAYBE—a lab university computer architecture courses and those published
kit for building an 8-bit TTL computer processor. Future 6.004 online by amateurs revealed only a handful of 4-bit processors.
students would use hardware simulation software instead. As each of these was either too complex or insufficiently
Although such simulation tools present a powerful and affordable documented, we set out to design our own processor. In the
course, we referred to it affectionately as "the CHUMP" ("Cheap
Homebrew Understandable Minimal Processor").

3. DATAPATH
In all aspects of design, we aimed to identify the simplest
solution. Designing an understandable processor meant using a
RISC architecture, in which a simple datapath and small
instruction set could give rise to complex behavior. We decided
that the simplest design would involve fetching and executing the
instruction in the same clock tick. Since both the instruction and
the data it manipulated in RAM would need to be accessed in a
single tick, we stored our program separately in an EEPROM.
Each CHUMP instruction consists of two parts: an op-code
(indicating which operation the processor should perform) and a
4-bit constant/immediate value (used as a data value, RAM
address, or program line number). Hence, the CHUMP can only
manipulate 4-bit data values, representing numbers in the narrow
range from 0 to 15 (or -8 to 7). Likewise, it can only access 16
locations in RAM. Finally, the use of a single 4-bit program
counter means that programs cannot exceed 16 lines.
Although we originally sought to limit the instruction set to
just four or five essential instructions, we found that supporting a
set of 14 instructions did not complicate our design. This larger
instruction set allows students to write programs that would be
both readable and compact. Thus, a 4-bit op-code is required to
distinguish among the 14 instruction types, and each CHUMP
instruction uses 8 bits, as shown in Figure 1.

Figure 1: Anatomy of a CHUMP Instruction Figure 2: The CHUMP Processor

The CHUMP processor design is illustrated in Figure 2, with This processor design suffers from several major limitations,
each of the major components corresponding to a single TTL the most significant being the maximum program length of 16
chip. All bold arrows indicate 4-bit connections (4 wires). The instructions (which cannot even support the simplest meaningful
program counter chip (labeled "PC") stores the number of the program). Equally frustrating is the inability to write interactive
instruction currently being accessed from the Program ROM. A programs, which might pause for user input from switches.
multiplexer selects between the instruction's constant value and Finally, the CHUMP instruction set does not support comparison
the data value read from the RAM chip. The selected value may operations, which could be used to perform arithmetic on larger
then be used as: numbers.

• the second operand to the ALU, which may increase,

decrease, or replace the value stored in the accumulator Table 1. CHUMP Constant Instructions
register (labeled "Accum").
Instruction Summary Description
• the next instruction number
LOAD accum = const; load constant into
• the next address to read/write (stored temporarily in 0000 pc++; accumulator
flip-flops labeled "Addr") ADD accum += const; add constant to
0010 pc++; accumulator
When a value is read from memory, it is available for use in SUBTRACT accum -= const; subtract constant
the next clock tick by the subsequent instruction. Thus, it takes 0100 pc++; from accumulator
two clock ticks and two different instructions to first read from an store accumulator
address in RAM and then load this value into the accumulator. STORETO mem[const] = accum;
0110 pc++; value to constant
However, only a single instruction is required to store a value in address
the accumulator to memory. Not surprisingly, this asymmetrical READ addr = const; read from constant
behavior proved to be a stumbling block for students. 1000 pc++; address
The overall datapath was selected both for its simplicity and GOTO
pc = const; jump to constant
its computational power. It allows the program execution to jump 1010 instruction address
to a line number stored in RAM, and to use a value stored in if (accum == 0) jump to constant
RAM as the next RAM address to access. It also allows the value IFZERO pc = const; instruction if
in the accumulator to be used as the next line number or memory 1100 else accumulator is
address, provided the programmer first stores it to RAM. pc++; zero
 Each of these limitations is easily addressed by the addition A is zero. (For the 74LS181 chip, the relevant A=B pin indicates
of a couple more chips. Nonetheless, we elected to keep the core whether the ALU's output is 1111. Therefore, the ALU should
processor as simple as possible, and then to allow students to perform the Logic 1 operation for the GOTO instruction, and ot A
make such modifications at the end of the course. Although for the IFZERO instruction.)
several students were capable of implementing such
enhancements, ultimately none chose to do so (a good indication
that the limited CHUMP design was sufficient for our course). Table 2. Control Logic
Instruction ALU Accumulator RAM Jump
4. I#STRUCTIO# SET
The CHUMP instruction set features seven key operations, each LOAD B load read next
of which comes in two flavors: constant and memory. For ADD A plus B load read next
example, there is an ADD command for adding a constant to the
accumulator, and another ADD for adding a value from memory to SUBTRACT A minus B load read next
the accumulator. The 4-bit constant portion of the instruction is STORETO ignore write next
ignored by the seven memory commands. Table 1 describes the
seven constant commands. The corresponding memory READ ignore read next
commands operate similarly on a memory value, and have a 1 in GOTO [see text] ignore read load if Z
the op-code's low-order bit.
IFZERO [see text] ignore read load if Z
For example, the following program increments the value in
RAM location 2 repeatedly. Used properly, every READ
command should be followed by a memory command, and every Finally, the 4 op-code bits output by the program ROM must
memory command should be preceded by a READ command. be fed through a layer of combinational logic so as to determine
the values of the many control bits indicated above. Students
0: 10000010 READ 2 chose to use an additional ROM to perform this task.
1: 00010000 LOAD IT
2: 00100001 ADD 1
3: 01100010 STORETO 2 6. LAB KIT
4: 10100000 GOTO 0 A fully assembled CHUMP processor is shown in Figure 3.

5. CO#TROL LOGIC
We now describe the portion of the processor that examines the 4-
bit op-code and uses it to control the operation of each chip. The
CHUMP has 5 control points:
• Multiplexer: may select the constant or memory value
• ALU: may perform one of several arithmetic operations
• Accumulator: may load or ignore the ALU's output
• RAM: may perform either a read or write operation
• Program Counter: may load a new value or increment
Because the ALU must perform multiple operations, it
requires several control bits (6, in the case of the 74LS181 ALU
chip we used). Note also that the control bit for the RAM must
first pass through a flip-flop, so that it is clocked together with the
4 address bits. (We used a single chip for all 5 flip-flops.)
We used a single bit to control jumps. This jump bit
indicates either (a) the program counter should increment,
regardless of the value of ALU output pin Z (which can be used to
determine if the accumulator value is zero), or (b) the program
counter's behavior should depend on Z. (Consequently, an extra Figure 3: A high school student built this CHUMP lab kit.
logic gate is needed to determine the program counter's load input
from the jump and Z bits.) Table 2 summarizes the values of the
control bits used by the CHUMP. The multiplexer's control bit The clock circuit we used ran at just 1 Hz, allowing students
(not shown) is simply the low order op-code bit. to follow the execution of their programs in real-time. In practice,
Note that the ALU function for a GOTO command should we rarely used the clock circuit, relying instead on a simple RS-
always cause Z to indicate a zero value, while the function for an circuit to serve as a manual clock source. Only at the end of the
IFZERO command should cause Z to reflect whether ALU input course, when the entire kit had been fully tested, did students
replace the manual clock with the real one to watch their The remainder of the lab kit cost was due to the various IC
computer run automatically. chips listed in Table 3, along with several simpler chips used
earlier in the course (inverter, AND, OR, XOR). Also included in
Our piecemeal lab kit featured the IC chips listed in Table 3.
this cost were LEDs (one connected by 330Ω resistor to each of
Most are easily replaced by other available TTL-compatible chips.
the 4 accumulator output pins), DIP switches (used with 2.2kΩ
resistors as input for various lab assignments), transistors (used
only in the first lab), and various resistors and capacitors required
Table 3. Integrated Circuits Used for the power supply and clock circuits. Finally, $50 payed for a
Chip # Description Usage single classroom EEPROM programmer.
555 Timer clock source
7. COURSE CO#TE#T
74LS00 Quad 2-Input NAND jump bit logic The course was built around a series of digital electronics lab
74LS157 Quad 2/1 Data Selector select constant/memory assignments, listed in Table 5. In many of the labs, students were
asked to use simpler circuit elements to build more complex ones.
74LS161 4-Bit Counter program counter For example, students used flip-flops and logic gates to build a
74LS174 Hex D Flip-Flop next read/write address simple counter, thereby earning a counter chip for their kits.
(Likewise, successful completion of the final lab earned a student
74LS181 Arithmetic Logic Unit add/subtract, test if zero the right to use a real computer to implement a simple virtual
74LS377 Octal D Register accumulator register machine, assembler, etc.)
74S289 64-Bit RAM data storage
AT28C17 2k × 8 Parallel EEPROM program, control logic Table 5. Lab Assignment Sequence
Lab Assignment Summary
Keeping lab costs low was essential to make digital build voltage regulator;
5 Volts
electronics accessible to a high school classroom. As students learn to use breadboard, switches, LEDs
would be required to pay for their lab kits, we were determined to Transistors build logic gates from transistors
keep the cost of a lab kit comparable to that of a text book. While
most such university lab kits cost many hundreds of dollars, our NAND Gates build logic gates from NANDs
minimal kit wound up costing less than $65 each. Table 4 shows Combinational Logic build selector/adder from NOT/AND/OR
a breakdown of the major costs involved.
The Clock build clock circuit
Finite State Machines build FSMs from gates and flip-flops
Table 4. Major Lab Material Costs use counter to cycle through ROM data
Counter / ROM
Item Cost Recommended Vendor (later served as PC and program storage)
load/subtract input value from register
solderless breadboard $20 CircuitSpecialists.com ALU / Register
(later serves as accumulator datapath)
four 9-volt batteries $6 Target, Walgreens RAM Datapath add selector, flip-flops, and RAM
22- or 24-gauge solid wire $5 Fry's Electronics connect program counter, control ROM;
Control Logic
set 4-bit op-code to test instructions
two AT28C17 EEPROMs $4 Jameco Electronics connect program ROM and clock;
Program Execution
wire stripper $4 Jameco Electronics write/execute programs
large plastic bin $2 Wal-Mart
The building of the processor was assigned incrementally,
needle-nose pliers $2 Orchard Supply Hardware
rather than as one large project. Thus, seven of the assignments
74LS181 ALU $2 Jameco Electronics listed in Table 5 walked the students through the building of a
particular subsystem of the emerging processor. Although these
labs provided students with the design (and sometimes explicitly
Although the CHUMP can be assembled on a much smaller told students which pins to use), the layout of chips on the board
board, a solderless breadboard with 3000+ contact points was and much of the wiring decisions were left to the students.
selected to give students greater flexibility in laying out
components. Such boards typically sell for $35, so finding them The course also addressed a variety of conceptual material,
online for $20 was critical in keeping the lab kit affordable. including the static discipline, Karnaugh maps, finite state
machines, and a cursory discussion of computability. In focusing
A 7805 voltage regulator (and requisite capacitors) provided only on material essential for teaching what a computer is, we
a steady 5-volt power source for the various chips. It requires an omitted topics such as timing, pipelining, caching, interrupts,
input of 7.5 – 12.5 volts to work effectively. Rather that using an virtual memory, and operating systems. On the other hand,
AC/DC adapter (easily destroyed by a temporary short), we opted students would not truly understand what a computer is without
to use a single 9-volt battery, and purchased several per lab kit. understanding what it means for a machine or language to be
universal. Thus, the final two weeks of the course were devoted worked, and how to translate the simplest Java code segments into
to an exploration of the power of the CHUMP language itself. machine language.
Of course, there are a few aspects of the course that did not
8. THE CHUMPA#ESE LA#GUAGE work out as well as we had hoped. In our software-based courses,
Clearly the CHUMP's 64-bit RAM is no match for a Turing students are able to debug most errors without teacher assistance.
machine's infinite tape. Therefore, we began talking about what When a student does need help, a quick glance at their output or
the CHUMP language could do if it weren't limited by 4-bit code is usually sufficient for us to advise them as to what to try
values, addresses, etc. We referred to this unlimited form of the next. Our experience teaching computer architecture, however,
language as "Chumpanese", and represented it with an assembly- was entirely different. Although a few students did master the art
like syntax. In Chumpanese: of hardware debugging, many of our best programmers found
themselves helpless to debug their circuitry. It seemed that
• Programs may be arbitrarily long.
students were constantly asking for help from every corner of the
• All values are integers of arbitrarily large magnitude. classroom. Because a hardware bug typically takes much more
time to address than a software one, helping a single student could
• There are an infinite number of memory locations. easily devour an entire class period, while other students grew
• Names are used to identify line numbers, memory increasingly frustrated waiting for help.
addresses, and memory offsets. Although the processor design proved to be robust and
For example, the following listings show a simple reproducible, the students found some of the supporting elements
Chumpanese program and an equivalent Java program. of the lab kit to be frustrating at times. By far, the largest
hardware frustration we faced concerned power consumption.
loop: READ count while (true) Students spent hours debugging problems due only to dead
LOAD IT count++; batteries. Although the simple circuits students built at the
ADD 1 beginning of the course did not draw much current, the completed
STORETO count CHUMP, with its EEPROMs, RAM, ALU, etc., drained the 9-volt
GOTO loop
batteries at a rate sometimes exceeding one battery per hour of
It can be shown that Chumpanese is indeed a universal use. We therefore needed to replace batteries frequently near the
language by demonstrating that any program in a known universal end of the course.
language can be translated into an equivalent Chumpanese
Finally, students had difficulty with the CHUMP instruction
program. (For example, the universal One Instruction Computer's
set. They frequently confused the READ and LOAD commands, as
SUBZ command can be translated into a sequence of nine
well as the constant and memory variants of each instruction.
Chumpanese instructions.) However, we decided that such a
This confusion hampered their ability to debug their processors,
proof would be tedious and potentially unconvincing to our
although most students understood the instruction set by the time
students. Instead, we aimed to develop their intuition that
the course ended. In retrospect, we wish we had provided the
Chumpanese was universal by teaching them how to emulate the
students with a Chumpanese virtual machine, and had them use it
common programming constructs of a language they already
to complete a set of programming exercises before assigning them
believed to be universal: Java.
to wire the CHUMP datapath.
We therefore taught students to represent variables as
It would also have helped to leave more time at the end of
memory addresses in Chumpanese, to translate if and while
the course to explore more advanced Chumpanese programs
statements into sequences with IFZERO and GOTO commands, to
involving procedures. These exercises proved to be too much for
see reference-type variables as memory locations containing all students to grasp in a limited time. Nonetheless, the students'
addresses of other memory locations, to represent arrays and initial skepticism regarding the power of their simple processors
simple objects (really structs) as contiguous segments of memory, gradually disappeared. Ultimately, we believe students left the
and to view array indices and instance variable names as offsets course with an appreciation for how even the most high-level
into that memory. We showed students how to represent a stack software must run as a sequence of simple commands by a
and how to write Chumpanese sequences that could push/pop computer processor which is no more than an arrangement of
stack values. Finally, we taught students to use PUSH and POP fluctuating voltages.
macros to implement procedures and procedure calls, thereby
connecting their understanding of computer architecture to the
material they had studied in AP Computer Science. 10. REFERE#CES
[1] Lancaster, D. E. TTL Cookbook. Howard W. Sams,
Indianapolis, IN, 1974.
9. REFLECTIO#S
On the whole, the course and the lab kit were overwhelming [2] Madnick, Stuart. Understanding the Computer (Little Man
successes, with all 18 students building functional computer Computer). Unpublished manuscript, 1993.
processors (with varying degrees of help). Students enjoyed the [3] Patterson, D. A. and Hennessy, J. L. Computer Organization
course quite a bit, and final exam responses indicate that most left and Design. Morgan Kaufmann, San Francisco, CA, 2004.
with a thorough understanding of how to design combinational
[4] Ward, S. and Terman, C. 6.004 Computation Structures.
logic circuits and finite state machines, how their processor
MIT OpenCourseWare, 2002