update

Writerside/topics/RA/MU1Rechner.md

@@ -38,4 +38,257 @@
 
 ![image_57.png](image_57.png)
 
-## 
+## Der Reset
+- Jeder Prozessor hat einen Reset-Eingang
+  - ist negiert angelegt → 0 macht [reset](MU1Rechner.md#reset)
+    - [Program Counter](MU0Rechner.md#steuerwerk) wird auf 0 gestellt, [Microprogram-Counter step](MU1Rechner.md#micro-program-counter-step) ebenfalls
+    - ALU wird auf Funktion NULL gesetzt
+- Beim Einschalten wird Reset-Signal verzögert gesetzt
+  - Prozessor braucht Zeit um Startzustand herzustellen
+
+## Micro-Program-Counter Step
+- Step ist ein Speicher in der Steuereinheit (_Timing/Control Unit_)
+- meiste Befehle benötigen mehrere Takte
+  - Micro-Program-Counter Step gibt Steuerlogik Informationen
+    - welche Aktionen sind auszuführen
+    - Step = Eingangsinformation für jeden Schritt
+- Steuerungstabelle weiß welcher step welcher Schritt ist
+
+## Befehlsablauf MU1
+![image_58.png](image_58.png)
+- Step == Null
+  - **Fetch** (lesen des Befehls in das Instruction Register)
+- letzter Schritt: Step = Null
+- Step wird meistens um 1 erhöht
+  - falls nicht → Schleife
+
+### Fetch-Zyklus
+- findet in einem Takt statt
+  - 1. Taktflanke
+    - Program Counter wird auf Adressbus und auf ALU[A] geschaltet
+    - An der ALU ist Befehl=A+1, S=0
+  - 2. Taktflanke
+    - Speicher liest nächste Instruktion und speichert in IR
+    - PC wird über ALU um 1 erhöht
+
+![image_59.png](image_59.png)
+
+### Befehl LDA (Laden des AKK aus Speicher)
+- Zwei Takte
+- ![image_60.png](image_60.png)
+
+### Zustandsbeschreibung des Ladebefehls
+![image_61.png](image_61.png)
+- Nach Fetch entscheidet Opcode im IR und Schrittnummer, welchen Zustand der Automat als nächstes annimmt
+- Step ist PC im Microcode und beschreibt Abfolge der Befehle im Microcode
+- Zu jedem Schritt gehört eindeutige Funktion
+  - Lässt sich in Timing-Control-Logik umsetzen
+
+## Adressierung
+### Direkte Adressierung (STO/LDA)
+![image_62.png](image_62.png)
+- Befehl erhält direkt die Speicheradresse
+  - Adresse kann zur Laufzeit nicht mehr verändert werden
+
+### Indirekte Adressierung (STR/LDR)
+![image_63.png](image_63.png)
+- Adresse steht an Speicherstelle
+  - effektive Adresse kann noch berechnet werden
+    - Schleifen können programmiert werden
+
+### Adressierungsarten
+#### Unmittelbare Adressierung (_immediate_)
+- Befehl erhält Konstante
+  - bspw.: _ADD #1_
+
+#### Direkte Adressierung (_direct, absolute_)
+- Befehlt enthält Adresse im Speicher, an der sich Operand befindet
+  - bspw.: _LDA S_ (_S gibt Adresse im Speicher an_)
+
+#### Indirekte Adressierung (_indirect_)
+- Befehl enthält Adresse, an der dich effektive Adresse mit Inhalt befindet
+  - bspw.: _LDR S_ (_S gibt indirekte Adresse an_)
+
+
+## Der Stack
+- stellt dynamischen Zwischenspeicher dar
+- Grundoperationen: [Push](MU1Rechner.md#stack-push), [Pop](MU1Rechner.md#stack-pop)
+- Meiste Speicherlayouts (_Konventionen_) sehen vor:
+  - wächst von oben nach unten
+  - wächst von großen zu kleinen Adressen
+
+### Stack - PUSH
+![image_65.png](image_65.png)
+- erniedrigt Stackpointer
+- schiebt einen Wert in Speicherwort, auf das der Stackpointer zeigt
+
+### Stack - POP
+![image_66.png](image_66.png)
+- liest ein Speicherwort von Adresse auf den der Stackpointer zeigt
+- erhöht den Stackpointer
+
+### Der Stack im Speicher
+![image_64.png](image_64.png)
+- Stackpointer wird auf Adresse am Ende des Speicherbereichs gesetzt
+- Programme werden im unteren Speicherbereich platziert
+  - Programm-Counter auf Adresse 0
+- Programmbereich schließt sich nach oben an Datenbereich an
+- Zwischen Daten und Stack findet man Heap
+
+### Zugriffe auf den Speicher
+![image_67.png](image_67.png)
+
+## Unterprogramme
+![image_68.png](image_68.png)
+- wichtiges Strukturierungsmittel für Programmierung
+- werden mit Sprungbefehl (_call, bl_) angesprungen
+- Nach Verlassen des UP wird ursprüngliches Programm wieder fortgesetzt
+  - Rücksprung erfolgt indem gespeicherte Adresse wieder in PC übertragen wird
+
+### Unterprogramm Aufrufe
+#### Call
+![image_69.png](image_69.png)
+- nächster nach der Rückkehr auszuführende Befehl wird auf den Stack gespeichert
+  - Sprungadresse wird aus IR in PC geladen
+
+#### Return
+![image_70.png](image_70.png)
+- Rücksprungadresse von Stack in PC geschrieben
+  - fetch-Zyklus lädt neue Instruktion
+
+
+## MU1-Befehlssatz
+![image_71.png](image_71.png)
+
+## Micro-Codes
+**X = Y**
+- Inhalt des Registers Y wird nach X verschoben
+
+**X = [Y]**
+- Inhalt von Adresse in Y wird nach X verschoben
+
+**X = Y op Z**
+- Inhalt von Y (A-Bus der ALU) wird mit Z (B-Bus der ALU) verrechnet und nach X transportiert
+
+**[X] = Y**
+- In Adresse in X wird Inhalt von Y geschrieben
+
+**ACC = Din**
+- ACC & Din sind Registernamen
+  - Inhalt von Din wird nach ACC transportiert
+- in Din muss oe gesetzt sein, in ACC muss ie gesetzt sein
+- Transport über ALU
+  - [ALU Funktion](MU1Rechner.md#grundfunktionen-mu1-alu) muss B sein
+- Da Speicher nicht angesprochen wird (keine [])
+  - [MEMeq=0](MU0Rechner.md#speicher-des-mu0) und [RnW beliebig](MU0Rechner.md#speicher-des-mu0) 
+
+**Din = [SP]**
+- Inhalt von SP ist Adressinformation
+  - Adressmultiplexer muss auf 0 stehen
+- Da Speicher angesprochen wird
+  - MEMrq = 1, RnW = 1
+- Da ALU nicht benutzt wird
+  - ALU-Funktion kann beliebig gesetzt werden
+
+**PC = PC + 1**
+- ALU-Funktion muss [A+1](MU1Rechner.md#grundfunktionen-mu1-alu) sein
+- PC wird auf A-Bus gelegt
+- in der zweiten Hälfte des Takts wird Ergebnis in PC geschrieben
+- oe und ie von PC müssen 1 sein
+
+**Din = [SP], SP = SP+1**
+- Beide Operationen können in einem Takt durchgeführt werden
+  - Adressierung in der ersten Takthälfte
+  - Zurückschreiben in der zweiten Takthälfte
+
+## Regeln für MU1
+**[X] = Dout**
+- wird in den Speicher geschrieben, muss rechte Seite [Dout](MU1Rechner.md#der-mu1-datenpfad) sein
+- [MEMrq = 1, RnW = 0](MU0Rechner.md#speicher-des-mu0)
+- zu schreibender Wert muss VORHER nach Dout gebracht werden
+
+**X = [Y]**
+- wird vom Speicher gelesen
+  - linke Seite muss IR oder Din sein
+- [MEMrq = 1, RnW = 1](MU0Rechner.md#speicher-des-mu0)
+
+**keine Adresse**
+- wird keine Adresse verwendet
+  - [MEMrq = 0, RnW = 1](MU0Rechner.md#speicher-des-mu0)
+- **Nur ein Register darf jeweils auf einen Bus schreiben (A- oder B-Bus), aber alle dürfen lesen**
+
+
+## Die Addition ADD S
+- IR wird zur Adressierung verwender und der Wert nach Din gebracht
+  - **Din = [IR]**
+- Inhalt des AKK wird auf A-Bus gelegt, Inhalt von Din auf B-Bus
+  - [ALU-Funktion](MU1Rechner.md#grundfunktionen-mu1-alu) ist **A+B, S : ACC = ACC + DIN**
+
+![image_72.png](image_72.png)
+
+## Die Operation PUSH
+**Akkumulator wird auf den Stack geschoben**
+- Besteht aus 3 Schritten
+  1. **SP = SP-1**
+     - ![image_73.png](image_73.png)
+  2. **Dout = ACC**
+     - ![image_74.png](image_74.png)
+  3. **[SP] = Dout**
+    - ![image_75.png](image_75.png)
+    - [Micro-Program-Counter Step](MU1Rechner.md#micro-program-counter-step) wird auf 0 gesetzt
+      - Fetch-Zyklus schließt sich an
+
+## MU1-Zustandsautomat für LDA, ADD, PUSH
+![image_76.png](image_76.png)
+- Nach dem Holen des Opcodes im Fetch-Zyklus
+  - Zustand des OpCode wird angesprungen
+- Step-Variable (PC im Micro-Code) wird in Schleife durchlaufen
+  - endet bei 0 im Fetch-Zyklus
+
+
+## Bedingte Sprünge
+- Bedingter Sprung **JGE** (_Jump on greater or equal_) 
+  - in Abhängigkeit des Negative-Flags im Statusregisters (~15 Bit des ACC, ACC >=0 oder ACC <0) wird ein unterschiedlicher Zustand angesprungen
+    - ? N = 0 (ACC >= 0)
+      - PC = IR
+    - ? N = 1 (ACC < 0)
+      - keine Operation wird ausgeführt (NOP)
+- Bedingter Sprung **JNE** (_Jump on not equal)
+  - strukturell gleich, Zusatzbedingung:
+    - Accumulator = Null (Zero-Flag = 1)
+
+### MU1-Steuerlogik für bedingte Sprünge
+- Beide Befehle weisen 2 Zustände auf
+  - unterscheiden sich durch Statusbits des Akkumulators
+- Beide Zustände haben Schrittnummer 1 und Folgeschritt 0
+- Funktion **NOP** ist gekennzeichnet
+  - kein Registerinhalt wird verändert
+    - Alle Register haben oe und ie auf 0
+  - Speicher wird nicht angesprochen
+    - MEMrq = 0
+- ![image_77.png](image_77.png)
+
+## Der Stop-Befehl
+- hat als Folgezustand _stop_
+- kein Fetch-Zyklus mehr
+  - Zustandsmaschine wird in der Stellung angehalten
+- ![image_78.png](image_78.png)
+
+## Reset
+- Zustandsmaschine geht in Zustand _reset_
+  - PC = 0
+  - Step = 0
+- Beendigung des Reset-Signals mit dem fetch fortgefahren und Befehl von Adresse 0 wiederholt
+- ![image_79.png](image_79.png)
+
+
+## Zusammenfassung
+- Funktionen ALU
+- Neue Register Stackpointer, Din, Dout
+- Micro-Programm-Counter Step
+- Fetch-Zyklus
+- Micro Programm + Micro Codes + Zustandsautomaten für LDA, ADD, Push, JGE, Stop, Reset
+- Direkt und indirekte Adressierung
+- Stack, Unterprogramme
+- Beschreibung der Microcode-Funktion durch einfache Sprache
+- Zentrales Register: ACC → Akkumulator-Architektur