# MU0-Rechner
## Historie
- **SSEM** _Small Scale Experimental Machine_ erste erfolgreiche Implementierung des Von-Neumann-Rechners
  - 1948 erstmals Programm aus dem Speicher ausgeführt

## Elemente
![image_22.png](image_22.png)
- **[Steuerwerk](MU0Rechner.md#steuerwerk)**
  - _Control_ - Takt, Steuerlogik
  - _IR - Instruction Register_ - speichert den aktuellen Befehlscode
  - _PC - Programm Counter_ - speichert die aktuelle Programmadresse
- **Rechenwerk**
  - _[ALU](MU0Rechner.md#alu) - Arithmetic Logic Unit_ - kann rechnen
  - _ACC - Akkumulator_ - Ergebnis Register für Rechnungen
- **[Speicherwerk](MU0Rechner.md#speicher)**
  - _Memory_ - speichert Programme und Daten
- **Bus** - verbindet alle Elemente

### Steuerwerk
- Steuert Elemente mithilfe von Steuersignalen
- Besteht aus
  - Ablaufsteuerung / Steuerlogik
  - Dekodierer
  - Befehlsregister IR
  - Befehls-Zähler PC
- **Endlicher Automat, der gemäß der Steuerlogik Steuersignale schaltet**
- führt für jeden Befehl ein Mikroprogramm aus Mikroschritten aus

### Register
![image_23.png](image_23.png)
- Zwischenspeicher
  - Register-Größe: 1 Wort (16 Bit)
- Arbeitsmodus Lesen / Schreiben
  - _output enable_ liegt an → Daten ausgeben (schreiben)
  - _input enable_ liegt an → Daten einlesen
- Ausgeben und Lesen erfolgt jeweils beim Flankenwechsel
  - Ausgeben erfolgt einen halben Takt früher als das Lesen, sodass ein Register in einem Zyklus schreiben und lesen kann
  - ![image_24.png](image_24.png)

### Speicher
- Stelle im Speicher wird über eine Adresse angesprochen
- Adresse wird vom Adressbus gelesen
- Daten werden vom Datenbus gelesen bzw. geschrieben
- ![image_25.png](image_25.png)

### Datenpfade
- je nach Steuerungscode lesen / schreiben
- geschriebene Daten liegen an Datenpfad an
- immer nur 1 Element schreiben
- ![image_26.png](image_26.png)

### ALU
- über Steuercode wird Funktion ausgewählt
  - Eingang A, B führt aus
  - mögliche Funktionen:
    - A+Β
    - A-B
    - A*Β
    - Konjunktion (logisches UND, bitweise)
    - Disjunktion (logisches ODER, bitweise)
    - Vergleich von A und B (bitweise)
    - ...

## Beispiel für einen Befehlsablauf
![image_27.png](image_27.png)

## Der Rechenzyklus
### Fetch
![image_28.png](image_28.png)
1. Wert des Programmcounters auf den Adressbus legen
2. Programmcode aus dem Speicher in das Instructionregister lesen
3. ALU erhöht gleichzeitig Wert des PC und speichert diesen wieder zurück

### Decode/Execute/Write für Rechenoperationen
![image_29.png](image_29.png)
1. Adresse des Operanden aus dem Befehl dekodieren (1)
2. Wert des angesprochenen Speicherworts an einen Eingang des ALU schalten (2)
3. zweiter Eingang der ALU erhält seine Information vom Akkumulator (2)
4. Rechenoperation wird aus dem Befehl dekodiert und and der ALU über Steuercode gewählt (1)
5. Ergebnis der Rechnung wird wieder im Akkumulator gespeichert (3)

## Taktsynchronität
- Register sind Zwischenspeicher und arbeiten getaktet
  - Daten liegen taktsynchron am Bus an
- ALU und Speicher sind nicht taktsynchron
  - folgen Steuercodes und dem Inhalt auf dem Bus

## Umsetzung MU0-Struktur in Hardware
- Architektur muss in Gattern und getaktet umsetzbar sein
- Prinzip des minimalen Hardwareaufwands

- Festlegung der Wortbreite: 16 Bit
- [Datenpfad-Modell](MU0Rechner.md#datenpfad-modell)
- Steuerung der Elemente durch Steuercodes
- Befehle (Instruction Set)
  - Kodierung der Befehle
  - Steuerlogik

### Datenpfad-Modell
![image_30.png](image_30.png)
- bisheriges Bild lässt sich nicht 1:1 umsetzen
  - ALU hat nur zwei Eingänge
    - Getrennte Datenpfade für jeden ALU-Eingang
  - Kontrolle der PFade für Daten und Adressen durch [Multiplexer](MU0Rechner.md#multiplexer)

#### Multiplexer
![image_31.png](image_31.png)
- Schalter, der durch Anlegen eines Steuersignals das ausgewählte Eingangssignal auf den Ausgang legt

#### Befehlsgruppen
- Multiplexer B steht auf 1 bei allen _Datenverarbeitungs-Befehlen_ und auf 0 bei allen _Sprung-Befehlen_
- Multiplexer A wird nur für _Fetchzyklus_ auf 0 gestellt
  - ansonsten wird S (unterer Teil von IR) immer als Adresse interpretiert
- Bei _Sprung-Befehlen erfolgt kein Datenzugriff, S (IR) wird direkt nach PC verschoben

## Kennwerte
- Wortbreite des Prozessors: 16 Bit
  - Registergröße
  - Busbreite
  - Eingänge/Ausgänge ALU
- Instruktionen immer 2 Takte lang
  - Fetch + Instruction (= Execute): 2 Takte
  - Schreiben + Lesen + Schreiben + Lesen: 4 Taktflanken

## Elemente und Steuercodes
![image_32.png](image_32.png)

## Speicher des MU0
- Steuersignale des Datenbus:
  - MemRQ (Memory Request)
    - Speicherbaustein wird angesprochen
  - RnW(Read / not Write)
    - gibt an, ob (von oder in) den Speicher geschrieben wird
      - _Lesen bei High, Schreiben bei Low_

## Instruction Set des MU0-Rechners (Befehlssatz)
![image_33.png](image_33.png)
- Prozessor kennt keine Befehle
  - zum **Laden und Speichern** von Werten
  - zur **Berechnung**
  - zur **Ablaufkontrolle**

- Die Instruktionen setzen sich zusammen aus
  - einem 4 Bit Operation Code
  - einer 12 Bit Adresse
  → 16 Befehle möglich

## MU0-Steuerlogik (_Kontroll-Logik_)
Opcode: 4Bits, Adresse: 12Bits
![image_34.png](image_34.png)

### Fetchen
![image_35.png](image_35.png)

### ADD S
![image_36.png](image_36.png)

## Ein erstes MU0-Programm
![image_37.png](image_37.png)

## Fazit
- Elemente der von-Neumann-Architektur
  - Steuerwerk, Rechenwerk, Speicherwerk, I/O
- Speicherprogrammiert
  - Programme (& Daten) liegen im Speicher
- Architektur muss in Gattern umsetzbar sein
  - Datenpfad & Steuertabelle
- Von-Neumann-Zyklus: Fetch-Decode-Execute-Write
- Steuerlogik wird über Opcodes (Befehle) abgefragt und generiert Steuercodes

- MU0 ist ein Modellrechner zum Lernen
  - 16-Bit Wortbreite, binär
  - Register: PC, IR, ACC
  - Befehlssatz (Instruction Set)
    - 4-Bit OpCode erlaubt 16 Befehle, 8 sind implementiert
  - Takt
    - Immer 2 Zyklen pro Mikroprogramm

