|
|  |
 |
 ELEKTRONIK |
 |
 |
|
|
|
CPU-Befehle
Anmerkungen:
- Mit A, B, D werden die Akkumulatoren bezeichnet
- Mit X, Y, S werden die Indexregister und der Stackpointer bezeichnet
- "adr." bezeichnet den Inhalt eines beliebigen Speicherbytes oder eine Konstante
- (A) oder (adr.) bezeichnet dein Inhalt von Akku A bzw. den Inhalt der Speicheradresse (adr.)
Transport-Befehle Ladebefehle:  Load Register from Memory or Constant - anwendbar auf A, B (8 Bit) oder D, S, X, Y (16 Bit)
- bei 8-Bit-Register:
LDAA adr.
LDAB adr. - bei 16-Bit-Register:LDD adr
LDS adr
LDX adr
LDY adr
in (adr) steht das MSB in (adr+1) das LSB - Beeinflusst: N, V, Z
- Flags
CLR Clear Akkumulator: 0  Akkumulator-Register
- CLRA
CLRB
- schneller als LDAA #0
Speicherbefehle:
Store Register into Memory (8 Bit/16 Bit)
STAA, STAB (8 Bit): (Reg) adr.
STD, STS, STX, STY (16 Bit): (Reg) adr., adr+1
Clear Memory
Transport zwischen Registern:
Kopie des Inhalts eines Registers in ein anderes (transfer)
- TAB
 (A) B
- TAP (A) Statusregister
- TBA (B) A
- TPA (Statusregister) A
- TSX (S) X
- TSY (S) Y
- TXS (X) S
- TYS (Y) S
Bit X im Statusregister kann mittels TAP nicht gesetzt werden.
Austausch von Registerinhalten (exchange)
- XGDX D
 X
- XGDY D Y
- Zweck: Adreßrechnung in D, Adressierung dann über X oder Y.
Beispiel: Tausch A B
Benötigt wird eine Hilfsvariable im Daten-Speicherbereich
STAA HILF
TBA
LDAB HILF
Beispiel: Tausch X Y
* Beispielbelegung X Y D
* 1 2 3
XGDX 3 2 1
XGDY 3 1 2
XGDX 2 1 3
Arithmetische Befehle
Dies sind Befehle, die arithmetische Operationen bewirken. Im allgemeinen steht ein
Operand in einem Akku und das Ergebnis wieder im gleichen Akku.
Additionsbefehle:
Addieren (add)
Addieren mit Übertrag (add with carry)
- ADCA adr. (A) + (adr.) + C A
- ADCB adr. (B) + (adr.) + C B
- Anwendung: Mehrbyte-Addition
Beispiel: Addition zweier 4-Byte-Zahlen
1. Operand: Adresse $41 - $44
2. Operand: Adresse $45 - $48
Ergebnis: Adresse $49 - $4C
LDAA $44 Niederwertiges Byte addieren
ADDA $48
STAA $4C
LDAA $43 Zweites Byte addieren
ADCA $47
STAA $4B
LDAA $42 Drittes Byte addieren
ADCA $46
STAA $4A
LDAA $41 Höchstwertiges Byte addieren
ADCA $45
STAA $49
Erhöhen (increment)
- Sonderfall: Addition von 1
- C-Flag wird nicht beeinflusst (Addition mod 256)
- Für z. B. Schleifenzähler
- INCA (A) + 1 A
- INCB (B) + 1 B
- INS (S) + 1 S
(kein Flag beeinflußt)
- INX (X) + 1 X
(nur Z-Flag beeinflußt)
- INY (Y) + 1 Y
(nur Z-Flag beeinflußt)
- INC adr. (adr.) + 1 adr.
(Increment eines Speicherbytes)
Subtraktionsbefehle:
Subtraktion (subtract) = Addition des Zweierkomplements
- SUBA adr. (A) - (adr.) A
- SUBB adr. (B) - (adr.) B
- SUBD: 16-Bit-Subtraktion, Operand in zwei aufeinanderfolgenden Speicherzellen
Subtraktion mit Übertrag (subtract with carry)
- SBCA adr. (A) - (adr.) + C A
- SBCB adr. (B) - (adr.) + C B
- Anwendung: Mehrbyte-Subtraktion
Erniedrigen (decrement)
- Sonderfall: Subtraktion von 1
- C-Flag wird nicht beeinflusst (Addition mod 256)
- Für z. B. Schleifenzähler
- DECA (A) - 1 A
- DECB (B) - 1 B
- DES (S) - 1 S
(kein Flag beeinflußt)
- DEX (X) - 1 X
(nur Z-Flag beeinflußt)
- DEY (Y) - 1 Y
(nur Z-Flag beeinflußt)
- DEC adr. (adr.) - 1 adr.
(Decrement eines Speicherbytes)
Vorzeichenwechsel (negate)
- Sonderfall: 0 - (Akku), Bildung des Zweierkomplements
- NEGA A komplementieren
- NEGB B komplementieren
- NEG adr. adr. komplementieren
Multiplikation und Division:
Multiplizieren (multiply)
- MUL Vorzeichenlose Multiplikation (A) * (B) D
- Z-Flag = 1, wenn Ergebnis = 0 ist, sonst Z = 0
- C-Flag = Bit 7 von B
Dividieren (divide)
- IDIV Vorzeichenlose Division, ganzzahliger Anteil (integer divide)
für D > X: (D) / (X) X, Rest in D
- FDIV Vorzeichenlose Division, Quotient echter Bruch (fractional divide)
für D < X: (D) / (X) X, Rest in D
Beispiele:
IDIV: FDIV:
$8421 : $0004 = $2108 R $0001 $1000 : $2000 = $.8000 R $0000
$0001 : $FFFF = $0000 R $0001 $0001 : $FFFF = $.0001 R $0001
$FFFF : $0001 = $FFFF R $0000 $FFFF : $0001 = unzulässig, V=1
Weitere arithmetische Befehle:
DAA Decimal Adjust A
- Dezimalkorrektur von Akku A für BCD-Arithmetik
- Jedes Halbbyte (Nibble) entspr. 1 Dezimalziffer
Akku enthält zwei BCD-Ziffern
- Anwendung nach Addition im Akku
- Korrekturaddition, wenn Pseudotetrade auftritt
- Nach DAA enthält C-Flag den Übertrag in die nächste Stelle
- NUR (!) nach dem Befehlen ABA, ADDA und ADCA wirksam (nicht beim INC-Befehl)
- Bei der Subtraktion gilt Zehnerkomplement. -1 wird also nicht als
$FF, sondern als $99 dargestellt (-2 $98,
-3 $97, usw.).
Beispiel: Addition zweier 4-stelligen BCD-Zahlen
1. Zahl: Adr. $31-$32
2. Zahl: Adr. $33-$34
Ergebnis: Adr. $35-$36
LDAA $32 niederwertige 2 Ziffern
ADDA $34 binär addieren
DAA BCD-Justage
STAA $36
LDAA $31 höherwertige 2 Ziffern
ADCA $34 binär addieren mit Carry!
DAA BCD-Justage
STAA $35
Logische Befehle
Bei logischen Befehlen erfolgt die bitweise logische Verknüpfung eines
Akku-Inhalts mit einem Operanden (Speicherinhalt oder Konstante).
Und-Verknüpfung (and)
- ANDA adr. (A) and (adr.) A
- ANDB adr. (B) and (adr.) B
- Anwendung: Löschen einzelner Bits in einem Wort
Beispiele:
1) Löschen der 4 höherwertigen Bits von Akku A
ANDA #$0F
2) Rücksetzen des 5. Bits
ANDA #%11101111
Oder-Verknüpfung (or)
- ORAA adr. (A) or (adr.) A
- ORAB adr. (B) or (adr.) B
- Anwendung: Setzen einzelner Bits in einem Wort
Beispiele:
1) Setzen der 4 höherwertigen Bits von Akku A
ORA #$F0
2) Setzen des 5. Bits
ORAA #%00010000
Exclusiv Oder (exor)
- EORA adr. (A) exor (adr.) A
- EORB adr. (B) exor (adr.) B
- Anwendung: Invertieren einzelner Bits
Maskenbit=1: Bit wird invertiert
Maskenbit=0: Bit unverändert
Beispiel:
Invertieren der 4 höherwertigen Bits von Akku A
EORA #%11110000
Bit prüfen (bit test)
- BITA adm. (A) and (adm.) Nur Flags neu setzen, A bleibt unverändert
- BITB adm. (B) and (adm.) Nur Flags neu setzen, B bleibt unverändert
Invertieren (complement)
1-Komplement Invertieren aller Bits
Auch auf auf Speicherbytes anwendbar.
- COMA adr. not (A) A
- COMB adr. not (B) B
- COM adr. not (adr.) adr.
Beispiel: Verwendung des Speicher-Bytes $41 als Software-Flip-Flop. Zu Beginn des
Programms muß der Inhalt von $41 gelöscht werden!
COM $41 Inhalt wird $FF
.
.
COM $41 Inhalt wird wieder 0
.
.
usw.
Schiebe- und Rotationsbefehle
Die Schiebebefehle bewirken die Verschieben eines Akku- oder
Speicherinhalts um eine Stelle nach rechts oder links.
Bei den Rotationsbefehlen erfolgt die Ringverschiebung eines Akku- oder
Speicherinhalts unter Einbeziehung des C-Flags nach links oder rechts.
Die Befehle sind auf A, B, D oder einen Speicherinhalt anwendbar.
Die Realisierung auf Speicherinhalt erfolgt durch: Laden in Rechenregister,
Schiebeoperation im Rechenregister, Zurückspeichern des Register-Inhalts).
Logische Verschiebung:
LSRx Logical Shift Right:
von links wird 0 nachgeschoben: 0 MSB
LSB C-Flag
- LSRA Akku A nach rechts schieben
- LSRB Akku B nach rechts schieben
- LSRD Akku D nach rechts schieben
- LSR adr. Speicherwort adr. nach rechts schieben
LSLx Logical Shift Left:
von rechts wird 0 nachgeschoben: 0 LSB
MSB C-Flag
- LSLA Akku A nach links schieben
- LSLB Akku B nach links schieben
- LSLD Akku D nach links schieben
- LSL adr. Speicherwort adr. nach links schieben
Arithmetische Verschiebung:
ASRx Arithmetic Shift Right:
Entspricht Division durch 2
MSB MSB (Vorzeichen bleibt erhalten)
- ASRA Akku A nach rechts schieben
- ASRB Akku B nach rechts schieben
- ASR adr. Speicherwort adr. nach rechts schieben
ASLx Arithmetic Shift Left:
von rechts wird 0 nachgeschoben: 0 LSB
MSB C-Flag
Identisch mit LSL!
- ASLA Akku A nach links schieben
- ASLB Akku B nach links schieben
- ASLD Akku D nach links schieben
- ASL adr. Speicherwort adr. nach links schieben
Rotationsbefehle:
Hin- und Herschieben des Akku- oder Speicherinhalts ohne ihn zu zerstören
(anschließend Test des C-Flags). Vorzeichenlose duale Multiplikation und
Division.
ROLx Rotate Left
C-Flag LSB
MSB C-Flag
- ROLA Akku A linksrotieren
- ROLB Akku B linksrotieren
- ROL adr. Speicherwort adr. linksrotieren
RORx Rotate Right
C-Flag MSB
LSB C-Flag
- RORA Akku A rechtsrotieren
- RORB Akku B rechtsrotieren
- ROR adr. Speicherwort adr. rechtsrotieren
Beispiele:
1) Multiplikation von Akku A mit 10: (A) * 10 A
ASLA (A)*2 A
STAA $40 Erg. zwischenspeichern
ASLA (A)*4 A
ASLA (A)*8 A
ADDA $40 (A)*8 + (A)*2 A
2) Akku D nach links schieben:
A C B
ASLB MSB von B --> Carry +----------+__+-+__+----------+
ROLA Carry --> LSB von A +----------+ +-+ +----------+
3) Zerlegung eines Bytes in zwei Halbbytes:
Die Halbbytes sind in getrennten Speicherzellen als niederwertiges Halbbyte
zu speichern (höherwertiges Halbbyte ist auf 0 zu setzen).
$70: zu zerlegendes Byte
$71: höherwertiges Nibble
$72: niederwetiges Nibble
LDAA $70 Byte holen (binär: xxxxyyyy)
ANDA #$0F niederwertiges Nibble maskieren
STAA $72 speichern (binär: 0000yyyy)
LDAA $70 Byte nochmal holen
LSRA 4 x nach rechts schieben (0xxxxyyy)
LSRA (00xxxxyy)
LSRA (000xxxxy)
LSRA (0000xxxx)
STAA $71 höherwertiges Nibble speichern
Test- und Statusregisterbefehle
Sie dienen der Überprüfung von Datenwerten auf bestimmte Eigenschaften.
Die Überprüfung erfolgt durch arithmetische und logische Operationen.
Als Ergebnis werden bestimmte Flags des CC-Register beeinflusst, der Inhalt der Akkus
bleibt unverändert. Die Flags können zur Steuerung bestimmter Sprungbefehle
verwendet werden Programmfortsetzung abhängig
von Dateneigenschaften Steuerbefehle.
Beispiele bei den Sprungbefehlen.
Test
Die Befehle sind anwendbar auf A, B und den Speicher. Test auf Null und negativ.
- Z-Flag = 1, wenn Akku- oder Speicherinhalt = 0 ist.
- N-Flag = MSB von Akku- oder Speicherinhalt
- TSTA Akku A = 0 ?
- TSTB Akku B = 0 ?
- TST adr. (adr.) = 0 ?
Vergleich (compare)
("Gedachte Subtraktion")
Die Befehle sind anwendbar auf A, B, D, X und Y. Es wird jeweils ein Registerinhalt
mit einem Speicherinhalt oder einer Konstanten verglichen (Ausnahme: CBA). Der
Vergleich erfolgt durch eine Subtraktion ohne Anfallen des Ergebnisses.
- Z-Flag = 1, wenn beide Operanden gleich sind
- N-Flag = 1, wenn (Reg) < Operand (konegative Zahl) und kein arith. Überlauf
- C-Flag = 1, wenn (Reg) < Operand (natürliche Zahl)
- V-Flag = 1, wenn arithm. Überlauf auftrat
- CMPA #0 und TSTA sind von der Funktion her identisch
Der Vergleich auf Null und "negativ" ermöglicht alle Vergleiche von Werten.
Mathematisch gesehen werden die links stehenden Ungleichungen in die rechts
stehenden umgesetzt:
| X1 = X2 |
X1 - X2 = 0 |
| X1 < X2 |
X1 - X2 < 0 |
| X1 > X2 |
X1 - X2 > 0 |
Durch bedingte Sprungbefehle kann dann abhängig vom Ergebnis im
Programm verzweigt werden. Es gibt 8-Bit- und 16-Bit-Vergleiche (je nach
Wortbreite des Registers).
- CMPA adr. (A) - (adr.) Flags
- CMPB adr. (B) - (adr.) Flags
- CPD adr. (D) - (adr., adr.+1) Flags
- CPX adr. (X) - (adr., adr.+1) Flags
- CPY adr. (Y) - (adr., adr.+1) Flags
- CBA (A) - (B) Flags
Bitorientierte Befehle
Bitbefehle Statusregister
Diese Befehle erlauben das komfortable Setzen und Rücksetzen einiger
Bits des Statusregisters.
| clear carry flag | X X X X X X X 0 |
| clear interrupt flag | X X X 0 X X X X |
| clear overflow flag | X X X X X X 0 X |
| set carry flag | X X X X X X X 1 |
| set interrupt flag | X X X 1 X X X X |
| set overflow flag | X X X X X X 1 X |
Bitbefehle Speicher
Diese Befehle erlauben das Setzen oder Löschen einzelner Bits in Speicherworten.
Als einzige Befehle haben sie zwei Operanden, die Adresse des zu ändernden
Speicherbytes und eine konstante Maske. Da die Maske immer konstant sein muß,
entfällt hier auch das "#"-Zeichen. Für jedes 1-Bit in der Maske
wird das entsprechende Speicherbit gesetzt (BSET) oder gelöscht (BCLR).
Beeinflussung des Systemzustands
Dies sind Befehle, welche die Programmausführung anhalten.
Sie dienen der Synchronisation des Programmablaufs mit externen Ereignissen.
Warte auf Interrupt (wait for interrupt)
Ablage aller Register auf dem Stack, dann warten auf Interrupt.
Stop
Reaktion hängt ab von S-Flag im Statusregister:
Freigabe des STOP-Befehls:
TPA Statusreg. nach Akku A
ANDA #$7F Freigabe (S-Flag auf 0)
TAP Akku A nach Statusreg.
Für den Fall S=0 und X=1 wird beim Aktivieren des XIRQ-Eingangs der
Prozessor nach einem STOP-Befehl "aufgeweckt" und er macht im Programm
ganz normal weiter.
Sprungbefehle
Alle Sprungbefehle verändern den PC-Inhalt
Programmausführung
wird an anderer Stelle fortgesetzt. Das Statusregister wird nicht beeinflußt.
Einige Befehle speichern Registerinhalte auf dem Stack oder holen Registerinhalte
von dort wieder zurück.
Unbedingte Sprungbefehle (jump, branch)
JMP adr. adr. PC
- vollst. absolute Adressierung (extended direct), indizierte Adressierung (X, Y)
- Sprung im gesamten Adreßraum möglich
BRA dest.
- Offset wird immer PC-relativ angegeben (-128 ... +127)
- Assembler übernimmt Offset-Berechnung
Bedingte Sprungbefehle (Bedingte "Verzeigungsbefehle")
Hier gibt es nur PC-relative Adressierung (branch conditionally). Es gibt 8 Paare
von zueinander komplementären Befehlen. Die Unterscheidung erfolgt in der
jeweiligen Verzweigungsbedingung. Als Verzweigungsbedingung dienen (1 oder mehr)
Bits des des Statusregisters Verzweigung
abhängig vom Ergebnis der vorhergehenden Operation
ist die Bedingung erfüllt, erfolgt ein Sprung;
im anderen Fall wird die Programmausführung beim nächsten Befehl fortgesetzt.
Der Assembler übernimmt die Offset-Berechnung.
| Befehl | Bedeutung | Sprungbedingung |
|---|
| einfach (simple) |
|---|
| BCC dest. | carry clear | C=0 |
| BCS dest. | carry set | C=1 |
| BVC dest. | overflow clear | V=0 |
| BVS dest. | overflow set | V=1 |
| BNE dest. | result not equal zero | Z=0 (BZC) |
| BEQ dest. | result equal zero | Z=1 (BZS) |
| BPL dest. | result plus | N=0 (BNC) |
| BMI dest. | result minus | N=1 (BNS) |
| natürlich (unsigned) |
|---|
| BHI dest. | higher | Op1 > Op2 |
| BLS dest. | lower or same | Op1 <= Op2 |
| BLO dest. | lower | OP1 < Op2 |
| BHS dest. | higher or same | Op1 >= Op2 |
| konegativ (signed) |
|---|
| BGT dest. | greater than | Op1 > Op2 |
| BLE dest. | less or equal | Op1 <= Op2 |
| BLT dest. | less than | Op1 < Op2 |
| BGE dest. | greater or equal | Op1 >= Op2 |
| bitabhängig |
|---|
| BRCLR | adr. mask dest |
springe, wenn die in der Maske mit "1" markierten
Bits alle "0" sind alle Bits des Speicherbytes adr.
werden mit der Maske UND-verknüpft und wenn das Ergebnis 0 ist, wird
gesprungen. |
| BRSET | adr. mask dest |
springe, wenn die in der Maske mit "1" markierten
Bits alle "1" sind alle Bits des Speicherbytes adr.
werden mit der Maske UND-verknüpft und wenn das Ergebnis gleich der
Maske ist, wird gesprungen. |
Unterprogrammsprünge (jump/branch to subroutine)
JSR adr.
- absolute Adressierung
- wie JMP adr., aber zusätzlich Ablage des PC (der die Adresse
des nächsten Befehls enthält) auf dem Stack
Möglichkeit der Rückkehr
BSR dest.
- Offset wird immer PC-relativ angegeben (-128 ... +127)
- Assembler übernimmt Offset-Berechnung
RTS (return from subroutine)
- Rücksprung aus Unterprogramm
- Die Rücksprungadresse wird vom Stack geholt
- letzter Befehl eines Unterprogramms
- PULX
JMP 0,X
Unterprogramme lassen sich beliebig schachteln.
Programmunterbrechungsbefehle
SWI (software interrupt)
- Sprung in eine Interrupt-Service-Routine (ISR)
- Startadresse ist Interruptvektor (steht in HW-mäßig festgelegter
Speicherzelle)
- vorher Ablage aller Register auf dem Stack
- Anwendung:
z. B. positionsunabhängiger Aufruf von BS-Routinen;
Parameter in Registern oder auf dem U-Stack
RTI (return from interrupt)
- Rücksprung aus einer ISR
- Rückladen der Register vom Stack
- letzter Befehl der ISR
Reine Verzögerungsbefehle
- NOP No Operation
- BRN Branch Never
Anwendungen:
- Zeitverzögerung (z. B. Laufzeitangleichung)
- Platzhalter für spätere Programmverzeigungen (bei der Programmentwicklung)
- Platz für Label
- "Patchen" von Programmen (Ändern des Maschinencodes)
|
| |
|
|
|
