8bit-computer

a custom-built 8-bit computer featuring a simple ALU, registers, RAM, and a basic instruction set.

Rather than using a modern microcontroller or FPGA as the processor, this computer executes instructions entirely through hardware. Every register, bus transfer, arithmetic operation, and control signal is implemented using individual logic ICs connected across multiple breadboards.

To complete the project, I also designed an Arduino Nano-based EEPROM programmer, allowing the control EEPROM to be programmed without dedicated commercial hardware.

---

Overview

This project explores computer architecture from the hardware level by building a complete 8-bit computer from individual components.

Instead of treating the CPU as a black box, every subsystem is visible and understandable:

• Clock Module
• Program Counter
• Memory Address Register
• RAM
• Instruction Register
• General Purpose Registers
• Arithmetic Logic Unit (ALU)
• Output Register
• Shared Data Bus
• EEPROM-based Control Unit

Watching instructions execute one clock cycle at a time provides an intuitive understanding of how processors actually work internally.

---

Features

• Complete 8-bit computer built entirely on breadboards
• 74LS TTL logic architecture
• Shared 8-bit data bus
• EEPROM-based microcode control unit
• Custom Arduino Nano EEPROM programmer
• Manual single-step execution
• Automatic clock mode
• Register-based architecture
• ALU capable of arithmetic operations
• Instruction fetch-decode-execute cycle
• Expandable instruction set
• Visual debugging using LEDs

---

Computer Architecture

The computer consists of several independent modules connected by a common 8-bit bus.

                   +--------------+
                   |     CLOCK    |
                   +-------+------+
                           |
                           v
+-----------+       +-------------+
| Program   | ----> |     MAR     |
| Counter   |       +-------------+
+-----------+              |
                           v
                    +-------------+
                    |     RAM     |
                    +-------------+
                           |
                           v
                    +-------------+
                    | Instruction |
                    |  Register   |
                    +-------------+
                           |
                           v
                    +-------------+
                    | Control ROM |
                    |  (EEPROM)   |
                    +-------------+
                           |
     +---------------------------------------------+
     |             Control Signals                 |
     +---------------------------------------------+
        |            |           |            |
        v            v           v            v
    Register A    Register B    ALU     Output Register

---

Instruction Cycle

Every instruction follows the classic fetch-decode-execute sequence.

1. Fetch

• Program Counter outputs address
• RAM places instruction on the bus
• Instruction Register stores instruction
• Program Counter increments

2. Decode

The EEPROM decodes the opcode and generates the required control signals.

3. Execute

Depending on the instruction:

• Read registers
• Perform ALU operation
• Access memory
• Store results
• Update output

---

EEPROM Programming

A dedicated Arduino Nano was used as a custom EEPROM programmer.

The Nano controls the EEPROM address lines, data lines, and write-enable signals to upload the complete microcode used by the control unit.

Programming process:

1. Generate microcode.
2. Upload EEPROM programmer firmware to the Arduino Nano.
3. Connect the EEPROM.
4. Program every memory location.
5. Verify the written data.
6. Install the EEPROM into the computer.

Using an Arduino instead of a commercial programmer helped deepen my understanding of parallel EEPROM communication and low-level hardware interfaces.