Zum Inhalt springen

English:Computer architecture, storage and embedded systems - Computing Year 8

Aus MOOCsWiki Staging
aiMOOC-Siegel aiMOOC

Computer architecture, storage and embedded systems - Computing Year 8

QR-Code



Introduction

Explain how processors, working memory, storage and input/output cooperate. Trace an original stored-instruction model, compare resource budgets, and analyse a focused embedded-system decision without controlling hardware. Year 8 placement is editorial within England’s KS3 Computing pathway.


Follow components and a stored-instruction trace

A computer system combines components with different responsibilities. Input components obtain data, a processor executes instructions, working memory holds active instructions and data, storage retains saved material, and output components present or act on results. Components communicate through connections and defined interfaces. The exact packaging varies: a desktop exposes several separate parts, while a microcontroller may integrate a processor, memory and input/output on one chip.

Exploded personal-computer illustration supports component identification
Gustavb’s unchanged diagram depicts an older desktop arrangement: monitor, motherboard,processor area,memory/expansion components,power supply,drives and input devices. It is not a diagram of every modern laptop or a claim that a CPU is the whole computer.

{| class="wikitable"

! Component or role !! Meaning in our model !! Important distinction |- | Processor / CPU || Executes the stored instruction sequence || Not the entire computer case |- | Control unit || Coordinates interpretation and execution || Not the same thing as long-term file storage |- | Arithmetic logic unit || Performs arithmetic and logical operations || Not a complete system by itself |- | Register || A small processor-internal working location || Not a permanently saved user file |- | Main memory || Holds active code/data accessible to the processor || Not identical to a saved storage copy |- | Input/output interface || Connects the processor system with inputs and outputs || A touchscreen can serve both input and output roles |} Stored instructions allow behaviour to change when the program changes, within the system's capabilities. A useful introductory cycle is fetch an instruction from memory, decode its operation and operands, then execute it and update the relevant state. Many operations write a register or memory result. The next-instruction position normally advances unless an instruction changes the flow. This is a conceptual model, not a promise that every real instruction finishes in one clock tick.

Our original tiny machine has two input data locations A and B, a SUM location, an accumulator and four stored instructions. With A five and B three, LOAD A puts five in the accumulator; ADD B makes eight; STORE SUM writes eight to SUM; HALT ends the model. The accumulator changes before SUM changes. Reading a value, calculating with it and storing the result are distinct actions.

def run_tiny_machine(a, b):
    for value in [a, b]:
        if type(value) is not int or not (value >= -100 and 100 >= value):
            raise ValueError("Use whole input values from -100 to 100")
    memory = {"A": a, "B": b, "SUM": 0}
    instructions = [("LOAD", "A"), ("ADD", "B"), ("STORE", "SUM"), ("HALT", None)]
    accumulator = 0
    trace = []
    for pc, (operation, address) in enumerate(instructions):
        if operation == "LOAD":
            accumulator = memory[address]
        elif operation == "ADD":
            accumulator += memory[address]
        elif operation == "STORE":
            memory[address] = accumulator
        elif operation == "HALT":
            trace.append([pc, operation, address, accumulator, memory["SUM"]])
            return memory, trace
        trace.append([pc, operation, address, accumulator, memory["SUM"]])
    raise RuntimeError("The teaching program did not halt")

{| class="wikitable"

! Instruction position !! Operation !! Accumulator after !! SUM after !! Explanation |- | 0 || LOAD A || 5 || 0 || Read input A into the accumulator |- | 1 || ADD B || 8 || 0 || Add input B; the data result is still not stored in SUM |- | 2 || STORE SUM || 8 || 8 || Copy accumulator to the model data location |- | 3 || HALT || 8 || 8 || End this four-instruction teaching program |} The code represents instructions as readable Python tuples and data as a dictionary. It is an original software interpreter model, not the binary instruction set of a real processor. The two Python structures are separated for clarity; that does not establish that all real computers use physically separate instruction and data memories. The for loop supplies a simple sequential program position; this model does not implement branches, interrupts, cache behaviour or timing.

The original Code.org/CodeAI CPU, memory, input/output video supplies a moving overview. Compare its hardware explanation with our deliberately simplified four-instruction trace. The full original source and written route remain available without external playback. Original: CodeAI, How Computers Work: CPU, Memory, Input & Output. The written explanations and native tasks work without sound or the external player. Test the model with another pair of values and record accumulator and SUM separately after every instruction. Ordinary Python integers here do not wrap at a small register width. A real finite-width processor model would need explicit representation and overflow rules rather than silently borrowing these unlimited-precision arithmetic results. A correct trace helps explain execution but does not prove practical hardware assembly.



Distinguish memory,storage and resource budgets

Memory and storage solve different problems. Ordinary DRAM working memory needs continued power to retain its data; flash and SSD storage are nonvolatile media that retain saved contents without normal operating power. Nonvolatile does not mean indestructible, always backed up or impossible to corrupt. Registers and caches provide other working locations closer to a processor. 'Memory' can be used broadly, so identify the specific technology and role rather than declaring that every form of memory behaves like DRAM.

In a desktop example, a saved document resides on storage and an active editable version is represented in working memory. Editing does not automatically update the saved copy unless the application actually performs a save or autosave. In an embedded device, firmware may be stored in flash and active variables in RAM. Some designs execute directly from suitable nonvolatile memory; others copy code into RAM. An operating system or separate disk drive is not required by every embedded design.

Empty SO-DIMM memory sockets illustrate a memory interface
D-Kuru’s unchanged photograph shows empty DDR4 SO-DIMM RAM sockets. It does not show an installed RAM module,an SSD or a visible capacity measurement. The connector context supports distinguishing working-memory hardware from unrelated storage devices.

Use an original fictional resource budget. A learning controller has two hundred and fifty-six kibibytes of flash and thirty-two kibibytes of RAM. Its program image occupies one hundred and eighty kibibytes of flash, leaving seventy-six kibibytes under that stated budget. During the modelled workload, buffers use twenty-two kibibytes of RAM and stack/working variables use seven, totalling twenty-nine and leaving three. One kibibyte is one thousand and twenty-four bytes; these quantities use binary units consistently.

Resource Stated capacity Stated use Remaining in this simplified budget
Flash 256 KiB 180 KiB program image 76 KiB
RAM 32 KiB 22 KiB buffers plus 7 KiB other working state 3 KiB

Unused flash cannot simply be counted as additional RAM. The roles, access paths and write characteristics differ. The budget also omits other real implementation needs and peak variation; its three-kibibyte arithmetic remainder is not a production readiness certificate. A design review would need actual toolchain measurements and device requirements. The values here are invented for comparing roles, not specifications for an identified appliance.

A stored-program diagram should label paths, not merely list parts: saved code or firmware provides instructions; processor-accessible memory supplies active instructions/data; input values enter through an interface; execution updates state; outputs are produced through an interface. Real components exchange represented data according to their connections and protocols. Storing binary digits does not by itself tell a processor whether they represent an instruction, character, measurement or image;interpretation is part of the design.

Clock frequency alone does not establish which computer completes a task sooner. Instruction work, architecture, memory access, core use and workload also matter. Increasing storage capacity is not the same operation as increasing processor speed or RAM. Compare a defined need with the relevant component and measured evidence instead of treating all advertised numbers as one scale of quality.

Do not perform a power-cut experiment to illustrate persistence. A paper or software state ledger can distinguish active and saved copies without disrupting a device. Sleep may preserve or save state depending on the system;loss of an unsaved working copy must be discussed under explicit assumptions rather than claiming that every closed laptop immediately loses all work.



Analyse an embedded system through inputs,state and outputs

An embedded system is defined by its role within a larger product. A controller built into a washing machine runs a focused program involving sensor input, state and outputs. A general-purpose laptop is designed to support many user-selected applications. Size alone does not decide the classification, and an embedded system need not be connected to the internet. A small development board can be used in an embedded product, as a teaching computer or in another role depending on its integration.

Consider a purely software thermostat model. Its sensor input is a whole-number temperature reading in degrees Celsius;its target is another whole-number value;and its state records the previous requested on/off condition. To avoid changing its request back and forth at a single threshold, the invented model requests on at least one degree below target, off at least one degree above target, and preserves the previous request between those thresholds. This retained-state gap is a simple form of hysteresis.

def thermostat_request(reading, target, was_on):
    if type(reading) is not int or not (reading >= 0 and 40 >= reading):
        raise ValueError("Use a whole model reading from 0 to 40")
    if type(target) is not int or not (target >= 10 and 30 >= target):
        raise ValueError("Use a whole model target from 10 to 30")
    if type(was_on) is not bool:
        raise ValueError("Use a Boolean previous request")
    if reading >= target + 1:
        return False
    if target - 1 >= reading:
        return True
    return was_on

{| class="wikitable"

! Model reading, target always20 !! Previous request !! Returned request |- | 18 || False || True |- | 19 || True || True |- | 20 || True || True |- | 21 || True || False |- | 20 || False || False |- | 19 || False || True |} Starting with request False and target twenty, the reading sequence eighteen, nineteen, twenty, twenty-one, twenty, nineteen produces True, True, True, False, False, True. At the central reading twenty, the previous state matters:it can retain either True or False. At the two thresholds, the new request is determined by the reading. The previous value is explicit input to this pure function;the caller must retain each returned request for the next step.

This function returns only a Boolean request. It connects to no heater, actuator, network or real sensor. The accepted reading range zero through forty and target range ten through thirty are invented test contracts, not installation limits or heating recommendations. Text, floats, missing readings and non-Boolean previous states are rejected. A failed model input raises an error;the surrounding real system would need its own independently designed fault behaviour. This small function is not a real appliance controller.

Code.org/CodeAI: Hardware and Software helps relate a focused stored program to the physical components that execute it. The original thermostat is a software model only.

Now meet the required washing-machine transfer. Identify water-level or temperature sensing as inputs, processor decisions as processing, active cycle stage and timer values as working state, firmware and saved settings as stored material, and display or actuator interfaces as outputs. A feedback path returns later sensor observations to the controller. The exact appliance design determines the real sensors, storage, programme states and independent protective mechanisms;this overview is not a service diagram or instruction to operate exposed equipment.

For an original conceptual state trace, use the labels idle, fill, wash, drain and complete. Explain that a later transition depends on the programme state and relevant feedback rather than assuming elapsed time alone proves a physical condition. The same reading may lead to different processing at different states. Do not claim our thermostat function implements those washing-machine transitions:it illustrates only a smaller stateful decision, while the washing-machine task is a separate labelled analysis.

The exact original tiny-machine and thermostat programs were actually executed against normal, boundary and invalid cases. That checks their software contracts, not the dynamics of real sensors or equipment. Submit a labelled component/data-flow diagram, full stored-instruction trace, resource-budget explanation and a justified embedded-system example. Include actual expected-versus-observed runs where possible, and label paper traces and physical-practical evidence separately. The wider KS3 digital-representation objective includes other topics beyond this architecture lesson.



Interactive Tasks


Quiz: Test Your Knowledge

Which component executes the instruction sequence in the introductory system model? (The processor or CPU) (!Only the long-term saved document file) (!The entire computer case as one indivisible component) (!A passive input label with no processing role)



What changes immediately after ADD B in the original five-plus-three trace? (The accumulator becomes eight while SUM is still zero) (!SUM becomes eight before the accumulator is read) (!The saved program is automatically deleted) (!The physical processor gains eight extra memory chips)



What does STORE SUM do in the original model? (Copy the accumulator value into the model SUM location) (!Convert every RAM chip into nonvolatile storage) (!Display a real washing-machine service code) (!Run an instruction from an external device)



What is a key distinction between ordinary DRAM and flash? (DRAM needs continued power for retention while flash is nonvolatile) (!Every flash device is indestructible and automatically backed up) (!DRAM and flash must always have identical roles) (!Every register is a permanently saved document)



How much flash remains in the fictional two-hundred-and-fifty-six-kibibyte budget? (Seventy-six kibibytes after the one-hundred-and-eighty-kibibyte image) (!Three kibibytes because flash and RAM are the same pool) (!Two hundred and fifty-six additional kibibytes of RAM) (!Nothing because a processor cannot store instructions)



What makes a controller embedded in the washing-machine example? (Its focused computing role integrated into the larger product) (!Being smaller than every laptop) (!Always being connected to the internet) (!Having no stored software or input signals)



What does the thermostat model return at reading twenty, target twenty, previous request True? (True because the central gap retains the previous request) (!False because every target-equal reading must switch off) (!A real instruction to a connected heater) (!An automatically saved appliance configuration)



What does the same model return at reading twenty-one, target twenty? (False regardless of the previous Boolean request) (!True because every above-target reading requests on) (!The previous request because the upper threshold is ignored) (!A numerical temperature rather than a Boolean request)



Which is a justified washing-machine data-flow description? (Sensors supply inputs, the processor uses programme state, and interfaces provide outputs) (!A motor is the only storage device for instructions) (!A water-level sensor alone replaces every processor decision) (!A saved setting automatically proves the current physical water level)



What can the original software checks establish? (Whether the two stated model contracts behave as tested) (!That a real appliance is safe to wire or service) (!That every modern processor executes one instruction per clock tick) (!That unused flash is automatically available as extra RAM)





Memory Game

Processor Executes instructions and coordinates computation
Register A small internal processor working location
RAM Working memory whose technology and role must be identified
Storage Retains saved program or data material
Embedded system Computing integrated into a larger product for a focused role
Feedback Later observations returned to influence subsequent processing





Drag and Drop

A result changes in the accumulator but not yet in SUM Distinguish calculation from the later STORE operation
Unused flash is counted as extra RAM Keep the different resource roles and budgets separate
A small board is called embedded only because of its size Justify the role and integration within a larger product
The thermostat reading is at target Use the previous Boolean request under the announced hysteresis rule
A paper sensor-to-output diagram is presented as physical practical proof Identify it as conceptual analysis and state what practical evidence remains





Crossword Puzzle

PROCESSOR What executes stored instructions?
REGISTER What small internal working location can hold a calculation?
MEMORY What broad term needs a specific technology and role to be clear?
STORAGE What retains saved material?
FIRMWARE What focused stored software can run in an embedded product?
SENSOR What obtains a physical observation as an input?





LearningApps

Optional extra practice. Choose an appropriate activity with your teacher. If the external collection is unavailable, use the native activities and independent tasks in this course.


Cloze Text

Complete the explanation.
A processor executes stored

. Fetch obtains the next instruction from

. The original ADD changes the

. STORE then changes the model

. Ordinary DRAM needs continued

for retention. Flash is

,not indestructible. The fictional RAM budget leaves

kibibytes. An embedded system has a focused role in a larger

. The thermostat gap preserves the previous

. Real feedback supplies later

.



Open Tasks


Easy

  1. Label a system: Identify processor, memory, storage, input and output in a desktop or conceptual controller diagram.
  2. Trace four instructions: Follow A five and B three through LOAD, ADD, STORE and HALT with accumulator and SUM separate.
  3. Compare memory roles: Explain ordinary DRAM and flash without saying all memory is volatile or all saved data is invulnerable.
  4. Explain integration: Justify why a washing-machine controller is embedded without relying only on size or internet connectivity.


Standard

  1. Run another program trace: Choose a different valid A and B, calculate expectations and record actual tiny-machine results if executed.
  2. Audit resource budgets: Calculate flash and RAM remainders with consistent kibibyte units and explain why they cannot simply be pooled.
  3. Trace retained state: Follow the six-reading thermostat sequence from the announced initial state and explain both target-equal outcomes.
  4. Analyse the transfer appliance: Map a washing-machine sensor, processor, working programme state, firmware and outputs, including a feedback path.


Advanced

  1. Compare abstraction levels: Explain which real CPU features the sequential tuple interpreter leaves out and why its source is not a real instruction set.
  2. Test model boundaries: Check accepted endpoints, wrong types and missing observations, distinguishing a model exception from real-system fault behaviour.
  3. Choose evidence for performance: Explain why clock frequency or storage capacity alone cannot determine task completion speed;propose a defined workload comparison.
  4. Extend the conceptual analysis: Develop a justified state/data-flow diagram for another embedded product and separate conceptual, executed-software and supervised physical evidence.



Learning Check

  1. System roles and instruction execution: Explain the original stored-program example.
  2. Memory and persistence: Distinguish specific technologies and saved state.
  3. Resource arithmetic: Check the original fictional budgets.
  4. Thermostat software trace: Apply the explicit state-dependent request rule.
  5. Embedded transfer: Analyse the washing-machine example.
  6. Evidence and limitations: Support a technically honest explanation.


Worked checks and assessment guidance

  1. A processor executes instructions using internal working state and access to memory and interfaces. With A five and B three, LOAD makes the accumulator five, ADD makes it eight while SUM is still zero, STORE makes SUM eight, and HALT ends the four-instruction model. The tuple interpreter is an original sequential software abstraction, not a real binary instruction set or a claim of one instruction per clock tick.
  2. Ordinary DRAM needs continued power to retain working data;flash/SSD storage is nonvolatile but can fail or lose/corrupt data. Registers and caches have other working roles. A saved file and an active edit are not automatically the same version without an actual save or autosave. Embedded firmware may be stored in flash with active state in RAM, and not every design requires a separate disk or operating system.
  3. From256 KiB flash,180 KiB for the stated programme image leaves76 KiB. From32 KiB RAM,22 KiB buffers plus7 KiB other working state uses29 KiB and leaves3 KiB. One kibibyte is1024bytes. Unused flash is not automatically extra RAM, and this simplified arithmetic budget is not proof of production readiness, peak sufficiency or a specification of a real appliance.
  4. At target20, readings18,19,20,21,20,19 from initial False produce True, True, True, False, False, True. At the central reading20, the previous request is retained;at21 it becomes False and at19 it becomes True. The function returns a Boolean request only and controls no device. Its integer ranges and exceptions are invented software contracts, not physical installation limits or a complete appliance fault design.
  5. Its computing is integrated into a larger product for a focused purpose. Sensors supply observations, the processor executes a focused programme, working memory holds active stage/timer/data, firmware and saved settings occupy appropriate storage, and interfaces provide displays or actuator outputs. Later observations close the feedback path. Idle, fill, wash, drain and complete are conceptual stage labels, not an implementation supplied by the smaller thermostat function or a real service diagram.
  6. Supply a labelled component/data-flow diagram, full accumulator/SUM trace, resource calculations and a justified embedded-system comparison. Actual model runs and independent expected results establish the stated software behaviour;paper traces do not prove execution and neither proves hardware assembly or physical safety. Processor frequency alone does not predict whole-workload speed. Broader KS3 digital representation and practical objectives require other evidence beyond this single course.


Learning evidence

Submit a labelled system/data-flow diagram,a full stored-instruction trace,resource-budget calculations and a justified embedded-system example including the washing-machine transfer. Add expected-versus-actual software runs where executed and a clear model limitation. Distinguish conceptual diagrams,software execution and supervised physical evidence;the original examples perform no hardware operations.


OER and Wikipedia

Original tiny-machine programme,thermostat request model,state traces,resource budgets and exercises. Arm CPU glossary supports processor components and conceptual instruction execution; Kingston memory/storage explanation supports the role distinction. No product marketing performance claim or indefinite-storage guarantee is adopted. Code.org/CodeAI original educational video library identifies the supporting CPU and hardware/software videos. DfE Computing programme of study, KS3 system components and stored instructions;Year8 allocation is editorial and the wider representation objective includes other courses. Primary sources checked14November2026. Commons originals retain exact attribution;the RAM photograph shows empty sockets,not installed capacity,and the desktop diagram is not universal modern packaging.

Personal computer, exploded.svg, Gustavb, CC BY 2.5. Unchanged original; caption and learning activities are original.

DDR 4 SO-DIMM RAM slot PNr°0837.jpg, D-Kuru, CC BY-SA 4.0. Unchanged original; caption and learning activities are original.


Linked learning areas


aiMOOC Projects



Schulfach+




aiMOOCs



aiMOOC Projekte









MOOCwiki · Deutsch

Nach dem Lernen ist vor dem Lernen

Entdecke direkt den nächsten Lernkurs. Weitere Inhalte erscheinen, wenn Du weiter nach unten scrollst.

Zur MOOCwiki-Hauptseite

Mediathek

Suche verfeinern

Dein Lernplan bestimmt, was oben steht. Alle anderen Inhalte bleiben erreichbar. Seitenaufrufe beeinflussen die Auswahl nicht.

Inhalte werden geladen ...

Mediathek wird aus dem Wiki geladen ...