Executive Project Report

                                       On

                     EEPROM based Computer

Mentors:-

1) Radhika

Dept of Electronics and Communication engineering

National Institute of Technology

Surathkal, Karnataka – 575025

7483426012

2)Jayanth Jha

Dept of Electronics and Electrical enginnering

National Institute of Technology

Surathkal, Karnataka – 575025

3)Bhavy Parashar

Dept of Electronics and Communication engineering

National Institute of Technology

Surathkal, Karnataka – 575025

9983287155

Mentees:-

1)Shreyan Ghosh

   Dept of Electronics and Communication engineering

   National Institute of Technology

   Surathkal, Karnataka – 575025

   8294138499

2) Ashmita Das

   Dept of Electronics and Communication engineering

   National Institute of Technology

   Surathkal, Karnataka – 575025

   7892120620

3) Ayush Srinivasan

   Dept of Electronics and Communication engineering

   National Institute of Technology

   Surathkal, Karnataka – 575025

   6363677240

4) Jay Surya

   Dept of Electronics and Communication engineering

   National Institute of Technology

   Surathkal, Karnataka – 575025

   9032081105

INTRODUCTION:

An EEPROM-based 8-bit computer is a minimalist, educational computer system that uses EEPROMs (Electrically Erasable Programmable Read-Only Memory) to implement key parts of its architecture—often including the control logic or even the entire instruction set. These kinds of projects are popular among hobbyists, educators, and retro-computing enthusiasts for learning about computer architecture from the ground up.

An 8-bit computer processes data in 8-bit chunks. That means:

1) Registers, data bus, and ALU operations are 8 bits wide.

2)It typically supports simple instructions like load, store, add, jump, and compare.

In an EEPROM-based design, EEPROMs are used to:

1)Store microcode (the low-level control signals for each CPU instruction).

2)Sometimes serve as ROM for the program code.

3)Allow easy reprogramming of the computer’s behaviour.

Why Use EEPROM?

1) Customizable: You can design your own instruction set or behaviour by reprogramming the EEPROM.

2) Simple Hardware: Avoids the need for complex programmable logic devices or CPUs.

3) Educational: Teaches how microcode and control logic work at a low level.

Example Architecture (Inspired by Ben Eater’s 8-bit Computer):-

EEPROM (2x)

Microcode ROM (addressed by instruction + step counter)

RAM (8-bit wide)

Stores user programs and data

ALU

8-bit adder/subtractor

Registers (A, B)

Temporary data storage

Instruction Register

Holds the current instruction

Program Counter

Tracks instruction address

Output Register

Drives LEDs or display

Control Unit

Sequencer + microcode

 LITERATURE REVIEW:

1. Historical Context and Relevance

EEPROM-based 8-bit computers draw inspiration from early computing systems (1970s–80s), when 8-bit processors like the Intel 8080, Zilog Z80, and MOS 6502 were dominant. These processors laid the foundation for personal computing. Today, simplified replicas using discrete logic and EEPROMs aim to demystify computer architecture, especially for educational purposes.

Tanembaum, A.S. in Structured Computer Organization outlines the basics of microarchitecture, which closely aligns with how EEPROMs are used for microcode storage.

Digital Design and Computer Architecture by Harris & Harris also covers control units, helping to justify EEPROM’s role in implementing control logic.

2. Educational Motivation

Modern designs like those by Ben Eater and various hobbyist communities use EEPROMs to store microcode that drives control logic. These platforms are used in classrooms and self-study to illustrate core computer architecture concepts:

Control signal generation

Instruction decoding

Microinstruction sequencing

Researchers and educators have noted that building such computers from scratch enhances comprehension of low-level processing, in contrast to abstracted modern CPUs.

Reference: L. Malavasi et al., “Learning computer architecture by building a breadboard CPU”, 2019, IEEE EDUCON.

3. Technical Design Patterns

EEPROM-based CPUs typically implement the control unit as a combination of:

An Instruction Register (IR) for the current opcode.

A Timing/Step counter (usually a 3-bit counter).

A set of EEPROMs (e.g., 2 AT28C64s) addressed by IR and counter, outputting control signals.

Each address in the EEPROM represents a unique step in the execution of a given instruction, and the output defines what action is taken (e.g., enable register, increment PC, read/write RAM).

This design allows for:

Custom instruction sets

Simplified debugging and modification

Flexible experimentation with control flow

Reference: Ben Eater’s 8-bit computer project (YouTube and website) is widely cited and used as an open-source blueprint.

4. Modern Relevance and Applications

While not practical for real-world computing, EEPROM-based 8-bit designs:

Serve as excellent teaching tools

Are used in museum demonstrations

Inspire retrocomputing and embedded hobbyist communities

Aid in logic design and digital systems courses

Additionally, projects like the Gigatron TTL computer and SAP-1/2 replicas show how EEPROMs can substitute complex hardware state machines with programmable logic.

Reference: Gigatron Project Documentation, 2018
SAP-1 and SAP-2 (Simple As Possible Computer), as described in Malvino & Brown’s Digital Computer Electronics.

5. Challenges in EEPROM-Based Design:-

Limited speed: EEPROM access times (150–250 ns) make them unsuitable for high-speed applications.

Reprogramming requirement: Changing instruction sets or control logic requires EEPROM programming tools.

Complexity for beginners: While simplified, the microcode concept can still be abstract for total beginners without guidance.

Suggested improvements include using microcontrollers to dynamically load EEPROMs or simulate EEPROM behavior using RAM and a bootloader.

METHODOLOGY:-

1. System Design and Planning

Objectives:

Build an educational 8-bit computer using discrete components.

Use EEPROMs for storing microinstructions (control logic).

Implement a basic instruction set including data transfer, arithmetic, and jump operations.

Tools and Components:

EEPROMs (e.g., AT28C64 or AT28C256)

74-series logic ICs (e.g., 74LS161, 74LS245, 74LS173)

Static RAM (e.g., 62256)

Clock generator (555 timer or crystal oscillator)

Breadboard or PCB

EEPROM programmer (e.g., TL866 or Arduino-based burner)

LEDs, push buttons, and switches for I/O

2. Architecture Design

The architecture is based on a Von Neumann or Harvard-like model and includes the following key modules:

Control Unit

Generates control signals using EEPROM

ALU

Performs 8-bit arithmetic and logic operations

Registers

Hold temporary data (Accumulator, Instruction Register, etc.)

Program Counter (PC)

Tracks the address of the next instruction

RAM

Stores data and possibly program code

Instruction Decoder

Extracts opcode for microcode addressing

The control unit uses a 2D EEPROM addressing scheme:

Address = {Instruction opcode (4 bits) + T-step counter (3 bits)} → 7-bit address

Output = 8-bit control signal per microinstruction

3. Microcode Design and EEPROM Programming

Steps:

Define a simple instruction set (e.g., LDA, ADD, SUB, OUT, JMP, HLT).

Create a microinstruction table describing each control signal for every clock cycle (T1–T6) of each instruction.

Encode control signals as 8-bit binary outputs.

Write the microcode as a hex or binary file.

Use an EEPROM programmer to write the control logic to the EEPROM chips.

4. Circuit Implementation

Module-wise Implementation:

Build and test each module (registers, ALU, PC, clock) independently.

Wire EEPROM outputs to corresponding control lines.

Use tri-state buffers and control logic for bus management.

Assemble all components on a breadboard or PCB in modular fashion.

Clocking:

Start with manual clock (push button) for step-by-step debugging.

Upgrade to oscillator or 555 timer for automated operation.

5. Testing and Debugging

Unit Testing:

Test each module (e.g., verify ALU output, register loading, PC incrementing).

Integration Testing:

Load simple programs into RAM (e.g., add two numbers and output the result).

Observe step-by-step execution via LEDs or logic analyzers.

Verification:

Verify control signals match the expected output from the EEPROM.

Use logic probes to ensure correct bus transactions and data flow.

6. Iteration and Expansion

After verifying the initial design:

Add new instructions by updating microcode and reprogramming EEPROMs.

Expand RAM or add stack/register functionality.

Implement features like conditional jumps or indirect addressing

MODULES:-

Program counter:-

The Program Counter (PC) is a crucial component in an EEPROM-based 8-bit computer. It is responsible for keeping track of the address of the next instruction to be executed from memory (usually RAM or ROM).

Key Functions of the Program Counter:

Stores the Current Instruction Address

It holds the memory address from which the CPU fetches the next instruction.

Automatically Increments After Each Instruction

During normal operation, the PC increases by 1 after fetching each instruction, unless a jump or branch instruction modifies it.

Can Be Overwritten for Jumps/Branches

For instructions like JMP, the PC is loaded with a new address, enabling non-sequential execution (e.g., loops or function calls).

Register A:-

Register A, often called the Accumulator, is one of the main general-purpose registers in an EEPROM-based 8-bit computer. It is used to hold data temporarily during processing and serves as the primary input/output for the ALU (Arithmetic Logic Unit).

Key Functions of Register A:

Stores Operands and Results

Holds data loaded from memory or another register.

Stores the result of arithmetic or logic operations.

Interacts Directly with the ALU

One input to the ALU is typically always connected to Register A.

Results from the ALU can be written back into Register A.

Controlled by Microcode

A_LD (Load A): Loads data from the internal bus into Register A.

A_EN (Enable A): Outputs data from Register A onto the internal bus.

ALU:-

The ALU (Arithmetic Logic Unit) is the heart of the computation in an EEPROM-based 8-bit computer. It performs all arithmetic and logic operations such as addition, subtraction, and bitwise logic (AND, OR, NOT, etc.).

Key Functions of the ALU:

Performs Arithmetic Operations

Most commonly: Addition (ADD) and sometimes Subtraction (SUB using two's complement).

Performs Logic Operations

Basic bitwise operations like AND, OR, XOR, and NOT (depending on the instruction set).

Outputs Flags

Often sets condition flags like Zero (Z) or Carry (C), used for branching and comparisons.

Provides Results to a Register

The result is typically sent back to Register A or an output register.

CLOCK:-

 The Clock in an EEPROM-based 8-bit computer provides the timing signal     that drives the sequential operation of the entire system. It acts as the "heartbeat" of the computer, coordinating the timing of all actions such as data transfers, instruction execution, and control signal sequencing.

Key Functions of the Clock:

Controls Execution Timing

Each clock pulse triggers the next step in the instruction cycle (fetch, decode, execute).

Synchronizes All Components

Ensures that registers, memory, ALU, and the control unit operate in a coordinated manner.

Drives the Step Counter

The T-state counter (step counter) advances with each clock tick, controlling which microinstruction is fetched from the EEPROM.

MADDR:-

The MADDR, short for Memory Address Register (MAR), is a critical component responsible for holding the address of the memory location that the CPU is currently accessing — either for reading or writing data or instructions.

Key Functions of MADDR:

Stores the Target Memory Address

It holds the address for the current memory access (instruction fetch, data load/store).

Feeds the Address Bus

The value in MADDR is sent to the address lines of the RAM or ROM.

Works During Instruction Fetch and Execution

During the fetch phase, it gets the address from the Program Counter (PC).

During memory operations (like LDA, STA), it may load a memory address from the instruction operand.

RAM:-

RAM (Random Access Memory) in an EEPROM-based 8-bit computer serves as the temporary storage space for both data and instructions. It allows the CPU to read from and write to specific memory locations during program execution.

Key Functions of RAM:

Stores Program Instructions and Data

Instructions can be loaded into RAM for the CPU to fetch and execute.

Data values (operands, results, variables) are temporarily stored here.

Supports Read/Write Operations

Unlike ROM or EEPROM, RAM is volatile and fully read/write capable.

Enables Flexible Program Execution

Programs can be changed or updated during runtime without reprogramming hardware.

INSTRUCTION REGISTER:-

The Instruction Register (IR) is a key component that temporarily stores the current instruction being executed. It allows the control logic (often implemented with EEPROM microcode) to decode the opcode and trigger the appropriate sequence of control signals.

Key Functions of the Instruction Register:

Holds the Current Instruction

After fetching an instruction from memory, it is loaded into the IR before decoding.

Provides the Opcode to the Control Unit

The upper bits (usually 4 bits) of the instruction represent the opcode, which is used to generate the address for microcode lookup in the EEPROM.

May Provide Operand Data

The lower bits of the instruction may contain immediate data or memory addresses.

OUTPUT REGISTER:-

The Output Register is a dedicated register that holds data to be displayed or sent to external devices. It’s typically connected to LEDs, 7-segment displays, or an I/O port, allowing the computer to present results to the user.

Key Functions of the Output Register:

Stores and Displays Output Data

Receives data from the internal data bus (usually from Register A or ALU).

Holds the data until it is updated by a new instruction.

Isolated from the Bus

Unlike general-purpose registers, the Output Register only receives data — it doesn't put data back on the bus (write-only).

Controlled by Microcode

Activated via a control signal like OUT_LD (Load Output Register).

DISPLAY MODULE:-

The Display Module is an optional but highly useful peripheral in an 8-bit EEPROM-based computer. It allows users to visually monitor outputs, such as register values or computation results. This makes debugging and interaction with the system much easier.

Key Functions of a Display Module:

Visual Output of Data

Displays binary or decimal values from the Output Register.

Helps confirm program behavior, like loop counters, arithmetic results, or memory content.

User Interface

Serves as the primary feedback mechanism for users when no screen or serial interface is present.

Diagnostic Tool

Can be used to display intermediate values during execution for troubleshooting and verification.

CONTROL LINES:-

Control lines are the backbone of the CPU’s internal coordination. These signals, generated by the control unit (usually through EEPROM-based microcode), orchestrate the behavior of all components—deciding when to load, read, write, or enable each part of the system.

Key Functions of Control Lines:

Direct Data Flow

Control which register places data on or takes data from the internal bus.

Trigger Operations

Enable the ALU, load memory, increment the program counter, etc.

Define Instruction Behavior

Each instruction is broken down into micro-steps, with specific control lines active at each step.

CONCLUSION

The EEPROM-based 8-bit computer is a powerful educational project that combines fundamental concepts of digital electronics and computer architecture. By building it from scratch using simple components like registers, RAM, ALU, clock, and control logic stored in EEPROM, learners gain deep insights into how real CPUs function at the hardware level.

Key Takeaways:

Modular Architecture: Each unit (PC, IR, ALU, RAM, etc.) has a clear, well-defined role, working together under the coordination of control lines.

Microcoded Control: EEPROMs are programmed with micro-instructions that generate precise control signals to execute complex instructions.

Real-Time Feedback: Components like the Output Register and Display Module provide tangible output, making it easier to understand and debug.

Hands-On Learning: Building this computer demystifies abstract computing concepts such as instruction execution, memory access, and data flow.

Educational Impact:

This project not only strengthens understanding of low-level computing but also encourages logical thinking, circuit design skills, and problem-solving. It lays a solid foundation for fields like embedded systems, digital design, and computer engineering.

Final Thoughts:

While the EEPROM-based 8-bit computer may seem simple compared to modern processors, it mirrors the essential principles behind all CPUs. It is a remarkable tool for learning, experimentation, and innovation, bridging the gap between theory and practice in a truly hands-on way.

ACKNOWLEDGEMENT:-

As executive members of IEEE NITK, we are extremely grateful for the opportunity to learn and work on this project under the prestigious name of IEEE NITK Student Chapter. We would like to extend our heartfelt thanks to IEEE for providing us with the necessary funds to complete this project successfully.