The Fetch–Execute Cycle

What is the CPU and Why Does It Matter?

The Central Processing Unit (CPU) is like the brain of a computer. It reads instructions from
memory and carries them out, one by one, billions of times per second. Understanding how
the CPU works helps us understand how all computer programs actually run.

Central Processing Unit (CPU)

The CPU is the main component that reads and carries out instructions stored in the
computer's memory. Its main job is to process data and control the rest of the computer
system by repeatedly performing the fetch–decode–execute (FDE) cycle.

The CPU has several important parts:

●​ Arithmetic Logic Unit (ALU) - performs calculations and logical operations

●​ Control Unit (CU) - manages the sequence of instructions and sends control signals
●​ Registers - small, very fast storage areas inside the CPU
●​ Buses - pathways that carry information:
●​ Data bus carries the actual data
●​ Address bus carries memory locations
●​ Control bus carries timing and control signals

Why the CPU Cycles Continuously

Modern programs contain billions of individual machine-code instructions. The FDE cycle
allows the CPU to handle them one at a time at very high speed - often billions of cycles
per second when the clock speed is measured in gigahertz (GHz).

Key terms

Accumulator (ACC) - A special register that stores the results of calculations performed by
the ALU.

Address Bus - A set of wires that carries memory addresses from the CPU to memory.

Arithmetic Logic Unit (ALU) - The part of the CPU that performs mathematical calculations
and logical comparisons.

Control Unit (CU) - Coordinates all parts of the CPU and manages the
fetch-decode-execute cycle.

Current Instruction Register (CIR) - Holds the instruction that is currently being processed.

Data Bus - A set of wires that carries actual data between the CPU and memory.
Fetch–Decode–Execute Cycle - The repetitive three-step process the CPU follows to run
instructions.

Memory Address Register (MAR) - Holds the address in memory that needs to be read
from or written to.

Memory Data Register (MDR) - Temporarily stores data or instructions moving between
memory and the CPU.

Opcode - The part of an instruction that tells the CPU what operation to perform.

Operand - The part of an instruction that provides the data or memory address to be used.

Program Counter (PC) - A register containing the address of the next instruction to be
fetched.

Register - A small, very fast storage location inside the CPU.

Key CPU Registers in the FDE Cycle

Comparison table

Register What it does in the cycle

Program Counter (PC) Stores the memory address of the next instruction to
fetch

Memory Address Register Receives an address and sends it to the address bus
(MAR)

Memory Data Register (MDR) Temporarily holds instructions or data from memory

Current Instruction Register Stores the instruction currently being processed

(CIR)

Accumulator (ACC) Stores results from calculations and operations

The Fetch–Decode–Execute Cycle: Step by Step

1. Fetch Stage
1.​ The PC sends the address of the next instruction to the MAR
2.​ The Control Unit sends a read signal along the control bus
3.​ The instruction at that memory address travels along the data bus into the MDR
4.​ The PC increases by 1 to point to the next instruction
 5.​ The instruction is copied from the MDR into the CIR

2. Decode Stage
●​ The Control Unit examines the opcode in the CIR to work out what operation is
needed
●​ It identifies any operand, which could be:
●​ A number to use directly
●​ A memory address
●​ A register name
●​ The CU prepares the correct parts of the CPU for the next stage

3. Execute Stage
1.​ The Control Unit activates the necessary components:
●​ If calculation is needed, the ALU performs it using the ACC and other
registers
●​ If data needs moving, the CU controls read/write operations using the buses
2.​ Any result from the ALU is stored in the ACC or another register
3.​ Status flags may be set (like zero flag, carry flag) for future instructions to use

After execution, the cycle repeats by fetching the next instruction.

Timing and the System Clock

Every step above happens in time with the CPU's master clock - like a metronome keeping
everything in sync.

Cycle Time=1Clock Frequency

Cycle Time=

Clock Frequency

Higher frequency means more FDE cycles per second, but also creates more heat and uses
more energy.

Worked example

Question: Follow through one complete FDE cycle for the instruction LDA 4 (Load into ACC
the data stored at address 4). Assume the Program Counter currently contains 0010₂.
Solution:

1. Fetch Stage

●​ PC → MAR (0010₂ goes to MAR)

●​ Memory returns LDA 4 → MDR
●​ MDR → CIR (instruction now in CIR)
●​ PC increments to 0011₂

2. Decode Stage

●​ CU examines CIR and identifies: opcode = LDA, operand = 4

●​ CU prepares for a memory read operation from address 4

3. Execute Stage

●​ Operand value 4 → MAR

●​ CU sends read signal; memory returns the value at address 4 (e.g., 57₁₀) → MDR
●​ MDR → ACC (ACC now contains 57₁₀)

The CPU is now ready to fetch the next instruction from address 0011₂.

Branching Instructions

A conditional jump instruction like JZ 100 (jump to address 100 if ACC is zero) shows how
the execute stage can change program flow. When the ALU completes an operation, it sets
status flags including the zero flag. If the zero flag is set to 1, the Control Unit loads 100
into the PC during the execute stage, making the program jump to a different instruction
instead of continuing in sequence.

Aim: To simulate the fetch-decode-execute cycle and understand the importance of timing.

Method:

1.​ Divide the class into groups with each student representing a register or bus
2.​ Give students flashcards to hold representing their current values
3.​ Provide a simple program of four machine-code instructions on separate cards
4.​ One student acts as the "system clock" and claps steadily
5.​ At each clap, students must perform the correct FDE cycle action
6.​ Observe what happens when timing goes wrong

Observations: Students will notice that without precise timing, data gets mixed up or lost.
Conclusion: Real CPUs need extremely precise clock signals and control to process billions
of instructions correctly every second.

Summary
The fetch-decode-execute cycle is the fundamental process that allows computers to run
programs. By repeating these three simple steps billions of times per second, the CPU can
execute complex software. Each cycle processes exactly one machine-code instruction, so
even simple programs require millions of these cycles to complete.

CPU Components: ALU, CU, and Cache

GCSE OCR Computer Science

The Central Processing Unit
The CPU (Central Processing Unit) is the brain of the computer. It's a small electronic chip
that carries out program instructions by following the fetch-decode-execute cycle. Think of
it like a factory manager who coordinates different departments to get work done
efficiently.

The CPU is made up of several specialised parts, each with a specific job. Understanding
how the Arithmetic Logic Unit (ALU), Control Unit (CU) and cache memory work together is
essential for understanding how software becomes actual electrical activity inside a
computer.

Arithmetic Logic Unit (ALU)

The ALU is like the computer's calculator - it performs all arithmetic and logical
calculations.

What the ALU does:

●​ Carries out mathematical operations like addition, subtraction, and comparisons

●​ Performs logical operations such as AND, OR, XOR and NOT on binary data
●​ Stores temporary data in small, internal storage areas called registers
●​ Updates a status register that tells the Control Unit about the results (like whether
the answer was zero or caused an overflow)

How the ALU works: During the execute phase of the fetch-decode-execute cycle, the ALU
receives instructions that need mathematical or logical processing. The ALU then:

1.​ Reads the numbers (operands) from registers provided by the Control Unit
2.​ Processes the calculation using digital logic gates
3.​ Returns the result to a register or sends it to main memory
Control Unit (CU)
The Control Unit is like the conductor of an orchestra - it coordinates everything that
happens in the CPU.

What the Control Unit does:

●​ Sends control signals to other CPU parts, main memory, and input/output devices
●​ Decodes machine code instructions fetched from memory
●​ Manages important registers like the program counter (PC) and current instruction
register (CIR)
●​ Controls data flow along the system bus (the pathways that carry addresses, data
and control signals)

How the Control Unit works in each cycle:

1.​ Increases the program counter so it points to the next instruction

2.​ Places the current address on the address bus to request data from memory
3.​ Loads the fetched instruction into the current instruction register
4.​ Sends the right signals to the ALU, cache and registers so the instruction executes
correctly

Cache Memory
Cache is like a small, super-fast notepad that sits right next to the CPU. It stores copies of
frequently used instructions and data so the CPU doesn't have to wait for slower main
memory.

Key features of cache:

●​ Much faster than main memory but smaller in size

●​ Organised into levels: L1 (smallest and fastest), L2, and sometimes L3 (larger but
slower)
●​ Uses smart prediction techniques to guess what data will be needed next
●​ Dramatically reduces the time the CPU spends waiting for data

How cache works: When the CPU needs data, it first checks the cache. If the data is there
(called a cache hit), it's delivered immediately. If not (called a cache miss), the CPU must
fetch from main memory and store a copy in cache for next time.

How Components Work Together During the Fetch-Decode-Execute Cycle

Here's how the ALU, Control Unit, and cache work together to process instructions:

1. Fetch Phase
 ●​ Control Unit puts the program counter value on the address bus
●​ Cache controller checks if the instruction is already stored in cache • Cache hit:
instruction loaded directly from cache into the current instruction register • Cache
miss: main memory provides the instruction, and cache stores a copy for future use

2. Decode Phase

●​ Control Unit interprets the binary instruction code

●​ Generates the correct sequence of control signals to execute the instruction

3. Execute Phase

●​ If the instruction needs calculations, Control Unit sends data to the ALU
●​ ALU performs the operation and updates status registers with information about the
result
●​ Result is written back to a register, cache, or main memory

4. Prepare for Next Instruction

●​ Control Unit updates the program counter (sometimes using the ALU for
calculations)
●​ The cycle repeats billions of times per second

Key terms

ALU (Arithmetic Logic Unit) - The part of the CPU that performs all mathematical
calculations and logical operations.

Cache - Small, very fast memory located close to the CPU that stores frequently used
instructions and data to speed up processing.

Control Unit (CU) - The part of the CPU that manages the fetch-decode-execute cycle and
coordinates all other components by sending control signals.

Fetch-Decode-Execute Cycle - The repeating process the CPU uses to read program
instructions from memory and carry them out.

Register - Tiny, extremely fast storage locations inside the CPU used to temporarily hold
data and addresses during processing.

Status Register - A special register that stores information about the results of ALU
operations, such as whether the result was zero or caused an overflow.

Worked example
Question: A machine code instruction stored at memory address ​

Explain how the CPU components work together to process this instruction.

Solution:

1. Fetch Phase The Control Unit places the address on the address bus. The cache
controller checks L1 cache and finds the instruction (cache hit), so the instruction is loaded
into the Current Instruction Register in just one clock cycle.

2. Decode Phase The Control Unit examines the binary code and recognises it as an "ADD
R1, R2" instruction (add the contents of register R1 to register R2). It generates control
signals to:

●​ Send the value in register R1 to ALU input A

●​ Send the value in register R2 to ALU input B
●​ Prepare the ALU for an addition operation

3. Execute Phase The ALU receives the operands. For example, if (92 in decimal) and (50 in
decimal), the ALU adds them to get (142 in decimal). The status register is updated with
flags showing

C=0

C=0 (no carry) and

Z=0

Z=0 (result not zero).

4. Complete the Cycle The result (142) is stored back in register R1. The Control Unit
increments the program counter to point to the next instruction.

This example shows how the Control Unit coordinates everything, the ALU does the
calculation, and cache provides fast access to instructions.

Gaming Console CPU Architecture

Modern gaming consoles like the PlayStation 5 or Xbox Series X use multi-core CPUs
where each core has its own ALU, Control Unit, and L1 cache, plus they share a larger L3
cache between cores.

When you're playing a game and fire a weapon, here's what happens:
 ●​ ALU: Calculates the projectile's path using physics equations (trajectory, gravity
effects, collision detection)
●​ Control Unit: Coordinates fetching texture data for explosion effects and schedules
when different calculations happen
●​ Cache: Stores frequently used game data like character models and nearby
environment textures so they load instantly

The cache is especially important for maintaining smooth frame rates - if the CPU had to
fetch every piece of graphics data from main memory, games would stutter and lag
constantly.

Comparison table

Component Location Primary Function Data Handled Speed

per Cycle (relative to
main
memory)

ALU Inside each Performs Two operands Very fast (1

CPU core arithmetic & logic and one result clock cycle)
operations

Control Unit Inside each Decodes Addresses, Very fast (1

CPU core instructions & instruction codes, clock cycle)
coordinates control signals
components

Cache (L1) On the CPU Stores recently 32-64 bytes per 10-100x
chip used cache line faster than
data/instructions RAM

Von Neumann Architecture and Registers

Understanding CPU Registers

1 The Stored-Programme Concept
In 1945, John von Neumann proposed that data and instructions should share the same
main memory. This revolutionary idea, called the stored-programme concept, is the
foundation of almost every general-purpose computer built today.

By storing both program code and working data in RAM, the computer can treat
instructions just like numbers - it can fetch them, decode them, and then carry them out.
This is why you can load different programs onto the same computer without changing the
hardware.
Central to this process are very small, very fast memory locations inside the CPU called
registers. Think of registers as the CPU's personal workspace - tiny storage areas where it
keeps the information it's currently working with.

2 Why Registers Matter

Registers solve a crucial speed problem. The CPU can process information incredibly
quickly, but main memory (RAM) is much slower in comparison. It's like having a brilliant
chef who can cook at lightning speed, but has to wait ages for ingredients to be delivered
from a distant warehouse.

Registers bridge this speed gap because they operate at the same speed as the CPU itself.
A single clock cycle is usually enough to read from or write to a register. Because of this
speed, the CPU constantly moves addresses and data through its registers while running a
program.

2.1 Data versus Address

Understanding the difference between data and addresses is crucial:

●​ An address is like a house number - it tells you where to find something in memory
●​ Data is the actual information stored at that location - like the contents of the house

A useful analogy is a street map: the house number (42 Oak Street) is the address, while
the people and furniture inside are the data. You wouldn't expect the house number itself to
be your dinner - you need to go to that address to find the actual food!

3 Core Registers in the OCR GCSE Specification

3.1 Memory Address Register (MAR)

The MAR is like the CPU's postal address book - it holds the address of the memory
location the CPU wants to access next.

●​ Stores: One memory address only

●​ Purpose: Points directly at a RAM location so the control unit knows exactly where
to read from or write to

For example, if the CPU needs to fetch an instruction stored at address, it first loads the
value into the MAR.

3.2 Memory Data Register (MDR)

The MDR (sometimes called the Memory Buffer Register) acts as a temporary storage area
for data moving between the CPU and memory. Think of it as a loading dock where data
waits before being processed.
 ●​ Stores: The actual binary data that has just been read from memory, or data about
to be written back to memory
●​ Purpose: Provides a temporary holding area so the ALU or control unit can use the
data in the next processing step

Remember: the MDR always contains data, never an address.

3.3 Program Counter (PC)

The PC is like a bookmark in a recipe book - it keeps track of which instruction the CPU
should execute next.

●​ Stores: The address of the next instruction to be fetched from memory

●​ Purpose: After each instruction is fetched, the PC automatically increases by one to
point to the next instruction (unless a jump or branch instruction changes the
sequence)

3.4 Accumulator (ACC)

The accumulator is the CPU's main workspace for calculations. It's like a calculator's display
screen - it shows the current result and can be used in the next calculation.

●​ Stores: Data produced by the ALU, such as the result of addition, subtraction, or
logical operations
●​ Purpose: Holds the current result for further processing and provides one of the
inputs for the next ALU operation

4 How Registers Work Together: The Fetch-Execute Cycle

Here's how these registers work together to run a program:

1.​ Fetch Setup: The PC contains the address of the next instruction to run
2.​ Address Transfer: This address is copied into the MAR
3.​ Memory Access: The control unit sends a read signal to memory; the instruction is
fetched into the MDR
4.​ Instruction Processing: The instruction moves from the MDR to be decoded and
executed
5.​ Counter Update: The PC increases by one to point to the next instruction
6.​ Execution: The instruction runs, and any calculation result is stored in the
accumulator

Throughout this entire process, the roles never change: MAR and PC always hold
addresses, while MDR and ACC always hold data.

5 Why This Design Works So Well

The register-based design is incredibly efficient because:

●​ Speed: Registers operate at full CPU speed with no delays

●​ Organization: Each register has a specific job, preventing confusion
●​ Flexibility: The same hardware can run any program by simply loading different
instructions into memory

Even though registers are tiny (typically holding just a few bytes), their speed makes them
essential for good computer performance.

Key terms

Accumulator (ACC) - A register that holds the results of arithmetic or logic operations
carried out by the ALU.

Address - A number that identifies a unique location in memory, like a house number on a
street.

Data - The actual binary information stored in memory or registers, such as numbers,
instructions, or characters.

Memory Address Register (MAR) - A CPU register that stores the address of the memory
location that is about to be accessed.

Memory Data Register (MDR) - A CPU register that temporarily holds data being
transferred to or from main memory.

Program Counter (PC) - A register that holds the address of the next instruction to be
fetched from memory.

Register - A small, very fast storage location inside the CPU used to hold addresses or data
for immediate processing.

Von Neumann Architecture - A computer design where data and instructions share the
same memory and travel along the same pathways.

Worked example

Question: Trace through the register contents as this simple program executes:

Address Contents Meaning

0100 2005 LOAD 5 (load the number 5 into accumulator)

 0101 3006 ADD 6 (add 6 to the accumulator)

0102 5000 STORE 0 (store result at address 0)

Solution:

Step 1: PC starts at

(pointing to first instruction)

Step 2: Copy PC value to MAR

●​ MAR =

●​ (now pointing at the memory location to read from)

Step 3: Fetch instruction from memory into MDR

●​ MDR =
●​ (the actual instruction code)

Step 4: Decode and execute LOAD 5

●​ ACC =
●​ (the number 5 is now in the accumulator)

Step 5: Increment PC for next instruction

●​ PC =
●​ (now pointing to the ADD instruction)

Key observation:

●​ PC and MAR only ever contain addresses

●​ MDR and ACC only ever contain data

Real-world application: Modern smartphones use ARM processors that still follow von
Neumann principles. When you tap an app icon, the phone's CPU uses these same registers
to fetch and execute the app's instructions from memory.

Historical context: Early computers like ENIAC had to be physically rewired to run different
programs. Von Neumann's stored-program concept meant that changing software became
as simple as loading different data into memory - no rewiring needed!
Comparison table

Register What It Stores Main Purpose Data or

Address?

Program Counter (PC) Address of next Keeps track of Address

instruction program sequence

Memory Address Address being Points to memory Address

Register (MAR) accessed right now location

Memory Data Data just read or about Temporary data Data

Register (MDR) to be written storage

Accumulator (ACC) Result of calculations Holds working values Data

CPU Performance Factors

OCR GCSE Computer Science 1.1 – Systems Architecture

CPU Performance and Why It Matters
The central processing unit (CPU) is the brain of a computer - it carries out every instruction
that runs on the system. The overall speed of a computer depends on how quickly the CPU
can complete the fetch-decode-execute cycle.

Three main hardware features control this speed:

●​ Clock speed (measured in Hz - cycles per second)

●​ Cache size (measured in bytes, KB, or MB)
●​ Number of cores (how many processors are on one chip)

Understanding how each feature affects performance helps us make smart decisions when
choosing or upgrading computer systems.

1. Clock Speed
Clock speed measures how many instruction cycles the CPU can complete every second.
Think of it like a metronome - each tick allows the CPU to process one instruction.

●​ A 3 GHz processor performs 3 billion cycles every second.

●​ A higher clock speed means more instructions can be executed per second, which
makes the computer run faster.
 ●​ However, there are limits - higher frequencies need more power and create more
heat, which can cause thermal throttling (the CPU automatically slows down to
prevent overheating).

2. Cache Size
Cache is super-fast memory built directly into the CPU chip. It's much faster than the main
memory (RAM) that sits elsewhere on the motherboard.

How cache works:

1.​ Cache levels - CPUs have multiple cache levels:

●​ L1 (smallest but fastest)
●​ L2 (larger but slightly slower)
●​ L3 (largest, shared between cores)
2.​ Hit rate - When the CPU needs data, it checks the cache first. If the data is there (a
"cache hit"), it can be accessed almost instantly. If not (a "cache miss"), the CPU
must fetch it from the much slower RAM.
3.​ Performance impact - A larger cache can hold more frequently used data and
instructions. This increases the chance of a cache hit, reducing the amount of time
the CPU spends waiting for data from RAM and improving overall performance.

3. Number of Cores
A core is a complete processing unit. Modern CPUs contain multiple cores on a single chip,
allowing them to work on several tasks simultaneously.

●​ True multitasking - Multiple cores allow the computer to run multiple programs at
the same time without slowing down, as each core can handle a different task.
●​ Parallel processing - A single complex task can be split into smaller parts, with each
core working on a different part at the same time. This is only possible if the
software is designed to use multiple cores.
●​ Diminishing returns - Doubling the number of cores doesn't always double the
performance. This is because not all tasks can be split up to run on different cores,
and software may not be able to take full advantage of the extra cores.

4. How the Factors Work Together

These three characteristics don't work independently - they affect each other:

1.​ Higher clock speeds create more heat, limiting how many cores can fit on one chip.
2.​ More cores have to share access to the cache and RAM, so a larger cache becomes
more important in a multi-core system.
 3.​ A balanced design often works better than maximising just one factor. For example,
a CPU with a slightly lower clock speed but more cores and a larger cache might
outperform a CPU with a very high clock speed but only one core.

Key terms

Clock speed - The frequency at which the CPU executes instruction cycles, measured in Hz
(cycles per second).

Cache - Fast memory built into the CPU that stores frequently used data and instructions to
reduce waiting time.

Core - An independent processing unit within a CPU that can execute instructions
separately from other cores.

Thermal throttling - When a CPU automatically reduces its clock speed to prevent
overheating and damage.

Hit rate - The percentage of times the CPU finds needed data in cache rather than having to
access slower main memory.

Worked example

Question: A graphic designer's computer has a 4-core, 3.0 GHz CPU with 8 MB cache. They
want to upgrade it for better performance in their design software. They have three options:

A) A new CPU with a higher clock speed of 3.6 GHz (still 4 cores, 8 MB cache). B) A new
CPU with a larger cache of 16 MB (still 4 cores, 3.0 GHz). C) A new CPU with more cores:
an 8-core CPU (still 3.0 GHz, 8 MB cache).

Testing shows the following for their specific software:

●​ A 20% increase in clock speed results in a 20% performance boost.

●​ Doubling the cache reduces waiting times, giving a 15% performance boost.
●​ The software can use multiple cores, but not perfectly. Doubling from 4 to 8 cores
gives a 35% performance boost.

Which upgrade offers the best performance for the designer?

Solution:

1.​ Option A (Higher clock speed):

●​ The clock speed increases from 3.0 GHz to 3.6 GHz, which is a 20% increase.
●​ This provides a 20% performance boost.
2.​ Option B (Larger cache):
 ●​ The cache size is doubled.
●​ This provides a 15% performance boost.
3.​ Option C (More cores):
●​ The number of cores is doubled from 4 to 8.
●​ This provides a 35% performance boost.

Answer: Option C (more cores) gives the biggest performance improvement at 35%. This is
the best choice for the graphic designer's specific software.

Real-world example: Gaming vs Office Work

A gaming laptop uses a 4-core CPU running at 4.2 GHz with 8 MB cache. This high clock
speed is perfect for games that rely heavily on single-core performance.

An office computer uses an 8-core CPU running at 2.8 GHz with 16 MB cache. The extra
cores handle multitasking well - users can run email, web browsers, and documents
simultaneously without slowdown.

A smartphone uses a "[Link]" design: 4 high-performance cores at 2.8 GHz for

demanding apps, plus 4 low-power cores at 1.8 GHz for basic tasks. This saves battery life
while providing good performance when needed.

Comparison table

Factor Main Advantage Main Limitation Best For

Higher Faster individual task Creates heat, uses more Gaming,

clock completion power single-threaded
speed applications

Larger Reduces waiting for Expensive, limited Programs that reuse

cache data from memory benefit beyond certain data frequently
size

More cores Better multitasking Software must be Video editing,

and parallel designed for multiple multitasking, server
processing cores applications

Embedded Systems

Purpose, Characteristics, and Real-World Examples

1. What Is an Embedded System?
An embedded system is a computer system designed to do one specific job, or a small
number of related jobs, inside a larger device. Unlike the computer or laptop you use at
school, which can run many different programs, an embedded system comes with all the
software it needs already built in. You can't install new apps or programs on it.

The processor, memory, and connections to other parts are usually all on one small circuit
board, or even combined into a single chip called a microcontroller. Think of it like having a
tiny, specialised computer hidden inside everyday objects to make them "smart".

2. Key Characteristics of Embedded Systems

Embedded systems have several important features that make them different from regular
computers:

●​ Does one specific job – the software is written to do just one task really well, like
controlling a washing machine or monitoring your heart rate
●​ Works in real-time – many embedded devices must respond very quickly. For
example, a car's airbag controller has just milliseconds to decide whether to inflate
the airbag
●​ Limited resources – they have much less memory and processing power than your
phone or computer, and run on very little electricity
●​ Very reliable – once installed, these systems need to work for years without
breaking down or needing to restart
●​ Low power use – devices like fitness trackers need to run on small batteries for
weeks or months
●​ Small and lightweight – they need to fit inside appliances, toys, and even medical
implants
●​ Cheap to make – manufacturers use inexpensive parts to keep costs down
●​ Simple interface – many don't have screens or keyboards - they just sense what's
happening and respond automatically

2.1 Hardware Limitations

Embedded hardware often combines the CPU, memory, and input/output connections into a
single chip. This system-on-chip (SoC) approach keeps costs and power use low, but means
you can't upgrade the system later.

2.2 Software Limitations

The software (called firmware) is usually very small - often just a few kilobytes. It's written
in programming languages like C and runs in a continuous loop, constantly checking
sensors and controlling outputs.

3. Why Do We Use Embedded Systems?

Embedded systems add digital intelligence to everyday objects while keeping them simple
to use. They serve three main purposes:

1.​ Making things safer – like anti-lock braking systems (ABS) that prevent car wheels
from locking up during emergency braking
2.​ Making things more efficient – like smart thermostats that learn your routine and
adjust heating to save energy
3.​ Adding new features – like smart speakers that respond to voice commands and
connect to the internet

4. Examples of Embedded Systems

4.1 Home and Consumer Electronics

●​ Washing machine controller that manages water levels and spin cycles
●​ Smart TV systems that handle streaming and apps
●​ Microwave oven timers and power controls

4.2 Medical Equipment

●​ Insulin pumps that automatically deliver precise doses
●​ Pacemakers that regulate heartbeat
●​ MRI scanner control systems

4.3 Transportation
●​ Engine control units that manage fuel injection in cars
●​ Airbag systems that detect crashes and deploy safety equipment
●​ Train door safety systems

4.4 Industrial and Infrastructure

●​ Factory automation controllers on production lines
●​ Smart electricity meters in homes
●​ Traffic light control systems

4.5 Wearables and Internet of Things (IoT)

●​ Fitness trackers that monitor heart rate and steps
●​ Smart thermostats you can control from your phone
●​ Smart light bulbs that connect via Bluetooth

5. How Embedded Systems Compare to Regular Computers

While your laptop might have multiple processors, gigabytes of memory, and can run
hundreds of different programs, an embedded device focuses on doing one job really well
with much less powerful hardware.
Comparison table

Feature Embedded System Regular Computer

Main purpose One specific task Many different tasks

Software updates Rarely changed by user Regular updates and new

programs

Memory and Very limited (kilobytes to Lots available (gigabytes)

processing power megabytes)

User interface Often none (just Keyboard, mouse, screen

buttons/lights)

Response time Must respond instantly Can take time to process

Power source Battery or low voltage Mains electricity

Cost Very cheap (pence to Expensive (hundreds to

pounds) thousands of pounds)

6. Design Challenges
Creating embedded systems involves making difficult choices. Engineers must balance:

●​ Cost vs performance
●​ Battery life vs processing speed
●​ Size vs functionality

For safety-critical applications (like medical devices or car systems), extensive testing is
required to meet strict safety standards.

Key terms

Embedded system - A computer system designed to do one specific job inside a larger
device

Firmware - The software permanently stored in an embedded device that controls how it
works

Microcontroller - A single chip containing a CPU, memory, and connections, designed

specifically for embedded systems

Real-time system - A computer system that must respond to events within strict time limits
System-on-chip (SoC) - A single chip that contains all the components needed for a
complete computer system

Smart Washing Machine Controller

A modern washing machine contains an embedded system that makes it "smart". The
microcontroller:

●​ Reads water level sensors to know when there's enough water

●​ Controls valves to let water in and out
●​ Manages drum rotation speed for different wash cycles
●​ Controls water temperature through heating elements
●​ Displays information on an LED panel

The system uses a low-power ARM processor with 128 KB of storage and 16 KB of
working memory. All the control software is permanently stored in the chip - you can't
install new programs or change how it works. The entire system costs just a few pounds
but makes the washing machine much more efficient and easier to use.