🖥️ 4-bit CPU Design — Computer Architecture Project

• Project Overview
• CPU Architecture
• Components
• Instruction Set
• Bonus Features
• How to Run
• Simulation Results

This project presents the design and simulation of a simplified 4-bit Central Processing Unit (CPU) built using Logisim Evolution. The CPU implements the fundamental components of a modern processor architecture:

• ALU — Performs arithmetic and logical operations
• Register File — Stores temporary values during computation
• Control Unit — Decodes instructions and generates control signals
• Program Counter — Tracks current instruction address
• Memory (ROM) — Stores program instructions

The CPU follows a standard Fetch → Decode → Execute cycle and supports 5 core instructions with 4 bonus features.

┌─────────────────────────────────────────────────────────────┐
│                     4-bit CPU Datapath                       │
│                                                              │
│   ┌──────────┐    ┌──────────┐    ┌──────────────────────┐  │
│   │  Program │───▶│  Memory  │───▶│    Control Unit      │  │
│   │ Counter  │    │  (ROM)   │    │  (Instruction Decode)│  │
│   └──────────┘    └──────────┘    └──────────────────────┘  │
│        ▲                              │  ALU_OP              │
│        │                             │  REG_LOAD            │
│     Clock                            │  REG_SELECT          │
│                                      ▼                      │
│   ┌──────────┐    ┌──────────────────────────────────────┐  │
│   │ Register │◀───│              ALU                      │  │
│   │   File   │───▶│  ADD | SUB | AND | OR | XOR          │  │
│   │  (A, B)  │    │  Z_FLAG | C_FLAG | V_FLAG            │  │
│   └──────────┘    └──────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

The computational core of the CPU. Built with two subcircuits:

• AU (Arithmetic Unit) — Handles ADD and SUB using full adders
• LU (Logic Unit) — Handles AND, OR, XOR using logic gates
• A MUX selects the output based on the OP code

Two 4-bit registers built using D flip-flops:

• Register A — Stores first operand
• Register B — Stores second operand
• SELECT signal chooses which register to write
• Synchronized with the CPU clock

Decodes 4-bit instructions into control signals:

• Uses a decoder to identify instruction type
• Generates: ALU_OP, REG_LOAD, REG_SELECT, MEM_WRITE
• Tested with all 5 supported instructions

• PC auto-increments each clock cycle using an adder
• RESET returns PC to 0000
• ROM (16×4) stores up to 16 instructions
• PC_OUT connects to ROM address input

• Zero Flag (Z) → Set to 1 when ALU result = 0000
• Carry Flag (C) → Set to 1 when addition overflows
• Both flags visible as output pins in main_cpu
• Enables conditional operations

• New instruction 0101 = Jump If Zero
• AND gate combines JZ detection + Z_FLAG
• JUMP_ENABLE output activates when Z=1 and instruction=0101
• Foundation of conditional branching and loops

• Extends Program Counter from 4-bit to 8-bit
• Supports 256 instructions instead of 16
• Wider register, adder, and ROM address bus
• File: BonusFeatures/8bit_Upgrade/PC_8bit.circ

1. Java — Download from https://adoptium.net
2. Logisim Evolution — Download from https://github.com/logisim-evolution/logisim-evolution/releases

# Clone the repository
git clone https://github.com/Noor-Riyadh/cpu-4bit-project.git
cd cpu-4bit-project

# Open the main integrated CPU
# Launch Logisim Evolution, then:
# File → Open → ProgramCounter_Memory/PC_Memory.circ
# Click "main_cpu" in the left panel
# Switch to Simulate mode
# Click RESET to 0, then use the clock button to step through instructions

ALU:           File → Open → ALU/ALU.circut.circ
Register File: File → Open → Registers/Registers.circ
Control Unit:  File → Open → ControlUnit/ControlUnit.circ
PC + Memory:   File → Open → ProgramCounter_Memory/PC_Memory.circ
Jump (Bonus):  File → Open → BonusFeatures/JumpInstruction/Jump.circ
8-bit PC:      File → Open → BonusFeatures/8bit_Upgrade/PC_8bit.circ

# Switch to your branch
git checkout feature/ALU-manar        # Manar
git checkout feature/Registers-hala   # Hala
git checkout feature/ControlUnit-rawan # Rawan
git checkout feature/ProgramCounter-nada # Nada

# Pull latest changes before starting
git pull origin <your-branch>

# After working, push your changes
git add <your-folder>/
git commit -m "Description of what you did"
git push origin <your-branch>