Intermezzo: Was wir schon wissen…

Für diesen Beitrag wurde das CBM prg Studio verwendet.
weitersagen ...
Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedIn

CBM prg StudioUnser vorhandenes Wissen einsetzen, um uns ‘neue‚ Befehle zu erschließen!

Im vorherigen Teil habe ich ja schon beim LDY-Befehl darauf verzichtet eine bekannte Adressierungsart mit einem extra Beispiel vorzustellen. Da wir uns langsam an Assembler gewöhnt haben und bereits fast alle Adressierungsarten kennen (es fehlen nur noch drei von 13 und diese drei werden nur von sieben Befehlen benutzt), werde ich ab jetzt nur noch neue Adressierungsarten und Befehle im Beispiel vorstellen. Alle Adressierungsarten und Varianten eines Befehls (z. B. sollte es uns auch ohne Beispiel nicht schwerfallen zu verstehen wie STY funktioniert, wenn wir STA schon kennen), die nicht im Beispiel erklärt wurden, findet ihr zukünftig in einer Liste am Ende des jeweiligen Beitrags und natürlich unter Mnemonics, dort ist auch eine Übersicht der Adressierungsarten zufinden.
Ich werde aber den Source-Code mit mehr Kommentaren versehen. Ja, ich habe im Video erklärt, dass das auch problematisch sein kann, da die Übersicht evtl. verloren geht. Ich denke aber, dass es hier im Grundlagen-Kurs eher förderlich ist. Zusätzlich versuche ich in späteren Beispielprogrammen die unterschiedlichen Adressierungsarten und Befehlsvarianten zu verwenden, auch wenn es evtl. nicht die eleganteste Methode ist ein Problem zu lösen.


Laßt uns also für alle bereits bekannten Befehle jetzt noch kurz die bisher nicht erwähnten Adressierungsarten und Varianten nachholen.

Ladebefehle
Erfreuen wird euch evtl. dass wir die Ladebefehle (LDA, LDX, LDY) bereits in allen Kombinationen verwendet haben. Glück gehabt, schon mal ein Punkt weniger. 😉


Speicherbefehle
Von den Speicherbefehlen haben wir bisher ausschließlich STA benutzt und dort nur vier der sieben Adressierungsarten kennengelernt.
STA: STore Accumulator (speichere den Inhalt des Akkus in…)
Der STA-Befehl besitzt, mit Ausnahme der unmittelbaren Adressierung, die selben Adressierungsarten, wie LDA.
Verwendet haben wir schon die Adressierungen: absolut | absolut X-indiziert | Zero-Page und indirekt Y-nach-indiziert.

STA absolut Y-indiziert ($99, 3B, 5T, <keine>)

Funktioniert genau so, wie die X-indizierte Adressierung, nur dass hier der Akku-Inhalt an der Adresse abgelegt wird, die sich durch Addition des Y-Registers und der übergebenen Adresse ergibt.

STA Zero-Page X-indiziert ($95, 2B, 4T, <keine>)

Der Akku-Inhalt wird an der Adresse abgelegt, die sich durch Addition der angegebenen Zero-Page-Adresse und des X-Registers ergibt.

STA indirekt X-indiziert ($81, 2B, 6T, <keine>)

Die Berechnung der Adresse, an der der Akku-Inhalt abgelegt wird, ist mit der vom LDA-Gegenstück identisch: Zur übergebenen Zero-Page-Adresse wird der Inhalt des X-Registers addiert, die dort zu findenen Adresse stellt das Ziel dieses Befehls dar.

 

Es wird euch nicht wirklich überraschen, dass man nicht nur den Inhalt des Akkumulators, sondern auch den Inhalt des X– & Y-Registers im Speicher ablegen kann.
Die Befehle lauten:
STX: STore X-Register (speichere den Inhalt des X-Registers in…)
und
STY: STore Y-Register (speichere den Inhalt des Y-Registers in…)

STX absolut ($8E, 3B, 4T, <keine>)

STY absolut ($8C, 3B, 4T, <keine>)
Registerinhalt an der angegebenen Adresse speichern.

 

STX Zero-Page ($86, 2B, 3T, <keine>)

STY Zero-Page ($84, 2B, 3T, <keine>)
Registerinhalt an der angegebenen Zero-Page-Adresse speichern.

 

STX Zero-Page Y-indiziert ($96, 2B, 4T, <keine>)
Inhalt des X-Registers an der Adresse ablegen, die sich aus Addition der angegebenen Zero-Page-Adresse und des Y-Registers ergibt.

STY Zero-Page X-indiziert ($94, 2B, 4T, <keine>)
Wie eben, nur das der Inhalt des Y-Registers an der Adresse abgelegt wird, die sich aus Addition der angegebenen Zero-Page-Adresse und des X-Registers ergibt.

Das wären dann auch schon alle Speicherbefehle! Mehr gibt es nicht, also kann auch dieser Block als erledigt betrachtet werden.


Transferbefehle
Von den sechs Transferbefehlen, haben wir schon TAX udn TXA kennengelernt, um den Akku-Inhalt ins X-Register und den Inhalt des X-Registers in den Akku zu kopieren. Es gibt ein nahezu identisches Befehlspaar für das Y-Register.

TYA: Transfer Y-Register to Akku (kopiere den Inhalt des Y-Registers in den Akku)
und
TAY: Transfer Akku to Y-Register (speichere den Inhalt des Akkus im Y-Register)

TAY implizit ($A8, 1B, 2T, NZ)
Kopiert den Inhalt des Akkumulators in das Y-Register.

TYA implizit ($98, 1B, 2T, NZ)
Kopiert den Inhalt des Y-Registers in den Akkumulator.

 

Der Vollständigkeit halber stelle ich euch noch kurz die letzten beiden Transferbefehle vor. Ich werde aber nochmal darauf zurückkommen, sobald wir den Stack benutzen.

Mit den letzten beiden Transferbefehlen könnt ihr noch den StackPointer (SP / Stapelzeiger) ins X-Register und zurück kopieren.

TSX: Transfer Stackpointer  to X-Register (kopiere den SP ins X-Register)
und
TXS: Transfer X-Register to Stackpointer (kopiere den Inhalt des X-Registers in den SP)

TSX implizit ($BA, 1B, 2T, NZ)
Kopiert den SP ins X-Register.

TXS implizit ($9A, 1B, 2T, <keine>)
Kopiert den Inhalt des X-Registers in den Stackpointer.


Rechenbefehle
Als einzige Rechenbefehle haben wir bisher die Möglichkeit kennengelernt – das X– und Y-Register (DEX und DEY) bzw. eine Speicherstelle (DEC) – um eins zu verringern. DEC bietet neben der schon benutzten Zero-Page-Adressierung noch drei weitere.

DEC: DECrement (das Byte an der angegebenen Speicherstelle um 1 verringern)

DEC absolut ($CE, 3B, 6T, NZ)
Zieht vom Byte an der angegebenen absoluten Adresse eins ab.

 

DEC absolut X-indiziert ($DE, 3B, 7T, NZ)

Das Byte, das an der angegebenen Adresse plus Inhalt des X-Registers steht, wird um eins verringert.

 

DEC Zero-Page X-indiziert ($D6, 2B, 6T, NZ)

Das Byte, das an der angegebenen Zero-Page-Adresse plus Inhalt des X-Registers steht, wird um 1 verringert.


Boolschebefehle
Da wir bisher nur den AND-Befehl mit unmittelbarer Adressierung kennengelernt haben, schauen wir uns hier nur noch seine restlichen Adressierungsarten an. Die anderen beiden Befehle aus diesem Bereich lernen wir später kennen. Für alle drei boolschen Befehle gilt übrigens, dass sie exakt die selben Adressierungsarten, wie der LDA-Befehl haben und dass das Ergebnis immer im Akku abgelegt wird.

AND: boolean AND (bitweises UND)

AND absolut ($2D, 3B, 4T, NZ)

Eine bitweise UND-Verknüpfung mit dem Byte, dass an der angegebenen Speicherstelle zu finden ist und dem Akkumulator. Das Ergebnis landet dann wieder, wie bei allen boolschen Befehlen, im Akku.

 

AND absolut X-indiziert ($3D, 3B, 4-5T, NZ)

Das Byte, dass an der angegebenen Speicherstelle zzgl. dem Inhalt des X-Registers zu finden ist wird mit dem Akkumulator bitweise UND-Verknüpft. Eigentlich benötigt der Befehl vier Taktzyklen, beim Überschreiten der Page-Grenze sind es 5!

 

AND absolut Y-indiziert ($39, 3B, 4-5T, NZ)

Eine bitweise UND-Verknüpfung wie eben, nur das die übergebene Adresse mit dem Y-Register addiert wird. Auch die Angaben zu den Taktzyklen sind identisch.

 

AND Zero-Page ($25, 2B, 3T, NZ)

Das Byte, das an der angegebenen Zero-Page-Adresse liegt, mit dem Akku UND-Verknüpfen.

 

AND Zero-Page X-indiziert ($35, 2B, 4T, NZ)

Eine bitweise UND-Verknüpfung mit dem Byte, das an der angegebenen Zero-Page-Adresse zzgl. dem Inhalt des X-Registers liegt und dem Akku.

 

AND indirekt X-indiziert ($21, 2B, 6T, NZ)

Die Adresse, deren Inhalt bitweise mit dem Akku UND-Verknüpft wird, befindet sich an der Stelle, die sich durch Addition des Inhalts des X-Registers mit der übergebenen Zero-Page-Adresse ergibt.

 

AND indirekt Y-nach-indiziert ($31, 2B, 5T, NZ)

In dem zur Adresse, die an der angegebene Zero-Page-Adresse liegt, der Inhalt des Y-Registers addiert wird, finden wir das Byte, das bitweise mit dem Akkumulator UND-Verknüpft wird.


Die Liste der Befehle, die wir bisher kennengelernt haben, wird von BNE, RTS, CLI und SEI vervollständigt. Die ‚ähnlichen‚ Befehle sind aber so wichtig, dass wir die später ausführlich betrachten werden.

Bevor wir (wie angekündigt) zu etwas Anspruchsvollerem kommen, gönnen wir uns noch etwas Entspannung mit einem mini Programm, dass aus nur drei Befehlen (die wir aber alle noch nicht kennen!) besteht und einer davon macht doch glatt einfach NICHTS!


Schrott!!Naja...Geht so...Ganz gut...SUPER! (11 Bewertungen | Ø 5,00 von 5 | 100,00%)

Loading...


<<< zurück | weiter >>>

 

weitersagen ...
Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedIn

2 Gedanken zu „Intermezzo: Was wir schon wissen…“

  1. Hallo Jörn,
    herzlichen Glückwunsch zu dieser wirklich super gelungenen Seite. Ich lese sie seit Tagen mit dem größten Vergnügen!
    Ich glaube es haben sich zwei kleine Fehler eingeschlichen:
    „TSX implizit ($BA, 1B, 2T, NZ)
    Kopiert den SP ins Y-Register.“ und
    „TXS implizit ($9A, 1B, 2T, )
    Kopiert den Inhalt des Y-Registers in den Stackpointer.“
    Muss es nicht X-Register in beiden Fallen heißen?

    Ansonsten weiter so!

    1. Hallo Marco.
      Igitt, da hast du vollkommen recht! Das kam wahrscheinlich durch Copy & Paste von den TAY & TYA Befehlen, weiter oben.

      Ich habe es eben korrigiert, danke fürs Melden und dein Lob!

      Viel Spass weiterhin,
      Jörn

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Protected by WP Anti Spam