Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige Überarbeitung Vorherige Überarbeitung
Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:assembler_sca [2022-06-29 08:42] – scagf_informatik:assembler_sca [2023-08-01 15:35] (aktuell) – [Instruction Set] sca
Zeile 13: Zeile 13:
  
  
-==== Instruction Set ==== 
- 
-^ Code ^ Name ^ Description ^ 
-| 0 | HLT | Stop (Little Man has a rest). | 
-| 1 | ADD | Add the contents of the memory address to the Accumulator | 
-| 2 | SUB | Subtract the contents of the memory address from the Accumulator | 
-| 3 | STA or STO | Store the value in the Accumulator in the memory address given. | 
-| 4 |      | This code is unused and gives an error. | 
-| 5 | LDA | Load the Accumulator with the contents of the memory address given | 
-| 6 | BRA | Branch - use the address given as the address of the next instruction | 
-| 7 | BRZ | Branch to the address given if the Accumulator is zero | 
-| 8 | BRP | Branch to the address given if the Accumulator is zero or positive | 
-| 9 | INP or OUT | Input or Output. Take from Input if address is 1, copy to Output if address is 2. | 
-| 9 | OTC | Output accumulator as a character if address is 22. (Non-standard instruction) | 
-| 9 | DAT | Used to indicate a location that contains data.| 
  
 ===== Aufgaben ===== ===== Aufgaben =====
Zeile 51: Zeile 36:
    1. Schreibe den Code so um, dass nun **vier Zahlen addiert** werden können.    1. Schreibe den Code so um, dass nun **vier Zahlen addiert** werden können.
  
-==== Aufgabe 3: Schleifen ====+==== Aufgabe 2: Schleifen ====
  
-Nun wollen wir **Schleifen** (ähnlich wie *while* in Python) in Assembler programmieren. Diese Funktionieren im Prinzip gleich wie die Verzweigungen in der letzten Aufgabe. Der Unterschied ist nun einfach, dass man mit den Sprung-Instruktionen (BR.) //zurück//springt.+Nun wollen wir **Schleifen** (ähnlich wie *while* in Python) in Assembler programmieren. Bei einer solchen wird eine *Bedingung* überprüft. Je nachdem, ob diese erfüllt ist, *springt* der Code dann wieder zurück. Dazu verwenden wir die **Sprung-Instruktionen** (**Branch**) in Assembler.
  
 <code asm> <code asm>
         ...         ...
-LOOP    ... // here loop starts (can also use other name)+LOOP    ... // here loop starts
         ...         ...
-        BRP LOOP // if accumulator is >= 0, jump to LOOP+        BRP LOOP // if accumulator is >= 0, jump to LOOP (can also use different name)
         ...         ...
 </code> </code>
  
-Schreibe Assembler-Code, der einen Countdown ausführt: +   1. Studiere im Manual die **Sprung-Instruktionen** BRA, BRZ, BRP 
-  * eine Zahl wird eingelesen +   1. Schreibe Assembler-Code, der einen **Countdown** ausführt (siehe unten): 
-  * wiederholen, solange die Zahl >= 0 ist: +     1. eine Zahl wird eingelesen 
-    * die Zahl wird ausgeben  +     1. wiederholen, solange die Zahl >= 0 ist: 
-    * die Zahl wird um 1 verringert+       1. die Zahl wird ausgeben  
 +       1. die Zahl wird um 1 verringert
  
-Hinweise: +**Hinweise:** 
-  * mit `ONE DAT 1` kann nach dem eigentlichen Programm eine Zahl (z.B. $1$) in den Speicher geschrieben werden, die dann für die Subtraktion verwendet werden kann.+  * Mit `ONE DAT 1` kann nach dem eigentlichen Programm eine Zahl (z.B. $1$) in den Speicher geschrieben werden, die dann für die Subtraktion verwendet werden kann. 
 +  * Welche **Sprung-Instruktion** musst du hier verwenden?
  
-<nodisp 1>+<nodisp 2>
 ++++Lösung:| ++++Lösung:|
 <code asm> <code asm>
Zeile 85: Zeile 72:
 </nodisp> </nodisp>
  
-==== Aufgabe 2: Verzweigungen ====+==== Aufgabe 3: Verzweigungen ====
  
-Nun wollen wir ein einfaches **if-else**-Statement in Assembler programmieren. Bei einem solchen wird eine *Bedingung* überprüft. Je nachdem, ob diese erfüllt ist, *springt* der Code dann an eine andere Stelle. Dazu verwenden wir die **Branch**-Elemente in Assembler. Mit diesen kann der aktuelle Wert im //Accumulator überprüft// werden und man kann an eine bestimmte Stelle //springen//.+Nun wollen wir einfache **Verzweigungen** (entspricht **if-else**-Statement in Python) in Assembler programmieren. Bei einem solchen wird eine *Bedingung* überprüft. Je nachdem, ob diese erfüllt ist, *springt* der Code dann an eine andere Stelle. Dazu verwendet man, ganz ähnlich wie bei Schleifen, die **Sprung-Instruktionen**. Der Unterschied hier ist, dass man nicht zurück sondern nach weiter unten im Code springt.
  
 <code asm> <code asm>
Zeile 100: Zeile 87:
    1. Schreibe ein Assembler-Programm, in welchem dem man zuerst zwei Zahlen eingeben kann. Von diesen wird das **Maximum** bestimmt und ausgegeben.     1. Schreibe ein Assembler-Programm, in welchem dem man zuerst zwei Zahlen eingeben kann. Von diesen wird das **Maximum** bestimmt und ausgegeben. 
  
-==== Aufgaben 3a-f ====+ 
 +<nodisp 2> 
 +++++Lösung:| 
 +<code asm> 
 +</code> 
 +++++ 
 +</nodisp> 
 + 
 + 
 +==== Aufgaben 4a-f ====
 Löse eine der folgenden Aufgaben; verwende Labels und Branching Instructions. Löse eine der folgenden Aufgaben; verwende Labels und Branching Instructions.
  
  • gf_informatik/assembler_sca.1656492174.txt.gz
  • Zuletzt geändert: 2022-06-29 08:42
  • von sca