Fetch-Decode-Execute Cycle (FDE)

Step 1: PC (Program Counter) = 100
        ↓
        "Next instruction is at address 100"

Step 2: PC sends address 100 to MAR (Memory Address Register)
        ↓
        MAR = 100

Step 3: MAR sends address via Address Bus
        ↓
        Address Bus carries 100 to Memory

Step 4: Control Unit sends READ signal via Control Bus
        ↓
        "Memory, please send me the instruction at address 100"

Step 5: Memory finds instruction at address 100: "ADD 5, 3"
        ↓
        Memory sends "ADD 5, 3" via Data Bus

Step 6: MDR (Memory Data Register) receives instruction
        ↓
        MDR = "ADD 5, 3"

Step 7: CIR (Current Instruction Register) gets copy
        ↓
        CIR = "ADD 5, 3"

Step 8: PC increments (adds 1)
        ↓
        PC = 100 → PC = 101
        (Points to next instruction)

Instruction: ADD 5, 3

┌─────────────────┐
│   OPCODE        │  = What operation to do
│   (Operation)   │  = Example: ADD, SUBTRACT, JUMP
└─────────────────┘

┌─────────────────┐
│   OPERAND       │  = What to do it to
│   (Data/Address)│  = Example: 5, 3, or memory location
└─────────────────┘

CIR contains: "ADD 5, 3"
             ↓
Control Unit reads CIR
             ↓
Control Unit splits instruction:
  - Opcode: ADD
  - Operand 1: 5
  - Operand 2: 3
             ↓
Control Unit understands:
  "I need to ADD two numbers: 5 and 3"
  "I need to use the ALU"
  "I need to store result in ACC"
             ↓
Ready to EXECUTE

Instruction: ADD 5, 3

What happens:
- ALU receives 5 and 3
- ALU adds: 5 + 3 = 8
- Result (8) stored in ACC (Accumulator)

Memory/Registers before: ACC = ?
Memory/Registers after:  ACC = 8

Instruction: STORE 200

What happens:
- Data in ACC is written to memory
- Memory address is 200
- ACC value is written to address 200

Memory location 200 before: [Empty]
Memory location 200 after:  [8]

Instruction: LOAD 300

What happens:
- Data from memory address 300 is read
- Data is stored in ACC
- Now ACC has the value from memory

Memory location 300: [15]
ACC before: [8]
ACC after:  [15]  (loaded from memory)

Instruction: IF ACC > 0 THEN JUMP 500

What happens:
- Check if ACC is greater than 0
- If TRUE: PC jumps to address 500
- If FALSE: PC continues normally

Result: The next instruction comes from address 500 (if true)
        or from the normal sequence (if false)

Instruction: COMPARE ACC WITH 10

What happens:
- ALU compares ACC value with 10
- Sets status flags (Equal, Greater, Less)
- These flags used by later instructions

Example:
If ACC = 10: Equal flag = True
If ACC = 15: Greater flag = True
If ACC = 5:  Less flag = True

Memory:
Address 100: ADD 7, 4
Address 101: STORE 200
Address 102: LOAD 300
...
Address 200: [Empty - will store result]
Address 300: [Some data]

"The CPU fetches, decodes, and executes instructions."

1. FETCH: The CPU fetches the next instruction from memory using 
   the address in the Program Counter.

2. DECODE: The Control Unit reads the instruction and determines 
   what operation needs to be performed.

3. EXECUTE: The CPU performs the operation specified by the 
   instruction (such as addition, storing data, or jumping to a 
   new location). The cycle then repeats.

1. The Program Counter (PC) holds the address of the next 
   instruction to be fetched. (1 mark)

2. The address held in the PC is sent to the Memory Address 
   Register (MAR). (1 mark)

3. The memory address is sent using the Address Bus. (1 mark)

4. The Control Unit sends a READ signal via the Control Bus. (1 mark)

5. The instruction is sent from memory to the Memory Data Register 
   (MDR) via the Data Bus. (1 mark)

6. The instruction is transferred to the Current Instruction 
   Register (CIR), and the PC increments by 1. (1 mark)

1. The ALU receives the two operands (5 and 3).

2. The ALU adds them together (5 + 3 = 8) and stores the result 
   in the Accumulator (ACC).