Erstellt: 9. Februar 2013 (zuletzt geändert: 1. Januar 2018)

Intermezzo: Was wir schon wissen…

Unser vorhandenes Wissen einsetzen, um uns weitere Befehle zu erschließen!

C64 Studio, AMCE & TASM

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, dass kann auch problematisch sein, da die Übersicht evtl. verloren geht. Ich denke aber, dass es hier im Grundlagenkurs 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

Es wird euch bestimmt erfreuen, dass wir die Ladebefehle LDA, LDX und 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 $0400,y

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 $fb,x

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 ($fb,x)

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 findende 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 $0821

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

 sty $08FA

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

 

 stx $fc

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

 sty $fb

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

 

 stx $fc,y

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 $fb,x

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 und 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

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

 tya

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

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

 txs

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 mittels DEX und DEY bzw. eine Speicherstelle mit DEC, um eins zu verringern. DEC bietet, neben der schon benutzten Zero-Page-Adressierung, noch drei weitere Adressierungsmöglichkeiten.

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

 dec $08f2

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

 

 dec $08f2,x

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 $fb,x

DEC Zero-Page X-indiziert ($D6, 2B, 6T, NZ)
Das Byte, das an der angegebenen Zero-Page-Adresse plus dem Inhalt des X-Registers steht, wird um 1 verringert.

Es gibt selbstverständlich noch weitere Befehle, mit denen man rechnen kann, die lernen wir später kennen.

Boolschebefehle

Da wir bisher nur den AND-Befehl mit unmittelbarer Adressierung kennengelernt haben, schauen wir uns hier 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 $0400

AND absolut ($2D, 3B, 4T, NZ)
Eine bitweise UND-Verknüpfung mit dem Byte, das an der angegebenen Speicherstelle zu finden ist und dem Akkumulator. Das Ergebnis landet dann wieder, wie bei allen boolschen Befehlen, im Akku.

 

 and $0400,x

AND absolut X-indiziert ($3D, 3B, 4-5T, NZ)
Das Byte, das 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 $0400,y

AND absolut Y-indiziert ($39, 3B, 4-5T, NZ)
Eine bitweise UND-Verknüpfung wie eben, nur dass die übergebene Adresse mit dem Y-Register addiert wird. Auch die Angaben zu den Taktzyklen sind identisch.

 

 and $fc

AND Zero-Page ($25, 2B, 3T, NZ)
Das Byte, das an der angegebenen Zero-Page-Adresse liegt, mit dem Akku UND-Verknüpfen.

 

 and $fc,x

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 ($fc,x)

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 ($fc),y

AND indirekt Y-nach-indiziert ($31, 2B, 5T, NZ)
Indem 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.

Schlußbemerkung

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 diese 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, welches 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! (14 Bewertungen | Ø 5,00 von 5 | 100,00%)

Loading...


ZurückWeiter

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

  1. Hallo,

    erst mal vielen Dank für all Deine Mühen und die tolle Tutorial Arbeit die Du Dir gemacht hast!
    Ganz großes Kino!

    Ich habe eine Verständnisfrage:
    wo genau liegt der unterschied zw der indirekten Adressierung und der direkten:

    Bsp.: LDX #$01
    LDA $fb,x
    und
    LDA ($fb,x)

    Wo ist da der Unterschied bei den letzten beiden LDA Befehlen? Bei beiden wäre das Adressergebnis $fc oder???

    Danke Dir und viele Grüße

    1. EDIT: folgendes Gedankenspiel, rein hypothetisch

      LDX#$01
      in $fb steht $05
      in $fc steht $08

      drei LDA Varianten:
      LDA $fb,x -> “=” LDA $fc
      LDA ($fb),x -> “=” LDA $06
      LDA ($fb,x) -> “=” LDA $08

      ….ist das mit direkt vs indirekt gemeint?

      Bitte enstchuldige die blöde Noob-Frage :_)

      1. Hallo Kolja,

        es gibt keinen Grund sich für eine Frage zu entschuldigen.

        Dein Gedankenspiel passt leider nicht so ganz, schau dir mal dieses Beispiel an:

        *=$0801

        !basic

        ;Vorbereitung
        sei

        lda farben+2
        sta $11

        lda #<farben
        sta $12
        lda #>farben
        sta $13

        lda #<(farben+7)
        sta $14
        lda #>(farben+7)
        sta $15

        ;Aussehen der Zeropage, nach den obigen Zeilen
        ;Adresse -> $10 $11 $12 $13 $14 $15
        ;Inhalt => ?? 02 3b 08 42 08

        ;Werte auslesen
        ldx #1
        lda $10,x ; -> lda $11 (dort steht 02 == rot)
        sta $d020

        ldy #13
        lda ($12),y ; -> Adresse von $12 => dort steht 3b 08 => lda $083b,y (hellgrün)
        sta $d020

        ldx #4
        lda ($10,x) ; -> Adresse von $10+4 => dort steht 42 08 => lda $0842 (gelb)
        sta $d021

        jmp *

        ;Adresse = $083b
        farben
        !byte 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

        Gruß,
        Jörn

        1. Top, Danke Dir,
          genau das wollte ich wissen:
          ldx #1
          lda $10,x ; -> lda $11 (dort steht 02 == rot)
          sta $d020

          ldy #13
          lda ($12),y ; -> Adresse von $12 => dort steht 3b 08 => lda $083b,y (hellgrün)
          sta $d020

          ldx #4
          lda ($10,x) ; -> Adresse von $10+4 => dort steht 42 08 => lda $0842 (gelb)
          sta $d021

          Also immer wenn die Klammern um die Adresse herum stehen, dann wird nicht der Wert an der Adresse übergeben, sondern der Wert als Adresse interpretiert, welche dann wiederum ausgelesen wird….

          Danke und bleib gesund +Gruß

          Kolja

  2. 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

Captcha
captcha
Reload

Protected by WP Anti Spam