CHUMP: ICS4U 4-bit TTL Processor Project

 

Given that ACES is an acronym for Advanced Computer Engineering School it seems reasonable to introduce students to just that: building their own processor from scratch. As Ken Shirriff reminds us, "Before the microprocessor era, minicomputers built their processors from boards of individual chips." It is highly instructive for ACES to physically manipulate and explore this precise architecture prior to their undergrad years, so here we go...

Of the variety of designs to choose from, our preference is for a 4-bit design based on TTL chips due to their availability, project documentation, and suitability for our background. PDF Reference: A Simple and Affordable TTL Processor for the Classroom. D. Feinberg.

Breadboard Photo IC Discussion
Chip # Description Who? Usage
555 Timer LM Clk: clock source
74LS00 (Digikey) Quad 2-Input NAND JP NAND: jump bit logic
74LS157 (Digikey) Quad 2/1 Data Selector SP SEL/MUX: select constant/memory
74LS161 (Digikey) 4-Bit Counter JL PC: Program Counter
74LS174 (Digikey) Hex D Flip-Flop MM Addr: next R/W address
74LS181 (ABRA) Arithmetic Logic Unit (ALU) JD ALU: Logic/Arithmetic test if zero
74LS377 (Digikey) Octal (8) D-Type F/F CM Accum: accumulator register
74S289 (ABRA)
74S189 (ABRA)
64-bit RAM EP RAM: data storage
AT28C16 (ABRA) 2k x 8 Parallel EEPROM FF Program Code and Control logic

CHUMP Task Sequence

You are about to embark on a hardware project that holds the promise of being one of the most important achievements of your young scholastic career, that is, to build a 4-bit computer from scratch. Reaching the summit will test your passion, dedication, and commitment to an engineering undergraduate program. D. Raymond and J. Corley accomplished the feat in their 2018/2019 ICS4U year:

https://www.youtube.com/embed/vZ13xud0qBc

 

 

  1. Code. With reference to the CHUMP Instruction Set, develop and submit a unique and (somewhat) interesting CHUMP program (presented in the manner below) as your first DER entry in your CHUMP Report. Your goal will be to demonstrate that the program you write this week, will run on the processor you build six weeks from now.

  2. Clock. Following Ben Eater's terrific 4-part video series on the 555-based Clock module, build, test and report on your own module. This will be the heartbeat of your CHUMP. For this project you MUST use the following parts I supply you with: Quad breadboard, 500 kΩ trim pot, rectangular LEDs (red, green, yellow), 3×555 timers, strip of 0.1μF caps, TTL AND, OR, NOT logic ICs, slide switch, and bags of 0.3" and 0.4" preformed jumper wires. Please take great care with these parts; they are not replaceable. Power can come from a 5V AC/DC adapter or your Arduino for the time being. Finally, for both your text and video presentations, strive to be as clear, concise, and detailed as Eater has been in his presentation, even going one better than him with a video that is under 3 minutes:)

     

  3. Arithmetic and Logic Unit (ALU). Assemble, test, and report on the SN74LS181 ALU Module. This stage represents the final independent exploratory module before we attempt to build our entire processor. Using the components you have been provided with (additional breadboard, 3" coloured jumper wires, SN74LS181, bargraph and 270 Ω bussed resistor network) and employing ACTIVE HIGH logic, wire up an ALU circuit that can be used to explore the 32 functions (16 logic and 16 arithmetic) the IC is capable of performing. For this submission only, arrange your circuit so that it closely matches the diagram below. (SN74LS181N.fzz) Note. If you're using Fritzing for your processor the generic IC component is probably your best bet. The inspector allow you to edit some characteristics. Finally, make a sincere effort to lay our your board with care and consideration so that your ALU video is clear, informative, and compelling to view.

  4. EEPROM. As a replacement for the complex combinational logic circuitry that would provide dynamic control for our processor's various modules and to provide storage for the machine language version of our program, we need to construct an EEPROM programmer for the two AT28C16 parallel EEPROM ICs our build requires. The Arduino nano or UNO serves as control for our programmer. Task. After viewing Eater's two (incredible) videos, create the programmer sketch and flash your code from Stage 1 into the AT28C16 EEPROM you have been provided with.

    Thinking ahead...as each of you will be required to create a shield for the Dolgin Development Board, an implementation of this programmer (that uses a 24Pin ZIF socket) based on the ATtiny84 would be a wonderful legacy asset for the DES.
  5.  

  6. IC. This stage requires that you introduce your peers to the specific CHUMP IC that you have been assigned (above) in the form of a clear and detailed 5-minute in class presentation. After which, over the course of the next few weeks, as questions arise from your classmates about your IC you will be required to provide answers and possible solutions. A fourth entry in your DER's CHUMP Report will summarize your presentation.
  7. Processor (Build). Ok, the big, next-to-last, module. After serious planning and layout considerations, using the TTL chipset described above, lengths of colour-coordinated hookup wire and LEDs available to you to, position all your processor's ICs on your chosen breadboard platform. The TTL ICs are NOT replaceable, so use the IC pullers provided to GENTLY relocate ICs, if necessary. For the purposes of confirming the Program Counter and Program EEPROM are functioning correctly, I have preflashed your Program EEPROM with the contents depicted in the screen capture below, right (click to enlarge). Two 3" jumper wires, on the input addresses A4 and A5, can be repositioned to address each of the four output test sequences. Complete the wiring up to the point where the four output test sequences can be confirmed.

    Once this is completed, return your Program EEPROM to me and I will flash the sample (common) code from Step 1 above onto it. The supplied Control EEPROM already has control codes flashed onto it. Complete the wiring of the full processor, perform testing and complete the ER reporting for this module.

    Focus of this Module EEPROM Output Test Sequences

  8. Processor (Executable). For this final stage I would suggest confirming Feinberg's Sample Code (below, left) with the Control EEPROM contents (below, right). Once this appears to be functioning you finally consider the code you submitted in the initial phase, hopefully making a MINIMUM of adjustments to it, knowing now what you did not appreciate then. Once you've settled on the program, you are to provide me with a hexadecimal encoding of both your program and its corresponding control codes. I will use this information to flash your EEPROM and return it to you for final testing and execution of your processor. Add one final subsection to your CHUMP project in your ER and complete the final Media and Reflection sections.

    Feinberg's Sample Code CHUMP Control EEPROM (p. 133 AVR Optimization)

  9. Presentation Day. Congratulations! You have completed a task unlike any other you or anyone else has ever undertaken. On this day you have the opportunity to demonstrate to your peers that you have developed a one-of-a-kind processor capable of running software in a language that you, yourself, designed and implemented. Simply amazing :)

 

 

Related

References

 

Jackson Russett's EEPROM Programmer Shield (Rollover):

 

Links