Copyright: (c) 1997, A. Roth


Inhalt
Hilfe für die XA-Controller

Befehlsübersicht

Gültige Operandenkombinationen

Updates von Statusbits

Legende

Alphabetische Befehlsbeschreibung

Assembler

Interrupts

Spezialfunktionsregister


Befehlsübersicht
Die Befehlsübersicht der XA-Controller

Datentransfer

MOV	MOVC	MOVS	MOVX

LEA	XCH	PUSH	POP

Arithmetik

ADD	ADDS	ADDC	SUB

SUBB	MUL	MULU	DIV

DIVU	DA	CMP	NEG	SEXT

Logik

AND	OR	XOR	CPL

Shift / Rotate

RR	RRC	RL	RLC

LSR	ASR	ASL	NORM

Bitoperationen

CLR	SETB	MOV	ANL	ORL

Bedingte Sprünge

JB	JBC	JNB	JNZ

JZ	DJNZ	CJNE	BOV

BNV	BPL	BCC	BCS

BEQ	BNE	BG	BGE

BGT	BL	BLE	BLT

BMI

Unbedingte Sprünge, Calls

JMP	FJMP	CALL	FCALL

BR	RET	RETI	NOP

Exceptions

BKPT	TRAP	RESET


Gültige Operandenkombinationen

ADD, ADDC, AND, CMP, OR, SUB, SUBB, XOR

R,R	R,[R]	[R],R	R,[R+]	[R+],R

R,[R+off8]	[R+off8],R	R,[R+off16]	[R+off16],R	R,direct	direct,R

R,#data	[R],#data	[R+],#data	[R+off8],#data	[R+off16],#data	direct,#data

ADDS, MOVS

R,#data4	[R],#data4	[R+],#data4	[R+off8],#data4	[R+off16],#data4	direct,#data4

ANL, ORL

C,bit	C,/bit

ASL, ASR, LSR

R,R	R,#data4	R,#data5

BCC, BCS, BEQ, BG, BGE, BGT, BL, BLE, BLT, BMI, BNE, BNV, BOV, BPL, BR, JNZ, JZ

Label

CALL

Label	[R]

CJNE

R,direct,Label	R,#data,Label	[R],#data,Label

CLR, SETB

bit

CPL, DA, NEG, SEXT

R

DIV, DIVU, MUL, MULU

R,R	R,#data

DJNZ

R,Label	direct,Label

FCALL, FJMP

Label	addr24

JB, JBC, JNB

bit,Label

JMP

Label	[R]	[A+DPTR]	[[R]]

LEA

R,R+off8	R,R+off16

MOV

R,R	R,[R]	[R],R	R,[R+]	[R+],R

R,[R+off8]	[R+off8],R	R,[R+off16]	[R+off16],R	R,direct	direct,R

R,#data	[R],#data	[R+],#data	[R+off8],#data	[R+off16],#data	direct,#data

[R+],[R+]	direct,[R]	[R],direct	direct,direct	R,USP	USP,R

C,bit	bit,C

MOVC

R,[R+]	A,[A+DPTR]	A,[A+PC]

MOVX

R,[R]	[R],R

NORM

R,R

POP, POPU, PUSH, PUSHU

direct	Rlist

RL, RLC, RR, RRC

R,#data4

TRAP

#data4

XCH

R,R	R,[R]	R,direct

BKPT, NOP, RESET, RET, RETI

keine


Updates von Statusbits

C	AC	V	N	Z

×	×	×	×	×	ADD, ADDC, CMP, SUB, SUBB

×	×	×	×	×	RESET

×	-	×	×	×	DIV, MUL, ASL

×	-	-	×	×	ASR, LSR, RLC, RRC

×	-	-	×	×	CJNE, DA

-	-	×	×	×	NEG

-	-	-	×	×	ADDS, MOVS

-	-	-	×	×	AND, OR, XOR, CPL

-	-	-	×	×	MOV, MOVC, MOVX

-	-	-	×	×	DJNZ, NORM, RL, RR

-	-	-	-	-	Sprünge, alle Bitbefehle, NOP

-	-	-	-	-	alle CALLs und Return

-	-	-	-	-	PUSH, POP, LEA, SEXT,TRAP, BKPT, XCH

C	Carry

AC	Hilfscarry

V	Overflow

N	Negativ Flag

Z	Zero Flag

×	Änderung

-	keine Änderung


Legende

Allgemein

dest	Destination = Ziel.

source	Source = Quelle.

offset8	Eine 8-Bit signierte Zahl, die zum Registerinhalt addiert wird, um die absolute Adresse zu erhalten.

offset16	Eine 16-Bit signierte Zahl, die zum Registerinhalt addiert wird, um die absolute Adresse zu erhalten.

direct	11-Bit-Feld: interner/externer RAM-Platz von 000 bis 3FFh oder SFR-Bereich von 400h bis 7FFh. direct kann ein Variablenname, eine Adressangabe oder eine SFR-Bezeichnung sein.

#data4	Eine 4-Bit Zahl im Bereich von -8 bis +7 bzw. für Shift-Befehle 0 bis +15.

#data	Eine 8-Bit oder 16-Bit Zahl. Die Größe ergibt sich aus dem Befehlscode.

bit	Eine 10-Bit Adresse für ein bitadressierbares Bit.

rel8	Ein 8-Bit relatives, signiertes Offset für Sprungbefehle im Bereich von -256 bis +254. Der Wert für rel8 wird durch den Assembler berechnet. Der Programmierer verwendet für das Sprungziel ein Label.

rel16	Ein 16-Bit relatives, signiertes Offset für Sprungbefehle im Bereich von -65536 bis +65534. Der Wert für rel16 wird durch den Assembler berechnet. Der Programmierer verwendet für das Sprungziel ein Label.

addr24	Eine 24-Bit absolute Adresse gestattet den Zugriff auf den ganzen XA-Adressbereich.

PC	Program Counter

SP	Der aktuelle Stackpointer (User oder System, abhängig vom Betriebsmodus).

USP	Der User Stackpointer.

SSP	Der System Stackpointer.

C	Das Carry-Bit im Programmstatuswort PSW.

AC	Das Hilfscarry-Bit im Programmstatuswort PSW.

V	Das Overflow-Bit im Programmstatuswort PSW.

N	Das Negativ-Bit im Programmstatuswort PSW.

Z	Das Zero-Bit im Programmstatuswort PSW.

Mnemonik

Rd	Destination Register = Zielregister.

Rs	Source Register = Quellregister.

Rn	n = 0 bis 15: Word-Register

RnL	n = 0 bis 7: Byte-Register Low

RnH	n = 0 bis 7: Byte-Register High

[ ]	Indirekte Adressierung, d.h. R0 = #1234: Variable = [R0] lädt Variable mit einen Wert aus der Adresse 1234.

[[ ]]	Doppelt indirekte Adressierung.

[R+]	Indirekte Adressierung mit Inkrement. Das Register wird anschließend um eins (Byte) bzw. um zwei (Word) erhöht.

[WS:R]	Das Register R wird zu einer 24-Bit Adresse mit dem aktuellen Segment-Register erweitert.

.b	Mnemonikerweiterung für eine Byte-Operation bei Mehrdeutigkeit.

.w	Mnemonikerweiterung für eine Word-Operation bei Mehrdeutigkeit.

.d	Mnemonikerweiterung für eine DWord-Operation (nur für gewisse Befehle).

A	Akku = R4L. Aufnahme aus Kompatibiltätsgründen zur MCS51-Familie.

DPTR	Datenpointer = R6. Aufnahme aus Kompatibiltätsgründen zur MCS51-Familie.

Pseudocode

←	Zuweisungsoperator

↔	Vertauschungsoperator

+	Addition

-	Subtraktion

/	Division

×	Multiplikation

∧	AND, logisches UND

∨	OR, logisches ODER

⊕	XOR, logisches Exklusiv-ODER

¬	NOT, Komplementbildung

(  )	Lies: Inhalt von ...

PC.x	Bitnummer x des Program Counter

((SP))	Lies: Inhalt des Datenspeichers, auf den der Stackpointer zeigt.

Rn.x	Bitnummer x von Register n.

Rn.x-y	Bitbereich x bis y von Register n.


ADD-Befehl
ADD	Integeraddition

Syntax:	ADD  dest,source

Aktion:	dest ← dest + source

Beschreibung:	ADD führt die Addition von signierten als auch unsignierten Zahlen aus. Es werden die Inhalte von dest und source addiert, das Ergebnis steht in dest. Der Inhalt von source wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
C, AC, V, N, Z
Ist dest das Low-Byte des Programmstatusworts PSWL, so überschreibt das Additionsergebnis die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Assembler:	dest += source ist identisch zu add dest,source.

Operanden

ADD Rd,Rs	Addiert den Inhalt zweier Register.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) + (Rs)

Kodierung:	0000 x001  dddd ssss
Word:	x = 1,  Byte:	x = 0

Beispiel:	add r3,r6 ist eine Word-Addition und erzeugt den Hexcode 09 36.
add r1L,r0H ist eine Byte-Addition und erzeugt den Hexcode 01 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += r6 bzw. r1l += r0h.

ADD Rd,[Rs]	Addiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes zum Register. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← (Rd) + ((WS:Rs))

Kodierung:	0000 x010  dddd 0sss
Word:	x = 1,  Byte:	x = 0

Beispiel:	add r3,[r6] ist eine Word-Addition und erzeugt den Hexcode 0A 36.
add r1L,[r2] ist eine Byte-Addition und erzeugt den Hexcode 02 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += [r6] bzw. r1l += [r2].

ADD [Rd],Rs	Addiert indirekt den Inhalt eines Registers zu einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rd)) + (Rs)

Kodierung:	0000 x010  ssss 1ddd
Word:	x = 1,  Byte:	x = 0

Beispiel:	add [r3],r6 ist eine Word-Addition und erzeugt den Hexcode 0A 6B.
add [r1],r2H ist eine Byte-Addition und erzeugt den Hexcode 02 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] += r6 bzw. [r1] += r2h.

ADD Rd,[Rs+]	Addiert indirekt den Inhalt eines externen oder internen RAM-Platzes zum Register. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) ← (Rd) + ((WS:Rs))
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0000 x011  dddd 0sss
Word:	x = 1,  Byte:	x = 0

Beispiel:	add r3,[r6+] ist eine Word-Addition und erzeugt den Hexcode 0B 36.
add r1L,[r2+] ist eine Byte-Addition und erzeugt den Hexcode 03 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += [r6+] bzw. r1l += [r2+].

ADD [Rd+],Rs	Addiert indirekt den Inhalt eines Registers zu einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) + (Rs)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0000 x011  ssss 1ddd
Word:	x = 1,  Byte:	x = 0

Beispiel:	add [r3+],r6 ist eine Word-Addition und erzeugt den Hexcode 0B 6B.
add [r1+],r2H ist eine Byte-Addition und erzeugt den Hexcode 03 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] += r6 bzw. [r1+] += r2h.

ADD Rd,[Rs+offset8]
Addiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes zum Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) ← (Rd) + ((WS:Rs) + offset8)

Kodierung:	0000 x100  dddd 0sss  oooo ooooo
Word: x = 1,  Byte: x = 0, o = Offset-Bits

Beispiel:	add r3,[r6-2] ist eine Word-Addition und erzeugt den Hexcode 0C 36 FE.
add r1L,[r3+5] ist eine Byte-Addition und erzeugt den Hexcode 04 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += [r6-2] bzw. r1l += [r3+5].

ADD [Rd+offset8],Rs
Addiert den Inhalt eines Registers zum indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd) + offset8) ← ((WS:Rs) + offset8) + (Rs)

Kodierung:	0000 x100  ssss 1ddd  oooo ooooo
Word:	x = 1,  Byte:	x = 0, o = Offset-Bits

Beispiel:	add [r6-2],r3 ist eine Word-Addition und erzeugt den Hexcode 0C 3E FE.
add [r3+5],r7H ist eine Byte-Addition und erzeugt den Hexcode 04 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] += r3 bzw. [r3+5] += r7H .

ADD Rd,[Rs+offset16]
Addiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes zum Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Lesen einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) ← (Rd) + ((WS:Rs) + offset16)

Kodierung:	0000 x101  dddd 0sss  hhhh hhhh  llll llll
Word:	x = 1,  Byte:	x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	add r3,[r6-30546] ist eine Word-Addition und erzeugt den Hexcode 0D 36 88 AE.
add r1L,[r3+1125] ist eine Byte-Addition und erzeugt den Hexcode 05 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += [r6-30546] bzw. r1l += [r3+1125].

ADD [Rd+offset16],Rs
Addiert den Inhalt eines Registers zum indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) ← ((WS:Rd) + offset16) + (Rs)

Kodierung:	0000 x101  ssss 1ddd  hhhh hhhh  llll llll
Word:	x = 1,  Byte:	x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	add [r6-30546],r3 ist eine Word-Addition und erzeugt den Hexcode 0D 3E 88 AE.
add [r3+1125],r7H ist eine Byte-Addition und erzeugt den Hexcode 05 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] += r3 bzw. [r3+5] += r7H.

ADD Rd,direct	Addiert den Inhalt einer direct-Adresse oder eines SFRs zu einem Register.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (Rd) + (direct)

Kodierung:	0000 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	add r3,2eh ist eine Word-Addition der direct-Adresse 2eh mit dem Register R3 und erzeugt den Hexcode 0E 30 2E.
add r1L,S0BUF ist eine Byte-Addition des seriellen Buffers mit Register 1 Low-Byte und erzeugt den Hexcode 06 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += 2eh bzw. r1L += S0BUF.

ADD direct,Rs	Addiert den Inhalt eines Registers zu einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) + (Rs)

Kodierung:	0000 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	add 1a3h,r6 ist eine Word-Addition der direct-Adresse 1a3h mit dem Register R6 und erzeugt den Hexcode 0E 69 A3.
add P2,r4H ist eine Byte-Addition von Port2 mit dem Inhalt von Register 4 High-Byte und erzeugt den Hexcode 06 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h += r6 bzw. P2 += r4H.

ADD Rd,#data	Addiert zum Register eine Zahl.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← (Rd) + #data

Kodierung:	1001 x001  dddd 0000  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	add r3,#2eh ist eine Word-Addition von Register R3 mit der Zahl 2eh und erzeugt den Hexcode 99 30 00 2E.
add r1L,#2eh ist eine Byte-Addition von Register 1 Low-Byte mit der Zahl 2eh und erzeugt den Hexcode 91 20 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += #2eh bzw. r1L += #2eh.

ADD [Rd],#data	Addiert zu einem indirekt adressierten RAM-Platz eine Zahl. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) + #data

Kodierung:	1001 x010  0ddd 0000  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	add.w [r3],#2e7h (oder add [r3],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9A 30 02 E7.
add.b [r1],#2eh (oder add [r1],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 92 10 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] += #2e7h.w bzw. [r1] += #2eh.b.

ADD [Rd+],#data
Addiert zu einem indirekt adressierten RAM-Platz eine Zahl und inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) + #data
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0000  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	add.w [r3+],#2e7h (oder add [r3+],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9B 30 02 E7.
add.b [r1+],#2eh (oder add [r1+],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 93 10 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] += #2e7h.w bzw. [r1+] += #2eh.b.

ADD [Rd+offset8],#data
Addiert eine Zahl zum indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muß das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) + #data

Kodierung:	1001 x100  0ddd 0000  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	add.w [r3+16],#2e7h (oder add [r3+16],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz plus dem offset8 mit der Zahl 2e7h und erzeugt den Hexcode 9C 30 10 02 E7.
add.b [r1-8],#2eh (oder add [r1-8],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz plus dem offset8 mit der Zahl 2eh und erzeugt den Hexcode 94 10 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] += #2e7h.w bzw. [r1-8] += #2eh.b.

ADD [Rd+offset16],#data
Addiert eine Zahl zum indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) + #data

Kodierung:	1001 x101  0ddd 0000  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	add.w [r3+165ah],#2e7h (oder add [r3+165ah],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz plus dem offset16 mit der Zahl 2e7h und erzeugt den Hexcode 9D 30 16 5A 02 E7.
add.b [r1-120h],#2eh (oder add [r1-120h],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz plus dem offset16 mit der Zahl 2eh und erzeugt den Hexcode 95 10 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] += #2e7h.w bzw. [r1-120h] += #2eh.b.

ADD direct,#data
Addiert eine Zahl zu einem direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) ← (direct) + #data

Kodierung:	1001 x110  0ddd 0000  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	add.w 30h,#2e7h (oder add 30h,#2e7h) ist eine Word-Addition von dem RAM-Platz an Adresse 30h mit der Zahl 2e7h und erzeugt den Hexcode 9E 00 30 02 E7.
add.b 123h,#2eh (oder add 123h,#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 96 10 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h += #2e7h.w bzw. 123h += #2eh.b.


ADDC-Befehl
ADDC	Integeraddition mit Übertrag

Syntax:	ADDC  dest,source

Aktion:	dest ← dest + source + C

Beschreibung:	ADDC führt die Addition von signierten als auch unsignierten Zahlen aus unter Einbeziehung des zuvor aktualisierten Carrys. Es werden die Inhalte von dest und source und C addiert, das Ergebnis steht in dest. Der Inhalt von source wird nicht verändert. Ist das Carry eine Eins, so ist auch die Summe von dest und source um eins größer, ist das Carry eine Null, so entspricht der ADDC-Befehl dem ADD-Befehl. ADDC wird für eine mehrfachgenaue Addition verwendet, bei der das Carry vor der ersten Addition gelöscht wird. Die Integerzahlen werden danach vom LSB zum MSB mit ADDC addiert.

Bits:	Folgende Bits werden aktualisiert:
C, AC, V, N, Z
Ist dest das Low-Byte des Programmstatusworts PSWL, so überschreibt das Additionsergebnis die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Assembler:	dest += +C source ist identisch zu ADDC dest,source.

Operanden

ADDC Rd,Rs	Addiert den Inhalt zweier Register mit Carry.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) + (Rs) + (C)

Kodierung:	0001 x001  dddd ssss
Word:	x = 1,  Byte:	x = 0

Beispiel:	ADDC r3,r6 ist eine Word-Addition und erzeugt den Hexcode 19 36.
ADDC r1L,r0H ist eine Byte-Addition und erzeugt den Hexcode 11 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += +c r6 bzw. r1l += +c r0h.

ADDC Rd,[Rs]	Addiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes zum Register mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← (Rd) + ((WS:Rs)) + (C)

Kodierung:	0001 x010  dddd 0sss
Word:	x = 1,  Byte:	x = 0

Beispiel:	ADDC r3,[r6] ist eine Word-Addition und erzeugt den Hexcode 1A 36.
ADDC r1L,[r2] ist eine Byte-Addition und erzeugt den Hexcode 12 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += +c [r6] bzw. r1l += +c [r2].

ADDC [Rd],Rs	Addiert den Inhalt eines Registers zu einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rd)) + (Rs) + (C)

Kodierung:	0001 x010  ssss 1ddd
Word:	x = 1,  Byte:	x = 0

Beispiel:	ADDC [r3],r6 ist eine Word-Addition und erzeugt den Hexcode 1A 6B.
ADDC [r1],r2H ist eine Byte-Addition und erzeugt den Hexcode 12 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] += +c r6 bzw. [r1] += +c r2h.

ADDC Rd,[Rs+]	Addiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes zum Register mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) ← (Rd) + ((WS:Rs)) + (C)
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0001 x011  dddd 0sss
Word:	x = 1,  Byte:	x = 0

Beispiel:	ADDC r3,[r6+] ist eine Word-Addition und erzeugt den Hexcode 1B 36.
ADDC r1L,[r2+] ist eine Byte-Addition und erzeugt den Hexcode 13 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += +c [r6+] bzw. r1l += +c [r2+].

ADDC [Rd+],Rs	Addiert den Inhalt eines Registers zu einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) + (Rs) + (C)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0001 x011  ssss 1ddd
Word:	x = 1,  Byte:	x = 0

Beispiel:	ADDC [r3+],r6 ist eine Word-Addition und erzeugt den Hexcode 1B 6B.
ADDC [r1+],r2H ist eine Byte-Addition und erzeugt den Hexcode 13 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] += +c r6 bzw. [r1+] += +c r2h.

ADDC Rd,[Rs+offset8]
Addiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes zum Register mit Carry. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) ← (Rd) + ((WS:Rs) + offset8) + (C)

Kodierung:	0001 x100  dddd 0sss  oooo ooooo
Word:	x = 1,  Byte:	x = 0, o = Offset-Bits

Beispiel:	ADDC r3,[r6-2] ist eine Word-Addition und erzeugt den Hexcode 1C 36 FE.
ADDC r1L,[r3+5] ist eine Byte-Addition und erzeugt den Hexcode 14 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += +c [r6-2] bzw. r1l += +c [r3+5].

ADDC [Rd+offset8],Rs
Addiert den Inhalt eines Registers zum indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd) + offset8) ← ((WS:Rs) + offset8) + (Rs) + (C)

Kodierung:	0001 x100  ssss 1ddd  oooo ooooo
Word:	x = 1,  Byte:	x = 0, o = Offset-Bits

Beispiel:	ADDC [r6-2],r3 ist eine Word-Addition und erzeugt den Hexcode 1C 3E FE.
ADDC [r3+5],r7H ist eine Byte-Addition und erzeugt den Hexcode 14 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] += +c r3 bzw. [r3+5] += +c r7H .

ADDC Rd,[Rs+offset16]
Addiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes zum Register mit Carry. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Lesen einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) ← (Rd) + ((WS:Rs) + offset16) + (C)

Kodierung:	0001 x101  dddd 0sss  hhhh hhhh  llll llll
Word:	x = 1,  Byte:	x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	ADDC r3,[r6-30546] ist eine Word-Addition und erzeugt den Hexcode 1D 36 88 AE.
ADDC r1l,[r3+1125] ist eine Byte-Addition und erzeugt den Hexcode 15 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += +c [r6-30546] bzw. r1l += +c [r3+1125].

ADDC [Rd+offset16],Rs
Addiert den Inhalt eines Registers zum indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) ← ((WS:Rd) + offset16) + (Rs) + (C)

Kodierung:	0001 x101  ssss 1ddd  hhhh hhhh  llll llll
Word:	x = 1,  Byte:	x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	ADDC [r6-30546],r3 ist eine Word-Addition und erzeugt den Hexcode 1D 3E 88 AE.
ADDC [r3+1125],r7h ist eine Byte-Addition und erzeugt den Hexcode 15 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] += +c r3 bzw. [r3+5] += +c r7h.

ADDC Rd,direct	Addiert den Inhalt einer direct-Adresse oder eines SFRs zu einem Register mit Carry.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (Rd) + (direct) + (C)

Kodierung:	0001 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	ADDC r3,2eh ist eine Word-Addition der direct-Adresse 2eh mit dem Register R3 und erzeugt den Hexcode 1E 30 2E.
ADDC r1L,S0BUF ist eine Byte-Addition des seriellen Buffers mit Register 1 Low-Byte und erzeugt den Hexcode 16 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += +c 2eh bzw. r1L += +c S0BUF.

ADDC direct,Rs	Addiert den Inhalt eines Registers zu einer direct-Adresse oder einem SFR mit Carry.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) + (Rs) + (C)

Kodierung:	0001 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	ADDC 1a3h,r6 ist eine Word-Addition der direct-Adresse 1a3h mit dem Register R6 und erzeugt den Hexcode 1E 69 A3.
ADDC P2,r4H ist eine Byte-Addition von Port2 mit dem Inhalt von Register 4 High-Byte und erzeugt den Hexcode 16 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h += +c r6 bzw. P2 += +c r4H.

ADDC Rd,#data	Addiert zum Register eine Zahl mit Carry.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← (Rd) + #data + (C)

Kodierung:	1001 x001  dddd 0001  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	ADDC r3,#2eh ist eine Word-Addition von Register R3 mit der Zahl 2eh und erzeugt den Hexcode 99 31 00 2E.
ADDC r1L,#2eh ist eine Byte-Addition von Register 1 Low-Byte mit der Zahl 2eh und erzeugt den Hexcode 91 21 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 += +c #2eh bzw. r1L += +c #2eh.

ADDC [Rd],#data
Addiert zu einem indirekt adressierten RAM-Platz eine Zahl mit Carry. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) + #data + (C)

Kodierung:	1001 x010  0ddd 0001  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	ADDC.w [r3],#2e7h (oder ADDC [r3],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9A 31 02 E7.
ADDC.b [r1],#2eh (oder ADDC [r1],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 92 11 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] += +c #2e7h.w bzw. [r1] += +c #2eh.b.

ADDC [Rd+],#data
Addiert zu einem indirekt adressierten RAM-Platz eine Zahl mit Carry und inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) + #data + (C)
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0001  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	ADDC.w [r3+],#2e7h (oder ADDC [r3+],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9B 31 02 E7.
ADDC.b [r1+],#2eh (oder ADDC [r1+],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 93 11 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] += +c #2e7h.w bzw. [r1+] += +c #2eh.b.

ADDC [Rd+offset8],#data
Addiert eine Zahl zum indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) + #data + (C)

Kodierung:	1001 x100  0ddd 0001  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	ADDC.w [r3+16],#2e7h (oder ADDC [r3+16],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz plus dem offset8 mit der Zahl 2e7h und erzeugt den Hexcode 9C 31 10 02 E7.
ADDC.b [r1-8],#2eh (oder ADDC [r1-8],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz plus dem offset8 mit der Zahl 2eh und erzeugt den Hexcode 94 11 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] += +c #2e7h.w bzw. [r1-8] += +c #2eh.b.

ADDC [Rd+offset16],#data
Addiert eine Zahl zum indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) + #data + (C)

Kodierung:	1001 x101  0ddd 0001  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	ADDC.w [r3+165ah],#2e7h (oder ADDC [r3+165ah],#2e7h) ist eine Word-Addition von dem mit R3 adressierten RAM-Platz plus dem offset16 mit der Zahl 2e7h und erzeugt den Hexcode 9D 31 16 5A 02 E7.
ADDC.b [r1-120h],#2eh (oder ADDC [r1-120h],#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz plus dem offset16 mit der Zahl 2eh und erzeugt den Hexcode 95 11 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] += +c #2e7h.w bzw. [r1-120h] += +c #2eh.b.

ADDC direct,#data
Addiert eine Zahl zu einem direct-RAM-Platz oder SFR mit Carry. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) ← (direct) + #data + (C)

Kodierung:	1001 x110  0ddd 0001  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	ADDC.w 30h,#2e7h (oder ADDC 30h,#2e7h) ist eine Word-Addition von dem RAM-Platz an Adresse 30h mit der Zahl 2e7h und erzeugt den Hexcode 9E 01 30 02 E7.
ADDC.b 123h,#2eh (oder ADDC 123h,#2eh) ist eine Byte-Addition von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 96 11 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h += +c #2e7h.w bzw. 123h += +c #2eh.b.


ADDS-Befehl
ADDS	Short Addition

Syntax:	ADDS  dest,#Konstante

Aktion:	dest ← dest + #data4

Beschreibung:	Der Zahlenwert für data4 darf nur aus dem Intervall [-8; +7] sein. Dieser Zahlenwert wird bei einer Byte-Operation auf acht Bits und bei einer Word-Operation auf 16 Bits unter Berücksichtigung des Vorzeichens erweitert und anschließend zu dest addiert. Ist z.B. data4 = -2, so wird im Falle einer Byte-Operation die Zahl FEh und im Falle einer Word-Operation die Zahl FFFEh addiert. Ist z.B. data4 = +5, so wird im Falle einer Byte-Operation die Zahl 05h und im Falle einer Word-Operation die Zahl 0005h addiert. Gedacht ist dieser Befehl hauptsächlich zum Inkrementieren oder Dekrementieren von Zählvariablen oder Pointer. Er ersetzt somit den INC- und DEC-Befehl der MCS-51 Controller. Da diese die Bits C und AC nicht verändern, tut es der ADDS-Befehl auch nicht.

Bits:	Folgende Bits werden aktualisiert:
N, Z
Ist dest das Low-Byte des Programmstatusworts PSWL, so überschreibt das Additionsergebnis die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Assembler:	dest++ ist identisch zu adds dest,#1 und
dest-- ist identisch zu adds dest,#-1.
Diese Ausdrücke ersetzen den nicht vorhanden Inkrement- bzw. Dekrement-Befehl.

Operanden

ADDS Rd,#data4	Addiert eine signierte 4-Bit-Konstante zum Inhalt eines Registers.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) + #data4

Kodierung:	1010 x001  dddd zzzz
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4

Beispiel:	ADDS r3,#4 ist eine Word-Addition und erzeugt den Hexcode A9 34.
ADDS r1L,#-2 ist eine Byte-Addition und erzeugt den Hexcode A1 2E.
r3++ ist mit adds r3,#1  und  r1l-- mit adds r1l,#-1 identisch.

ADDS [Rd],#data4	Addiert eine signierte 4-Bit-Konstante zu einem indirekt adressierten RAM-Platz. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	2

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) + #data4

Kodierung:	1010 x010  0ddd zzzz
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4

Beispiel:	ADDS.w [r3],#4 ist eine Word-Addition und erzeugt den Hexcode AA 34.
ADDS.b [r1],#-2 ist eine Byte-Addition und erzeugt den Hexcode A2 1E.
[r3]++ .w ist mit adds.w [r3],#1  und  [r1]-- .b mit adds.b [r1],#-1 identisch.

ADDS [Rd+],#data4	Addiert eine signierte 4-Bit-Konstante zu einem indirekt adressierten RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, deren Inhalt anschließend inkrementiert wird. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) + #data4
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	1010 x011  0ddd zzzz
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4

Beispiel:	ADDS.w [r3+],#4 ist eine Word-Addition und erzeugt den Hexcode AB 34.
ADDS.b [r1+],#-2 ist eine Byte-Addition und erzeugt den Hexcode A3 1E.
[r3+]++ .w ist mit adds.w [r3+],#1  und  [r1+]-- .b mit adds.b [r1+],#-1 identisch.

ADDS [Rd+offset8],#data4	Addiert eine signierte 4-Bit-Konstante zu einem indirekt adressierten RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) + #data4

Kodierung:	1010 x100  0ddd zzzz oooo oooo
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4, o = offset8

Beispiel:	ADDS.w [r3+18],#4 ist eine Word-Addition und erzeugt den Hexcode AC 34 12.
ADDS.b [r1-4],#-2 ist eine Byte-Addition und erzeugt den Hexcode A4 1E FC.
[r3+18]++ .w ist mit adds.w [r3+18],#1  und  [r1-4]-- .b mit adds.b [r1-4],#-1 identisch.

ADDS [Rd+offset16],#data4	Addiert eine signierte 4-Bit-Konstante zu einem indirekt adressierten RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) + #data4

Kodierung:	1010 x101  0ddd zzzz oooo oooo  ffff ffff
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4,  o = MSB offset16,  f = LSB offset16

Beispiel:	ADDS.w [r3+1859],#4 ist eine Word-Addition und erzeugt den Hexcode AD 34 07 43.
ADDS.b [r1-2010],#-2 ist eine Byte-Addition und erzeugt den Hexcode A5 1E F8 26.
[r3+1859]++ .w ist mit adds.w [r3+1859],#1  und  [r1-2010]-- .b mit adds.b [r1-2010],#-1 identisch.

ADDS direct,#data4	Addiert eine signierte 4-Bit-Konstante zu einem direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muß das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet sich der Assembler für eine Byte-Operation.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) + #data4

Kodierung:	1010 x110  0ddd zzzz  iiii iiii
Word: x = 1,  Byte: x = 0,  z = data4,  d = MSB direct,  i = LSB direct

Beispiel:	ADDS.w 140h,#5 ist eine Word-Addition und erzeugt den Hexcode AE 15 40.
ADDS.b 140h,#-2 ist eine Byte-Addition und erzeugt den Hexcode A6 1E 40.
P2++ ist mit adds.b P2,#1  und  var-- .w mit adds.w var,#-1 identisch.


AND-Befehl
AND	Logisches UND

Syntax:	AND  dest,source

Aktion:	dest ← dest ∧ source

Beschreibung:	AND führt eine bitweise logische UND-Verknüpfung der Inhalte von source mit dest aus. Das Ergebnis steht in dest. Der Inhalt von source wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte oder Word/Word

Assembler:	dest &= source ist identisch zu and dest,source.

Operanden

AND Rd,Rs	Logisches UND zweier Register

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) ∧ (Rs)

Kodierung:	0101 x001  dddd ssss
Word:	x = 1,  Byte:	x = 0

Beispiel:	and r3,r6 ist eine Word-Operation und erzeugt den Hexcode 59 36.
and r1L,r0H ist eine Byte-Operation und erzeugt den Hexcode 51 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 &= r6  bzw. r1l &= r0h.

AND Rd,[Rs]	Logisches UND eines externen oder internen RAM-Platzes mit dem Register. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← (Rd) ∧ ((WS:Rs))

Kodierung:	0101 x010  dddd 0sss
Word:	x = 1,  Byte:	x = 0

Beispiel:	and r3,[r6] ist eine Word-Operation und erzeugt den Hexcode 5A 36.
and r1L,[r2] ist eine Byte-Operation und erzeugt den Hexcode 52 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 &= [r6] bzw. r1l &= [r2].

AND [Rd],Rs	Logisches UND eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rd)) ∧ (Rs)

Kodierung:	0101 x010  ssss 1ddd
Word:	x = 1,  Byte:	x = 0

Beispiel:	and [r3],r6 ist eine Word-Operation und erzeugt den Hexcode 5A 6B.
and [r1],r2H ist eine Byte-Operation und erzeugt den Hexcode 52 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] &= r6 bzw. [r1] &= r2h.

AND Rd,[Rs+]	Logisches UND eines externen oder internen RAM-Platzes zum Register. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) ← (Rd) ∧ ((WS:Rs))
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0101 x011  dddd 0sss
Word:	x = 1,  Byte:	x = 0

Beispiel:	and r3,[r6+] ist eine Word-Operation und erzeugt den Hexcode 5B 36.
and r1L,[r2+] ist eine Byte-Operation und erzeugt den Hexcode 53 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 &= [r6+] bzw. r1l &= [r2+].

AND [Rd+],Rs	Logisches UND eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) ∧ (Rs)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0101 x011  ssss 1ddd
Word:	x = 1,  Byte:	x = 0

Beispiel:	and [r3+],r6 ist eine Word-Operation und erzeugt den Hexcode 5B 6B.
and [r1+],r2H ist eine Byte-Operation und erzeugt den Hexcode 53 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] &= r6 bzw. [r1+] &= r2h.

AND Rd,[Rs+offset8]
Logisches UND eines indirekt adressierten externen oder internen RAM-Platzes mit einem Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) ← (Rd) ∧ ((WS:Rs) + offset8)

Kodierung:	0101 x100  dddd 0sss  oooo ooooo
Word:	x = 1,  Byte:	x = 0, o = Offset-Bits

Beispiel:	and r3,[r6-2] ist eine Word-Operation und erzeugt den Hexcode 5C 36 FE.
and r1L,[r3+5] ist eine Byte-Operation und erzeugt den Hexcode 54 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 &= [r6-2] bzw. r1l &= [r3+5].

AND [Rd+offset8],Rs
Logisches UND eines Registers mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd) + offset8) ← ((WS:Rs) + offset8) ∧ (Rs)

Kodierung:	0101 x100  ssss 1ddd  oooo ooooo
Word: x = 1,  Byte: x = 0,  o = Offset-Bits

Beispiel:	and [r6-2],r3 ist eine Word-Operation und erzeugt den Hexcode 5C 3E FE.
and [r3+5],r7H ist eine Byte-Operation und erzeugt den Hexcode 54 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] &= r3 bzw. [r3+5] &= r7H .

AND Rd,[Rs+offset16]
Logisches UND eines indirekt adressierten externen oder internen RAM-Platzes mit einem Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Lesen einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) ← (Rd) ∧ ((WS:Rs) + offset16)

Kodierung:	0101 x101  dddd 0sss  hhhh hhhh  llll llll
Word:	x = 1,  Byte:	x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	and r3,[r6-30546] ist eine Word-Operation und erzeugt den Hexcode 5D 36 88 AE.
and r1L,[r3+1125] ist eine Byte-Operation und erzeugt den Hexcode 55 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 &= [r6-30546] bzw. r1l &= [r3+1125].

AND [Rd+offset16],Rs
Logisches UND eines Registers mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) ← ((WS:Rd) + offset16) ∧ (Rs)

Kodierung:	0101 x101  ssss 1ddd  hhhh hhhh  llll llll
Word:	x = 1,  Byte:	x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	and [r6-30546],r3 ist eine Word-Operation und erzeugt den Hexcode 5D 3E 88 AE.
and [r3+1125],r7h ist eine Byte-Operation und erzeugt den Hexcode 55 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] &= r3 bzw. [r3+5] &= r7h.

AND Rd,direct	Logisches UND einer direct-Adresse oder eines SFRs mit einem Register.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (Rd) ∧ (direct)

Kodierung:	0101 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	and r3,2eh ist eine Word-Operation der direct-Adresse 2eh mit dem Register R3 und erzeugt den Hexcode 5E 30 2E.
and r1L,S0BUF ist eine Byte-Operation des seriellen Buffers mit Register 1 Low-Byte und erzeugt den Hexcode 56 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 &= 2eh bzw. r1L &= S0BUF.

AND direct,Rs	Logisches UND eines Registers mit einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) ∧ (Rs)

Kodierung:	0101 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	and 1a3h,r6 ist eine Word-Operation der direct-Adresse 1a3h mit dem Register R6 und erzeugt den Hexcode 5E 69 A3.
and P2,r4H ist eine Byte-Operation von Port2 mit dem Inhalt von Register 4 High-Byte und erzeugt den Hexcode 56 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h &= r6 bzw. P2 &= r4H.

AND Rd,#data	Logisches UND eines Registers mit einer Zahl.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← (Rd) ∧ #data

Kodierung:	1001 x001  dddd 0101  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	and r3,#2eh ist eine Word-Operation von Register R3 mit der Zahl 2eh und erzeugt den Hexcode 99 35 00 2E.
and r1L,#2eh ist eine Byte-Operation von Register 1 Low-Byte mit der Zahl 2eh und erzeugt den Hexcode 91 25 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 &= #2eh bzw. r1L &= #2eh.

AND [Rd],#data	Logisches UND eines indirekt adressierten RAM-Platz mit einer Zahl. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) ∧ #data

Kodierung:	1001 x010  0ddd 0101  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	and.w [r3],#2e7h (oder and [r3],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9A 35 02 E7.
and.b [r1],#2eh (oder and [r1],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 92 15 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] &= #2e7h.w bzw. [r1] &= #2eh.b.

AND [Rd+],#data
Logisches UND eines indirekt adressierten RAM-Platz mit einer Zahl und inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) ∧ #data
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0101  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	and.w [r3+],#2e7h (oder and [r3+],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9B 35 02 E7.
and.b [r1+],#2eh (oder and [r1+],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 93 15 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] &= #2e7h.w bzw. [r1+] &= #2eh.b.

AND [Rd+offset8],#data
Logisches UND einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) ∧ #data

Kodierung:	1001 x100  0ddd 0101  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	and.w [r3+16],#2e7h (oder and [r3+16],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz plus dem offset8 mit der Zahl 2e7h und erzeugt den Hexcode 9C 35 10 02 E7.
and.b [r1-8],#2eh (oder and [r1-8],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz plus dem offset8 mit der Zahl 2eh und erzeugt den Hexcode 94 15 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] &= #2e7h.w bzw. [r1-8] &= #2eh.b.

AND [Rd+offset16],#data
Logisches UND einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) ∧ #data

Kodierung:	1001 x101  0ddd 0101  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	and.w [r3+165ah],#2e7h (oder and [r3+165ah],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz plus dem offset16 mit der Zahl 2e7h und erzeugt den Hexcode 9D 35 16 5A 02 E7.
and.b [r1-120h],#2eh (oder and [r1-120h],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz plus dem offset16 mit der Zahl 2eh und erzeugt den Hexcode 95 15 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] &= #2e7h.w bzw. [r1-120h] &= #2eh.b.

AND direct,#data
Logisches UND einer Zahl mit einem direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) ← (direct) ∧ #data

Kodierung:	1001 x110  0ddd 0101  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	and.w 30h,#2e7h (oder and 30h,#2e7h) ist eine Word-Operation von dem RAM-Platz an Adresse 30h mit der Zahl 2e7h und erzeugt den Hexcode 9E 05 30 02 E7.
and.b 123h,#2eh (oder and 123h,#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 96 15 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h &= #2e7h.w bzw. 123h &= #2eh.b.


ANL-Befehl
ANL	Logisches UND Bit mit Carry

Syntax:	ANL  C,bit

Aktion:	C ← C ∧ bit

Beschreibung:	ANL führt eine logische UND-Verknüpfung von bit mit C aus. Das Ergebnis steht in C. Der Inhalt von bit  wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
C

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0100 00aa  bbbb bbbb
a = MSB Bitadresse,  b = LSB Bitadresse

Beispiel:	anl C,P2.3 erzeugt den Hexcode 08 43 93.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle anl C,R5.10 und anl C,R5h.2 gleichwertig, sie erzeugen den Code 08 40 5A. Das gleiche gilt für die Bits im SFR-Bereich. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: anl C,S1CON.1 und anl C,TI_1 und anl C,321h.


ANL/-Befehl
ANL	Logisches UND Bitkomplement mit Carry

Syntax:	ANL  C,/bit

Aktion:	C ← C ∧ ¬bit

Beschreibung:	ANL führt eine logische UND-Verknüpfung mit dem Komplement von bit und C aus. Das Ergebnis steht in C. Der Inhalt von bit  wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
C

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0101 00aa  bbbb bbbb
a = MSB Bitadresse,  b = LSB Bitadresse

Beispiel:	anl C,/P2.3 erzeugt den Hexcode 08 53 93.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle anl C,/R5.10 und anl C,/R5h.2 gleichwertig, sie erzeugen den Code 08 50 5A. Das gleiche gilt für die Bits im SFR-Bereich. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: anl C,/S1CON.1 und anl C,/TI_1 und anl C,/321h.


ASL-Befehl
ASL	Arithmetic Shift Left

Syntax:	ASL  dest,count

Aktion:	V ← 0
Do while (count ≠ 0)
C ← dest.MSB
dest.bit(n+1) ← dest.bit(n)
dest.LSB ← 0
count = count - 1
falls Vorzeichenänderung während Shift V ← 1
End while

Beschreibung:	Wenn der Operand count größer als 0 ist, werden die Bits von dest so oft nach links geschoben, wie count angibt. Die von rechts reingeschobenen Bits sind immer Null. Das rausgeschobene Bit erscheint im Carry. Ist count = 0, erfolgt keine Aktion. Der Inhalt von count wird bei der Aktion nicht verändert.

count kann sein:
- eine 4-Bit- oder 5-Bit-Zahl
- ein Register, von dem nur die unteren 5 Bits benutzt werden.

count ist ein positiver Wert von 1 bis 31 und dest ist ein signierter Integerwert, der 8-, 16- oder 32-Bit groß sein kann. Im Falle eines 32-Bit Shifts muss dest ein geradzahliges Register sein.  Sollte der Inhalt von count größer als 32 sein, werden nur die untersten 5 Bits für die Zählung verwendet.

Mathematisch bedeutet jeder Shift-Vorgang eine Multiplikation mit 2: dest ← dest · 2count.

Bits:	Folgende Bits werden aktualisiert:
C, V, N, Z
Zu Beginn des Befehls wird das Overflow-Bit V im PSW gelöscht. Sobald sich der Inhalt des Vorzeichenbits in dest ändert, wird gesetzt es und bleibt bis zum Ende des Shift-Vorgangs gesetzt, auch wenn das Vorzeichenbit wieder seinen alten Wert annehmen sollte.

Größe:	Byte, Word oder DWord

Assembler:	dest << count ist identisch zu asl dest,count.

Operanden

ASL Rd,Rs	Linksschieben von Rd. Die Anzahl der Schiebevorgänge steht in Rs. Rs ist immer ein Byte-Register. Ein DWord-Shift muss mit ASL.d gekennzeichnet werden.

Bytes:	2

Größe:	Byte/Byte, Word/Byte oder DWord/Byte

Takte:	Rd = Byte oder Word: 4 (+ 1 für je 2 geshiftete Bits)
Rd = DWord: 6 (+ 1 für je 2 geshiftete Bits)

Aktion:	(Rd) ← (Rd) << (Rs)

Kodierung:	1100 xx01  dddd ssss
DWord: xx = 11, Word: xx = 10, Byte: xx = 00, d = Rd, s = RsL/H

Beispiel:	r4l = #1111 0111b: r0 = #3: asl r4l,r0l ist ein Byte-Shift und erzeugt den Hexcode C1 80. In R4L steht danach 1011 1000,  und C = 1.
r4 = #1111 0111b: r0l = #3: asl r4,r0l ist ein Word-Shift und erzeugt den Hexcode C9 40. In R4 steht danach 0000 0111 1011 1000,  und C = 0.
r5 = #0: r4 = #1111 0111b: r0l = #10: asl.d r4,r0l ist ein DWord-Shift und erzeugt den Hexcode CD 40. In R5 steht danach 0000 0000 0000 0011, in R4 1101 1100 0000 0000,  und C = 0.
Die vorstehenden Shift-Befehle können durch folgende Schreibweisen ersetzt werden:
r4l << r0l  bzw. r4 << r0l bzw. r4 << r0l.d

ASL Rd,#data4(5)	Linksschieben von Rd. Die Anzahl der Schiebevorgänge gibt data4(5) an. Ein DWord-Shift muss mit ASL.d gekennzeichnet werden.

Bytes:	2

Takte:	Rd = Byte oder Word: 4 (+ 1 für je 2 geshiftete Bits)
Rd = DWord: 6 (+ 1 für je 2 geshiftete Bits)

Aktion:	(Rd) ← (Rd) << #data4(5)

Kodierung:	1101 x001  dddd ssss (Word/Byte)
Word: x = 1, Byte: x = 0, d = Rd, s = #data4
1101 1101  ddds ssss (DWord)
d = Rd, s = #data5

Beispiel:	r4l = #1111 0111b: asl r4l,#3 ist ein Byte-Shift und erzeugt den Hexcode D1 83. In R4L steht danach 1011 1000,  und C = 1.
r4 = #1111 0111b: asl r4,#3 ist ein Word-Shift und erzeugt den Hexcode D9 43. In R4 steht danach 0000 0111 1011 1000,  und C = 0.
r5 = #0: r4 = #1111 0111b: asl.d r4,#10 ist ein DWord-Shift und erzeugt den Hexcode DD 4A. In R5 steht danach 0000 0000 0000 0011, in R4 1101 1100 0000 0000,  und C = 0.
Die vorstehenden Shift-Befehle können durch folgende Schreibweisen ersetzt werden:
r4l << #3  bzw. r4 << #3 bzw. r4 << #10.d


ASR-Befehl
ASR	Arithmetic Shift Right

Syntax:	ASR  dest,count

Aktion:	Do while (count ≠ 0)
C ← dest.0
dest.bit(n) ← dest.bit(n+1)
dest.MSB ← Vorzeichenbit
count = count - 1
End while

Beschreibung:	Wenn der Operand count größer als 0 ist, werden die Bits von dest so oft nach rechts geschoben, wie count angibt. Die von links reingeschobenen Bits sind immer identisch mit dem Vorzeichenbit, d.h. war das MSB eine Null, werden Nullen reingeschoben, war das MSB eine Eins, werden Einsen reingeschoben. Da das Rechtsschieben der Division mit 2 entspricht, bleibt somit das Vorzeichen im Ergebnis erhalten und das Verfahren ist auf signierte Zahlen anwendbar.

Das rausgeschobene Bit erscheint im Carry. Ist count = 0, erfolgt keine Aktion. Der Inhalt von count wird bei der Aktion nicht verändert.

count kann sein:
- eine 4-Bit- oder 5-Bit-Zahl
- ein Register, von dem nur die unteren 5 Bits benutzt werden.

count ist ein positiver Wert von 1 bis 31 und dest ist ein signierter Integerwert, der 8-, 16- oder 32-Bit groß sein kann. Im Falle eines 32-Bit Shifts muss dest ein geradzahliges Register sein.  Sollte der Inhalt von count größer als 32 sein, werden nur die untersten 5 Bits für die Zählung verwendet.

Mathematisch bedeutet jeder Shift-Vorgang eine Division durch 2: dest ← dest : 2count.

Bits:	Folgende Bits werden aktualisiert:
C, N, Z

Größe:	Byte, Word oder DWord

Assembler:	dest >> count ist identisch zu asr dest,count.

Operanden

ASR Rd,Rs	Rechtsschieben von Rd. Die Anzahl der Schiebevorgänge steht in Rs. Rs ist immmer ein Byte-Register. Ein DWord-Shift muss mit ASR.d gekennzeichnet werden.

Bytes:	2

Größe:	Byte/Byte, Word/Byte oder DWord/Byte

Takte:	Rd = Byte oder Word: 4 (+ 1 für je 2 geshiftete Bits)
Rd = DWord: 6 (+ 1 für je 2 geshiftete Bits)

Aktion:	(Rd) ← (Rd) >> (Rs)

Kodierung:	1100 xx10  dddd ssss
DWord: xx = 11, Word: xx = 10, Byte: xx = 00, d = Rd, s = RsL/H

Beispiel:	r4l = #1011 1111b: r0 = #3: asr r4l,r0l ist ein Byte-Shift und erzeugt den Hexcode C2 80. In R4L steht danach 1111 0111,  und C = 1.
r4 = #1111 0011b: r0h = #3: asr r4,r0h ist ein Word-Shift und erzeugt den Hexcode CA 41. In R4 steht danach 0000 0000 0001 1110,  und C = 0.
r5 = #1111 0111b: r4 = #0: r1l = #5: asr.d r4,r1l ist ein DWord-Shift und erzeugt den Hexcode CE 42. In R5 steht danach 0000 0000 0000 0111, in R4 1011 1000 0000 0000,  und C = 0.
Die vorstehenden Shift-Befehle können durch folgende Schreibweisen ersetzt werden:
r4l >> r0l  bzw. r4 >> r0h bzw. r4 >> r1l.d

ASR Rd,#data4(5)	Rechtsschieben von Rd. Die Anzahl der Schiebevorgänge gibt data4(5) an. Ein DWord-Shift muss mit ASR.d gekennzeichnet werden.

Bytes:	2

Takte:	Rd = Byte oder Word: 4 (+ 1 für je 2 geshiftete Bits)
Rd = DWord: 6 (+ 1 für je 2 geshiftete Bits)

Aktion:	(Rd) ← (Rd) >> #data4(5)

Kodierung:	1101 x010  dddd ssss (Word/Byte)
Word: x = 1, Byte: x = 0, d = Rd, s = #data4
1101 1110  ddds ssss (DWord)
d = Rd, s = #data5

Beispiel:	r4l = #1111 0111b: asr r4l,#3 ist ein Byte-Shift und erzeugt den Hexcode D2 83. In R4L steht danach 1111 1110,  und C = 1.
r4 = #1111 0011b: asr r4,#3 ist ein Word-Shift und erzeugt den Hexcode DA 43. In R4 steht danach 0000 0000 0001 1110,  und C = 0.
r5 = #1111 0111b: r4 = #0: asr.d r4,#10 ist ein DWord-Shift und erzeugt den Hexcode DE 4A. In R5 steht danach 0000 0000 0000 0000, in R4 0011 1101 1100 0000,  und C = 0.
Die vorstehenden Shift-Befehle können durch folgende Schreibweisen ersetzt werden:
r4l >> #3  bzw. r4 >> #3 bzw. r4 >> #10.d


BCC-Befehl
BCC	Branch if Carry Clear

Syntax:	BCC  rel8

Aktion:	(PC) ← (PC) + 2
if C = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird nur bei gelöschtem Carry ausgeführt. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 0000  rrrr rrrr
r = rel8

Beispiel:	bcc Label erzeugt den Code F0 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn das Carry gelöscht ist. Also werden die nachfolgende Befehle ausgeführt, wenn das Carry gesetzt ist. Daher kann der Befehl bcc rel8 durch die Konstruktion If C then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.


BCS-Befehl
BCS	Branch if Carry Set

Syntax:	BCS  rel8

Aktion:	(PC) ← (PC) + 2
if C = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird nur bei gesetztem Carry ausgeführt. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung; 3  ohne Sprung

Kodierung:	1111 0001  rrrr rrrr
r = rel8

Beispiel:	bcs Label erzeugt den Code F1 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn das Carry gesetzt ist. Also werden die nachfolgende Befehle ausgeführt, wenn das Carry gelöscht ist. Daher kann der Befehl bcs rel8 durch die Konstruktion If not C then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.


BEQ-Befehl
BEQ	Branch if zero

Syntax:	BEQ  rel8

Aktion:	(PC) ← (PC) + 2
if Z = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird nur bei gesetztem Zero-Flag ausgeführt. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 0011  rrrr rrrr
r = rel8

Beispiel:	beq Label erzeugt den Code F3 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn die vorausgegange Operation ein Ergebnis von 0 hatte. Also werden die nachfolgende Befehle ausgeführt, wenn das Ergebnis ungleich 0 war. Daher kann der Befehl beq rel8 durch die Konstruktion If not zero then oder If !=0 then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 != Var then. Daraus werden die Befehle: cmp r0,var: beq rel8.


BG-Befehl
BG	Branch if greater than (unsignierter Vergleich)

Syntax:	BG  rel8

Aktion:	(PC) ← (PC) + 2
if Z = 0 or C = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird nur bei gelöschtem Zero- oder gelöschtem Carry-Flag ausgeführt, d.h. wenn beim vorausgegangenen Compare-Befehl der Wert von dest größer war als der Wert von source. Der Vergleich erfolgt ohne Berücksichtigung des Vorzeichens. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 1000  rrrr rrrr
r = rel8

Beispiel:	bg Label erzeugt den Code F8 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest größer war als der Wert von source.. Also werden die nachfolgende Befehle ausgeführt, wenn dest <= source war. Daher kann der Befehl bg rel8 durch die Konstruktion If <= then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 <= Var then. Daraus werden die Befehle: cmp r0,var: bg rel8.


BGE-Befehl
BGE	Branch if greater than or equal to (signierter Vergleich)

Syntax:	BGE  rel8

Aktion:	(PC) ← (PC) + 2
if N = 0 xor V = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest größer oder gleich dem Wert von source war. Der Vergleich erfolgt mit Berücksichtigung des Vorzeichens.
Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 1010  rrrr rrrr
r = rel8

Beispiel:	bge Label erzeugt den Code FA (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest größer oder gleich dem Wert von source war. Also werden die nachfolgende Befehle ausgeführt, wenn gilt dest < source. Daher kann der Befehl bge rel8 durch die Konstruktion If <s then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich signierter Werte eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 < Var.s then. Daraus werden die Befehle: cmp r0,var: bge rel8. Das Suffix .s weist den Assembler an, signierte Werte zu vergleichen.


BGT-Befehl
BGT	Branch if greater than (signierter Vergleich)

Syntax:	BGT  rel8

Aktion:	(PC) ← (PC) + 2
if (Z = 0 or N = 0) xor V = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest größer dem Wert von source war. Der Vergleich erfolgt mit Berücksichtigung des Vorzeichens.
Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 1100  rrrr rrrr
r = rel8

Beispiel:	bgt Label erzeugt den Code FC (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest größer dem Wert von source war. Also werden die nachfolgende Befehle ausgeführt, wenn gilt dest <= source. Daher kann der Befehl bgt rel8 durch die Konstruktion If <=s then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich signierter Werte eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 <= Var.s then. Daraus werden die Befehle: cmp r0,var: bgt rel8. Das Suffix .s weist den Assembler an, signierte Werte zu vergleichen.


BKPT-Befehl
BKPT	Breakpoint

Syntax:	BKPT

Aktion:	(PC) ← (PC) + 1
(SSP) ← (SSP) - 6
((SSP)) ← (PC)
((SSP)) ← (PSW)
(PSW) ← (bkpt vector low-DWord)
(PC.15-0) ← (bkpt vector high-DWord)
(PC.23-16) ← 0
(PC.0) ← 0

Beschreibung:	Aufruf einer Breakpoint-Routine. In Emulationssystemen lassen sich mit dieser Methode einfache Hardware Breakpoints einrichten. Der Breakpoint ist ein Exception-Interrupt, der Ereignis- und Software-Interupts unabhängig von ihrer Priorität sofort unterbrechen kann und im System-Modus ausgeführt wird. Unter den Exception-Interrupts hat er allerdings den niedrigsten Vorrang.

Damit mit dem Breakpoint zuverlässig in allen Situationen gearbeitet werden kann, darf seine Befehlslänge nicht größer sein als die Länge des kürzesten Befehls, z.B. NOP = 1 Byte. Denn der BKPT-Befehl muss einen NOP ersetzen können, ohne den folgenden Befehl zu zerstören, der vielleicht Ziel eines Sprunges ist.

Für diesen Befehl wurde bewußt der Wert FFh gewählt, so dass ein unprogrammiertes EPROM automatisch Breakpoints aufweist. Das ist vergleichbar mit dem NOP-Befehl, der in einem mit Nullen gefüllten Speicher keinen Schaden anrichtet.

Bits:	alle werden durch den BKPT-Vektor ersetzt

Bytes:	1

Takte:	23,  19 (in Zero-Page)

Kodierung:	1111 1111

Assembler:	Breakpoint (008F):	;Definition des Breakpoint-Vektors
. . . 	;BKPT-Routine
RETI
. . . 	;Programm-Code
BKPT	;Aufruf der Breakpoint-Routine


BL-Befehl
BL	Branch if less than or equal to (unsignierter Vergleich)

Syntax:	BL  rel8

Aktion:	(PC) ← (PC) + 2
if Z = 1 or C = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest kleiner oder gleich dem Wert von source war. Der Vergleich erfolgt ohne Berücksichtigung des Vorzeichens.
Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 1001  rrrr rrrr
r = rel8

Beispiel:	bl Label erzeugt den Code F9 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest kleiner oder gleich dem Wert von source war. Also werden die nachfolgende Befehle ausgeführt, wenn gilt dest > source. Daher kann der Befehl bl rel8 durch die Konstruktion If > then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich unsignierter Werte eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 > Var then. Daraus werden die Befehle: cmp r0,var: bl rel8.


BLE-Befehl
BLE	Branch if less than or equal to (signierter Vergleich)

Syntax:	BLE  rel8

Aktion:	(PC) ← (PC) + 2
if (Z = 1 or N = 1) xor V = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest kleiner oder gleich dem Wert von source war. Der Vergleich erfolgt mit Berücksichtigung des Vorzeichens.
Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 1101  rrrr rrrr
r = rel8

Beispiel:	ble Label erzeugt den Code FD (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest kleiner oder gleich dem Wert von source war. Also werden die nachfolgende Befehle ausgeführt, wenn gilt dest > source. Daher kann der Befehl ble rel8 durch die Konstruktion If >s then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich signierter Werte eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 > Var.s then. Daraus werden die Befehle: cmp r0,var: ble rel8. Das Suffix .s weist den Assembler an, signierte Werte zu vergleichen.


BLT-Befehl
BLT	Branch if less than (signierter Vergleich)

Syntax:	BLT  rel8

Aktion:	(PC) ← (PC) + 2
if N = 1 xor V = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest kleiner als der Wert von source war. Der Vergleich erfolgt mit Berücksichtigung des Vorzeichens.
Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 1011  rrrr rrrr
r = rel8

Beispiel:	blt Label erzeugt den Code FB (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Compare-Befehl der Wert von dest kleiner als der Wert von source war. Also werden die nachfolgende Befehle ausgeführt, wenn gilt dest >= source. Daher kann der Befehl blt rel8 durch die Konstruktion If >=s then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich signierter Werte eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 >= Var.s then. Daraus werden die Befehle: cmp r0,var: blt rel8. Das Suffix .s weist den Assembler an, signierte Werte zu vergleichen.


BMI-Befehl
BMI	Branch if negativ

Syntax:	BMI  rel8

Aktion:	(PC) ← (PC) + 2
if N = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn beim vorausgegangenen Befehl ein Wert kleiner 0 entstand. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 0111  rrrr rrrr
r = rel8

Beispiel:	bmi Label erzeugt den Code F7 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Befehl ein Wert kleiner 0 entstand. Also werden die nachfolgende Befehle ausgeführt, wenn das Ergebnis >= 0 war. Daher kann der Befehl bmi rel8 durch die Konstruktion If >=0 then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich unsignierter Werte eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 >= Var then. Daraus werden die Befehle: cmp r0,var: bmi rel8.


BNE-Befehl
BNE	Branch if not equal

Syntax:	BNE  rel8

Aktion:	(PC) ← (PC) + 2
if Z = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird nur bei gelöschtem Zero-Flag ausgeführt. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 0010  rrrr rrrr
r = rel8

Beispiel:	bne Label erzeugt den Code F2 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn die vorausgegange Operation ein Ergebnis ungleich 0 hatte. Also werden die nachfolgende Befehle ausgeführt, wenn das Ergebnis gleich 0 war. Daher kann der Befehl bne rel8 durch die Konstruktion If zero then oder If 0 then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 = Var then. Daraus werden die Befehle: cmp r0,var: bne rel8. Sind die Vergleichsoperanden Rd = direct, Rd = #data oder [Rd] = #data, so wird der CJNE-Befehl benutzt.


BNV-Befehl
BNV	Branch if no overflow

Syntax:	BNV  rel8

Aktion:	(PC) ← (PC) + 2
if V = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn der vorausgegangene Befehl keinen Überlauf erzeugte, also gültig innerhalb seines Zahlenbereichs war. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 0100  rrrr rrrr
r = rel8

Beispiel:	bnv Label erzeugt den Code F4 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn der vorausgegangene Befehl keinen Überlauf erzeugte, also gültig innerhalb seines Zahlenbereichs war. Es können damit z.B. fehlerhafte Berechnungen entdeckt und darauf reagiert werden. Also werden die nachfolgende Befehle ausgeführt, wenn ein Überlauf erfolgte. Daher kann der Befehl bnv rel8 durch die Konstruktion If OV then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.


BOV-Befehl
BOV	Branch if overflow

Syntax:	BOV  rel8

Aktion:	(PC) ← (PC) + 2
if V = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn der vorausgegangene Befehl einen Überlauf erzeugte, also ungültig innerhalb seines Zahlenbereichs war. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 0101  rrrr rrrr
r = rel8

Beispiel:	bov Label erzeugt den Code F4 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn der vorausgegangene Befehl einen Überlauf erzeugte, also ungültig innerhalb seines Zahlenbereichs war. Es können damit z.B. fehlerhafte Berechnungen entdeckt und darauf reagiert werden. Also werden die nachfolgende Befehle ausgeführt, wenn kein Überlauf erfolgte. Daher kann der Befehl bov rel8 durch die Konstruktion If not OV then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.


BPL-Befehl
BPL	Branch if positiv

Syntax:	BPL  rel8

Aktion:	(PC) ← (PC) + 2
if N = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn beim vorausgegangenen Befehl ein Wert größer oder gleich 0 entstand. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1111 0110  rrrr rrrr
r = rel8

Beispiel:	bpl Label erzeugt den Code F6 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn beim vorausgegangenen Befehl ein Wert größer oder gleich 0 entstand. Also werden die nachfolgende Befehle ausgeführt, wenn das Ergebnis < 0 war. Daher kann der Befehl bpl rel8 durch die Konstruktion If <0 then ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

Dieser Befehl wird im allgemeinen nach einem Größenvergleich unsignierter Werte eingesetzt werden. Der Assembler erzeugt den Größenvergleich und den Sprung durch die Anweisung z.B. If R0 < Var then. Daraus werden die Befehle: cmp r0,var: bpl rel8.


BR-Befehl
BR	Unconditional Branch

Syntax:	BR  rel8

Aktion:	(PC) ← (PC) + 2
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ohne Prüfung irgendeiner Bedingung ausgeführt. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	2

Takte:	3

Kodierung:	1111 1110  rrrr rrrr
r = rel8

Beispiel:	br Label erzeugt den Code FE (Labeladresse - PC) : 2.

Assembler:	Der Assembler erwartet als rel8 ein Label. Liegt das Label vor dem BR-Befehl, ensteht eine Endlosschleife, die nur durch einen Interrupt oder einem bedingten Sprungbefehl verlassen werden kann. Der Assembler stellt zur Erzeugung solcher Konstruktionen die Syntax Loop - End Loop zur Verfügung.

Um zu verhindern, dass das Hauptprogramm nach Beendigung weiteren Code ausführt, sollte folgender Kostrukt stehen:

Stop:
br Stop

Der Assembler erzeugt diese Sequenz durch das Wort End.


CALL relativ
CALL	Call Subroutine Relativ

Syntax:	CALL  rel16

Aktion:	(PC) ← (PC) + 3
(SP) ← (SP) - 4
((SP)) ← (PC.23-0)
(PC) ← (PC + rel16 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ohne Prüfung irgendeiner Bedingung ausgeführt. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -65536 und +65534 Bytes bezüglich des abgerundeten aktuellen Programmzählers. Befindet sich der XA im Page 0 Modus, werden nur 16 Adressbits auf den Stack gelegt.

Bits:	keine Änderung

Bytes:	3

Takte:	7,  4 (in Page 0)

Kodierung:	1100 0101  hhhh hhhh  llll llll
h = high(rel16), l = low(rel16)

Beispiel:	call Label erzeugt den Code C5 (Labeladresse - PC) : 2.

Assembler:	Der Assembler erwartet als rel16 ein Label. Der Befehl call kann auch ganz weggelassen werden und nur das Label genannt werden. Der Assembler erzeugt dann automatisch einen CALL, wenn das Label existiert.


CALL [Rs]
CALL	Call Subroutine Indirect

Syntax:	CALL  [Rs]

Aktion:	(PC) ← (PC) + 2
(SP) ← (SP) - 4
((SP)) ← (PC.23-0)
(PC.15-1) ← (Rs.15-1)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ohne Prüfung irgendeiner Bedingung zur Adresse, die sich im Register Rs befindet, innerhalb der aktuellen 64K Page ausgeführt. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -65536 und +65534 Bytes bezüglich des abgerundeten aktuellen Programmzählers. Befindet sich der XA im Page 0 Modus, werden nur 16 Adressbits auf den Stack gelegt.

Bits:	keine Änderung

Bytes:	2

Takte:	8,  5 (in Page 0)

Kodierung:	1100 0110  0000 0sss
s = R0 - R7

Beispiel:	call [R3] erzeugt den Code C6 03.


CJNE-Befehl
CJNE	Compare and jump if not equal

Syntax:	CJNE  dest, source, rel3

Aktion:	(PC) ← (PC) + Zahl der Befehlsbytes
(dest) - (source)
if Z = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	CJNE führt eine Subtraktion von dest und source aus. Sind dest und source nicht gleich, erfolgt der Sprung, bei Gleichheit wird mit dem Folgebefehl fortgefahren. Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.
CJNE wurde aus Kompatibilitätsgründen zum 8051 dem XA-Befehlssatz hinzugefügt. Der CMP-Befehl ist bedeutend mächtiger.

Bits:	Folgende Bits werden aktualisiert:
C, N, Z

Größe:	Byte/Byte oder Word/Word

Assembler:	if dest = source [then] mit den folgenden Operanden ist identisch zu cjne dest,source,rel8.

Operanden

CJNE Rd,direct,rel8	Vergleicht ein Register mit einer direct-Adresse oder einem SFR.

Bytes:	4

Takte:	10 bei Sprung;  7 ohne Sprung

Kodierung:	1110 x010  dddd 0hhh  llll llll  rrrr rrrr
Word:.x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits, r = rel8

Beispiel:	cjne r3l,S0BUF,Label ist ein Byte-Vergleich und erzeugt den Hexcode E2 64 60 rel8.
cjne r3,5eh,Label ist ein Word-Vergleich und erzeugt den Hexcode EA 30 5E rel8.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
if r3l = S0BUF [then] bzw. if r3 = 5eh [then]. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

CJNE Rd,#data,rel8	Vergleicht ein Register mit einer Zahl.

Bytes:	4 (Byte), 5 (Word)

Takte:	9 bei Sprung;  6 ohne Sprung

Kodierung:	1110 x011  dddd 0000  rrrr rrrr  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, r = rel8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cjne r3l,#13,Label ist ein Byte-Vergleich und erzeugt den Hexcode E3 60 rel8 0D.
cjne r3,#13,Label ist ein Word-Vergleich und erzeugt den Hexcode EB 30 rel8 00 0D .
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
if r3l = #13 [then] bzw. if r3 = #13 [then]. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.

CJNE [Rd],#data,rel8	Vergleicht einen indirekt adressierten RAM-Platz mit einer Zahl.

Bytes:	4 (Byte), 5 (Word)

Takte:	10 bei Sprung;  7 ohne Sprung

Kodierung:	1110 x011  0ddd 1000  rrrr rrrr  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, r = rel8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cjne.b [r3],#13,Label ist ein Byte-Vergleich und erzeugt den Hexcode E3 38 rel8 0D.
cjne.w [r3],#13,Label ist ein Word-Vergleich und erzeugt den Hexcode EB 38 rel8 00 0D .
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
if [r3] = #13.b [then] bzw. if [r3] = #13.w [then]. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.


CLR-Befehl
CLR	Clear Bit

Syntax:	CLR  Bit

Aktion:	(bit) ← 0

Beschreibung:	In das mit Bit genannte Bit wird eine Null geschrieben.

Bits:	kein Änderung des Programmstatusworts, es sei denn, Bit liegt im Programmstatuswort.

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0000 00aa  bbbb bbbb
a = MSB der Bitadresse (1a = SFR-Bit, 0a = RAM-Bit), b = LSB der Bitadresse

Beispiel:	clr 132h löscht das Bit an der Bitadresse 132h (= Bit 2 in der internen RAM-Adresse 23h) und erzeugt den Hexcode 08 01 32.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle clr R5.10 und clr R5h.2 gleichwertig, sie erzeugen den Code 08 00 5A. Das gleiche gilt für die Bits im SFR-Bereich. Das dritte Bit von Port 2 lässt sich mit clr P2.3 löschen. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: clr S1CON.1 und clr TI_1 und clr 321h.

Siehe auch: SETB


CMP-Befehl
CMP	Integer Compare

Syntax:	CMP  dest, source

Aktion:	dest - source

Beschreibung:	CMP vergleicht dest mit source durch Subtraktion. Die Bits im Prorgammstatuswort werden gemäß den Subtraktionsregeln verändert. Die Inhalte von dest und source bleiben unangetastet. Somit macht der CMP-Befehl nur Sinn, wenn nachfolgend die Flags mit bedingten Sprüngen getestet werden. Damit macht der CMP-Befehl Aussagen über die folgenden Relationen < kleiner, > größer, = gleich, >= größer gleich, <= kleiner gleich, != ungleich sowohl für unsignierte als auch für signierte Zahlen.

Bits:	Folgende Bits werden aktualisiert:
C, AC, V, N, Z

Größe:	Byte/Byte oder Word/Word

Assembler:	Der Compare-Befehl mit anschließendem Bit-Test wird vom Assembler bei IF-, WHILE- und FOR-Strukturen automatisch erzeugt. Syntax:
IF dest ~ source [then]
LOOP WHILE dest ~ source
FOR (Initiierung | dest ~ source | Aktion), wobei ~ eines der Zeichen <, >, =, <=, >=, != ist. Sollen signierte Zahlen verglichen werden, ist an source das Suffix .s anzuhängen dest ~ source.s. Die gültigen dest/source-Kombinationen entnehmen Sie der nachfogenden Operandenaufstellung.

Operanden

CMP Rd,Rs	Registervergleich

Bytes:	2

Takte:	3

Aktion:	(Rd) - (Rs)

Kodierung:	0100 x001  dddd ssss
Word: x = 1,  Byte: x = 0,  d = dest,  s = source

Beispiel:	cmp r3,r6 ist ein Byte-Vergleich und erzeugt den Hexcode 49 36.
cmp r1L,r0H ist ein Byte-Vergleich und erzeugt den Hexcode 41 21.

CMP Rd,[Rs]	Vergleich eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) - ((WS:Rs))

Kodierung:	0100 x010  dddd 0sss
Word: x = 1,  Byte: x = 0,  d = dest,  s = source

Beispiel:	cmp r3,[r6] ist ein Word-Vergleich und erzeugt den Hexcode 4A 36.
cmp r1L,[r2] ist ein Byte-Vergleich und erzeugt den Hexcode 42 22.

CMP [Rd],Rs	Vergleich eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	((WS:Rd)) - (Rs)

Kodierung:	0100 x010  ssss 1ddd
Word: x = 1,  Byte: x = 0,  d = dest,  s = source

Beispiel:	cmp [r3],r6 ist ein Word-Vergleich und erzeugt den Hexcode 4A 6B.
cmp [r1],r2H ist ein Byte-Vergleich und erzeugt den Hexcode 42 59.

CMP Rd,[Rs+]	Vergleich eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) - ((WS:Rs))
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0100 x011  dddd 0sss
Word: x = 1,  Byte: x = 0,  d = dest,  s = source

Beispiel:	cmp r3,[r6+] ist ein Word-Vergleich und erzeugt den Hexcode 4B 36.
cmp r1L,[r2+] ist ein Byte-Vergleich und erzeugt den Hexcode 43 22.

CMP [Rd+],Rs	Vergleich eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) - (Rs)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0100 x011  ssss 1ddd
Word: x = 1,  Byte: x = 0,  d = dest,  s = source

Beispiel:	cmp [r3+],r6 ist ein Word-Vergleich und erzeugt den Hexcode 4B 6B.
cmp [r1+],r2H ist ein Byte-Vergleich und erzeugt den Hexcode 43 59.

CMP Rd,[Rs+offset8]
Vergleich eines Registers mit einem externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Vegleich einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) - ((WS:Rs) + offset8)

Kodierung:	0100 x100  dddd 0sss  oooo ooooo
Word: x = 1,  Byte: x = 0,  d = dest,  s = source, o = Offset-Bits

Beispiel:	cmp r3,[r6-2] ist ein Word-Vergleich und erzeugt den Hexcode 4C 36 FE.
cmp r1L,[r3+5] ist ein Byte-Vergleich und erzeugt den Hexcode 44 23 05.

CMP [Rd+offset8],Rs
Vergleich eines Registers mit einem externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Vergleich einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rs) + offset8) - (Rs)

Kodierung:	0100 x100  ssss 1ddd  oooo ooooo
Word: x = 1,  Byte: x = 0,  d = dest,  s = source, o = Offset-Bits

Beispiel:	cmp [r6-2],r3 ist ein Word-Vergleich und erzeugt den Hexcode 4C 3E FE.
cmp [r3+5],r7H ist ein Byte-Vergleich und erzeugt den Hexcode 44 FB 05.

CMP Rd,[Rs+offset16]
Vergleich eines Registers mit einem externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Vergleich einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) - ((WS:Rs) + offset16)

Kodierung:	0100 x101  dddd 0sss  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = dest,  s = source, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	cmp r3,[r6-30546] ist ein Word-Vergleich und erzeugt den Hexcode 4D 36 88 AE.
cmp r1L,[r3+1125] ist ein Byte-Vergleich und erzeugt den Hexcode 45 23 04 65.

CMP [Rd+offset16],Rs
Vergleich eines Registers mit einem externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Vergleich einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) - (Rs)

Kodierung:	0100 x101  ssss 1ddd  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = dest,  s = source, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	cmp [r6-30546],r3 ist ein Word-Vergleich und erzeugt den Hexcode 4D 3E 88 AE.
cmp [r3+1125],r7H ist ein Byte-Vergleich und erzeugt den Hexcode 45 FB 04 65.

CMP Rd,direct	Vergleich eines Registers mit einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	4

Aktion:	(Rd) - (direct)

Kodierung:	0100 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	cmp r3,2eh ist ein Word-Vergleich der direct-Adresse 2eh mit dem Register R3 und erzeugt den Hexcode 4E 30 2E.
cmp r1L,S0BUF ist ein Byte-Vergleich des seriellen Buffers mit Register 1 Low-Byte und erzeugt den Hexcode 46 24 60.

CMP direct,Rs	Vergleich eines Registers mit einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	4

Aktion:	(direct) - (Rs)

Kodierung:	0100 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	cmp 1a3h,r6 ist ein Word-Vergleich der direct-Adresse 1a3h mit dem Register R6 und erzeugt den Hexcode 4E 69 A3.
cmp P2,r4H ist ein Byte-Vergleich von Port2 mit dem Inhalt von Register 4 High-Byte und erzeugt den Hexcode 46 9C 32.

CMP Rd,#data	Vergleich eines Registers mit einer Zahl.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) - #data

Kodierung:	1001 x001  dddd 0100  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cmp r3,#2eh ist ein Word-Vergleich von Register R3 mit der Zahl 2eh und erzeugt den Hexcode 99 34 00 2E.
cmp r1L,#2eh ist ein Byte-Vergleich von Register 1 Low-Byte mit der Zahl 2eh und erzeugt den Hexcode 91 24 2E.

CMP [Rd],#data	Vergleich eines indirekt adressierten RAM-Platzes mit einer Zahl. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) - #data

Kodierung:	1001 x010  0ddd 0100  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cmp.w [r3],#2e7h (oder cmp [r3],#2e7h) ist ein Word-Vergleich von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9A 34 02 E7.
cmp.b [r1],#2eh (oder cmp [r1],#2eh) ist ein Byte-Vergleich von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 92 14 2E.

CMP [Rd+],#data
Vergleich eines indirekt adressierten RAM-Platzes mit einer Zahl und anschließender Inkrementierung des Registers. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ∧ #data
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0100  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cmp.w [r3+],#2e7h (oder cmp [r3+],#2e7h) ist ein Word-Vergleich von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9B 34 02 E7.
cmp.b [r1+],#2eh (oder cmp [r1+],#2eh) ist ein Byte-Vergleich von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 93 14 2E.

CMP [Rd+offset8],#data
Vergleich einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) - #data

Kodierung:	1001 x100  0ddd 0100  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cmp.w [r3+16],#2e7h (oder cmp [r3+16],#2e7h) ist ein Word-Vergleich von dem mit R3 adressierten RAM-Platz plus dem offset8 mit der Zahl 2e7h und erzeugt den Hexcode 9C 34 10 02 E7.
cmp.b [r1-8],#2eh (oder cmp [r1-8],#2eh) ist ein Byte-Vergleich von dem mit R1 adressierten RAM-Platz plus offset8 mit der Zahl 2eh und erzeugt den Hexcode 94 14 F8 2E.

CMP [Rd+offset16],#data
Vergleich einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) - #data

Kodierung:	1001 x101  0ddd 0100  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cmp.w [r3+165ah],#2e7h (oder cmp [r3+165ah],#2e7h) ist ein Word-Vergleich von dem mit R3 adressierten RAM-Platz plus dem offset16 mit der Zahl 2e7h und erzeugt den Hexcode 9D 34 16 5A 02 E7.
cmp.b [r1-120h],#2eh (oder cmp [r1-120h],#2eh) ist ein Byte-Vergleich von dem mit R1 adressierten RAM-Platz plus dem offset16 mit der Zahl 2eh und erzeugt den Hexcode 95 14 FE E0 2E.

CMP direct,#data
Vergleich einer Zahl mit einem direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) - #data

Kodierung:	1001 x110  0ddd 0100  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	cmp.w 30h,#2e7h (oder cmp 30h,#2e7h) ist ein Word-Vergleich von dem RAM-Platz an Adresse 30h mit der Zahl 2e7h und erzeugt den Hexcode 9E 04 30 02 E7.
cmp.b 123h,#2eh (oder cmp 123h,#2eh) ist ein Byte-Vergleich von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 96 14 23 2E.


CPL-Befehl
CPL	Integer Ones Complement

Syntax:	CPL  Rd

Aktion:	(Rd) ← ¬(Rd)

Beschreibung:	Jedes Bit des Registers wird invertiert, d.h. aus einer Eins wird eine Null und aus einer Null wird eine Eins. Der Befehl bildet nicht das Zweierkomplelemt einer Zahl, das macht der Befehl NEG.

Bits:	N, Z

Größe:	Byte, Word

Bytes:	2

Takte:	3

Kodierung:	1001 x000  dddd 1010
Word: x = 1,  Byte: x = 0, d = Register

Beispiel:	cpl r4 invertiert die 16 Bits des Register 4 und erzeugt den Hexcode 98 4A.
cpl r4L invertiert die 8 Bits des Low-Bytes von Register 4 und erzeugt den Hexcode 90 8A.

Assembler:	Die vorstehenden Beispiele können ersetzt werden durch r4 = ~r4 oder einfach r4 =~ ,bzw. r4l = ~r4l oder einfach r4l =~  .


DA-Befehl
DA	Decimal Adjust

Syntax:	DA  Rd

Aktion:	if (Rd.3-0) > 9 or AC = 1 then
(Rd.3-0) ← (Rd.3-0) + 6
if (Rd.7-4) > 9 or C = 1 then
(Rd.7-4) ← (Rd.7-4) + 6

Beschreibung:	Der Befehl korrigiert das Ergebnis einer Addition von BCD-Zahlen (binary coded decimal number) und macht nur nach einem ADD- bzw. ADDC-Befehl Sinn. Man beachte, dass er nur Byte-Register bearbeiten kann.
Wenn die unteren vier Bits des Registers größer als 9 sind oder das Hilfscarry AC gesetzt ist, wird die Zahl 6 zum Register addiert. Das kann zur Folge haben, dass das Carry gesetzt wird, wenn dabei ein Überlauf über das achte Bit auftritt, d.h. wenn die Summe größer als 255 wird.
Wenn die oberen vier Bits des Registers größer als 9 sind oder wenn das Carry C durch die Korrektur der unteren Bits gesetzt wurde, wird die Zahl 60h zum Register addiert. Auch das kann einen Überlauf und damit das Setzen des Carrys erwirken, wenn die Summe größer als 25 wird.
Das Carry wird durch den DA-Befehl nicht gelöscht, wenn es innerhalb des DA-Befehls jemals gesetzt wurde.

Bits:	C, N, Z

Größe:	Byte

Bytes:	2

Takte:	4

Kodierung:	1001 0000  dddd 1000
d = Byte-Register

Beispiel:	da r4l führt eine Dezimalkorrektur mit dem Low-Byte des Register 4 durch und erzeugt den Hexcode 90 88.


DIV-, DIVU-Befehl
DIV, DIVU	Signed, Unsigned Division

Syntax:	DIV(U)  dest, source

Aktion:	dest ← dest / source

Beschreibung:	dest wird durch source geteilt und der Quotient und der Rest nach dest geschrieben. Bei der signierten Division erhält der Rest das Vorzeichen des Dividenden, d.h. das Vorzeichen, das dest vor der Division hatte.

Bits:	C, V, N, Z
Bei jeder Division wird das Carry gelöscht. Das Overflow-Bit V wird beim Auftreten der folgenden Bedingungen gesetzt, sonst gelöscht:

•  DIVU.b: V wird bei der Division durch 0 gesetzt, gleichzeitig wird der Divide-by-zero Interrupt aufgerufen.

•  DIV(U).w: V wird gesetzt, wenn das Ergebnis der Division acht Bits überschreitet, wenn also der Quotient nicht mehr in dest passt, z.B. 203Ah / 2 = 101Dh.

•  DIV(U).d: V wird gesetzt, wenn das Ergebnis der Division 16 Bits überschreitet, wenn also der Quotient nicht mehr in dest passt, z.B. 8203Ah / 7 = 1292Ch.

Die Flags Z und N werden auf Grund der Struktur des Integerquotienten verändert und nicht bezüglich des Rests.

Größe:	Byte/Byte, Word/Byte, DWord/Word

Operanden

DIV.w  Rd,Rs	Signierte 16/8-Bit Division

Bytes:	2

Takte:	14

Aktion:	(RdL) ← 8-Bit Vorkommastelle von (Rd) / (Rs)
(RdH) ← 8-Bit Rest von (Rd) / (Rs)

Kodierung:	1110 0111  dddd ssss
d = Word-Register,  s = Byte-Register

Beispiel:	div.w r3,r6l teilt den Inhalt von R3 durch den Inhalt von R6 Low-Byte und erzeugt den Hexcode E7 3C.

DIV.w  Rd,#data8	Signierte 16/8-Bit Division

Bytes:	3

Takte:	14

Aktion:	(RdL) ← 8-Bit Vorkommastelle von (Rd) / #data8
(RdH) ← 8-Bit Rest von (Rd) / #data8

Kodierung:	1110 1000  dddd 1011  ssss ssss
d = Word-Register,  s = Zahl

Beispiel:	div.w r3,#14 teilt den Inhalt von R3 durch Zahl 14 und erzeugt den Hexcode E8 3B 0E.

DIV.d  Rd,Rs	Signierte 32/16-Bit Division

Bytes:	2

Takte:	22

Aktion:	(Rd) ← 16-Bit Vorkommastelle von (Rd) / (Rs)
(Rd+1) ← 16-Bit Rest von (Rd) / (Rs)

Kodierung:	1110 1111  ddd0 ssss
d = DWord-Register (geradzahlig),  s = Word-Register

Beispiel:	div.d r4,r2 teilt den Inhalt von R5:R4 durch den Inhalt von R2 und erzeugt den Hexcode EF 42.

DIV.d  Rd,#data16	Signierte 16/8-Bit Division

Bytes:	4

Takte:	22

Aktion:	(Rd) ← 16-Bit Vorkommastelle von (Rd) / #data16
(Rd+1) ← 16-Bit Rest von (Rd) / #data16

Kodierung:	1110 1001  ddd0 0001  hhhh hhhh  llll llll
d = DWord-Register (geradzahlig),  h = high-Byte, l = low-Byte der 16-Bit-Zahl

Beispiel:	mov r3,#FF3Fh
mov r2,#214Dh	;(R3:R2) = FF3F214Dh = -12639923d
div.d r2,#-553 teilt den Inhalt von R3:R2 durch die Zahl -553 und erzeugt den Hexcode E9 29 FD D7.
In R2 steht danach der Integerwert  5949h = +22857d, in R3 der Rest FFFEh = -2, denn -12639923d : (-553d) = +22857d Rest -2.

DIVU.b  Rd,Rs	Unsignierte 8/8-Bit Division

Bytes:	2

Takte:	12

Aktion:	(RdL) ← 8-Bit Vorkommastelle von (Rd) / (Rs)
(RdH) ← 8-Bit Rest von (Rd) / (Rs)

Kodierung:	1110 0001  dddd ssss
d = Byte-Register,  s = Byte-Register

Beispiel:	mov r2l,#FAh
mov r1l,#4
divu.b r2l,r1l teilt den Inhalt von R2L durch den Inhalt von R1L und erzeugt den Hexcode E1 42. Der Quotient 3Eh findet sich in R2L, der Rest 2h steht in R2H.
Ist Rd das High-Byte eines Registers, so wird der Quotient in das High-Byte zurückgeschrieben, aber nachfolgend sogleich mit dem Rest überschrieben, so dass der Integerwert verloren geht und nur der Rest oder Modulowert in RdH steht. Diese Einschränkung gilt für den Divisor Rs nicht. Er kann RsL oder RsH sein.
Der vorstehende Befehl kann durch folgende Schreibweise ersetzt werden:
r2l /= r1l.b.

DIVU.b  Rd,#data8	Unsignierte 8/8-Bit Division

Bytes:	3

Takte:	12

Aktion:	(RdL) ← 8-Bit Vorkommastelle von (Rd) / #data8
(RdH) ← 8-Bit Rest von (Rd) / #data8

Kodierung:	1110 0001  dddd 0001  ssss ssss
d = Byte-Register,  s = #data8

Beispiel:	mov r2l,#FAh
divu.b r2l,#4 teilt den Inhalt von R2L durch die Zahl 4 und erzeugt den Hexcode E8 41 04. Der Quotient 3Eh findet sich in R2L, der Rest 2h steht in R2H.
Ist Rd das High-Byte eines Registers, so wird der Quotient in das High-Byte zurückgeschrieben, aber nachfolgend sogleich mit dem Rest überschrieben, so dass der Integerwert verloren geht und nur der Rest oder Modulowert in RdH steht.
Der vorstehende Befehl kann durch folgende Schreibweise ersetzt werden:
r2l /= #4.b.

DIVU.w  Rd,Rs	Unsignierte 16/8-Bit Division

Bytes:	2

Takte:	12

Aktion:	(RdL) ← 8-Bit Vorkommastelle von (Rd) / (Rs)
(RdH) ← 8-Bit Rest von (Rd) / (Rs)

Kodierung:	1110 0101  dddd ssss
d = Word-Register,  s = Byte-Register

Beispiel:	mov r2,#3E45h
mov r1l,#90h
divu.w r2,r1l teilt den Inhalt von R2 durch den Inhalt von R1L und erzeugt den Hexcode E5 22. Der Quotient 6Eh findet sich in R2L, der Rest 65h steht in R2H.
Der vorstehende Befehl kann durch folgende Schreibweise ersetzt werden:
r2 /= r1l.w.

DIVU.w  Rd,#data8	Unsignierte 16/8-Bit Division

Bytes:	3

Takte:	12

Aktion:	(RdL) ← 8-Bit Vorkommastelle von (Rd) / #data8
(RdH) ← 8-Bit Rest von (Rd) / #data8

Kodierung:	1110 1000  dddd 0011  ssss ssss
d = Word-Register,  s = #data8

Beispiel:	mov r2,#3E45h
divu.w r2,#90h teilt den Inhalt von R2L durch die Zahl 90h und erzeugt den Hexcode E8 23 90. Der Quotient 6Eh findet sich in R2L, der Rest 65h steht in R2H.
Der vorstehende Befehl kann durch folgende Schreibweise ersetzt werden:
r2 /= #90h.w.

DIVU.d  Rd,Rs	Unsignierte 32/16-Bit Division

Bytes:	2

Takte:	22

Aktion:	(Rd) ← 16-Bit Vorkommastelle von (Rd) / (Rs)
(Rd+1) ← 16-Bit Rest von (Rd) / (Rs)

Kodierung:	1110 1101  ddd0 ssss
d = DWord-Register (geradzahlig),  s = Word-Register

Beispiel:	mov r3,#3E45h
mov r2,#2007h
mov r1,#FFe3h
divu.d r2,r1 teilt den Inhalt von R3:R2 durch den Inhalt von R1 und erzeugt den Hexcode ED 21. Der Quotient 3E4Ch findet sich in R2, der Rest 2EA3h steht in R3.
Der vorstehende Befehl kann durch folgende Schreibweise ersetzt werden:
r2 /= r1.d.

DIVU.d  Rd,#data16	Unsignierte 32/16-Bit Division

Bytes:	4

Takte:	22

Aktion:	(Rd) ← 16-Bit Vorkommastelle von (Rd) / #data16
(Rd+1) ← 16-Bit Rest von (Rd) / #data16

Kodierung:	1110 1001  ddd0 0001  hhhh hhhh  llll llll
d = DWord-Register (geradzahlig),  h = #data16 High-Byte,  l = #data16 Low-Byte

Beispiel:	mov r3,#3E45h
mov r2,#2007h
divu.d r2,#FFE3h teilt den Inhalt von R3:R2 durch die Zahl #FFe3h und erzeugt den Hexcode E9 21 FF E3. Der Quotient 3E4Ch findet sich in R2, der Rest 2EA3h steht in R3.
Der vorstehende Befehl kann durch folgende Schreibweise ersetzt werden:
r2 /= #FFE3h.d.


DJNZ-Befehl
DJNZ	Decrement and jump if not zero

Syntax:	DJNZ  dest, rel8

Aktion:	(PC) ← (PC) + 3
(dest) ← (dest) - 1
if Z = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Befehl erniedrigt zunächst den Inhalt von dest um Eins, prüft anschließend den Inhalt auf Null und fährt mit dem folgenden Befehl fort, wenn der Inhalt von 0 verschieden ist. Ist der Inhalt Null, erfolgt der Sprung zur relativen Adresse, die üblicherweise als Label mit dem Befehl genannt ist.
Beim Sprung wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	N, Z

Größe:	Byte, Word

Assembler:	Mit DJNZ werden überwiegend Zählschleifen gebildet, wobei dest den Abwärtszähler bildet. Wird dest vor der Schleife mit der Zahl n geladen, wird die Schleife n-mal durchlaufen. Diese Arbeit übernimmt der Assembler mit einer FOR-Schleife. FOR dest = n lädt den Zähler mit dem Startwert. Das Ende der Schleife wird mit NEXT markiert. Der Assembler übersetzt NEXT unter Berücksichtigung der Art von dest mit einen DJNZ-Befehl und errechnet die relative Adresse. Somit sind die einfachen FOR-Konstrukte immer in Einerschritten abwärtszählende Zählschleifen.

Operanden

DJNZ  Rd,rel8	Dekrement Register und springe wenn Null

Bytes:	3

Takte:	8 bei Sprung;  5 ohne Sprung

Kodierung:	1000 x111  dddd 1000  rrrr rrrr
Word: x = 1,  Byte: x = 0,  d = Register,  r = signierte relative Adresse

Beispiel:	djnz r3,Label ist ein Word-Befehl und erzeugt den Code 8F 38 (Labeladresse - PC) : 2,
djnz r3h,Label ist ein Byte-Befehl und erzeugt den Code 87 78 (Labeladresse - PC) : 2.

DJNZ  direct,rel8	Dekrement direct-Adresse bzw. SFR und springe wenn Null. Da der Assembler der direct-Bezeichnung die Byte- oder Word-Größe nicht ansehen kann, müssen die Kennzeichnungen .b oder .w verwendet werden.

Bytes:	4

Takte:	9 bei Sprung;  5 ohne Sprung

Kodierung:	1110 x010  0000 1hhh  llll llll  rrrr rrrr
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR, l = low-Bits,  r = signierte relative Adresse

Beispiel:	djnz.w 130h,Label ist ein Word-Befehl und erzeugt den Code EA 09 30 (Labeladresse - PC) : 2,
djnz.b P2,Label ist ein Byte-Befehl und erzeugt den Code E2 0C 32 (Labeladresse - PC) : 2.


FCALL-Befehl
FCALL	Far Call subroutine absolute

Syntax:	FCALL  addr24

Aktion:	(PC) ← (PC) + 4
(SP) ← (SP) - 4
((SP)) ← (PC)
(PC.23-0) ← addr24
(PC.0) ← 0

Beschreibung:	FCALL bewirkt einen Subroutinenaufruf an einer beliebigen Stelle im gesamten 16MB Adressraum. Die aktuelle Adresse des folgenden Befehls wird als 24-Bit Wert auf den Stack gelegt. Im Page 0 Modus werden nur 16 Adressbits auf den Stack gelegt und der Programmzähler nur mit den unteren 16 Bits geladen. Die Zieladresse muss geradzahlig sein.

Bits:	keine Änderung

Bytes:	4

Takte:	12  im 16MB Adressraum;  9  in der Zeropage

Kodierung:	1100 0100  mmmm mmmm  llll llll  hhhh hhhh
m = Middle-Byte,  l = Low-Byte,  h = High-Byte von addr24

Beispiel:	fcall 023E10h ruft eine Subroutine an Adresse 023E10h auf und erzeugt den Hexcode C4 3E 10 02. Statt einer absoluten Adresse kann auch ein Label genannt werden.


FJMP-Befehl
FJMP	Far Jump absolute

Syntax:	FJMP  addr24

Aktion:	(PC.23-0) ← addr24
(PC.0) ← 0

Beschreibung:	FJMP bewirkt einen unbedingten Sprung zu einer beliebigen Stelle im gesamten 16MB Adressraum. Die Zieladresse muss geradzahlig sein. Im Zeropage Modus werden nur 16 Bits der Adresse benutzt.

Bits:	keine Änderung

Bytes:	4

Takte:	7

Kodierung:	1101 0100  mmmm mmmm  llll llll  hhhh hhhh
m = Middle-Byte,  l = Low-Byte,  h = High-Byte von addr24

Beispiel:	fjmp 023E10h führt einen Sprung nach Adresse 023E10h aus (im Zeropage Modus nach Adresse 3E10h) und erzeugt den Hexcode D4 3E 10 02. Statt einer absoluten Adresse kann auch ein Label genannt werden.


JB-Befehl
JB	Jump if bit is set

Syntax:	JB  bit, rel8

Aktion:	(PC) ← (PC) + 4
if (bit) = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird bei gesetzem Bit ausgeführt. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	4

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1001 0111  1000 00aa  bbbb bbbb  rrrr rrrr
a = MSB der Bitadresse,  b = LSB der Bitadresse,  r = rel8

Beispiel:	jb F1,Label erzeugt den Code 97 82 11 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn das Bit gesetzt ist. Also werden die nachfolgende Befehle ausgeführt, wenn das Bit gelöscht ist. Daher kann der Befehl jb bit,rel8 durch die Konstruktion If not bit [then] ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.
Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Das gleiche gilt für die Bits im SFR-Bereich. Das dritte Bit von Port 2 lässt sich mit jb P2.3,Label testen. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: jb S1CON.1,Label und jb TI_1,Label und jb 321h,Label. Sie erzeugen alle den Hexcode 97 83 21 rel8.


JBC-Befehl
JBC	Jump if bit is set then clear bit

Syntax:	JBC  bit, rel8

Aktion:	(PC) ← (PC) + 4
if (bit) = 1 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0
(bit) ← 0

Beschreibung:	Der Programmsprung wird bei gesetzem Bit ausgeführt. Dabei werden das Bit und das Bit 0 der Adresse des Folgebefehls gelöscht, d.h. letzteres wird auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	4

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1001 0111  1100 00aa  bbbb bbbb  rrrr rrrr
a = MSB der Bitadresse,  b = LSB der Bitadresse,  r = rel8

Beispiel:	jbc F1,Label erzeugt den Code 97 C2 11 (Labeladresse - PC) : 2.

Assembler:	Der Assembler hält für diesen speziellen Befehl keine hochsprachenähnliche Vereinfachung bereit.
Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Das gleiche gilt für die Bits im SFR-Bereich. Das dritte Bit von Port 2 lässt sich mit jbc P2.3,Label testen. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: jbc S1CON.1,Label und jbc TI_1,Label und jbc 321h,Label. Sie erzeugen alle den Hexcode 97 C3 21 rel8.


JMP-Befehl
JMP	Unconditional Jump

Syntax:	JMP  dest

Beschreibung:	JMP springt ohne Bedingung zur in dest genannten Stelle. Diese muss sich an gerader Adresse befinden.

Bits:	Es werden keine Bits verändert.

Operanden

JMP rel16	Springe zu relativer Adresse.

Aktion:	(PC) ← (PC) + 3
(PC) ← (PC + rel16 · 2)
(PC.0) ← 0

Beschreibung:	JMP rel16 springt ohne Bedingung zur relativen Adressangabe. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -65536 und +65535 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bytes:	3

Takte:	6

Kodierung:	1101 0101  hhhh hhhh  llll llll
h = MSB von rel 16,  l = LSB von rel 16

Beispiel:	jmp Label erzeugt den Hexcode D5 HH LL.

JMP [Rs]	Springe indirekt über ein Register.

Aktion:	(PC) ← (PC) + 2
(PC.15-1) ← (Rs.15-1)
(PC.0) ← 0

Beschreibung:	JMP [Rs] springt ohne Bedingung zur Adresse im 64K Segment, deren absoluter Wert im Register Rs steht. Dabei wird Bit 0 der Zieladresse gelöscht, d.h. auf die nächste gerade Zahl abgerundet.

Bytes:	2

Takte:	7

Kodierung:	1101 0110  0111 0sss
s = Rs

Beispiel:	mov r2,#352h
jmp [R2] erzeugt den Hexcode D6 72 und springt zur Adresse 352h im Segment, in dem der dem JMP folgende Befehl steht.

JMP [A+DPTR]	Springe indirekt über Akku und Datenpointer.

Aktion:	(PC) ← (PC) + 2
(PC.15-1) ← (A) + (DPTR)
(PC.0) ← 0

Beschreibung:	JMP [A+DPTR] springt ohne Bedingung zur Adresse im 64K Segment, die sich aus der Summe aus Akku und Datenpointer ergibt. Da der Akku das Register 4 Low-Byte und der Datenpointer das Register 6 ist, wird die Zieladresse aus der Summe von R6 + R4L gebildet.. Dabei wird Bit 0 der Zieladresse gelöscht, d.h. auf die nächste gerade Zahl abgerundet. Dieser Befehl wurde aus Software-Kompatibilitätsgründen zur MCS-51 Familie hinzugefügt.

Bytes:	2

Takte:	5

Kodierung:	1101 0110  0100 0110

Beispiel:	mov r6,#3520h
mov r4L,#5
jmp [a+dptr] erzeugt den Hexcode D6 46 und springt zur Adresse 3525h im Segment, in dem der dem JMP folgende Befehl steht.

JMP [[Rs+]]	Springe doppelt indirekt über Register.

Aktion:	(PC) ← (PC) + 2
(PC.15-0) ← Programmspeicher ((WS:Rs))
(PC.0) ← 0
(Rs) ← (Rs) + 2

Beschreibung:	JMP [[Rs+]] lädt den Inhalt der Adresse, auf die Rs zeigt, in den Programmzähler. Rs wird anschließend inkrementiert. Man beachte, dass Rs auf den Programmspeicher und nicht wie üblich auf den Datenspeicher zeigt. Gedacht ist dieser Befehl für die Benutzung von Sprungtabellen, die die Erzeugung eines kompakten Codes erlauben.

Bytes:	2

Takte:	5

Kodierung:	1101 0110  0110 0sss
s = Register Rs

Beispiel:	0160	99	28	02	10	r2 = #210h
0164	D6	62	jmp [[r2+]]
. . .
org 200h
0164	D6	62	P2 = #f0h
0204	FE	FF	end
org 210h
0210	02	00 	DB 0200h
jmp [[R2+]] erzeugt den Hexcode D6 62. Der vorstehende Programmausschnitt schreibt an Adresse 210h den Tabellenwert 0200h, der von dem JMP-Befehl als Sprungziel geladen wird. Das Programm wird an Adresse 200h fortgesetzt, wo es Port 2 mit dem Wert F0h beschreibt.


JNB-Befehl
JNB	Jump if bit is not set

Syntax:	JNB  bit, rel8

Aktion:	(PC) ← (PC) + 4
if (bit) = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird bei gelöschtem Bit ausgeführt. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers.

Bits:	keine Änderung

Größe:	Bit

Bytes:	4

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1001 0111  1010 00aa  bbbb bbbb  rrrr rrrr
a = MSB der Bitadresse,  b = LSB der Bitadresse,  r = rel8

Beispiel:	jnb F1,Label erzeugt den Code 97 A2 11 (Labeladresse - PC) : 2.

Assembler:	Der Sprung erfolgt, wenn das Bit gelöscht ist. Also werden die nachfolgende Befehle ausgeführt, wenn das Bit gesetzt ist. Daher kann der Befehl jnb bit,rel8 durch die Konstruktion If bit [then] ersetzt werden. Das Sprungziel wird mit Else bzw. End If gekennzeichnet.
Als Bitadresse können Sie auch eine Registerbezeichnung und eine durch einen Punkt getrennte Bitnummer angeben. Das gleiche gilt für die Bits im SFR-Bereich. Das dritte Bit von Port 2 lässt sich z.B. mit jnb P2.3,Label testen. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: jnb S1CON.1,Label und jnb TI_1,Label und jnb 321h,Label. Sie erzeugen alle den Hexcode 97 A3 21 rel8.


JNZ-Befehl
JNZ	Jump if Akku Register is not zero

Syntax:	JNZ  rel8

Aktion:	(PC) ← (PC) + 2
if (A) ≠ 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn der Akku nicht Null ist. Der Akku wird durch das Register 4 Low-Byte gebildet. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers. Dieser Befehl ist aus Kompatibilitätsgründen zur MCS-51-Familie hinzugefügt worden.

Bits:	keine Änderung

Größe:	Byte

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1110 1110  rrrr rrrr
r = rel8

Beispiel:	jnz Label erzeugt den Code EE (Labeladresse - PC) : 2.

Assembler:	Der Assembler unterstützt diesen Befehl nicht durch eine IF-Struktur.


JZ-Befehl
JZ	Jump if Akku Register is zero

Syntax:	JZ  rel8

Aktion:	(PC) ← (PC) + 2
if (A) = 0 then
(PC) ← (PC + rel8 · 2)
(PC.0) ← 0

Beschreibung:	Der Programmsprung wird ausgeführt, wenn der Akku Null ist. Der Akku wird durch das Register 4 Low-Byte gebildet. Dabei wird Bit 0 der Adresse des Folgebefehls gelöscht, d.h. auf die nächste gerade Zahl abgerundet, und das Doppelte des signierten, relativen Offsets addiert. Diese Rechnung ergibt die Adresse des Sprungziels, das nur an einer geraden Adresse stehen kann. Der Sprungbereich liegt zwischen -256 und + 254 Bytes bezüglich des abgerundeten aktuellen Programmzählers. Dieser Befehl ist aus Kompatibilitätsgründen zur MCS-51-Familie hinzugefügt worden.

Bits:	keine Änderung

Größe:	Byte

Bytes:	2

Takte:	6  bei Sprung;  3  ohne Sprung

Kodierung:	1110 1100  rrrr rrrr
r = rel8

Beispiel:	jz Label erzeugt den Code EC (Labeladresse - PC) : 2.

Assembler:	Der Assembler unterstützt diesen Befehl nicht durch eine IF-Struktur.


LEA-Befehl
LEA	Load effective adress

Syntax:	LEA  Rd, Rs + offset

Aktion:	(Rd) ← (Rs) + offset8/16

Beschreibung:	Das Offset wird zum Regsiter Rs addiert und die Summe in das Register Rd geschrieben. Beide Register sind Word-Register. Der Offsetwert ist eine 8-Bit oder eine 16-Bit Zahl.
Dieser Befehl vollführt eine Adressberechnung, wie sie von anderen Befehlen bei der indirekten Offsetadressierung ausgeführt wird, und legt die Berechnung in einem Register ab, wo die Adresse für andere Zwecke zur Verfügung steht.

Bits:	Es werden keine Bits verändert.

Größe:	Word/Word

Bytes:	3 offset8,  4 offset16

Takte:	3

Kodierung:	0100 x000  0ddd 0sss  oooo oooo  (llll llll)
x = 0: offset 8, x = 1: offset 16, d = Rd, s = Rs, o = offset8 oder High-Byte von offset16, l = LSB von offset16

Beispiel:	lea r2,r5+12h erzeugt den Hexcode 40 25 12. Der Assembler entscheidet auf Grund der Offsetgröße über offset8 oder offset16.


LSR-Befehl
LSR	Logical Shift Right

Syntax:	LSR  dest,count

Aktion:	Do while (count ≠ 0)
C ← dest.0
dest.bit(n) ← dest.bit(n+1)
dest.MSB ← 0
count = count - 1
End while

Beschreibung:	Wenn der Operand count größer als 0 ist, werden die Bits von dest so oft nach rechts geschoben, wie count angibt. Die von links reingeschobenen Bits sind immer 0. Das bitweise Rechtsschieben entspricht der Division mit 2. Das Verfahren ist nur auf unsignierte Zahlen anwendbar.

Das rausgeschobene Bit erscheint im Carry. Ist count = 0, erfolgt keine Aktion. Der Inhalt von count wird bei der Aktion nicht verändert.

count kann sein:
- eine 4-Bit- oder 5-Bit-Zahl
- ein Register, von dem aber nur die unteren 5 Bits benutzt werden.

count ist ein positiver Wert von 1 bis 31 und dest ist ein unsignierter Integerwert, der 8-, 16- oder 32-Bit groß sein kann. Im Falle eines 32-Bit Shifts muss dest ein geradzahliges Register sein.  Sollte der Inhalt von count größer als 32 sein, werden nur die untersten 5 Bits für die Zählung verwendet.

Mathematisch bedeutet jeder Shift-Vorgang eine Division durch 2: dest ← dest : 2count.

Bits:	Folgende Bits werden aktualisiert:
C, N, Z

Größe:	Byte, Word oder DWord

Assembler:	Beachte: dest >> count ist identisch zu asr dest,count und nicht mit lsr dest,count.

Operanden

LSR Rd,Rs	Rechtsschieben von Rd. Die Anzahl der Schiebevorgänge steht in Rs. Rs ist immer ein Byte-Register. Ein DWord-Shift muss mit LSR.d gekennzeichnet werden.

Bytes:	2

Größe:	Byte/Byte, Word/Byte oder DWord/Byte

Takte:	4 (+ 1 für je 2 geshiftete Bits)

Kodierung:	1100 xx00  dddd ssss
DWord: xx = 11, Word: xx = 10, Byte: xx = 00, d = Rd, s = RsL/H

Beispiel:	r4l = #1011 1111b: r0 = #3: lsr r4l,r0l ist ein Byte-Shift und erzeugt den Hexcode C0 80. In R4L steht danach 0001 0111,  und C = 1.
r4 = #1111 0011b: r2l = #3: lsr r4,r2l ist ein Word-Shift und erzeugt den Hexcode C8 44. In R4 steht danach 0000 0000 0001 1110,  und C = 0.
r5 = #1111 0111b: r4 = #0: r1h = #5: lsr.d r4,r1h ist ein DWord-Shift und erzeugt den Hexcode CC 43. In R5 steht danach 0000 0000 0000 0111, in R4 1011 1000 0000 0000,  und C = 0.

LSR Rd,#data4(5)	Rechtsschieben von Rd. Die Anzahl der Schiebevorgänge gibt data4(5) an. Ein DWord-Shift muss mit ASR.d gekennzeichnet werden.

Bytes:	2

Takte:	6 + 1 für je 2 geshiftete Bits

Kodierung:	1101 x000  dddd ssss (Word/Byte)
Word: x = 1, Byte: x = 0, d = Rd, s = #data4
1101 1100  ddds ssss (DWord)
d = Rd, s = #data5

Beispiel:	r4l = #1111 0111b: lsr r4l,#3 ist ein Byte-Shift und erzeugt den Hexcode D0 83. In R4L steht danach 0001 1110,  und C = 1.
r4 = #1111 0011b: lsr r4,#3 ist ein Word-Shift und erzeugt den Hexcode D8 43. In R4 steht danach 0000 0000 0001 1110,  und C = 0.
r5 = #1111 0111b: r4 = #0: lsr.d r4,#10 ist ein DWord-Shift und erzeugt den Hexcode DC 4A. In R5 steht danach 0000 0000 0000 0000, in R4 0011 1101 1100 0000,  und C = 0.


MOV-Befehl
MOV	Move Data

Syntax:	MOV  dest, source

Aktion:	dest ← dest + source

Beschreibung:	MOV kopiert den Inhalt von source nach dest. Der Inhalt von source wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
N, Z
Ist dest das Low-Byte des Programmstatusworts PSWL, so überschreibt mov PSWL,source die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Assembler:	dest = source ist identisch zu mov dest,source.

Operanden

MOV Rd,Rs	Kopiert ein Register in ein anderes.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rs)

Kodierung:	1000 x001  dddd ssss
Word: x = 1,  Byte: x = 0

Beispiel:	mov r3,r6 ist ein Word-Transfer und erzeugt den Hexcode 89 36.
mov r1l,r0h ist ein Byte-Transfer und erzeugt den Hexcode 81 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 = r6 bzw. r1l = r0h.

MOV Rd,[Rs]	Kopiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes in ein Register. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← ((WS:Rs))

Kodierung:	1000 x010  dddd 0sss
Word: x = 1,  Byte: x = 0

Beispiel:	mov r3,[r6] ist ein Word-Transfer und erzeugt den Hexcode 8A 36.
mov r1l,[r2] ist ein Byte-Transfer und erzeugt den Hexcode 82 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 = [r6] bzw. r1l = [r2].

MOV [Rd],Rs	Kopiert indirekt den Inhalt eines Registers in einen externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	3

Aktion:	((WS:Rd)) ← (Rs)

Kodierung:	1000 x010  ssss 1ddd
Word: x = 1,  Byte: x = 0

Beispiel:	mov [r3],r6 ist ein Word-Transfer und erzeugt den Hexcode 8A 6B.
mov [r1],r2h ist ein Byte-Transfer und erzeugt den Hexcode 82 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] = r6 bzw. [r1] = r2h.

MOV Rd,[Rs+]	Kopiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes in ein Register. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rs))
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	1000 x011  dddd 0sss
Word: x = 1,  Byte: x = 0

Beispiel:	mov r3,[r6+] ist ein Word-Transfer und erzeugt den Hexcode 8B 36.
mov r1l,[r2+] ist ein Byte-Transfer und erzeugt den Hexcode 83 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 = [r6+] bzw. r1l = [r2+].

MOV [Rd+],Rs	Kopiert den Inhalt eines Registers in einen indirekt adressierten externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	4

Aktion:	((WS:Rd)) ← (Rs)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	1000 x011  ssss 1ddd
Word: x = 1,  Byte: x = 0

Beispiel:	mov [r3+],r6 ist ein Word-Transfer und erzeugt den Hexcode 8B 6B.
mov [r1+],r2h ist ein Byte-Transfer und erzeugt den Hexcode 83 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] = r6 bzw. [r1+] = r2h.

MOV Rd,[Rs+offset8]
Kopiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes in ein Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	5

Aktion:	(Rd) ← ((WS:Rs) + offset8)

Kodierung:	1000 x100  dddd 0sss  oooo ooooo
Word: x = 1,  Byte: x = 0, o = Offset-Bits

Beispiel:	mov r3,[r6-2] ist ein Word-Transfer und erzeugt den Hexcode 8C 36 FE.
mov r1l,[r3+5] ist ein Byte-Transfer und erzeugt den Hexcode 84 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 = [r6-2] bzw. r1l = [r3+5].

MOV [Rd+offset8],Rs
Kopiert den Inhalt eines Registers in einen indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	5

Aktion:	((WS:Rd) + offset8) ← (Rs)

Kodierung:	1000 x100  ssss 1ddd  oooo ooooo
Word: x = 1,  Byte: x = 0, o = Offset-Bits

Beispiel:	mov [r6-2],r3 ist ein Word-Transfer und erzeugt den Hexcode 8C 3E FE.
mov [r3+5],r7h ist ein Byte-Transfer und erzeugt den Hexcode 84 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] = r3 bzw. [r3+5] = r7H .

MOV Rd,[Rs+offset16]
Kopiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes in ein Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Lesen einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	5

Aktion:	(Rd) ← ((WS:Rs) + offset16)

Kodierung:	1000 x101  dddd 0sss  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	mov r3,[r6-30546] ist ein Word-Transfer und erzeugt den Hexcode 8D 36 88 AE.
mov r1l,[r3+1125] ist ein Byte-Transfer und erzeugt den Hexcode 85 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 = [r6-30546] bzw. r1l = [r3+1125].

MOV [Rd+offset16],Rs
Kopiert den Inhalt eines Registers in einen indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	5

Aktion:	((WS:Rd) + offset16) ← (Rs)

Kodierung:	1000 x101  ssss 1ddd  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	mov [r6-30546],r3 ist ein Word-Transfer und erzeugt den Hexcode 8D 3E 88 AE.
mov [r3+1125],r7h ist ein Byte-Transfer und erzeugt den Hexcode 85 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] = r3 bzw. [r3+5] = r7h.

MOV [Rd+],[Rs+]	Kopiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platz in einen anderen. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden. Die Unterscheidung zwischen einem Byte- und Word-Transfer muss mit der Befehlserweiterung .b bzw. .w erfolgen. Ohne diese Kennzeichnung entscheidet sich der Assembler für einen Word-Transfer.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rs))
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	1001 x000  0sss 0ddd
Word: x = 1,  Byte: x = 0

Beispiel:	mov.w [r3+],[r6+] ist ein Word-Transfer und erzeugt den Hexcode 98 36.
mov.b [r1+],[r2+] ist ein Byte-Transfer und erzeugt den Hexcode 90 12.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] = [r6+].w bzw. [r1+] = [r2+].b.

MOV Rd,direct	Kopiert den Inhalt einer direct-Adresse oder eines SFRs in ein Register.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (direct)

Kodierung:	1000 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	mov r3,2eh ist ein Word-Transfer der direct-Adresse 2eh in das Register R3 und erzeugt den Hexcode 8E 30 2E.
mov r1l,S0BUF ist ein Byte-Transfer des seriellen Buffers in das Register 1 Low-Byte und erzeugt den Hexcode 86 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 = 2eh bzw. r1l = S0BUF.

MOV direct,Rs	Kopiert den Inhalt eines Registers in eine direct-Adresse oder in ein SFR.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (Rs)

Kodierung:	1000 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	mov 1a3h,r6 ist ein Word-Transfer des Register R6 in die direct-Adresse 1a3h und erzeugt den Hexcode 8E 69 A3.
mov P2,r4h ist ein Byte-Transfer von Register 4 High-Byte in den Port 2 und erzeugt den Hexcode 86 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h = r6 bzw. P2 = r4h.

MOV [Rd],direct	Kopiert den Inhalt einer direct-Adresse oder eines SFRs in einen indirekt adressierten RAM-Platz. Die Unterscheidung zwischen einem Byte- und Word-Transfer muß mit der Befehlserweiterung .b bzw. .w erfolgen. Ohne diese Kennzeichnung entscheidet sich der Assembler für einen Byte-Transfer.

Bytes:	3

Takte:	4

Aktion:	((WS:Rd)) ← (direct)

Kodierung:	1010 x000  0ddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register 0-7, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	mov.w [r3],2eh ist ein Word-Transfer der direct-Adresse 2eh in den mit Register 3 adressierten RAM-Platz und erzeugt den Hexcode A8 30 2E.
mov.b [r1],S0BUF ist ein Byte-Transfer des seriellen Buffers in den mit Register 1 adressierten RAM-Platz und erzeugt den Hexcode A0 14 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] = 2eh.w bzw. [r1] = S0BUF.b.

MOV direct,[Rs]	Kopiert den Inhalt eines indirekt adressierten RAM-Platzes in eine direct-Adresse oder in ein SFR. Die Unterscheidung zwischen einem Byte- und Word-Transfer muß mit der Befehlserweiterung .b bzw. .w erfolgen. Ohne diese Kennzeichnung entscheidet sich der Assembler für einen Byte-Transfer.

Bytes:	3

Takte:	4

Aktion:	(direct) ← ((WS:Rs))

Kodierung:	1010 x000  1sss 0hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	mov.w 1a3h,[r6] ist ein Word-Transfer des mit Register 6 adressierten RAM-Platzes in die direct-Adresse 1a3h und erzeugt den Hexcode A8 E1 A3.
mov.b P2,[r4] ist ein Byte-Transfer des mit Register 4 adressierten RAM-Platzes in den Port 2 und erzeugt den Hexcode A0 C4 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h = [r6].w bzw. P2 = [r4].b.

MOV Rd,#data	Lädt ein Register mit einer Zahl.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← #data

Kodierung:	1001 x001  dddd 1000  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	mov r3,#2eh schreibt die Word-Zahl 002eh in das Register 3 und erzeugt den Hexcode 99 38 00 2E.
mov r1l,#2eh schreibt die Byte-Zahl 2eh in das Low-Byte von Register 1 und erzeugt den Hexcode 91 28 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 = #2eh bzw. r1l = #2eh.

MOV [Rd],#data	Schreibt eine Zahl in einen indirekt adressierten RAM-Platz . Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← #data

Kodierung:	1001 x010  0ddd 1000  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	mov.w [r3],#2e7h (oder mov [r3],#2e7h) schreibt die Word-Zahl 2e7h an den mit R3 adressierten RAM-Platz und erzeugt den Hexcode 9A 38 02 E7.
mov.b [r1],#2eh (oder mov [r1],#2eh) schreibt die Byte-Zahl an den mit R1 adressierten RAM-Platz und erzeugt den Hexcode 92 18 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] = #2e7h.w bzw. [r1] = #2eh.b.

MOV [Rd+],#data
Schreibt eine Zahl in einen indirekt adressierten RAM-Platz und inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← #data
(Rd) ← (Rd) + 1 (Byte) / + 2 (Word)

Kodierung:	1001 x011  0ddd 1000  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	mov.w [r3+],#2e7h (oder mov [r3+],#2e7h) schreibt die Word-Zahl 02e7h an den mit R3 adressierten RAM-Platz und erzeugt den Hexcode 9B 38 02 E7.
mov.b [r1+],#2eh (oder mov [r1+],#2eh) schreibt die Byte-Zahl 2eh an den mit R1 adressierten RAM-Platz und erzeugt den Hexcode 93 18 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] = #2e7h.w bzw. [r1+] = #2eh.b.

MOV [Rd+offset8],#data
Schreibt eine Zahl in einen indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	5

Aktion:	((WS:Rd)+offset8) ← #data

Kodierung:	1001 x100  0ddd 1000  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	mov.w [r3+16],#2e7h (oder mov [r3+16],#2e7h) schreibt die Word-Zahl 02e7h an den mit R3 plus dem offset8 adressierten RAM-Platz und erzeugt den Hexcode 9C 38 10 02 E7.
mov.b [r1-8],#2eh (oder mov [r1-8],#2eh) schreibt die Word-Zahl 2eh an den mit R3 plus dem offset8 adressierten RAM-Platz und erzeugt den Hexcode 94 18 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] = #2e7h.w bzw. [r1-8] = #2eh.b.

MOV [Rd+offset16],#data
Schreibt eine Zahl in einen indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	5

Aktion:	((WS:Rd)+offset16) ← #data

Kodierung:	1001 x101  0ddd 1000  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	mov r3,#2000h: mov.w [r3+165ah],#2e7h (oder mov [r3+165ah],#2e7h) schreibt die Zahl 2e7h an die Adresse 365ah und erzeugt den Hexcode 9D 38 16 5A 02 E7.
mov r1,#5120h: mov.b [r1-120h],#2eh (oder mov [r1-120h],#2eh) schreibt die Zahl 2eh an die Adresse 5000h und erzeugt den Hexcode 95 18 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] = #2e7h.w bzw. [r1-120h] = #2eh.b.

MOV direct,#data
Schreibt eine Zahl in einen direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	3

Aktion:	(direct) ← #data

Kodierung:	1001 x110  0ddd 1000  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	mov.w 30h,#2e7h (oder mov 30h,#2e7h) ist ein Word-Transfer von dem RAM-Platz an Adresse 30h mit der Zahl 2e7h und erzeugt den Hexcode 9E 08 30 02 E7.
mov.b P2,#2eh (oder mov P2,#2eh) ist ein Byte-Transfer von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 96 48 32 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h = #2e7h.w bzw. P2 = #2eh.b.

MOV direct-d,direct-s	Kopiert den Inhalt eines direct-RAM-Platzes oder SFRs in einen anderen direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet sich der Assembler für eine Byte-Operation.

Bytes:	4

Takte:	4

Aktion:	(direct-d) ← (direct-s)

Kodierung:	1001 x111  0ddd 0sss  eeee eeee  tttt tttt
Word: x = 1,  Byte: x = 0, d = MSB direct-d, s = MSB direct-s, e = LSB direct-d, t = LSB direct-s

Beispiel:	mov.w 30h,2e6h ist ein Word-Transfer und kopiert den Inhalt der Adressen 2e6h/2e7h in die Adressen 030h/031h. Der Hexcode lautet 9F 02 30 E6.
mov.b P2,S0BUF (oder mov P2,S0BUF) ist ein Byte-Transfer und kopiert den Inhalt von S0BUF nach Port 2. Der Hexcode lautet 97 44 32 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h = 2e6h.w bzw. P2 = S0BUF.b.

MOV Rd,USP	Schreibt den Inhalt des User Stackpointers in ein Word-Register.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (USP)

Kodierung:	1001 0000  dddd 1111
d = Register

Beispiel:	mov r3,USP schreibt den User Stackpointer nach R3. Der Hexcode lautet 90 3F.
Der vorstehende Befehl kann durch die folgende Schreibweise ersetzt werden:
r3 = USP.

MOV USP,Rs	Schreibt den Inhalt eines Word-Registers in den User Stackpointer.

Bytes:	2

Takte:	3

Aktion:	(USP) ← (Rs)

Kodierung:	1001 1000  ssss 1111
s = Register

Beispiel:	mov USP,r3 schreibt den Inhalt von Register 3 in den User Stackpointer. Der Hexcode lautet 98 3F.
Der vorstehende Befehl kann durch die folgende Schreibweise ersetzt werden:
USP = r3.


MOV C,bit
MOV	Move Bit to Carry

Syntax:	MOV  C, bit

Aktion:	C ← bit

Beschreibung:	MOV C,bit schreibt den Inhalt von bit in das Carry. Der Inhalt von bit  wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
C

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0010 00aa  bbbb bbbb
a = MSB Bitadresse,  b = LSB Bitadresse

Beispiel:	mov C,P2.3 schreibt den Zustand von P2.3 in das Carry und erzeugt den Hexcode 08 23 93.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle mov C,R5.10 und mov C,R5h.2 gleichwertig, sie erzeugen den Code 08 20 5A. Das gleiche gilt für die Bits im SFR-Bereich. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: mov C,S1CON.1 und mov C,TI_1 und mov C,321h.


MOV bit,C
MOV	Move Carry to Bit

Syntax:	MOV  bit, C

Aktion:	bit ← C

Beschreibung:	MOV bit,C schreibt das Carry nach bit. Der Inhalt von C wird nicht verändert.

Bits:	Es werden keine Bits verändert.

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0011 00aa  bbbb bbbb
a = MSB Bitadresse,  b = LSB Bitadresse

Beispiel:	mov P2.3,C schreibt das Carry nach P2.3 und erzeugt den Hexcode 08 33 93.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle mov R5.10,C und mov R5h.2,C gleichwertig, sie erzeugen den Code 08 30 5A. Das gleiche gilt für die Bits im SFR-Bereich. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: mov S1CON.1,C und mov TI_1,C und mov 321h,C.


MOVC Rd,[Rs+]
MOVC	Move Code

Syntax:	MOVC  Rd, [Rs+]

Aktion:	(Rd) ← Programmspeicher ((WS:Rs))
(Rd) ← (Rs) + 1 (Byte) oder + 2 (Word)

Beschreibung:	Inhalte des Programmspeichers werden in ein Register kopiert. Die Adresse der Daten steht in Rs. Rs wird nach einem Byte-Zugriff um eins, nach einem Word-Zugriff um zwei erhöht, so dass nachfolgende MOVC-Befehle ohne weiteren Softwareaufwand die nächsten Werte lesen. MOVC dient zum Auslesen von Tabellenwerten.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte oder Word/Word

Bytes:	2

Takte:	4

Kodierung:	1000 x000  dddd 0sss
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	mov r1,#2000h: movc r3,[r1+] liest ein Word aus der Adresse 2000h des Programmspeichers und schreibt den Inhalt in das Register 3. Der nächste Befehl movc r3,[r1+] liest ein Wort von der Adresse 2002h etc. Der Hexcode lautet 88 31.
mov r1,#2000h: movc r3l,[r1+] liest ein Byte aus der Adresse 2000h des Programmspeichers und schreibt den Inhalt in das Low-Byte des Register 3. Der nächste Befehl movc r3l,[r1+] liest ein Wort von der Adresse 2001h etc. Der Hexcode lautet 80 61.


MOVC A,[A+DPTR]
MOVC	Move Code to A (DPTR)

Syntax:	MOVC  A, [A+DPTR]

Aktion:	PC ← PC + 2
(A) ← Programmspeicher (PC.23-16: (A) + (DPTR))
bzw.
(R4L) ← Programmspeicher (PC.23-16:(R4L) + (R6))

Beschreibung:	Dieser Befehl wurde aus Kompatibilitätsgründen zum traditionellen 8051 aufgenommen und sollte bei neuer Softwareentwicklung nicht verwendet werden. Der Befehl bildet nach der Aktualisierung des Programmzählers die Summe aus Akku und Datenpointer DPTR, d.h. aus R4L und R6. Diese 16-Bit-Summe wird nun in den unteren Teil des Programmzählers geschrieben, ein Byte aus der so errechneten Adresse des Programmspeichers gelesen und in den Akku, d.h. nach Register 4 Low-Byte geschrieben.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte

Bytes:	2

Takte:	6

Kodierung:	1001 0000  0100 1110

Beispiel:	mov r6,#2000h: mov r4l,#0: movc a,[a+dptr] liest ein Byte aus der Adresse 2000h des Programmspeichers und schreibt den Inhalt in das Low-Byte des Register 4. Der Hexcode lautet 90 4E.


MOVC A,[A+PC]
MOVC	Move Code to A (PC)

Syntax:	MOVC  A, [A+PC]

Aktion:	PC ← PC + 2
(A) ← Programmspeicher (PC.23-16: (A + PC.15-0))

Beschreibung:	Dieser Befehl wurde aus Kompatibilitätsgründen zum traditionellen 8051 aufgenommen und sollte bei neuer Softwareentwicklung nicht verwendet werden. Der Befehl bildet nach der der Aktualisierung des Programmzählers die Summe aus Akku und Programmzähler, d.h. aus R4L und PC. Diese 16-Bit-Summe wird nun in den unteren Teil des Programmzählers geschrieben, ein Byte aus der so errechneten Adresse des Programmspeichers gelesen und in den Akku, d.h. nach Register 4 Low-Byte geschrieben.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte

Bytes:	2

Takte:	6

Kodierung:	1001 0000  0100 1100

Beispiel:	mov r4l,#20h: movc a,[a+pc] liest ein Byte aus der aktuellen Adresse + 20h des Programmspeichers und schreibt den Inhalt in das Low-Byte des Register 4. Der Hexcode lautet 90 4C.


MOVS-Befehl
MOVS	Move Short

Syntax:	MOVS  dest, #Konstante

Aktion:	dest ← #data4

Beschreibung:	Der Zahlenwert für data4 darf nur aus dem Intervall [-8; +7] sein. Dieser Zahlenwert wird bei einer Byte-Operation auf acht Bits und bei einer Word-Operation auf 16 Bits unter Berücksichtigung des Vorzeichens erweitert und anschließend nach dest geschrieben. Ist z.B. data4 = -2, so wird im Falle einer Byte-Operation -2 zu FEh und im Falle einer Word-Operation -2 zu FFFEh. Ist z.B. data4 = +5, so wird im Falle einer Byte-Operation dest mit 05h und im Falle einer Word-Operation dest mit 0005h beschrieben. Gedacht ist dieser Befehl hauptsächlich zum Schreiben von kleinen Konstanten, die Zeit und ROM-Platz sparen sollen.

Bits:	Folgende Bits werden aktualisiert:
N, Z
Ist dest das Low-Byte des Programmstatusworts PSWL, so überschreibt MOVS die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Operanden

MOVS Rd,#data4	Schreibt eine signierte 4-Bit-Konstante in ein Register.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← #data4

Kodierung:	1011 x001  dddd zzzz
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4

Beispiel:	movs r3,#4 ist eine Word-Addition und erzeugt den Hexcode B9 34.
movs r1l,#-2 ist eine Byte-Addition und erzeugt den Hexcode B1 2E.

MOVS [Rd],#data4	Schreibt eine signierte 4-Bit-Konstante in einen indirekt adressierten RAM-Platz. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Ohne dieses Suffix nimmt der Assembler einen Byte-Transfer vor. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	2

Takte:	3

Aktion:	((WS:Rd)) ← #data4

Kodierung:	1011 x010  0ddd zzzz
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4

Beispiel:	movs.w [r3],#4 ist ein Word-Transfer und erzeugt den Hexcode BA 34.
movs.b [r1],#-2 ist ein Byte-Transfer und erzeugt den Hexcode B2 1E.

MOVS [Rd+],#data4	Schreibt eine signierte 4-Bit-Konstante in einen indirekt adressierten RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, deren Inhalt anschließend inkrementiert wird. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Ohne dieses Suffix nimmt der Assembler einen Byte-Transfer vor.

Bytes:	2

Takte:	4

Aktion:	((WS:Rd)) ← #data4
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	1011 x011  0ddd zzzz
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4

Beispiel:	movs.w [r3+],#4 ist ein Word-Transfer und erzeugt den Hexcode BB 34.
movs.b [r1+],#-2 ist ein Byte-Transfer und erzeugt den Hexcode B3 1E.

MOVS [Rd+offset8],#data4	Schreibt eine signierte 4-Bit-Konstante in einen indirekt adressierten RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Ohne dieses Suffix nimmt der Assembler einen Byte-Transfer vor. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3

Takte:	5

Aktion:	((WS:Rd)+offset8) ← #data4

Kodierung:	1011 x100  0ddd zzzz oooo oooo
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4, o = offset8

Beispiel:	movs.w [r3+18],#4 ist ein Word-Transfer und erzeugt den Hexcode BC 34 12.
movs.b [r1-4],#-2 ist ein Byte-Transfer und erzeugt den Hexcode B4 1E FC.

MOVS [Rd+offset16],#data4	Schreibt eine signierte 4-Bit-Konstante in einen indirekt adressierten RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Ohne dieses Suffix nimmt der Assembler einen Byte-Transfer vor. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4

Takte:	5

Aktion:	((WS:Rd)+offset16) ← #data4

Kodierung:	1011 x101  0ddd zzzz oooo oooo  ffff ffff
Word: x = 1,  Byte: x = 0,  d = Register,  z = data4,  o = MSB offset16,  f = LSB offset16

Beispiel:	movs.w [r3+1859],#4 ist ein Word-Transfer und erzeugt den Hexcode BD 34 07 43.
movs.b [r1-2010],#-2 ist ein Byte-Transfer und erzeugt den Hexcode B5 1E F8 26.

MOVS direct,#data4	Schreibt eine signierte 4-Bit-Konstante in einen direct-RAM-Platz oder in ein SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet sich der Assembler für eine Byte-Operation.

Bytes:	3

Takte:	3

Aktion:	(direct) ← #data4

Kodierung:	1011 x110  0ddd zzzz  iiii iiii
Word: x = 1,  Byte: x = 0,  z = data4,  d = MSB direct,  i = LSB direct

Beispiel:	movs.w 140h,#5 ist ein Word-Transfer und erzeugt den Hexcode BE 15 40.
movs.b 140h,#-2 ist ein Byte-Transfer und erzeugt den Hexcode B6 1E 40.


MOVX-Befehl
MOVX	Move External Data

Syntax:	MOVX  dest, source

Beschreibung:	Der Befehl bewegt Daten zwischen einem Register und dem externen RAM. Im Gegensatz zum Standard-indirekt-MOV-Befehl, der auf das externe RAM nur oberhalb der internen RAM-Grenze zugreift, greift MOVX komplett auf das externe RAM im Adressbereich von 0 bis FFFFh (64K) zu. Allerdings operiert MOVX nur in den ersten 64K des externen Datenspeichers

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte oder Word/Word

Bytes:	2

Takte:	6

MOVX Rd,[Rs]	Schreibt einen indirekt adressierten externen RAM-Platz in ein Register. Als Zeiger dienen die Word-Register R0 bis R7.

Aktion:	(Rd) ← externer Datenspeicher ((Rs))

Kodierung:	1010 x111  dddd 0sss
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	mov r6,#10h: movx r3,[r6] schreibt ein Word aus der externen RAM-Adresse 0010h in das Register 3 und erzeugt den Hexcode AF 36.
mov r2,#10h: movx r1l,[r2] schreibt ein Byte aus der externen RAM-Adresse 0010h in das Low-Byte des Register 1 und erzeugt den Hexcode A7 22.

MOVX [Rd],Rs	Schreibt den Inhalt eines Registers in einen indirekt adressierten externen RAM-Platz. Als Zeiger dienen die Word-Register R0 bis R7.

Aktion:	externer Datenspeicher ((Rd)) ← (Rs)

Kodierung:	1010 x111  ssss 1ddd
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	mov r6,#10h: movx [r6],r3 schreibt den Inhalt von R3, ein Word, in die externe RAM-Adresse 0010h und erzeugt den Hexcode AF 3E.
mov r3,#10h: movx [r3],r1l schreibt den Inhalt von Register 1 Low-Byte in die externe RAM-Adresse 0010h und erzeugt den Hexcode A7 2B.


MUL-, MULU-Befehl
MUL, MULU	Signed, Unsigned Multiply

Syntax:	MUL(U)  dest, source

Aktion:	dest ← dest × source

Beschreibung:	dest wird mit source multipliziert und das Produkt nach dest geschrieben. dest muss die doppelte Größe von source haben (Word für Byte × Byte, DWord für Word × Word). Ein DWord-Register wird durch die Register R1:R0, R3:R2, R5:R4 oder R7:R6 gebildet.

Bits:	C, V, N, Z
Bei jeder Multiplikation wird das Carry gelöscht. Das Overflow-Bit V wird beim Auftreten der folgenden Bedingungen gesetzt, sonst gelöscht:

•  MULU.b: V wird gesetzt, wenn das Ergebnis einer Byte × Byte Multiplikation FFh überschreitet.

•  MULU.w: V wird gesetzt, wenn das Ergebnis einer Word × Word Multiplikation FFFFh überschreitet.

•  MUL.w: V wird gesetzt, wenn der Betrag einer signierten Word × Word Multiplikation 7FFFh überschreitet .

Größe:	Byte/Byte, Word/Word

Operanden

MUL.w  Rd,Rs	Signierte 16×16-Bit Multiplikation

Bytes:	2

Takte:	12

Aktion:	(Rd+1) ← High-Word von (Rd) × (Rs)
(Rd) ← Low-Word von (Rd) × (Rs)

Kodierung:	1110 0110  dddd ssss
d = Rd,  s = Rs

Beispiel:	r2=#1234h: r6=#15abh: mul.w r2,r6 multipliziert R2 mit R6 und speichert das Ergebnis 018A 6CBCh in R3:R2. (R3h) = 01h, (R3l) = 8Ah, (R2h) = 6Ch, (R2l) = BCh.
mul.w r2,r6 erzeugt den Hexcode E6 26.
Ist Rd ein ungeradzahliges Register, sieht das Ergebnis wie folgt aus: r3=#1234h: r6=#15abh: mul.w r3,r6 multipliziert R3 mit R6 und speichert nur das Low-Word des Produkts 018A 6CBCh in R3. (R3h) = 6Ch, (R3l) = BCh. Das High-Word geht verloren. Ein ungeradzahliges Register Rd kann also nur dann verwendet werden, wenn der Betrag des Produkts nicht größer als 7FFFh wird. Ein ungeradzahliges Register Rs hingegen liefert das vollständige Produkt, z.B. mul.w r2,r5.

MUL.w  Rd,#data16	Signierte 16×16-Bit Multiplikation

Bytes:	4

Takte:	12

Aktion:	(Rd+1) ← High-Word von (Rd) × #data16
(Rd) ← Low-Word von (Rd) × #data16

Kodierung:	1110 1001  dddd 1000  hhhh hhhh   llll llll
d = Word-Register,  h = MSB data16, l = LSB data16

Beispiel:	r2=#1234h: mul.w r2,#15abh multipliziert R2 mit der Zahl 15ABh und speichert das Ergebnis 018A 6CBCh in R3:R2. (R3h) = 01h, (R3l) = 8Ah, (R2h) = 6Ch, (R2l) = BCh.
mul.w r2,#15abh erzeugt den Hexcode E9 28 15 AB.
Ist Rd ein ungeradzahliges Register, sieht das Ergebnis wie folgt aus: r3=#1234h: mul.w r3,#15abh multipliziert R3 mit der Zahl 15ABh und speichert nur das Low-Word des Produkts 018A 6CBCh in R3. (R3h) = 6Ch, (R3l) = BCh. Das High-Word geht verloren. Ein ungeradzahliges Register Rd kann also nur dann verwendet werden, wenn das Produkt kleiner 10000h bleibt.

MULU.b  Rd,Rs	Unsignierte 8×8-Bit Multiplikation

Bytes:	2

Takte:	12

Aktion:	(RdH) ← MSB von (Rd) × (Rs)
(RdL) ← LSB von (Rd) × (Rs)

Kodierung:	1110 0000  dddd ssss
d = Byte-Register,  s = Byte-Register

Beispiel:	mov r2l,#FAh: mov r1l,#4: mulu.b r2l,r1l
multipliziert den Inhalt von R2L mit dem Inhalt von R1L und erzeugt den Hexcode E0 42. Das Produkt FAh × 4h = 3E8h findet sich mit Low-Byte E8h in R2L, mit High-Byte 03h in R2H.
Ist Rd das High-Byte eines Registers, z.B.
mov r2h,#FAh: mov r1l,#4: mulu.b r2h,r1l,
so wird das High-Byte des Produkts 03H nach R2H und das Low-Byte E8h nach R2L geschrieben, so dass das Ergebnis vollständig und richtig bleibt. Man beachte allerdings, dass das LSB des Produkts immer im Low-Register und das MSB immer im High-Register zu finden ist.
mulu.b r2l,r1l kann durch folgende Schreibweise ersetzt werden:
r2l *= r1l.b.

MULU.b  Rd,#data8	Unsignierte 8×8-Bit Multiplikation

Bytes:	3

Takte:	12

Aktion:	(RdH) ← MSB von (Rd) ×  #data8
(RdL) ← LSB von (Rd) ×  #data8

Kodierung:	1110 1000  dddd 0000  ssss ssss
d = Byte-Register,  s = #data8

Beispiel:	mov r2l,#FAh: mulu.b r2l,#4
multipliziert den Inhalt von R2L mit der Zahl 4 und erzeugt den Hexcode E8 40 04. Das Produkt FAh × 4h = 3E8h findet sich mit Low-Byte E8h in R2L, mit High-Byte 03h in R2H.
Ist Rd das High-Byte eines Registers, z.B.
mov r2h,#FAh: mulu.b r2h,#4,
so wird das High-Byte des Produkts 03H nach R2H und das Low-Byte E8h nach R2L geschrieben, so dass das Ergebnis vollständig und richtig bleibt. Man beachte allerdings, dass das LSB des Produkts immer im Low-Register und das MSB immer im High-Register zu finden ist.
mulu.b r2l,#4 kann durch folgende Schreibweise ersetzt werden:
r2l *= #4.b.

MULU.w  Rd,Rs	Unsignierte 16×16-Bit Multiplikation

Bytes:	2

Takte:	12

Aktion:	(Rd+1) ← High-Word von (Rd) × (Rs)
(Rd) ← Low-Word von (Rd) × (Rs)

Kodierung:	1110 0100  dddd ssss
d = Word-Register,  s = Word-Register

Beispiel:	mov r2,#3E45h: mov r0,#490h: mulu.w r2,r0
multipliziert den Inhalt von R2 mit dem Inhalt von R0 und erzeugt den Hexcode E4 20. Das Produkt 3E45h × 490h = 011C1AD0h findet sich mit High-Word 011Ch in R3 und mit Low-Word 1AD0h in R2.
Ist Rd ein ungeradzahliges Register, z.B.
mov r3,#3E45h: mov r0,#490h: mulu.w r3,r0,
so findet sich nur das Low-Word 1AD0h in Register 3, das High-Word geht verloren. Ein ungeradzahliges Register Rd kann also nur dann verwendet werden, wenn das Produkt nicht größer als FFFFh wird. Ein ungeradzahliges Register Rs hingegen liefert das vollständige Produkt, z.B. mul.w r2,r1.
mulu.w r2,r0 kann durch folgende Schreibweise ersetzt werden:
r2 *= r0.w.

MULU.w  Rd,#data16	Unsignierte 16×16-Bit Multiplikation

Bytes:	4

Takte:	12

Aktion:	(Rd+1) ← High-Word von (Rd) × #data16
(Rd) ← Low-Word von (Rd) × #data16

Kodierung:	1110 1001  dddd 0000  hhhh hhhh  llll llll
d = Word-Register,  h = #data16 High-Byte,  l = #data16 Low-Byte

Beispiel:	mov r2,#2007h: mulu.w r2,#FFE3h
multipliziert Register 2 mit der Zahl FFE3h und erzeugt den Hexcode E9 20 FF E3. Das Produkt 2007h × FFE3h = 20035F35h findet sich mit High-Word 2003h in R3 und mit Low-Word 5F35h in R2.
Ist Rd ein ungeradzahliges Register, z.B.
mov r3,#2007h: mulu.w r3,#FFE3h
so findet sich nur das Low-Word 5F35h in Register 3, das High-Word geht verloren. Ein ungeradzahliges Register Rd kann also nur dann verwendet werden, wenn das Produkt nicht größer als FFFFh wird.
mulu.w r2,#FFE3h kann durch folgende Schreibweise ersetzt werden:
r2 *= #FFE3h.w.


NEG-Befehl
NEG	Negate

Syntax:	NEG  Rd

Aktion:	(Rd) ← ¬(Rd) + 1

Beschreibung:	NEG erzeugt die Gegenzahl g (= Zweierkomplement) einer Zahl z, die in einem Register steht. Für die Gegenzahl g und die Zahl z gilt:  g + z = 0. Aus -4 wird +4, aus +4711 wird -4711. Der ähnliche CPL-Befehl invertiert lediglich alle Bits, liefert aber nicht das Zweierkomplement.

Bits:	Folgende Bits werden aktualisiert:
V, N, Z

Größe:	Byte/Byte, Word/Word

Bytes:	2

Takte:	3

Kodierung:	1001 x000  dddd 1011
Word: x = 1,  Byte: x = 0,  d = Register

Beispiel:	neg r4 ist ein Word-Befehl und erzeugt den Hexcode 98 4B.
neg r4l ist ein Byte-Befehl und erzeugt den Hexcode 90 8B.
Die Betragsbildung erfolgt mit
if bit r4.15 then
  neg r4
end if
Der Assembler gestattet die Abkürzung: r4 = -r4, bzw. r4l = -r4l.


NOP-Befehl
NOP	No Operation

Syntax:	NOP

Aktion:	(PC) ← (PC) + 1

Beschreibung:	NOP erhöht den Programmzähler PC um eins, so dass das Programm mit dem folgenden Befehl fortfährt. Außer dieser Aktion vollführt NOP nichts weiteres. NOP wird in den Programmcode eingefügt, um Sprungziele auf gerade Adressen zu legen. Diese Aktion führt der Assembler automatisch aus, der Programmierer braucht sich darum nicht zu kümmern. Ferner kann NOP für vorhersagbare Zeitverzögerungen im Programmablauf verwendet werden.

Bits:	Es werden keine Bits verändert.

Bytes:	1

Takte:	3

Kodierung:	0000 0000


NORM-Befehl
NORM	Normalize

Syntax:	NORM  Rd, Rs

Aktion:	count = 0
Do while (Rd.MSB = 0)
Rd.n+1 ← Rd.n
Rd.0 ← 0
count = count + 1
End while
Rs ← count

Beschreibung:	NORM schiebt den Inhalt von Rd solange nach links, bis das linke Bit eine Eins aufweist. Die Zahl der Schiebevorgänge wird in Rs gespeichert, das Negativ-Bit N gesetzt und das Zero-Bit Z gelöscht. Falls Rd nur Nullen aufweist, wird als Zahl der Schiebevorgänge der Wert Null übergeben, gleichzeitig wird das Negativ-Bit N gelöscht und das Zero-Bit Z gesetzt. Rs muss immer ein Byte-Register sein.
Der NORM-Befehl wird ausschließlich in Routinen zur Berechung von Fließkommazahlen verwendet, wo er eine Menge Programmcode und damit viel Zeit einsparen kann. Er normalisiert die Mantisse und übergibt in Rs die Exponentenkorrektur.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte, Word/Byte, DWord/Byte

Bytes:	2

Takte:	Für Byte und Word: 4  plus 1 für je zwei geschobenen Bits.
Für DWord: 6  plus 1 für je zwei geschobenen Bits.

Kodierung:	1100 xx11  dddd ssss
DWord: xx = 11, Word: xx = 10,  Byte: xx = 00,  d = Rd, s = Byte-Register

Beispiele:	norm r4h,r1l (oder norm.b r4h,r1l) ist ein Byte-Befehl und erzeugt den Hexcode C3 92.
norm r4,r1l (oder norm.w r4,r1l) ist ein Word-Befehl und erzeugt den Hexcode CB 42.
norm.d r4,r1l ist ein DWord-Befehl und erzeugt den Hexcode CF 42.

r4=#3: norm r4,r1l schiebt den Inhalt von R4 um 14 Stellen nach links. Danach steht in R4 der Wert C000h und in R1L der Wert 0Eh.


OR-Befehl
OR	Logisches Oder

Syntax:	OR  dest, source

Aktion:	dest ← dest ∨ source

Beschreibung:	OR führt eine bitweise logische ODER-Verknüpfung der Inhalte von source mit dest aus. Das Ergebnis steht in dest. Der Inhalt von source wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte oder Word/Word

Assembler:	dest |= source ist identisch zu or dest,source.

Operanden

OR Rd,Rs	Logisches ODER zweier Register

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) ∨ (Rs)

Kodierung:	0110 x001  dddd ssss
Word: x = 1,  Byte: x = 0

Beispiel:	or r3,r6 ist eine Word-Operation und erzeugt den Hexcode 69 36.
or r1L,r0H ist eine Byte-Operation und erzeugt den Hexcode 61 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 |= r6  bzw. r1l |= r0h.

OR Rd,[Rs]	Logisches ODER eines externen oder internen RAM-Platzes mit dem Register. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← (Rd) ∨ ((WS:Rs))

Kodierung:	0110 x010  dddd 0sss
Word: x = 1,  Byte: x = 0

Beispiel:	or r3,[r6] ist eine Word-Operation und erzeugt den Hexcode 6A 36.
or r1l,[r2] ist eine Byte-Operation und erzeugt den Hexcode 62 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 |= [r6] bzw. r1l |= [r2].

OR [Rd],Rs	Logisches ODER eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rd)) ∨ (Rs)

Kodierung:	0110 x010  ssss 1ddd
Word: x = 1,  Byte: x = 0

Beispiel:	or [r3],r6 ist eine Word-Operation und erzeugt den Hexcode 6A 6B.
or [r1],r2h ist eine Byte-Operation und erzeugt den Hexcode 62 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] |= r6 bzw. [r1] |= r2h.

OR Rd,[Rs+]	Logisches ODER eines externen oder internen RAM-Platzes mit einem Register. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) ← (Rd) ∨ ((WS:Rs))
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0110 x011  dddd 0sss
Word: x = 1,  Byte: x = 0

Beispiel:	or r3,[r6+] ist eine Word-Operation und erzeugt den Hexcode 6B 36.
or r1L,[r2+] ist eine Byte-Operation und erzeugt den Hexcode 63 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 |= [r6+] bzw. r1l |= [r2+].

OR [Rd+],Rs	Logisches ODER eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) ∨ (Rs)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0110 x011  ssss 1ddd
Word: x = 1,  Byte: x = 0

Beispiel:	or [r3+],r6 ist eine Word-Operation und erzeugt den Hexcode 6B 6B.
or [r1+],r2h ist eine Byte-Operation und erzeugt den Hexcode 63 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] |= r6 bzw. [r1+] |= r2h.

OR Rd,[Rs+offset8]
Logisches ODER eines indirekt adressierten externen oder internen RAM-Platzes mit einem Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) ← (Rd) ∨ ((WS:Rs) + offset8)

Kodierung:	0110 x100  dddd 0sss  oooo ooooo
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs, o = offset8

Beispiel:	or r3,[r6-2] ist eine Word-Operation und erzeugt den Hexcode 6C 36 FE.
or r1L,[r3+5] ist eine Byte-Operation und erzeugt den Hexcode 64 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 |= [r6-2] bzw. r1l |= [r3+5].

OR [Rd+offset8],Rs
Logisches ODER eines Registers mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd) + offset8) ← ((WS:Rs) + offset8) ∨ (Rs)

Kodierung:	0110 x100  ssss 1ddd  oooo ooooo
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs,  o = Offset-Bits

Beispiel:	or [r6-2],r3 ist eine Word-Operation und erzeugt den Hexcode 6C 3E FE.
or [r3+5],r7h ist eine Byte-Operation und erzeugt den Hexcode 64 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] |= r3 bzw. [r3+5] |= r7h.

OR Rd,[Rs+offset16]
Logisches ODER eines indirekt adressierten externen oder internen RAM-Platzes mit einem Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Lesen einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) ← (Rd) ∨ ((WS:Rs) + offset16)

Kodierung:	0110 x101  dddd 0sss  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs, h = high-offset16, l = low-offset16

Beispiel:	or r3,[r6-30546] ist eine Word-Operation und erzeugt den Hexcode 6D 36 88 AE.
or r1l,[r3+1125] ist eine Byte-Operation und erzeugt den Hexcode 65 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 |= [r6-30546] bzw. r1l |= [r3+1125].

OR [Rd+offset16],Rs
Logisches ODER eines Registers mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) ← ((WS:Rd) + offset16) ∨ (Rs)

Kodierung:	0110 x101  ssss 1ddd  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs, h = high-offset16, l = low-offset16

Beispiel:	or [r6-30546],r3 ist eine Word-Operation und erzeugt den Hexcode 6D 3E 88 AE.
or [r3+1125],r7h ist eine Byte-Operation und erzeugt den Hexcode 65 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] |= r3 bzw. [r3+5] |= r7h.

OR Rd,direct	Logisches ODER einer direct-Adresse oder eines SFRs mit einem Register.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (Rd) ∨ (direct)

Kodierung:	0110 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	or r3,2eh ist eine Word-Operation der direct-Adresse 2eh mit dem Register R3 und erzeugt den Hexcode 6E 30 2E.
or r1l,S0BUF ist eine Byte-Operation des seriellen Buffers mit Register 1 Low-Byte und erzeugt den Hexcode 66 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 |= 2eh bzw. r1l |= S0BUF.

OR direct,Rs	Logisches ODER eines Registers mit einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) ∨ (Rs)

Kodierung:	0110 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	or 1a3h,r6 ist eine Word-Operation der direct-Adresse 1a3h mit dem Register R6 und erzeugt den Hexcode 6E 69 A3.
or P2,r4h ist eine Byte-Operation von Port 2 mit dem Inhalt von Register 4 High-Byte und erzeugt den Hexcode 66 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h |= r6 bzw. P2 |= r4h.

OR Rd,#data	Logisches ODER eines Registers mit einer Zahl.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← (Rd) ∨ #data

Kodierung:	1001 x001  dddd 0110  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	or r3,#2eh ist eine Word-Operation von Register R3 mit der Zahl 2eh und erzeugt den Hexcode 99 36 00 2E.
or r1l,#2eh ist eine Byte-Operation von Register 1 Low-Byte mit der Zahl 2eh und erzeugt den Hexcode 91 26 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 |= #2eh bzw. r1l |= #2eh.

OR [Rd],#data	Logisches ODER eines indirekt adressierten RAM-Platz mit einer Zahl. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) ∨ #data

Kodierung:	1001 x010  0ddd 0110  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	or.w [r3],#2e7h (oder or [r3],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9A 36 02 E7.
or.b [r1],#2eh (oder or [r1],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 92 16 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] |= #2e7h.w bzw. [r1] |= #2eh.b.

OR [Rd+],#data
Logisches ODER eines indirekt adressierten RAM-Platz mit einer Zahl. Der Befehl inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) ∨ #data
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0110  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	or.w [r3+],#2e7h (oder or [r3+],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9B 36 02 E7.
or.b [r1+],#2eh (oder or [r1+],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 93 16 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] |= #2e7h.w bzw. [r1+] |= #2eh.b.

OR [Rd+offset8],#data
Logisches ODER einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) ∨ #data

Kodierung:	1001 x100  0ddd 0110  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	or.w [r3+16],#2e7h (oder or [r3+16],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz plus dem offset8 mit der Zahl 2e7h und erzeugt den Hexcode 9C 36 10 02 E7.
or.b [r1-8],#2eh (oder or [r1-8],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz plus dem offset8 mit der Zahl 2eh und erzeugt den Hexcode 94 16 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] |= #2e7h.w bzw. [r1-8] |= #2eh.b.

OR [Rd+offset16],#data
Logisches ODER einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) ∨ #data

Kodierung:	1001 x101  0ddd 0110  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	or.w [r3+165ah],#2e7h (oder or [r3+165ah],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz plus dem offset16 mit der Zahl 2e7h und erzeugt den Hexcode 9D 36 16 5A 02 E7.
or.b [r1-120h],#2eh (oder or [r1-120h],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz plus dem offset16 mit der Zahl 2eh und erzeugt den Hexcode 95 16 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] |= #2e7h.w bzw. [r1-120h] |= #2eh.b.

OR direct,#data
Logisches ODER einer Zahl mit einem direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) ← (direct) ∨ #data

Kodierung:	1001 x110  0ddd 0110  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	or.w 30h,#2e7h (oder or 30h,#2e7h) ist eine Word-Operation von dem RAM-Platz an Adresse 30h mit der Zahl 2e7h und erzeugt den Hexcode 9E 06 30 02 E7.
or.b 123h,#2eh (oder or 123h,#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 96 16 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h |= #2e7h.w bzw. 123h |= #2eh.b.


ORL-Befehl
ORL	Logisches ODER Bit mit Carry

Syntax:	ORL  C, bit

Aktion:	C ← C ∨ bit

Beschreibung:	ORL führt eine logische ODER-Verknüpfung von bit mit C aus. Das Ergebnis steht in C. Der Inhalt von bit  wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
C

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0110 00aa  bbbb bbbb
a = MSB Bitadresse,  b = LSB Bitadresse

Beispiel:	orl C,P2.3 erzeugt den Hexcode 08 63 93.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle orl C,R5.10 und orl C,R5h.2 gleichwertig, sie erzeugen den Code 08 60 5A. Das gleiche gilt für die Bits im SFR-Bereich. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: orl C,S1CON.1 und orl C,TI_1 und orl C,321h.


ORL/-Befehl
ORL	Logisches ODER Bitkomplement mit Carry

Syntax:	ORL  C, /bit

Aktion:	C ← C ∨ ¬bit

Beschreibung:	ORL führt eine logische ODER-Verknüpfung mit dem Komplement von bit mit C aus. Das Ergebnis steht in C. Der Inhalt von bit  wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
C

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0111 00aa  bbbb bbbb
a = MSB Bitadresse,  b = LSB Bitadresse

Beispiel:	orl C,/P2.3 erzeugt den Hexcode 08 73 93.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle orl C,/R5.10 und orl C,/R5h.2 gleichwertig, sie erzeugen den Code 08 70 5A. Das gleiche gilt für die Bits im SFR-Bereich. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: orl C,/S1CON.1 und orl C,/TI_1 und orl C,/321h.


POP-Befehl
POP(U)	Pop (User)

Syntax:	POP  dest

Beschreibung:	Der Befehl holt Daten vom Stack und legt sie in einer direct-Adresse oder in Registern ab. POP benutzt den Stackpointer, während  POPU den Userstackpointer benutzt.

Bits:	Es werden keine Bits verändert.

Größe:	Byte oder Word

POP direct	Holt ein Byte oder ein Word vom Stack und schreibt es in eine direct-Adresse oder in ein SFR. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	3

Takte:	5

Aktion:	(direct) ← ((SP))
(SP) ← (SP) + 2

Kodierung:	1000 x111  0001 0hhh  llll llll
Word: x = 1,  Byte: x = 0, h = MSB direct,  l = LSB direct

Beispiel:	pop.w 14Ah holt ein Word vom Stack und schreibt es an die direct-Adresse 14Ah. Der Befehl erzeugt den Hexcode 8F 11 4A.
pop.b P2 holt ein Byte vom Stack und schreibt es in Port 2. Der Befehl erzeugt den Hexcode 87 14 32.

POPU direct	Holt ein Byte oder ein Word vom Userstack und schreibt es in eine direct-Adresse oder in ein SFR. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	3

Takte:	5

Aktion:	(direct) ← ((USP))
(USP) ← (USP) + 2

Kodierung:	1000 x111  0000 0hhh  llll llll
Word: x = 1,  Byte: x = 0, h = MSB direct,  l = LSB direct

Beispiel:	popu.w 14Ah holt ein Word vom Userstack und schreibt es an die direct-Adresse 14Ah. Der Befehl erzeugt den Hexcode 8F 01 4A.
popu.b P2 holt ein Byte vom Userstack und schreibt es in Port 2. Der Befehl erzeugt den Hexcode 87 04 32.

POP Rlist	Holt mehrere Byte oder Word vom Stack und schreibt sie in die in Rlist genannten Register. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	2

Takte:	4 + 2 je Register

Aktion:	Wiederhole für alle gewählten Register Rn
(Rn) ← ((SP))
(SP) ← (SP) + 2

Kodierung:	0a10 x111  rrrr rrrr
a = 0: R0-R7 bzw. R0L-R3H,  a = 1: R8-R15 bzw. R4L-R7H,  Word: x = 1,  Byte: x = 0, r = Rlist

Beispiel:	pop r2,r3,r5 holt drei Word vom Stack und schreibt sie in die Register R2, R3 und R5. Der Befehl erzeugt den Hexcode 2F 2C. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0, Bit1 = R1, .. , Bit 7 = R7.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R8, Bit1 = R9, .. , Bit 7 = R15.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl pop r2,r3,r9 erzeugt eine Fehlermeldung.
pop r1l,r2l,r2h,r3l holt vier Byte vom Stack und schreibt sie in die Register R1L, R2L, R2H und R3L . Der Befehl erzeugt den Hexcode 27 74. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0L, Bit1 = R0H, .. , Bit 7 = R3H.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R4L, Bit1 = R4H, .. , Bit 7 = R7H.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl pop r2l,r3h,r5l erzeugt eine Fehlermeldung.

POPU Rlist	Holt mehrere Byte oder Word vom Userstack und schreibt sie in die in Rlist genannten Register. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	2

Takte:	4 + 2 je Register

Aktion:	Wiederhole für alle gewählten Register Rn
(Rn) ← ((USP))
(USP) ← (USP) + 2

Kodierung:	0a11 x111  rrrr rrrr
a = 0: R0-R7 bzw. R0L-R3H,  a = 1: R8-R15 bzw. R4L-R7H,  Word: x = 1,  Byte: x = 0, r = Rlist

Beispiel:	popu r2,r3,r5 holt drei Word vom Userstack und schreibt sie in die Register R2, R3 und R5. Der Befehl erzeugt den Hexcode 3F 2C. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0, Bit1 = R1, .. , Bit 7 = R7.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R8, Bit1 = R9, .. , Bit 7 = R15.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl popu r2,r3,r9 erzeugt eine Fehlermeldung.
popu r1l,r2l,r2h,r3l holt vier Byte vom Userstack und schreibt sie in die Register R1L, R2L, R2H und R3L . Der Befehl erzeugt den Hexcode 37 74. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0L, Bit1 = R0H, .. , Bit 7 = R3H.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R4L, Bit1 = R4H, .. , Bit 7 = R7H.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl popu r2l,r3h,r5l erzeugt eine Fehlermeldung.


PUSH-Befehl
PUSH(U)	Push (User)

Syntax:	PUSH  source

Beschreibung:	Der Befehl liest Daten aus einer direct-Adresse oder aus Registern und legt sie auf dem Stack ab. PUSH benutzt den Stackpointer, während  PUSHU den Userstackpointer benutzt.

Bits:	Es werden keine Bits verändert.

Größe:	Byte oder Word

PUSH direct	Legt ein Byte oder ein Word aus einer direct-Adresse oder aus ein SFR auf dem Stack ab. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	3

Takte:	5

Aktion:	(SP) ← (SP) - 2
((SP)) ← (direct)

Kodierung:	1000 x111  0011 0hhh  llll llll
Word: x = 1,  Byte: x = 0, h = MSB direct,  l = LSB direct

Beispiel:	push.w 14Ah holt ein Word aus der direct-Adresse 14Ah und legt es auf dem Stack ab. Der Befehl erzeugt den Hexcode 8F 31 4A.
push.b P2 legt den Inhalt von Port 2 auf den Stack ab. Der Befehl erzeugt den Hexcode 87 34 32.

PUSHU direct	Legt ein Byte oder ein Word aus einer direct-Adresse oder aus ein SFR auf dem Userstack ab. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	3

Takte:	5

Aktion:	(USP) ← (USP) - 2
((USP)) ← (direct)

Kodierung:	1000 x111  0010 0hhh  llll llll
Word: x = 1,  Byte: x = 0, h = MSB direct,  l = LSB direct

Beispiel:	pushu.w 14Ah holt ein Word aus der direct-Adresse 14Ah und legt es auf dem Userstack ab. Der Befehl erzeugt den Hexcode 8F 21 4A.
pushu.b P2 legt den Inhalt von Port 2 auf den Userstack ab. Der Befehl erzeugt den Hexcode 87 24 32.

PUSH Rlist	Legt mehrere Register auf dem Stack ab. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	2

Takte:	3 + 3 je Register

Aktion:	Wiederhole für alle gewählten Register Rn
(SP) ← (SP) - 2
((SP)) ← (Rn)

Kodierung:	0a00 x111  rrrr rrrr
a = 0: R0-R7 bzw. R0L-R3H,  a = 1: R8-R15 bzw. R4L-R7H,  Word: x = 1,  Byte: x = 0, r = Rlist

Beispiel:	push r2,r3,r5 legt die Inhalte der Register R2, R3 und R5 auf dem Stack ab. Der Befehl erzeugt den Hexcode 0F 2C. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0, Bit1 = R1, .. , Bit 7 = R7.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R8, Bit1 = R9, .. , Bit 7 = R15.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl push r2,r3,r9 erzeugt eine Fehlermeldung.
push r1l,r2l,r2h,r3l legt die Inhalte der Register R1L, R2L, R2H und R3L auf dem Stack ab. Der Befehl erzeugt den Hexcode 07 74. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0L, Bit1 = R0H, .. , Bit 7 = R3H.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R4L, Bit1 = R4H, .. , Bit 7 = R7H.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl push r2l,r3h,r5l erzeugt eine Fehlermeldung. Die Reihenfolge auf dem Stack ist von links nach rechts in Rlist.

PUSHU Rlist	Legt mehrere Register auf dem Userstack ab. Die Datengröße muss dem Assembler durch das Suffix .b bzw. .w mitgeteilt werden.

Bytes:	2

Takte:	3 + 3 je Register

Aktion:	Wiederhole für alle gewählten Register Rn
(USP) ← (USP) - 2
((USP)) ← (Rn)

Kodierung:	0a01 x111  rrrr rrrr
a = 0: R0-R7 bzw. R0L-R3H,  a = 1: R8-R15 bzw. R4L-R7H,  Word: x = 1,  Byte: x = 0, r = Rlist

Beispiel:	pushu r2,r3,r5 legt die Inhalte der Register R2, R3 und R5 auf dem Userstack ab. Der Befehl erzeugt den Hexcode 1F 2C. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0, Bit1 = R1, .. , Bit 7 = R7.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R8, Bit1 = R9, .. , Bit 7 = R15.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl pushu r2,r3,r9 erzeugt eine Fehlermeldung.
pushu r4l,r5l,r6h,r7l legt die Inhalte der Register R4L, R5L, R6H und R7L auf dem Userstack ab. Der Befehl erzeugt den Hexcode 57 65. Jedes gesetzte Bit in Rlist entspricht einem gewählten Register. Wenn a = 0, dann gilt die Zuordnung: Bit0 = R0L, Bit1 = R0H, .. , Bit 7 = R3H.  Wenn a = 1, dann gilt die Zuordnung: Bit0 = R4L, Bit1 = R4H, .. , Bit 7 = R7H.  Eine Mischung der Bereiche ist nicht möglich. Der Befehl pushu r2l,r3h,r5l erzeugt eine Fehlermeldung. Die Reihenfolge auf dem Stack ist von links nach rechts in Rlist.


RESET-Befehl
RESET	Sotware Reset

Syntax:	RESET

Aktion:	(PC) ← vector(0)
(PSW) ← vector(0)
(SFRs) ← Resetwerte

Beschreibung:	Es wird ein Reset ausgeführt, der sich von einem externen Reset nur dadurch unterscheidet, dass die Eingangspins, die den Chip konfigurieren, nicht abgefragt werden, z.B. EA, BUSW etc. Ferner wird auch kein Reset-Impuls nach außen hin abgegeben.

Bits:	Alle Bits des Programmstatuswort werden mit dem Inhalt des Resetvektors aktualisiert.

Bytes:	2

Takte:	19

Kodierung:	1101 0110  0001 0000

Beispiel:	reset erzeugt den Hexcode D6 10.


RET-Befehl
RET	Return from Subroutine

Syntax:	RET

Aktion:	(PC) ← ((SP))
(SP) ← (SP) + 4

Beschreibung:	Eine 24-Bit Return-Adresse, die beim Subroutinenaufruf auf den Stack gelegt wurde, wird vom Stack geholt und in den Programmzähler geschrieben. Ist der XA-Controller im Page 0 Modus, wird nur eine 16-Bit Adresse geholt. RET muss zum Abbruch von Subroutinen, die mit CALL oder FCALL aufgerufen wurden, verwendet werden.

Bits:	Keine Änderung von Bits.

Bytes:	2

Takte:	8,  6 im Zeropage-Modus

Kodierung:	1101 0110  1000 0000

Beispiel:	ret erzeugt den Hexcode D6 80.


RETI-Befehl
RETI	Return from Interrupt

Syntax:	RETI

Aktion:	(PSW) ← ((SSP))
(PC) ← ((SSP))
(SSP) ← (SSP) + 6

Beschreibung:	Eine 24-Bit Return-Adresse, die beim Interruptaufruf auf den Stack gelegt wurde, wird vom Stack geholt und in den Programmzähler geschrieben. Auch das ursprüngliche Programmstatuswort wird wiederhergestellt. RETI erfüllt seine Aufgabe nur im Systemmodus, im Usermodus erzeugt RETI einen Trap.
Ist der XA-Controller im Page 0 Modus, wird nur eine 16-Bit Adresse geholt. RET muss zum Abbruch von Subroutinen, die mit CALL oder FCALL aufgerufen wurden, verwendet werden.

Bits:	Wiederherstellung aller Bits vor dem Interrupt. Im Usermodus werden die geschützten Bits des PSW nicht geändert.

Bytes:	2

Takte:	10,  8 im Zeropage-Modus

Kodierung:	1101 0110  1001 0000

Beispiel:	reti erzeugt den Hexcode D6 90.


RL-Befehl
RL	Rotate Left

Syntax:	RL  Rd, #data4

Aktion:	count ← data4
do while (count > 0)
Rd.0 ← Rd.MSB
Rd.n ← Rd.n-1
count ← count - 1
end while

Beschreibung:	Das Register Rd wird data4-mal bitweise nach links rotiert. Das höchste Bit gelangt jeweils in das Bit 0. data4 kann die Werte von 0 bis 15 aufweisen.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte, Word

Bytes:	2

Takte:	4  plus 1 für je zwei rotierte Bits

Kodierung:	1101 x011  dddd zzzz
Word: x = 1,  Byte: x = 0, d = Rd,  z = data4

Beispiel:	mov r4,#27Ah: rl r4,#9 ist ein Word-Befehl und erzeugt den Hexcode DB 49. Danach steht in R4 der Wert 7404h.
mov r4l,#7Ah: rl r4l,#4 ist ein Byte-Befehl und erzeugt den Hexcode D3 84. Danach steht in R4L der Wert A7h. rl r4l,#4 vertauscht also die Nibbles im Byte R4L und ersetzt den SWAP-Befehl der 8051-Controller.


RLC-Befehl
RLC	Rotate Left through Carry

Syntax:	RLC  Rd, #data4

Aktion:	count ← data4
do while (count > 0)
C ← Rd.MSB
Rd.n ← Rd.n-1
Rd.0 ← C
count ← count - 1
end while

Beschreibung:	Das Register Rd wird data4-mal bitweise durch das Carry nach links rotiert. Das höchste Bit gelangt jeweils in das Carry, das mit seinem alten Zustand in das Bit 0 geschrieben wird. data4 kann die Werte von 0 bis 15 aufweisen.

Bits:	Folgende Bits werden aktualisiert:
C, N, Z

Größe:	Byte, Word

Bytes:	2

Takte:	4  plus 1 für je zwei rotierte Bits

Kodierung:	1101 x111  dddd zzzz
Word: x = 1,  Byte: x = 0, d = Rd,  z = data4

Beispiel:	rlc r4,#9 ist ein Word-Befehl und erzeugt den Hexcode DF 49.
rlc r4l,#4 ist ein Byte-Befehl und erzeugt den Hexcode D7 84.


RR-Befehl
RR	Rotate Right

Syntax:	RR  Rd, #data4

Aktion:	count ← data4
do while (count > 0)
Rd.MSB ← Rd.0
Rd.n-1 ← Rd.n
count ← count - 1
end while

Beschreibung:	Das Register Rd wird data4-mal bitweise nach rechts rotiert. Das Bit 0 gelangt jeweils in das höchste Bit. data4 kann die Werte von 0 bis 15 aufweisen.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte, Word

Bytes:	2

Takte:	4  plus 1 für je zwei rotierte Bits

Kodierung:	1011 x000  dddd zzzz
Word: x = 1,  Byte: x = 0, d = Rd,  z = data4

Beispiel:	mov r4,#027Ah: rr r4,#8 ist ein Word-Befehl und erzeugt den Hexcode B8 48. Danach steht in R4 der Wert 7A02h, es wurden also MSB und LSB vertauscht.
mov r4l,#7Ah: rr r4l,#4 ist ein Byte-Befehl und erzeugt den Hexcode B0 84. Danach steht in R4L der Wert A7h. rr r4l,#4 vertauscht also die Nibbles im Byte R4L und ersetzt den SWAP-Befehl der 8051-Controller.


RRC-Befehl
RRC	Rotate Right through Carry

Syntax:	RRC  Rd, #data4

Aktion:	count ← data4
do while (count > 0)
C ← Rd.0
Rd.n-1 ← Rd.n
Rd.MSB ← C
count ← count - 1
end while

Beschreibung:	Das Register Rd wird data4-mal bitweise durch das Carry nach rechts rotiert. Bit 0 gelangt jeweils in das Carry, das mit seinem alten Zustand in das höchste Bit geschrieben wird. data4 kann die Werte von 0 bis 15 aufweisen.

Bits:	Folgende Bits werden aktualisiert:
C, N, Z

Größe:	Byte, Word

Bytes:	2

Takte:	4  plus 1 für je zwei rotierte Bits

Kodierung:	1011 x111  dddd zzzz
Word: x = 1,  Byte: x = 0, d = Rd,  z = data4

Beispiel:	rrc r4,#9 ist ein Word-Befehl und erzeugt den Hexcode BF 49.
rrc r4l,#4 ist ein Byte-Befehl und erzeugt den Hexcode B7 84.


SETB-Befehl
SETB	Set Bit

Syntax:	SETB  Bit

Aktion:	(bit) ← 1

Beschreibung:	In das mit Bit genannte Bit wird eine Eins geschrieben.

Bits:	Kein Änderung des Programmstatusworts, es sei denn, Bit liegt im Programmstatuswort.

Größe:	Bit

Bytes:	3

Takte:	4

Kodierung:	0000 1000  0001 00aa  bbbb bbbb
a = MSB der Bitadresse (1a = SFR-Bit, 0a = RAM-Bit), b = LSB der Bitadresse

Beispiel:	setb 132h setzt das Bit an der Bitadresse 132h (= Bit 2 in der internen RAM-Adresse 23h) und erzeugt den Hexcode 08 11 32.

Assembler:	Als Bitadresse können Sie auch eine Registerbezeichnung und der durch einen Punkt getrennten Bitnummer angeben. Somit sind die beiden Befehle setb R5.10 und setb R5h.2 gleichwertig, sie erzeugen den Code 08 10 5A. Das gleiche gilt für die Bits im SFR-Bereich. Das dritte Bit von Port 2 lässt sich mit setb P2.3 setzen. Hier haben Sie ferner die Wahl zwischen der Registernummerierung und dem Bitnamen. Daher sind folgenden drei Befehle gleichwertig: setb S1CON.1 und setb TI_1 und setb 321h.

Siehe auch: CLR


SEXT-Befehl
SEXT	Sign Extend

Syntax:	SEXT  Rd

Aktion:	if N = 1 then
(Rd) ← FFh (Byte) oder FFFFh (Word)
if N = 0 then
(Rd) ← 00h (Byte) oder 0000h (Word)

Beschreibung:	Füllt das Register Rd mit dem Negative-Bit N, dem Vorzeichen der letzten ALU-Operation, auf.

Bits:	Kein Änderung des Programmstatusworts.

Größe:	Byte, Word

Bytes:	2

Takte:	3

Kodierung:	1001 x000  dddd 1001
Word: x = 1,  Byte: x = 0, d = Rd

Beispiel:	sext r2 schreibt FFFFh in das Register 2, wenn das N-Flag gesetzt ist, sonst 0000h und erzeugt den Hexcode 98 29.
sext r2l schreibt FFh in das Register 2 Low-Byte, wenn das N-Flag gesetzt ist, sonst 00h und erzeugt den Hexcode 90 49.


SUB-Befehl
SUB	Integersubtraktion

Syntax:	SUB  dest, source

Aktion:	dest ← dest - source

Beschreibung:	SUB führt die Subtraktion von signierten als auch unsignierten Zahlen aus. Es werden die Inhalte von dest und source subtrahiert, das Ergebnis steht in dest. Der Inhalt von source wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
C, AC, V, N, Z
Ist dest das Low-Byte des Programmstatusworts PSWL, so überschreibt das Subtraktionsergebnis die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Assembler:	dest -= source ist identisch zu sub dest,source.

Operanden

SUB Rd,Rs	Subtrahiert den Inhalt zweier Register.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) - (Rs)

Kodierung:	0010 x001  dddd ssss
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	sub r3,r6 ist eine Word-Subtraktion und erzeugt den Hexcode 29 36.
sub r1l,r0h ist eine Byte-Subtraktion und erzeugt den Hexcode 21 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= r6 bzw. r1l -= r0h.

SUB Rd,[Rs]	Subtrahiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes vom Register Rd. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← (Rd) - ((WS:Rs))

Kodierung:	0010 x010  dddd 0sss
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	sub r3,[r6] ist eine Word-Subtraktion und erzeugt den Hexcode 2A 36.
sub r1l,[r2] ist eine Byte-Subtraktion und erzeugt den Hexcode 22 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= [r6] bzw. r1l -= [r2].

SUB [Rd],Rs	Subtrahiert indirekt den Inhalt eines Registers von einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rd)) - (Rs)

Kodierung:	0010 x010  ssss 1ddd
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	sub [r3],r6 ist eine Word-Subtraktion und erzeugt den Hexcode 2A 6B.
sub [r1],r2h ist eine Byte-Subtraktion und erzeugt den Hexcode 22 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] -= r6 bzw. [r1] -= r2h.

SUB Rd,[Rs+]	Subtrahiert indirekt den Inhalt eines externen oder internen RAM-Platzes vom Register Rd. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) ← (Rd) - ((WS:Rs))
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0010 x011  dddd 0sss
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	sub r3,[r6+] ist eine Word-Subtraktion und erzeugt den Hexcode 2B 36.
sub r1l,[r2+] ist eine Byte-Subtraktion und erzeugt den Hexcode 23 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= [r6+] bzw. r1l -= [r2+].

SUB [Rd+],Rs	Subtrahiert indirekt den Inhalt eines Registers von einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) - (Rs)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0010 x011  ssss 1ddd
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs

Beispiel:	sub [r3+],r6 ist eine Word-Subtraktion und erzeugt den Hexcode 2B 6B.
sub [r1+],r2h ist eine Byte-Subtraktion und erzeugt den Hexcode 23 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] -= r6 bzw. [r1+] -= r2h.

SUB Rd,[Rs+offset8]
Subtrahiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes vom Register Rd. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) ← (Rd) - ((WS:Rs) + offset8)

Kodierung:	0010 x100  dddd 0sss  oooo ooooo
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs, o = Offset-Bits

Beispiel:	sub r3,[r6-2] ist eine Word-Subtraktion und erzeugt den Hexcode 2C 36 FE.
sub r1l,[r3+5] ist eine Byte-Subtraktion und erzeugt den Hexcode 24 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= [r6-2] bzw. r1l -= [r3+5].

SUB [Rd+offset8],Rs
Subtrahiert den Inhalt eines Registers von einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd) + offset8) ← ((WS:Rs) + offset8) - (Rs)

Kodierung:	0010 x100  ssss 1ddd  oooo ooooo
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs, o = Offset-Bits

Beispiel:	sub [r6-2],r3 ist eine Word-Subtraktion und erzeugt den Hexcode 2C 3E FE.
sub [r3+5],r7h ist eine Byte-Subtraktion und erzeugt den Hexcode 24 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] -= r3 bzw. [r3+5] -= r7h.

SUB Rd,[Rs+offset16]
Subtrahiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes vom Register Rd. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Rechnen mt einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) ← (Rd) - ((WS:Rs) + offset16)

Kodierung:	0010 x101  dddd 0sss  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	sub r3,[r6-30546] ist eine Word-Subtraktion und erzeugt den Hexcode 2D 36 88 AE.
sub r1l,[r3+1125] ist eine Byte-Subtraktion und erzeugt den Hexcode 25 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= [r6-30546] bzw. r1l -= [r3+1125].

SUB [Rd+offset16],Rs
Subtrahiert den Inhalt eines Registers von einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Rechnen mit einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) ← ((WS:Rd) + offset16) - (Rs)

Kodierung:	0010 x101  ssss 1ddd  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	sub [r6-30546],r3 ist eine Word-Subtraktion und erzeugt den Hexcode 2D 3E 88 AE.
sub [r3+1125],r7h ist eine Byte-Subtraktion und erzeugt den Hexcode 25 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] -= r3 bzw. [r3+5] -= r7h.

SUB Rd,direct	Subtrahiert den Inhalt einer direct-Adresse oder eines SFRs vom Register Rd.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (Rd) - (direct)

Kodierung:	0010 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	sub r3,2eh ist eine Word-Subtraktion der direct-Adresse 2eh vom Register R3 und erzeugt den Hexcode 2E 30 2E.
sub r1l,S0BUF ist eine Byte-Subtraktion des seriellen Buffers vom Register 1 Low-Byte und erzeugt den Hexcode 26 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= 2eh bzw. r1l -= S0BUF.

SUB direct,Rs	Subtrahiert den Inhalt eines Registers von einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) - (Rs)

Kodierung:	0010 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	sub 1a3h,r6 ist eine Word-Subtraktion der direct-Adresse 1a3h mit dem Register R6 und erzeugt den Hexcode 2E 69 A3.
sub P2,r4h ist eine Byte-Subtraktion von Port2 mit dem Inhalt von Register 4 High-Byte und erzeugt den Hexcode 26 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h -= r6 bzw. P2 -= r4h.

SUB Rd,#data	Subtrahiert eine Zahl vom Register Rd.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← (Rd) - #data

Kodierung:	1001 x001  dddd 0010  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	sub r3,#2eh ist eine Word-Subtraktion von Register R3 und der Zahl 2eh und erzeugt den Hexcode 99 32 00 2E.
sub r1l,#2eh ist eine Byte-Subtraktion von Register 1 Low-Byte mit der Zahl 2eh und erzeugt den Hexcode 91 22 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= #2eh bzw. r1l -= #2eh.

SUB [Rd],#data	Subtrahiert eine Zahl von einem indirekt adressierten RAM-Platz. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) - #data

Kodierung:	1001 x010  0ddd 0010  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	sub.w [r3],#2e7h (oder sub [r3],#2e7h) ist eine Word-Subtraktion von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9A 32 02 E7.
sub.b [r1],#2eh (oder sub [r1],#2eh) ist eine Byte-Subtraktion von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 92 12 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] -= #2e7h.w bzw. [r1] -= #2eh.b.

SUB [Rd+],#data
Subtrahiert eine Zahl von einem indirekt adressierten RAM-Platz und inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) - #data
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0010  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	sub.w [r3+],#2e7h (oder sub [r3+],#2e7h) ist eine Word-Subtraktion von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9B 32 02 E7.
sub.b [r1+],#2eh (oder sub [r1+],#2eh) ist eine Byte-Subtraktion von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 93 12 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] -= #2e7h.w bzw. [r1+] -= #2eh.b.

SUB [Rd+offset8],#data
Subtrahiert eine Zahl von einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) - #data

Kodierung:	1001 x100  0ddd 0010  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	sub.w [r3+16],#2e7h (oder sub [r3+16],#2e7h) ist eine Word-Subtraktion von dem mit R3 adressierten RAM-Platz plus dem offset8 minus der Zahl 2e7h und erzeugt den Hexcode 9C 32 10 02 E7.
sub.b [r1-8],#2eh (oder sub [r1-8],#2eh) ist eine Byte-Subtraktion von dem mit R1 adressierten RAM-Platz plus dem offset8 minus der Zahl 2eh und erzeugt den Hexcode 94 12 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] -= #2e7h.w bzw. [r1-8] -= #2eh.b.

SUB [Rd+offset16],#data
Subtrahiert eine Zahl von einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) - #data

Kodierung:	1001 x101  0ddd 0010  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	sub.w [r3+165ah],#2e7h (oder sub [r3+165ah],#2e7h) ist eine Word-Subtraktion von dem mit R3 adressierten RAM-Platz plus dem offset16 minus der Zahl 2e7h und erzeugt den Hexcode 9D 32 16 5A 02 E7.
sub.b [r1-120h],#2eh (oder sub [r1-120h],#2eh) ist eine Byte-Subtraktion von dem mit R1 adressierten RAM-Platz plus dem offset16 minus der Zahl 2eh und erzeugt den Hexcode 95 12 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] -= #2e7h.w bzw. [r1-120h] -= #2eh.b.

SUB direct,#data
Subtrahiert eine Zahl von einem direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) ← (direct) - #data

Kodierung:	1001 x110  0ddd 0010  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	sub.w 30h,#2e7h (oder sub 30h,#2e7h) ist eine Word-Subtraktion von dem RAM-Platz an Adresse 30h und der Zahl 2e7h und erzeugt den Hexcode 9E 02 30 02 E7.
sub.b 123h,#2eh (oder sub 123h,#2eh) ist eine Byte-Subtraktion von dem mit R1 adressierten RAM-Platz und der Zahl 2eh und erzeugt den Hexcode 96 12 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h -= #2e7h.w bzw. 123h -= #2eh.b.


SUBB-Befehl
SUBB	Integersubtraktion mit Übertrag

Syntax:	SUBB  dest, source

Aktion:	dest ← dest - source - C

Beschreibung:	SUBB führt die Subtraktion von signierten als auch unsignierten Zahlen unter Einbeziehung des zuvor aktualisierten Carrys aus. Es werden die Inhalte von dest und source und C subtrahiert, das Ergebnis steht in dest. Der Inhalt von source wird nicht verändert. Ist das Carry eine Eins, so ist auch die Differenz von dest und source um eins kleiner, ist das Carry eine Null, so entspricht der SUBB-Befehl dem SUB-Befehl. SUBB wird für eine mehrfachgenaue Subtraktion verwendet, bei der das Carry vor der ersten Subtraktion gelöscht wird. Die Integerzahlen werden danach vom LSB zum MSB mit SUBB subtrahiert.

Bits:	Folgende Bits werden aktualisiert:
C, AC, V, N, Z
Ist dest das Low-Byte des Programmstatusworts PSWL, so überschreibt das Subtraktionsergebnis die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Assembler:	dest -= -C source ist identisch zu subb dest,source.

Operanden

SUBB Rd,Rs	Subtrahiert den Inhalt zweier Register mit Carry.

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) - (Rs) - (C)

Kodierung:	0011 x001  dddd ssss
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs

Beispiel:	subb r3,r6 ist eine Word-Subtraktion und erzeugt den Hexcode 39 36.
subb r1l,r0h ist eine Byte-Subtraktion und erzeugt den Hexcode 31 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= -C r6 bzw. r1l -= -C r0h.

SUBB Rd,[Rs]	Subtrahiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes von einem Register mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← (Rd) - ((WS:Rs)) - (C)

Kodierung:	0011 x010  dddd 0sss
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs

Beispiel:	subb r3,[r6] ist eine Word-Subtraktion und erzeugt den Hexcode 3A 36.
subb r1l,[r2] ist eine Byte-Subtraktion und erzeugt den Hexcode 32 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= -C [r6] bzw. r1l -= -C [r2].

SUBB [Rd],Rs	Subtrahiert den Inhalt eines Registers von einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rd)) - (Rs) - (C)

Kodierung:	0011 x010  ssss 1ddd
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs

Beispiel:	subb [r3],r6 ist eine Word-Subtraktion und erzeugt den Hexcode 3A 6B.
subb [r1],r2h ist eine Byte-Subtraktion und erzeugt den Hexcode 32 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] -= -C r6 bzw. [r1] -= -C r2h.

SUBB Rd,[Rs+]	Subtrahiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes von einem Register mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) ← (Rd) - ((WS:Rs)) - (C)
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0011 x011  dddd 0sss
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs

Beispiel:	subb r3,[r6+] ist eine Word-Subtraktion und erzeugt den Hexcode 3B 36.
subb r1L,[r2+] ist eine Byte-Subtraktion und erzeugt den Hexcode 33 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= -C [r6+] bzw. r1l -= -C [r2+].

SUBB [Rd+],Rs	Subtrahiert den Inhalt eines Registers von einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) - (Rs) - (C)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0011 x011  ssss 1ddd
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs

Beispiel:	subb [r3+],r6 ist eine Word-Subtraktion und erzeugt den Hexcode 3B 6B.
subb [r1+],r2h ist eine Byte-Subtraktion und erzeugt den Hexcode 33 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] -= -C r6 bzw. [r1+] -= -C r2h.

SUBB Rd,[Rs+offset8]
Subtrahiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes von einem Register mit Carry. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) ← (Rd) - ((WS:Rs) + offset8) - (C)

Kodierung:	0011 x100  dddd 0sss  oooo ooooo
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs,  o = Offset-Bits

Beispiel:	subb r3,[r6-2] ist eine Word-Subtraktion und erzeugt den Hexcode 3C 36 FE.
subb r1l,[r3+5] ist eine Byte-Subtraktion und erzeugt den Hexcode 34 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= -C [r6-2] bzw. r1l -= -C [r3+5].

SUBB [Rd+offset8],Rs
Subtrahiert den Inhalt eines Registers von einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd) + offset8) ← ((WS:Rs) + offset8) - (Rs) - (C)

Kodierung:	0011 x100  ssss 1ddd  oooo ooooo
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs, o = Offset-Bits

Beispiel:	subb [r6-2],r3 ist eine Word-Subtraktion und erzeugt den Hexcode 3C 3E FE.
subb [r3+5],r7h ist eine Byte-Subtraktion und erzeugt den Hexcode 34 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] -= -C r3 bzw. [r3+5] -= -C r7H .

SUBB Rd,[Rs+offset16]
Subtrahiert den Inhalt eines indirekt adressierten externen oder internen RAM-Platzes von einem Register mit Carry. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Lesen einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) ← (Rd) - ((WS:Rs) + offset16) - (C)

Kodierung:	0011 x101  dddd 0sss  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	subb r3,[r6-30546] ist eine Word-Subtraktion und erzeugt den Hexcode 3D 36 88 AE.
subb r1l,[r3+1125] ist eine Byte-Subtraktion und erzeugt den Hexcode 35 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= -C [r6-30546] bzw. r1l -= -C [r3+1125].

SUBB [Rd+offset16],Rs
Subtrahiert den Inhalt eines Registers von einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) ← ((WS:Rd) + offset16) - (Rs) - (C)

Kodierung:	0011 x101  ssss 1ddd  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs, h = high-Offset-Bits, l = low-Offset-Bits

Beispiel:	subb [r6-30546],r3 ist eine Word-Subtraktion und erzeugt den Hexcode 3D 3E 88 AE.
subb [r3+1125],r7h ist eine Byte-Subtraktion und erzeugt den Hexcode 35 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] -= -C r3 bzw. [r3+5] -= -C r7h.

SUBB Rd,direct	Subtrahiert den Inhalt einer direct-Adresse oder eines SFRs von einem Register mit Carry.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (Rd) - (direct) - (C)

Kodierung:	0011 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	subb r3,2eh ist eine Word-Subtraktion der direct-Adresse 2eh von dem Register R3 und erzeugt den Hexcode 3E 30 2E.
subb r1l,S0BUF ist eine Byte-Subtraktion des seriellen Buffers von dem Register 1 Low-Byte und erzeugt den Hexcode 36 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= -C 2eh bzw. r1l -= -C S0BUF.

SUBB direct,Rs	Subtrahiert den Inhalt eines Registers von einer direct-Adresse oder einem SFR mit Carry.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) - (Rs) - (C)

Kodierung:	0011 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	subb 1a3h,r6 ist eine Word-Subtraktion des Register R6 von der direct-Adresse 1a3h und erzeugt den Hexcode 3E 69 A3.
subb P2,r4h ist eine Byte-Subtraktion des Register 4 High-Byte von Port2 und erzeugt den Hexcode 36 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h -= -C r6 bzw. P2 -= -C r4h.

SUBB Rd,#data	Subtrahiert eine Zahl von einem Register mit Carry.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← (Rd) - #data - (C)

Kodierung:	1001 x001  dddd 0011  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	subb r3,#2eh ist eine Word-Subtraktion der Zahl 2eh von Register R3 und erzeugt den Hexcode 99 33 00 2E.
subb r1l,#2eh ist eine Byte-Subtraktion der Zahl 2eh von Register 1 Low-Byte und erzeugt den Hexcode 91 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 -= -C #2eh bzw. r1l -= -C #2eh.

SUBB [Rd],#data
Subtrahiert eine Zahl von einem indirekt adressierten RAM-Platz mit Carry. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muß das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) - #data - (C)

Kodierung:	1001 x010  0ddd 0011  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	subb.w [r3],#2e7h (oder subb [r3],#2e7h) ist eine Word-Subtraktion der Zahl 2e7h von dem mit R3 adressierten RAM-Platz und erzeugt den Hexcode 9A 33 02 E7.
subb.b [r1],#2eh (oder subb [r1],#2eh) ist eine Byte-Subtraktion der Zahl 2eh von dem mit R1 adressierten RAM-Platz und erzeugt den Hexcode 92 13 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] -= -C #2e7h.w bzw. [r1] -= -C #2eh.b.

SUBB [Rd+],#data
Subtrahiert eine Zahl von einem indirekt adressierten RAM-Platz mit Carry und inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) - #data - (C)
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0011  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	subb.w [r3+],#2e7h (oder subb [r3+],#2e7h) ist eine Word-Subtraktion der Zahl 2e7h von dem mit R3 adressierten RAM-Platz und erzeugt den Hexcode 9B 33 02 E7.
subb.b [r1+],#2eh (oder subb [r1+],#2eh) ist eine Byte-Subtraktion der Zahl 2eh von dem mit R1 adressierten RAM-Platz und erzeugt den Hexcode 93 13 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] -= -C #2e7h.w bzw. [r1+] -= -C #2eh.b.

SUBB [Rd+offset8],#data
Subtrahiert eine Zahl von einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) - #data - (C)

Kodierung:	1001 x100  0ddd 0011  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	subb.w [r3+16],#2e7h (oder subb [r3+16],#2e7h) ist eine Word-Subtraktion der Zahl 2e7h von dem mit R3 adressierten RAM-Platz plus dem offset8 und erzeugt den Hexcode 9C 33 10 02 E7.
subb.b [r1-8],#2eh (oder subb [r1-8],#2eh) ist eine Byte-Subtraktion der Zahl 2eh von dem mit R1 adressierten RAM-Platz plus dem offset8 und erzeugt den Hexcode 94 13 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] -= -C #2e7h.w bzw. [r1-8] -= -C #2eh.b.

SUBB [Rd+offset16],#data
Subtrahiert eine Zahl von einem indirekt adressierten externen oder internen RAM-Platz mit Carry. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) - #data - (C)

Kodierung:	1001 x101  0ddd 0011  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	subb.w [r3+165ah],#2e7h (oder subb [r3+165ah],#2e7h) ist eine Word-Subtraktion der Zahl 2e7h von dem mit R3 adressierten RAM-Platz plus dem offset16 und erzeugt den Hexcode 9D 33 16 5A 02 E7.
subb.b [r1-120h],#2eh (oder subb [r1-120h],#2eh) ist eine Byte-Subtraktion der Zahl 2eh von dem mit R1 adressierten RAM-Platz plus dem offset16 und erzeugt den Hexcode 95 13 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] -= -C #2e7h.w bzw. [r1-120h] -= -C #2eh.b.

SUBB direct,#data
Subtrahiert eine Zahl von einem direct-RAM-Platz oder SFR mit Carry. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) ← (direct) - #data - (C)

Kodierung:	1001 x110  0ddd 0011  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	subb.w 30h,#2e7h (oder subb 30h,#2e7h) ist eine Word-Subtraktion der Zahl 2e7h von dem RAM-Platz an Adresse 30h und erzeugt den Hexcode 9E 03 30 02 E7.
subb.b 123h,#2eh (oder subb 123h,#2eh) ist eine Byte-Subtraktion der Zahl 2eh von dem mit R1 adressierten RAM-Platz und erzeugt den Hexcode 96 13 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h -= -C #2e7h.w bzw. 123h -= -C #2eh.b.


TRAP-Befehl
TRAP	Software Trap

Syntax:	TRAP   #data4

Aktion:	(PC) ← (PC) + 2
(SSP) ← (SSP) - 6
((SSP)) ← (PC)
((SSP)) ← (PSW)
(PSW) ← Trap vector (#data4)
(PC.15-0) ← Trap vector (#data4) + 2
(PC.23-16) ← 0
(PC.0) ← 0

Beschreibung:	TRAP löst den bezeichneten Software-Trap aus. Die Adresse und das Programmstatuswort der aufgerufenen Routine werden der Vektortabelle entnommen. Die Trap-Routine muss mit einem RETI-Befehl beendet werden. Somit ist ein Trap wie ein unmittelbarer Interrupt, der im Systemmodus ausgeführt wird. Der Sinn ist die Änderung von Systemeinstellung für eine spezielle Anwendung.

Bits:	Keine Bits werden verändert.

Bytes:	2

Takte:	23,  19 im Zeropage-Modus

Kodierung:	1101 0110  0011 zzzz
z = data4

Beispiel:	01CE	D6	35	trap #5
01D0	FE	FF	end
01D2	trap5 (008F):
0054	00	8F	D2	01	TRAP5-VECTOR
01D2	xx	xx	Trap-Befehle . . .
trap #5 erzeugt den Hexcode D6 35.
In Ihrem Quellcode erzeugen Sie die Trap-Routine an der gewünschten Stelle durch den Eintrag trap5 (PSW):. Der Assembler erzeugt damit den richtigen Eintrag in die Vektortabelle. Sobald das Programm nun auf den Befehl trap #5 trifft, wird ein Interrupt ausgelöst und mit der TRAP5-Routine fortgefahren.


XCH-Befehl
XCH	Exchange

Syntax:	XCH  dest, source

Aktion:	dest ↔ source

Beschreibung:	Die Daten von dest und source werden vertauscht.

Bits:	Ist source das Low-Byte des Programmstatusworts PSWL, so überschreibt XCH die eventuell geänderten Bits.

Größe:	Byte/Byte oder Word/Word

Operanden

XCH Rd,Rs	Vertauscht die Inhalte zweier Register.

Bytes:	2

Takte:	5

Aktion:	(Rd) ↔ (Rs)

Kodierung:	0110 x000  dddd ssss
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs

Beispiel:	xch r3,r4 ist ein Word-Befehl und erzeugt den Hexcode 68 34.
xch r1l,r1h ist ein Byte-Befehl und erzeugt den Hexcode 60 23.

XCH Rd,[Rs]	Vertauscht die Inhalte eines Registers mit einem indirekt adressierten RAM-Platz.

Bytes:	2

Takte:	6

Aktion:	(Rd) ↔ ((WS:Rs))

Kodierung:	0101 x000  dddd 0sss
Word: x = 1,  Byte: x = 0,  d = Rd,  s = R0 - R7

Beispiel:	xch r3,[r4] ist ein Word-Befehl und erzeugt den Hexcode 58 34.
xch r1l,[r1] ist ein Byte-Befehl und erzeugt den Hexcode 50 21.

XCH Rd,direct	Vertauscht die Inhalte eines Registers mit einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	6

Aktion:	(Rd) ↔ (direct)

Kodierung:	1010 x000  dddd 1hhh  llll llll
Word: x = 1,  Byte: x = 0,  d = Rd,  h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits

Beispiel:	xch r3,230h ist ein Word-Befehl und erzeugt den Hexcode A8 3A 30.
xch r1l,P2 ist ein Byte-Befehl und erzeugt den Hexcode A0 2C 32.


XOR-Befehl
XOR	Exklusiv Oder

Syntax:	XOR  dest, source

Aktion:	dest ← dest ⊕ source

Beschreibung:	XOR führt eine bitweise logische Exklusiv-ODER-Verknüpfung der Inhalte von source mit dest aus. Das Ergebnis steht in dest. Der Inhalt von source wird nicht verändert.

Bits:	Folgende Bits werden aktualisiert:
N, Z

Größe:	Byte/Byte oder Word/Word

Assembler:	dest ^= source ist identisch zu xor dest,source.

Operanden

XOR Rd,Rs	Logisches Exklusiv-ODER zweier Register

Bytes:	2

Takte:	3

Aktion:	(Rd) ← (Rd) ⊕ (Rs)

Kodierung:	0111 x001  dddd ssss
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs

Beispiel:	xor r3,r6 ist eine Word-Operation und erzeugt den Hexcode 79 36.
xor r1l,r0h ist eine Byte-Operation und erzeugt den Hexcode 71 21.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 ^= r6  bzw. r1l ^= r0h.

XOR Rd,[Rs]	Logisches Exklusiv-ODER eines externen oder internen RAM-Platzes mit dem Register. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← (Rd) ⊕ ((WS:Rs))

Kodierung:	0111 x010  dddd 0sss
Word: x = 1,  Byte: x = 0  d = Rd,  s = Rs

Beispiel:	xor r3,[r6] ist eine Word-Operation und erzeugt den Hexcode 7A 36.
xor r1l,[r2] ist eine Byte-Operation und erzeugt den Hexcode 72 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 ^= [r6] bzw. r1l ^= [r2].

XOR [Rd],Rs	Logisches Exklusiv-ODER eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7.

Bytes:	2

Takte:	4

Aktion:	(Rd) ← ((WS:Rd)) ⊕ (Rs)

Kodierung:	0111 x010  ssss 1ddd
Word: x = 1,  Byte: x = 0  d = Rd,  s = Rs

Beispiel:	xor [r3],r6 ist eine Word-Operation und erzeugt den Hexcode 7A 6B.
xor [r1],r2h ist eine Byte-Operation und erzeugt den Hexcode 72 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] ^= r6 bzw. [r1] ^= r2h.

XOR Rd,[Rs+]	Logisches Exklusiv-ODER eines externen oder internen RAM-Platzes mit einem Register. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	(Rd) ← (Rd) ⊕ ((WS:Rs))
(Rs) ← (Rs) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0111 x011  dddd 0sss
Word: x = 1,  Byte: x = 0  d = Rd,  s = Rs

Beispiel:	xor r3,[r6+] ist eine Word-Operation und erzeugt den Hexcode 7B 36.
xor r1l,[r2+] ist eine Byte-Operation und erzeugt den Hexcode 73 22.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 ^= [r6+] bzw. r1l ^= [r2+].

XOR [Rd+],Rs	Logisches Exklusiv-ODER eines Registers mit einem externen oder internen RAM-Platz. Als Zeiger dienen nur die Word-Register R0 bis R7, die anschließend inkrementiert werden.

Bytes:	2

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) ⊕ (Rs)
(Rd) ← (Rd) + 1 (für Byte) oder + 2 (für Word)

Kodierung:	0111 x011  ssss 1ddd
Word: x = 1,  Byte: x = 0  d = Rd,  s = Rs

Beispiel:	xor [r3+],r6 ist eine Word-Operation und erzeugt den Hexcode 7B 6B.
xor [r1+],r2h ist eine Byte-Operation und erzeugt den Hexcode 73 59.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] ^= r6 bzw. [r1+] ^= r2h.

XOR Rd,[Rs+offset8]
Logisches Exklusiv-ODER eines indirekt adressierten externen oder internen RAM-Platzes mit einem Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 8-Bit signierten Offset gebildet. Dient zum Lesen einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	(Rd) ← (Rd) ⊕ ((WS:Rs) + offset8)

Kodierung:	0111 x100  dddd 0sss  oooo ooooo
Word: x = 1,  Byte: x = 0, d = Rd, s = Rs, o = offset8

Beispiel:	xor r3,[r6-2] ist eine Word-Operation und erzeugt den Hexcode 7C 36 FE.
xor r1l,[r3+5] ist eine Byte-Operation und erzeugt den Hexcode 74 23 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 ^= [r6-2] bzw. r1l ^= [r3+5].

XOR [Rd+offset8],Rs
Logisches Exklusiv-ODER eines Registers mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Array- oder Stack-Variablen. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	3

Takte:	6

Aktion:	((WS:Rd) + offset8) ← ((WS:Rs) + offset8) ⊕ (Rs)

Kodierung:	0111 x100  ssss 1ddd  oooo ooooo
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs,  o = Offset-Bits

Beispiel:	xor [r6-2],r3 ist eine Word-Operation und erzeugt den Hexcode 7C 3E FE.
xor [r3+5],r7h ist eine Byte-Operation und erzeugt den Hexcode 74 FB 05.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-2] ^= r3 bzw. [r3+5] ^= r7h.

XOR Rd,[Rs+offset16]
Logisches Exklusiv-ODER eines indirekt adressierten externen oder internen RAM-Platzes mit einem Register. Die Adresse wird durch den Inhalt des Registers Rs und dem 16-Bit signierten Offset gebildet. Dient zum Lesen einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	(Rd) ← (Rd) ⊕ ((WS:Rs) + offset16)

Kodierung:	0111 x101  dddd 0sss  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs, h = high-offset16, l = low-offset16

Beispiel:	xor r3,[r6-30546] ist eine Word-Operation und erzeugt den Hexcode 7D 36 88 AE.
xor r1l,[r3+1125] ist eine Byte-Operation und erzeugt den Hexcode 75 23 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 ^= [r6-30546] bzw. r1l ^= [r3+1125].

XOR [Rd+offset16],Rs
Logisches Exklusiv-ODER eines Registers mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Dient zum Schreiben einer Variablen in einem großen Array. Ist der Offsetwert im Bereich von -128 bis +127, wählt der Assembler offset8, sonst offset16.

Bytes:	4

Takte:	6

Aktion:	((WS:Rd) + offset16) ← ((WS:Rd) + offset16) ⊕ (Rs)

Kodierung:	0111 x101  ssss 1ddd  hhhh hhhh  llll llll
Word: x = 1,  Byte: x = 0,  d = Rd,  s = Rs, h = high-offset16, l = low-offset16

Beispiel:	xor [r6-30546],r3 ist eine Word-Operation und erzeugt den Hexcode 7D 3E 88 AE.
xor [r3+1125],r7h ist eine Byte-Operation und erzeugt den Hexcode 75 FB 04 65.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r6-30546] ^= r3 bzw. [r3+5] ^= r7h.

XOR Rd,direct	Logisches Exklusiv-ODER einer direct-Adresse oder eines SFRs mit einem Register.

Bytes:	3

Takte:	4

Aktion:	(Rd) ← (Rd) ⊕ (direct)

Kodierung:	0111 x110  dddd 0hhh  llll llll
Word: x = 1,  Byte: x = 0, d = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	xor r3,2eh ist eine Word-Operation der direct-Adresse 2eh mit dem Register R3 und erzeugt den Hexcode 7E 30 2E.
xor r1l,S0BUF ist eine Byte-Operation des seriellen Buffers mit Register 1 Low-Byte und erzeugt den Hexcode 76 24 60.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 ^= 2eh bzw. r1l ^= S0BUF.

XOR direct,Rs	Logisches Exklusiv-ODER eines Registers mit einer direct-Adresse oder einem SFR.

Bytes:	3

Takte:	4

Aktion:	(direct) ← (direct) ⊕ (Rs)

Kodierung:	0111 x110  ssss 1hhh  llll llll
Word: x = 1,  Byte: x = 0, s = Register, h = MSB der direct-Adresse bzw. SFR (1hh ist SFR, 0hh ist direct), l = low-Bits.

Beispiel:	xor 1a3h,r6 ist eine Word-Operation der direct-Adresse 1a3h mit dem Register R6 und erzeugt den Hexcode 7E 69 A3.
xor P2,r4h ist eine Byte-Operation von Port 2 mit dem Inhalt von Register 4 High-Byte und erzeugt den Hexcode 76 9C 32.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
1a3h ^= r6 bzw. P2 ^= r4h.

XOR Rd,#data	Logisches Exklusiv-ODER eines Registers mit einer Zahl.

Bytes:	3 (Byte), 4 (Word)

Takte:	3

Aktion:	(Rd) ← (Rd) ⊕ #data

Kodierung:	1001 x001  dddd 0111  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	xor r3,#2eh ist eine Word-Operation von Register R3 mit der Zahl 2eh und erzeugt den Hexcode 99 37 00 2E.
xor r1l,#2eh ist eine Byte-Operation von Register 1 Low-Byte mit der Zahl 2eh und erzeugt den Hexcode 91 27 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
r3 ^= #2eh bzw. r1l ^= #2eh.

XOR [Rd],#data	Logisches Exklusiv-ODER eines indirekt adressierten RAM-Platz mit einer Zahl. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muß das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	4

Aktion:	((WS:Rd)) ← ((WS:Rd)) ⊕ #data

Kodierung:	1001 x010  0ddd 0111  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	xor.w [r3],#2e7h (oder xor [r3],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9A 37 02 E7.
xor.b [r1],#2eh (oder xor [r1],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 92 17 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3] ^= #2e7h.w bzw. [r1] ^= #2eh.b.

XOR [Rd+],#data
Logisches Exklusiv-ODER eines indirekt adressierten RAM-Platz mit einer Zahl. Der Befehl inkrementiert anschließend das Register. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	3 (Byte), 4 (Word)

Takte:	5

Aktion:	((WS:Rd)) ← ((WS:Rd)) ⊕ #data
(Rd) ← (Rd) + 1 (Byte) + 2 (Word)

Kodierung:	1001 x011  0ddd 0111  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	xor.w [r3+],#2e7h (oder xor [r3+],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz mit der Zahl 2e7h und erzeugt den Hexcode 9B 37 02 E7.
xor.b [r1+],#2eh (oder xor [r1+],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 93 17 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+] ^= #2e7h.w bzw. [r1+] ^= #2eh.b.

XOR [Rd+offset8],#data
Logisches Exklusiv-ODER einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 8-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	4 (Byte), 5 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset8) ← ((WS:Rd)+offset8) ⊕ #data

Kodierung:	1001 x100  0ddd 0111  oooo oooo  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = offset8, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	xor.w [r3+16],#2e7h (oder xor [r3+16],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz plus dem offset8 mit der Zahl 2e7h und erzeugt den Hexcode 9C 37 10 02 E7.
xor.b [r1-8],#2eh (oder xor [r1-8],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz plus dem offset8 mit der Zahl 2eh und erzeugt den Hexcode 94 17 F8 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+16] ^= #2e7h.w bzw. [r1-8] ^= #2eh.b.

XOR [Rd+offset16],#data
Logisches Exklusiv-ODER einer Zahl mit einem indirekt adressierten externen oder internen RAM-Platz. Die Adresse wird durch den Inhalt des Registers Rd und dem 16-Bit signierten Offset gebildet. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße. Es können nur die Register R0 bis R7 verwendet werden.

Bytes:	5 (Byte), 6 (Word)

Takte:	6

Aktion:	((WS:Rd)+offset16) ← ((WS:Rd)+offset16) ⊕ #data

Kodierung:	1001 x101  0ddd 0111  oooo oooo  ffff ffff  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = Register, o = MSB offset16, f = LSB offset16, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	xor.w [r3+165ah],#2e7h (oder xor [r3+165ah],#2e7h) ist eine Word-Operation von dem mit R3 adressierten RAM-Platz plus dem offset16 mit der Zahl 2e7h und erzeugt den Hexcode 9D 37 16 5A 02 E7.
xor.b [r1-120h],#2eh (oder xor [r1-120h],#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz plus dem offset16 mit der Zahl 2eh und erzeugt den Hexcode 95 17 FE E0 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
[r3+165ah] ^= #2e7h.w bzw. [r1-120h] ^= #2eh.b.

XOR direct,#data
Logisches Exklusiv-ODER einer Zahl mit einem direct-RAM-Platz oder SFR. Da der Assembler an den Operanden die Word- bzw. Byte-Wahl nicht erkennen kann, muss das durch den Zusatz .w bzw. .b kenntlich gemacht werden. Bei fehlender Kennzeichnung entscheidet der Assembler nach der Zahlengröße.

Bytes:	4 (Byte), 5 (Word)

Takte:	4

Aktion:	(direct) ← (direct) ⊕ #data

Kodierung:	1001 x110  0ddd 0111  iiii iiii  hhhh hhhh  (llll llll)
Word: x = 1,  Byte: x = 0, d = MSB direct, i = LSB direct, h = 8-Bit-Zahl (Byte) bzw. MSB der 16-Bit-Zahl (Word), l = LSB der 16-Bit-Zahl.

Beispiel:	xor.w 30h,#2e7h (oder xor 30h,#2e7h) ist eine Word-Operation von dem RAM-Platz an Adresse 30h mit der Zahl 2e7h und erzeugt den Hexcode 9E 07 30 02 E7.
xor.b 123h,#2eh (oder xor 123h,#2eh) ist eine Byte-Operation von dem mit R1 adressierten RAM-Platz mit der Zahl 2eh und erzeugt den Hexcode 96 17 23 2E.
Die vorstehenden Befehle können durch folgende Schreibweisen ersetzt werden:
30h ^= #2e7h.w bzw. 123h ^= #2eh.b.


Assembler
Der XA-Assembler

Arbeitsweise

Bei der Analyse eines Befehls entfernt der Assembler alle Leerzeichen und Tabulatoren rechts und links einer Befehlszeile sowie eventuelle Kommentare und wandelt alle Tabulatoren in Spaces um. Nun interpretiert er den Text bis zum ersten Leerzeichen als Mnemonik. Danach schaut er, ob ein erstes und ein zweites Komma in der Befehlszeile enthalten ist. Der Text dazwischen und der restliche Text bilden die Operanden. Somit dürfen in der Mnemonik keine, in den Operanden beliebige Leerzeichen oder Tabs enthalten sein. Ferner ist die Groß-/Kleinschreibung mit Ausnahme von #define-Begriffen (Makros) belanglos.

Programmbeispiel

Für die Erstellung des Quelltextes gilt:

Mehrere Befehle können durch einen Doppelpunkt getrennt in einer Zeile stehen, wobei die Einzelbefehle auch Kommentare umfassen können. Eine Befehlszeile darf nicht mit einem Doppelpunkt enden. Tip: Fassen Sie damit logisch zusammengehörige Befehle zusammen, damit Ihr Blick für die Entscheidungsstrukturen frei ist.

Syntax:	Befehl 1: Befehl 2 [; Kommentar]: Befehl 3: . . : Befehl n

Das Kommentarzeichen ist das Semikolon ( ; ). Es werden alle Zeichen ab dem Semikolon bis zum Zeilenende bzw. bis zum nächsten Doppelpunkt ignoriert. Tip: Verwenden Sie Kommentare als Variablenname oder als Makro (#define). Dadurch wird Ihr Programm leserlicher.

Syntax: . . Befehl . .	; Kommentar

Die Adressvergabe für den nächsten Befehl erfolgt automatisch durch den Assembler in aufsteigender Form. Eine Ausnahme hiervon kann mit der ORG-Anweisung erfolgen.

Syntax: ORG Adresse,	z.B. org 30a5h

Jedes Programm sollte nach einer eventuellen Makro- und Variablendefinition mit dem Reset-Vektor beginnen, d.h. mit dem Eintrag Reset(PSW):. Der Assembler trägt dann automatisch an die Adressen 0000 bis 0003 des Programmspeichers die Adresse des Reset-Vektors und das mit PSW genannte Programmstatuswort ein. Ohne eine vorausgehende Org-Anweisung und ohne vorausgehende Befehle verwendet der Assembler die Adresse 011Ch; das ist die erste Adresse nach der Vektortabelle.

Das Wort End erzeugt einen unbedingten Sprung BR auf der Stelle und verhindert damit die Ausführung von nachfolgenden Code, der eventuell zu Subroutinen oder zu Tabellen gehört. End beschließt daher das Programm. End kann nur durch einen Interrupt unterbrochen werden.

Siehe auch #define

#include

Label

Variablen

Arrays

Zahlen

Tabellen

Zuweisungsoperatoren

Registeradressierung

IF-Strukturen

FOR-Strukturen

Schleifen

String

Makro

Org-Anweisung


Programmbeispiel

#define Warte {for r2 = #6000h: next}

Byte Zähler	;Variablendefinition

Reset(008F):	;Programmbeginn, i.a. an Adresse 11Ch.

SCR = #1: BCR = #0	;Wähle Zero-Page mit 12 Bit Adressbus.

WFEED1 = #a5h: WFEED2 = #5ah: clr WDRUN

;Watchdog stoppen.

;Hauptprogramm:

Zähler = #0: R0L = #11111110b	;Initialisierung

Loop	;Schleife

for R1H = #7	;Zählschleife

p2 = R0L	;Register R0-Low nach Port 2

Warte	;Makro einfügen

rl r0L,#1	;Inhalt von Register 0-Low verändern

next	;Ende der Zählschleife

for R1H = #7

p2=R0L: Warte: rr r0L,#1

next

Zähler ++	;Zähler erhöhen

if Zähler = #100: end: end if	;Programmende

end loop


Ein Makro ist ein Wort, das für einen Befehl oder eine Befehlsfolge steht. Ein Makro wird mit #define Makroname {Befehl(e)} definiert. Der Makroname ist case-sensitive.

Syntax: #define Makroname {Befehle(e)}


Das Wort ORG mit nachfolgender Zahl weist den Assembler an, die genannte Zahl als neue Adresse für den folgenden Befehl zu verwenden. Achtung! Sie können damit zurückliegenden Code überschreiben. Der Assembler gibt in diesem Falle eine Warnung aus.

Syntax: ORG Adresse,	z.B. org 30a5h


#define

Sie können einem Befehl oder einer ganzen Befehlsfolge einen neuen Begriff zuordnen. Wenn Sie diesen Begriff später im Quelltext verwenden, substituiert der Assembler den Begriff durch die zuvor festgelegte Befehlsfolge. Diese Methode ist ratsam, wenn

- der Befehl eine ganz bestimmte Funktion hat, z.B. #define Motor an {setb P2.1}

oder

- eine häufig verwendete Befehlssequenz benutzt wird, z.B. #define Warte {for r2 = #6000h: next}

Im letzen Fall ist zu überlegen, ob die Benutzung einer Subroutine nicht eventuell Platz spart.

Pro Zeile ist nur eine #define-Anweisung möglich. Die #define-Anweisung ist case-sensitive, d.h. sie unterscheidet zwischen Groß- und Kleinschreibung.

Syntax	#define NeuerName {Befehl 1[: Befehl 2: ... : Befehl n]}

Beispiel	#define Warte {P2 = R1H: for r2 = Tempo: next}


#include

#include fügt den Programmcode, der in der Include-Datei steht, an der aktuellen Position des Programms ein. Dieser Programmcode unterscheidet sich durch nichts von dem üblichen Quellcode. Sie können #define-Anweisungen, Variablendefinitionen, Interrupts, Schleifen etc. in der Include-Datei vornehmen. Subroutinen darin können vom Hauptprogramm aus aufgerufen werden und umgekehrt. Die Variablen sind generell global, d.h. ihr Geltungsbereich beginnt ab der Stelle, an der sie definiert werden, und dann für den gesamten Rest des Programms.

Syntax	#include [Pfad-]Dateiname

Beispiel	#include d:\xa-ass\datei1.xai

Pro Zeile ist nur eine #include-Anweisung möglich, sie darf nicht durch Doppelpunkte getrennt mit anderen Befehlen in einer Zeile stehen. Der Dateiname ist nicht in Hochkommas oder anderen Einrahmungszeichen zu setzen. Die Pfadangabe kann nur weggelassen werden, wenn die Datei im Standardverzeichnis steht.

Include-Dateien können wiederum andere Include-Dateien beinhalten. Die Zahl der geöffneten Include-Dateien hängt von Ihrem System und dessen aktuellem Zustand ab. Im Programmlisting finden sich die Zeilennummern der Include-Befehle mit einer voranstehenden Nummer, die die laufende Nummer der Include-Datei angibt, wobei das Hauptprogramm die Nummer 1, die erste Include-Datei die Nummer 2 etc. erhält. Das folgende Beispiel zeigt das.

Beispiel, der Quelltext:

Reset(008F):

SCR = #1: BCR = #0

WFEED1 = #a5h: WFEED2 = #5ah: clr WDRUN

;Programm:

R1H = #FEh

#include d:\xa-ass\datei1.xai

for (r1L = #0| r1L < #7| r1L++)

P2 = R1H: rl R1H,#1

. . . .

Beispiel, das Listing:

011C	1:7	Reset(008F):

0000	8F	00	1C	01	RESET-VECTOR

011C	96	48	40	01	1:8	SCR = #1

0120	96	48	6A	00	1:8	BCR = #0

0124	96	48	5D	A5	1:9	WFEED1 = #a5h

0128	96	48	5E	5A	1:9	WFEED2 = #5ah

012C	08	02	FA	1:9	clr WDRUN

;Programm:

012F	91	38	FE	1:12	R1H	= #FEh

1:14	#include d:\xa-ass\datei1.xai

;Inhalt der Include-Datei:

2:2	#define Warte {for r2 = #6000h: next}

0132	91	08	FE	2:4	R0L = #11111110b

0135	91	38	07	2:5	for R1H = #7

0138	86	0C	32	2:6	p2 = R0L

013B	99	28	60	00	00	2:7	for r2 = #6000h

0140	8F	28	FF	2:7	next

0143	D3	01	2:8	rl r0L,#1

0145	87	38	F8	2:9	next

0148	91	28	00	00	1:16	for (r1L = #0| r1L < #7| r1L++)

014C	91	24	07	1:16	r1L < #7

014F	F6	09

0151	86	3C	32	1:17	P2 = R1H

0154	D3	31	1:17	rl R1H,#1


Label

Labels sind Namen für Sprungziele, die erst während des Compilierens eine Adresse erhalten. Labels werden für Sprungbefehle, Subroutinenaufrufe und Interrupts benötigt. Da der Assembler über komfortable Schleifen- und IF-Konstrukte verfügt, wird man für bedingte Sprünge kaum Labels benötigen. In diesen hochspracheähnlichen Konstrukten erzeugt der Assembler selbst die temporären internen Labels. Somit ist der Hauptverwendungszweck die Markierung von Subroutinen. Im Programm kann daher der Labelname ohne den CALL-Befehl verwendet werden; der Assembler ergänzt den fehlenden CALL-Befehl.

Labels müssen allein in einer Zeile stehen und mit einem Doppelpunkt enden, z.B. Label: Kommentare hinter Labels sind zulässig.

Word-Pointer von Labels erhalten sie durch das Zeichen #, z.B. mov r0,#Label. Bei Label-Pointer haben Sie die Wahl, nur den High-Teil #high(Label) bzw. den Low-Teil #low(Label) als Byte zu wählen, z.B. mov r0h,#low(Label) bzw. mov r0h,#high(Label).

Konkurrenz von Label und Variablen

Der Compiler übersetzt ein Label in eine Adresse, also in eine Zahl. Mit dieser Zahl kann gearbeitet werden, z.B. MOV R2,#Label. Haben nun eine Variable und ein Label denselben Namen, so zieht der Compiler die Variable vor. Abhilfe schafft nur eine Namensänderung. Vermeiden Sie ferner gleiche Makro- und Labelnamen.

Beispiel

for R1H = #7

p2=R0L

Warte	;Subroutinenaufruf

next

end

Warte:	;Label = Subroutinenname

for r2 = #6000h

next

rr r0L,#1

ret

Interrupt-Vektoren sind Labels mit dem Unterschied, dass vor dem Doppelpunkt das Programmstatuswort in runden Klammern als vierstellige Hexzahl stehen muss. Der Assembler schreibt die aktuelle Adresse des Interrupts und das Programmstatuswort in die Vektortabelle. Die Vektortabelle sollte nicht selbst beschrieben werden.

Beispiel	Reset (008F):

Das Wort hier bezeichnet die eigene Adresse als Label. JB P2.0,hier wartet hier solange, bis Pin 0 von Port 2 an Masse geht. Ein Label muss deswegen nicht vergeben werden.

Siehe auch Interrupt-Tabelle


Variablen

Eine Variable ist ein Name für einen bestimmten Speicherplatz im RAM. Im XA-Assembler muss jede Variable vor Ihrer Benutzung angemeldet (deklariert) werden. Leerzeichen in den Variablen sind erlaubt. Mehrere Variablen desselben Typs können durch ein Komma getrennt in einer Zeile folgen. Variablen können bei ihrer Anmeldung mit dem Gleichheitszeichen eine Adresse erhalten.

Der Assembler unterscheidet zwischen Bit-, Byte-, Wordvariablen und Konstanten.

Syntax

BIT	Bitname1[=Bitadresse][, Bitname2[=Bitadresse], ... , Bitnamen[=Bitadresse]]

Gültige Bitadressen liegen zwischen 100h und 1FFh. Bitvariablen sind nur in Bitbefehlen verwendbar. Die Bits der bitadressierbaren Spezialfunktionsregister können durch Angabe der SFR-Bezeichnung und die Bitnummer getrennt durch einen Punkt angegeben werden, z.B. P2.5 ist das Bit Nummer 5 von Port 2.

BYTE	Bytename1[=Byteadresse][, Bytename2[=Byteadresse], ... , Bytenamen[=Byteadresse]]

WORD	Wordname1[=Wordadresse][, Wordname2[=Wordadresse], ... , Wordnamen[=Wordadresse]]

Byte- und Wordvariablen bezeichnen directadressierbare Speicherplätze im Bereich von 000h bis 3FFh. Byte- und Wordvariablen sind also gleich bis auf ihre Länge. Zudem achtet der Assembler darauf, dass Wordvariablen immer auf gerade Adressen zu liegen kommen. Sind die Bit-, Byte- oder Wordadressen nicht angegeben, vergibt der Assembler selbstständig die Adressen in steigender Reihenfolge beginnend mit der Adresse 40h, um den Bitbereich (20h bis 3Fh) nicht zu stören.

Byte- und Wordvariablen sind bei direct- oder #data-Befehlen verwendbar.

CONST	Constname 1=Wert 1[, Constname 2=Wert 2, ... , Constname n=Wert n]

Eine Konstante muss bei ihrer Deklaration mit einem Wert versehen werden, z.B. Const Display = FE80h; der Konstantenname ist hier Display. Konstanten belegen keinen Speicherplatz im RAM, da sie beim Compilieren in Zahlen umgewandelt werden.

Auch Strings können als Werte bei Variablenzuweisungen benutzt werden. Sie dürfen maximal vier Zeichen enthalten.

Verbotene Zeichen für Variablen sind = : ; + * - / [ ] , ; . Leerzeichen und Tabulatoren sind belanglos, da der Assembler diese entfernt.

Eine Word-Variable kann auch in einem Byte-Befehl Verwendung finden, ebenso kann eine Byte-Variable auch in einem Word-Befehl Verwendung finden, nur macht letzteres keinen Sinn, da das High-Byte der Variablen einer anderen Variablen zugeordnet sein kann.

Beispiele

Word Zwischenspeicher, Zähler, Dummy = 90h

Byte n, tmp, a

Die Verwendung der Variablen erfolgt als Bezeichner (Var) für eine direct-Adresse oder als Pointer (#Var) der direct-Adresse. Die Namen der Spezialfunktionsregister und deren Bits müssen nicht definiert werden. Die sind dem Assembler bekannt.

Beispiele

mov R0L,var ;schreibt den Inhalt der Variablen nach R0L

mov R0,#var ;schreibt die Adresse der Variablen als Word nach R0

mov R0L,#var ;schreibt die Low-Adresse der Variablen als Byte nach R0

Bei einem Label (= Sprungziel) haben Sie die Wahl, nur den High-Teil #high(Var) bzw. den Low-Teil #low(Var) als Byte zu wählen.

Jede Variable kann als Basisadresse für ein Array benutzt werden.


Ein String ist eine Zeichenkette, die Buchstaben und Zahlen aufweisen kann. Im XA-Assembler werden Strings in zwei Hochkommas (Shift+# Taste) eingeschlossen. Jedes String-Zeichen wird mit seinem ANSI-Code übersetzt.

Syntax: String	z.B. 'Hallo Welt'


Array
Arrays

Ein Array ist eine Variable, die aus mehreren Bytes oder Words besteht und bei der die einzelnen Elemente nummerierbar sind. In der aktuellen Version gibt es nur eindimensionale Arrays. Ein Array muss wie eine Byte- oder Word-Variable deklariert werden und kann mit ihnen in einer Zeile stehen. Bei der Deklaration ist die Arraygröße in eckiger Klammer anzugeben.

Beispiele

Byte Var[12]

oder zusammen mit anderen Variablen:

Byte Zähler, Var[12], Verzögerung

Sie können auch bei der Deklaration gleich die Startadresse für das erste Element festlegen: Byte Var[16]=60h. Danach sind die Direct-Adressen von 60h bis 6Fh im internen RAM für dieses Array reserviert und von anderen Variablen nicht mehr nutzbar. Gehen Sie aber mit Adressvergaben äußerst sparsam um, da das der Compiler automatisch und effizient macht.

Wird ein Array als Word-Array deklariert, benötigt es den doppelten Platz. Die Anweisung Word Var[16]=0 belegt die Adressen von 0 bis 1Fh.

Ein Element einer Array-Variablen wird mit seinem Index adressiert. Der Index eines jeden Arrays beginnt mit 0. R2=a[3] schreibt den vierten Platz des Arrays in das Register R2. Die Befehle R2=a und R2=a[0] haben dieselbe Wirkung. Auch eine negative Indizierung ist möglich, sie bezeichnet dann Speicherplätze vor dem Arraybeginn.

Auch wenn eine Variable nicht als Array deklariet wurde, kann man sie als Basisadresse eines Arrays verwenden:

Beispiel

Word Tempo

Tempo = #6000h

Tempo[1]--

Der Dekrement-Befehl Tempo[1]-- bezieht sich auf das High-Byte der Variablen Tempo und entspricht somit dem Befehl sub Tempo,#100h.


Zahlen

Hexzahlen werden durch ein nachgestelltes H, Binärzahlen durch ein nachgestelltes B gekennzeichnet. Dezimalzahlen sind ohne Kennung. Strings stehen in Hochkommas und dürfen maximal zwei Zeichen enthalten. Die Eingabe negativer Zahlen mit dem Minuszeichen ist nur bei Dezimalzahlen und Hexadezimalzahlen möglich, z.B. -5263 wird zu EB71h, die Eingabe -7Eh wird zu FF82h.

Bei den Short-Befehlen - z.B. adds, movs - dürfen nur die die Dezimalzahlen -8 bis +7 verwendet werden.

Konstanten sind Namen für Zahlen. Auch Variablen und Arrays können als Zahl verwendet werden, wenn das Zeichen # davor geschrieben wird.


Tabelle
Tabellen

Daten für Tabellen werden durch die vorangestellten Buchstaben DB (Define Byte) gekennzeichnet. Nach dem DB und einem Leerzeichen folgen nun die Tabellendaten durch Kommas getrennt. Tabellendaten können alle Zahlen, Variablen und Srings sein. Strings müssen zwischen zwei Hochkommas stehen. Die Tabellendaten werden an der Adresse abgelegt, an der sie beim Compilieren im Quelltext erscheinen. Sollen sie an andere Stelle geschrieben werden, muss mit der Org-Anweisung eine neue Adresse gesetzt werden.

Beispiel

DB 55, 9Ah, 'Text' 	;es werden sechs Bytes als Tabelleneintrag geschrieben


Zuweisungsoperatoren

Zahlreiche artihmetische und logische Befehle können durch C-gleiche Zuweisungsoperatoren ersetzt werden. Die Information über Byte, Word bzw. DWord wird als Endung .b, .w oder .d falls erforderlich angehängt. Gültige Operanden sind die jeweils unter dem betreffenden Befehl beschrieben Operanden.

Zeichen	Befehl	Beispiel

=	MOV	; P2 = #30h wird zu  mov P2,#30h
; [R4] = #e2h.w wird zu  mov.w [R4],#e2h

+=	ADD	; [R0+] += R1L wird zu  add [R0+],R1L

+=+C	ADDC	; [R0+] += +C R1L wird zu  addc [R0+],R1L

-=	SUB	; R2 -= #14 wird zu  sub R2,#14

-=-C	SUBB	; R2 -= -C Variable wird zu  subb R2,Variable

/=	DIVU	; R4 /= #2f3h.d wird zu  divu.d r4,#2f3h

*=	MULU	; R0 *= R3 wird zu  mulu.w R0,R3

&=	AND	; P2 &= R2h wird zu  and P2,R2h

|=	OR	; Var |= #FEh.w wird zu  or.w Var,#feh

^=	XOR	; P2 ^= R2h wird zu  xor P2,R2h

<<	ASL	; R2 << #5 wird zu  asl R2,#5, gültige Operanden siehe ASL-Befehl

>>	LSR	; R2 >> R3 wird zu  lsr R2,R3, gültige Operanden siehe LSR-Befehl

=~	CPL	; R0 = ~R0 wird zu  cpl R0 (oder einfach R0 =~), nur Register

=-	NEG	; R3L = -R3L wird zu  neg R3L (oder einfach R3L =-), nur Register

Es werden auch der Inkrement-Operator ++ und Dekrement-Operator -- unterstützt. Diese Operatoren dürfen nur nachgestellt sein:

++	ADDS #1	; [r0]++ wird zu adds.b [R0],#1 und [r0]++.w wird zu adds.w [R0],#1

--	ADDS #-1	; var-- wird zu adds.b var,#-1 und var--.w wird zu adds.w var,#-1


Registeradressierung

Byte/Word-Unterscheidung bei der Registeradressierung.

Die Zuordnung ist bei der Registeradressierung eindeutig. Add R2,#14h ist ein Word-Befehl, da mit R2 das Word-Register R2 bezeichnet wird, und es wird der Wert 0014h zum Register R2 addiert. Add R2L,#14h ist ein Byte-Befehl, da mit R2L ein 8-Bit-Speicherplatz bezeichnet wird. Überall, wo die Eindeutigkeit nicht gegeben ist, muss die Unterscheidung mit .b, .w bzw. .d erfolgen.

Mov [R2],Variable ist nicht eindeutig, da entweder nur das Low-Byte der Variablen oder beide Bytes (Word) der Variablen gemeint sein könnten. Schreiben Sie hier mov.b [R2],Variable oder mov.w [P2],Variable. Tun Sie das nicht, nimmt der Assembler einen Byte-Befehl an. Operatoranweisungen sind bei Doppeldeutigkeit durch ein nachgestelltes .B oder .W zu kennzeichnen: [R4] = Variable.b oder [R4] = Variable.w. Fehlt bei nicht eindeutigen Befehlen die Kennzeichnung, nimmt der Assembler eine Byte-Operation vor. Im Fall von #data entscheidet er sich bei #data < 100h für eine Byte- sonst für eine Word-Operation.

Siehe auch Zuweisungsoperatoren


IF-Strukturen

Syntax

IF Argumente [THEN]

Befehle . .

[ELSE

Befehle . . ]

END IF

Der Abstand von IF zu END IF darf 254 Bytes nicht überschreiten. Bei größeren Abständen müssen Teile des Inhaltes in eine Subroutine geschrieben und diese aufgerufen werden. If-Strukturen können beliebig oft geschachtelt werden. If-Strukturen können sich mit allgemeinen Schleifen- und For-Konstruktionen überlappen.

Einfache If-Strukturen

werden durch Bit-Sprünge oder durch den CJNE-Befehl realisiert. Bedingte Sprungbefehle, die ihre Sprungziele an nachfolgenden Adressen haben, können mit IF anschaulicher verwendet werden. In einer If-Anweisung kann das THEN auch weggelassen werden, ebenso das ELSE.

Argumente:

1. Flags	Die verschiedenen Flags im XA können mit zahlreichen Sprungbefehlen getestet werden. Für diese Flags gibt es die Argumente:

"<=", "<=s", "<=", "C", "not C", "zero" oder "0", "not zero" oder "!=0", "OV", "not OV", "<0", ">=0", ">", "<=", "<s", ">=s", "<=s", ">s", "a=0", "a>0"

Das nachgestellte S bei den Relationen steht für den Test nach signierten Operationen.

Beispiel

If <= then

. . Befehle . .

end if

2. Bits	Bits werden auf Eins mit If bit Bitbezeichnung und auf einen Null mit If not bit Bitbezeichnung getestet.

Beispiel

if bit r2.10 then

. . Befehle . .

end if

Es wird das 11. Bit von Register 2 auf eine Eins überprüft und die folgenden Befehle ausgeführt, wenn das Bit r2.10 eine Eins ist.

3. Bytes	Bytes, die mit dem CJNE-Befehl verglichen werden, haben die Syntax:

If Rd=direct, if RdL/H=direct, if Rd=#data16, if RdL/H=#data8, if [Rd]=#data.b, if [Rd]=#data.w, if [Rd]=#data

Wenn wie im letzten Fall die eindeutige Zuardnung .b oder .w. fehlt, entscheidet sich der Assembler nach der Zahlengröße für einen Byte- bzw. Word-Befehl.

Erweiterte If-Strukturen

werden durch eine Befehlssequenz erzeugt, die der Assembler vornimmt. Dabei wird zunächst ein CMP-Befehl ausgeführt und das Ergebnis nachfolgend mit einem Bit-Test ausgewertet. Es sind die folgenden relationalen Operatoren zulässig:

< kleiner, > größer, = gleich, >= größer gleich, <= kleiner gleich, ! = ungleich

Beispiel

If [R2] < #2FEh.w then

. . Befehle . .

end if

Es können alle Operandenkombinationen des CMP-Befehls verwendet werden. Die Unterscheidung zwischen Byte- und Word-Befehl erfolgt durch die Kennzeichnung .b bzw. .w, die an die Vergleichsoperanden angehängt wird.

Die erweiterte IF-Struktur gestattet ferner den Vergleich signierter Byte- und Word-Zahlen. Es sind die vier Relationen <, >, <= und >= möglich. Der Assembler wird durch ein nachgestelltes .s zu diesem Vergleich angehalten.

Beispiel

If R2 < R3.s oder If [R2] < #FEh.b.s

Exit If

Exit If ist nur in verschachtelten If-Strukturen anwendbar. Es bewirkt ein Verlassen der eigenen und der nächsten übergeordneten If-Struktur. Exit If kann in einer If-Struktur mehrmals auftreten.

Beispiel

If r4 >= #14 then

. . Befehle . .

if bit Test

exit if	;Es erfolgt ein Sprung zu Weitere Befehle

end if

. . Befehle . .

end if

Weitere Befehle..


FOR-Strukturen

Einfache FOR-Strukturen

Syntax I

FOR Startwert

Befehle . .

[Exit For]

Befehle . .

NEXT

Den einfachen FOR-NEXT-Schleifen liegt der DJNZ-Befehl zugrunde. Sie sind somit in Einerschritten abwärtszählende Schleifen mit dem hinter FOR genannten Zähler. Als Zählvariable kommt nur ein Register oder eine direct-Adresse (SFR) in Betracht. Eine direct-Adresse kann als 8- oder 16-Bit Zähler benutzt werden. Treffen Sie hierbei die Unterscheidung mit der Endung .b oder .w, z.B. for Adresse = #3Dh.w. Das macht natürlich nur Sinn, wenn die Variable zuvor als Word definiert wurde: z.B. Word Adresse. Bei fehlender Endung entscheidet sich der Assembler für eine Byte-Operation.

Beispiele

for r2 = #3000h

. . Befehle . .

next

oder

for Zähler = r5	;Zähler ist wegen r5 automatisch von der Größe Word.

. . Befehle . .

next

Erweiterte FOR-Strukturen

Syntax II

FOR ([Initiierung] | Laufbedingung | [Aktion])

Befehle . .

[Exit For]

Befehle . .

NEXT

Die erweiterten FOR-Next-Schleifen werden durch ein dynamisches Makro erzeugt. Die drei Argumente (Initiierung | Laufbedingung | Aktion) müssen in Klammern stehen, wobei Initiierung und Aktion entfallen können. Das Trennzeichen ist der Bar (Alt+< auf der PC-Tastatur).

Die Befehle zwischen For und Next werden solange wiederholt, bis die Auswertung von  Laufbedingung nicht mehr zutrifft, d.h. solange Laufbedingung gültig ist. Initiierung wird vor dem ersten Durchlauf ausgeführt und initialisiert normalerweise eine Laufvariable, die zum Test mit Laufbedingung verwendet wird. Aktion wird nach jedem Durchlauf ausgewertet und dient normalerweise zur Erhöhung der Laufvariablen.

Initiierung und Aktion stellen gewöhnliche Maschinenbefehle oder unäre Zuweisungen dar z.B. mov R2L,#100 oder  R2L = #33h oder Zähler += #5 etc. Laufbedingung ist ein Ausdruck mit einem in der IF-Struktur aufgeführten Vergleichsoperator.

Beispiel

for (r2h=#13| r2h<=#100| r2h+=#2)	;Zeile 18

P2=r2h	;Zeile 19

next	;Zeile 20

Wird übersetzt zu:

mov r2h,#13

Label 1:

cmp r2h,#100

BG Label 2

mov P2,r2h

add r2h,#2

BR Label 1

Label 2:

Als Listing erhalten Sie:

014A	91 58 0D 00	1:18	for (r2h=#13| r2h<=#100| r2h+=#2)

014E	91 54 64	1:18	IF r2h<=#100

0151	F8 05

0153	86 5C 32	1:19	P2=r2h

0156	91 50 02	1:20	r2h+=#2

0159	FE FA 00	1:20	Next

015C

Diese Schleife wird 44mal durchlaufen. Beim 45ten Mal ist der Inhalt von r2h gleich 101, somit nicht mehr <= 100. Also wird die Schleife abgebrochen und das Programm mit dem Befehl nach Next fortgesetzt.

EXIT FOR

EXIT FOR beendet augenblicklich die aktuelle FOR-Schleife. Üblicherweise steht Exit For in einer bedingten Abfrage, z.B. if bit Test then: exit for: end if. Exit For kann in einer Schleife an mehreren Stellen auftreten. Der Abstand von FOR zu NEXT darf 254 Bytes nicht überschreiten. Bei größeren Abständen müssen Teile des Inhaltes in eine Subroutine geschrieben und diese aufgerufen werden. For-Schleifen können beliebig oft geschachtelt werden. For-Schleifen können sich mit IF- und allgemeinen Schleifen-Konstruktionen überlappen.


Loop
Schleifen

Der Assembler kennt vier Arten von Schleifen

Endlosschleife

Syntax I

LOOP

Befehle . .

[Exit Loop]

Befehle . .

END LOOP

Eine Endlosschleife trägt zu Beginn die Bezeichnung LOOP und am Ende END LOOP. Sie kann nur durch einen Interrupt oder EXIT LOOP verlassen werden.

Bedingte Schleife mit Prüfung am Anfang

Syntax II

WHILE Bedingung

Befehle . .

[Exit Loop]

Befehle . .

END LOOP

Die Schleife wird durchlaufen, solange die Bedingung gültig ist. Ist die Bedingung zu Beginn ungültig, wird die Schleife nicht durchlaufen. Als Bedingung sind alle unter IF-aufgeführten Relation möglich.

Beispiele

while [r3+]<#13h .b

. . Befehle . .

end loop

oder

while bit r2.11

. . Befehle . .

end loop

Bedingte Schleife mit Prüfung am Schluß

Syntax III

LOOP

Befehle . .

[Exit Loop]

Befehle . .

UNTIL Bedingung

Die Schleife wird solange durchlaufen, bis die Bedingung gültig ist. Ist die Bedingung zu Beginn bereits gültig, wird die Schleife genau einmal durchlaufen. Als Bedingung sind alle unter IF-aufgeführten Relation möglich.

Beispiele

loop

. . Befehle . .

until [r3+]<#13h .b

oder

loop

. . Befehle . .

until bit r2.11

Bedingte Schleife mit Prüfung am Anfang und am Schluß

Syntax IV

WHILE Bedingung1

Befehle . .

[Exit Loop]

Befehle . .

UNTIL Bedingung2

Die Schleife wird solange durchlaufen, bis die erste Bedingungen ungültig oder die zweite Bedingung gültig wird.

Beispiel

loop while [r3+]<#13h .b

. . Befehle . .

until r3<#2aeh

Exit Loop

Ein Exit Loop führt zum vorzeitigen Verlassen einer Schleife. Üblicherweise steht Exit Loop in einer bedingten Abfrage, z.B. if bit Test then: exit loop: end if. Exit loop kann in einer Schleife an mehreren Stellen auftreten. Der Abstand vom Schleifenstart bis zum Schleifenende darf 254 Bytes nicht überschreiten. Bei größeren Abständen müssen Teile des Inhaltes in eine Subroutine geschrieben und diese aufgerufen werden. Schleifen können beliebig oft geschachtelt werden. Schleifen können sich mit IF- und For-Konstruktionen überlappen.


XA-Einstellungen

Die Angaben in diesem Einstellungsfenster werden beim Beenden des Programms in der Datei XA.CFG gespeichert und beim Starten von dort geladen, so dass sie für Ihre weitere Arbeit wirksam sind.

Extentions	In dieser Gruppe können Sie die Endungen für die Dateinamen Ihren Wünschen anpassen. Die Standard-Extentions sind:

XAQ	für Quelldateien

XAL	für Listingdateien

XAB	für Programmdateien (binär)

XAI	für Include-Dateien

XAD	für Disassemblings

Wann immer Sie Dateien laden oder speichern, werden diese Endungen vorgeschlagen.

Tabulator	Um Schleifen, Subroutinen und andere logische Strukturen optisch in Ihrer Quelldatei leichter erkennen zu können, sind Einrückungen mit dem Tabulator unerlässlich. Die Einstellung für den Tabulator wirkt sich sofort auf das aktuelle und alle danach geöffneten Fenster aus. Der Wert für den Tabulator ist abhängig von der Schriftgröße, der Schriftart und Ihrem persönlichem Empfinden.

Rechner	Im Hilfemenü finden Sie den Eintrag Rechner. Dieser Befehl öffnet Ihnen den Windows eigenen Rechner. Sollte sich der Rechner in einem anderen Pfad befinden oder wollen Sie ein anderes Programm starten, können Sie hier die entsprechende Änderung vornehmen.

OK	übernimmt die angezeigten Einstellungen und lässt sie sofort wirksam werden.

Standard	gibt für alle Felder mit Ausnahme des Tabulators die Standardwerte vor.

Abbrechen	schließt das Fenster, ohne Übernahme eventueller Änderungen.

Hilfe	zeigt diese Hilfeseite an.


Spezialfunktionsregister, SFR
Die XA-Spezialfunktionsregister SFR

System

Bus Configuration Register, BCR

Bus Timing Register High, BTRH

Bus Timing Register Low, BTRL

Die Segment Register CS, DS und ES

Segment Select Register, SSEL, Bits: ESWN, R6SEG, R5SEG, R4SEG, R3SEG, R2SEG, R1SEG, R0SEG

System Configuration Register, SCR

Power Control Register, PCON, Bits: PD, IDL

Programmstatuswort High, PSWH, Bits: SM, TM, RS1, RS0, IM3, IM2, IM1, IM0

Programmstatuswort Low, PSWL, Bits: C, AC, V, N, Z

MCS51 kompatibles PSW, PSW51, Bits: C, AC, F0, RS1, RS0, V, F1, P

Watchdog

Watchdog Control Register, WDCON; Bits: PRE2, PRE1, PRE0, WDRUN, WDTOF

Watchdog Feed Register, WFEED1 und WFEED2

Watchdog Timer Relod Register, WDL

Ports

Port 0 und Port 2, P0 und P2, Bits: P0.7 - P0.0 und P2.7 - P2.0

Port 1, P1, Bits: T2EX, T2, TxD1, RxD1, WRH

Port 3, P3, Bits: RD, WR, T1, T0, INT1, INT0, TxD0, RxD0

Portkonfigurationsregister, PnCFGA und PnCFGB

Timer

Timer Control Register, TCON, Bits: TF1, TR1, TF0, TR0, IE1, IT1, IE0, IT0

Timer Modus Register, TMOD

Timer Status Register, TSTAT, Bits: T1RD, T1OE, T0RD, T0OE

Timer 2 Control Register, T2CON, Bits: TF2, EXF2, RCLK0, TCLK0, EXEN2, TR2, C/T2, CP/RL2

Timer 2 Modus Register, T2MOD; Bits: RCLK1, TCLK1, T2RD, T2OE, DCEN

Die Timer und ihre Register: TL0, TH0, RTL0, RTH0, TL1, TH1, RTL1, RTH1, TL2, TH2, T2CAPL, T2CAPH

Serielle Ports

Serial Control Register, S0CON und S1CON, Bits: SM0_0, SM1_0, SM2_0, REN_0, TB8_0, RB8_0, TI_0, RI_0, SM0_1, SM1_1, SM2_1, REN_1, TB8_1, RB8_1, TI_1, RI_1

Serial Staus Register, S0STAT und S1STAT, Bits: FE0, BR0, OE0, STINT0, FE1, BR1, OE1, STINT1

Serial Buffer, S0BUF und S1BUF

Serielle Adressregister, SnADDR und SnADEN

Interrupt

Interrupt Freigabe-Register, IEH und IEL, Bits: ETI1, ERI1, ETI0, ERI0, EA, ET2, ET1, ET0, EX1, EX0

Interrupt Prioritäts-Register, IPAn

Software Interrupt Register, SWE und SWR, Bits: SWR7, SWR6, SWR5, SWR4, SWR3, SWR2, SWR1

Interrupt-Tabelle

Die Register, deren Adressen zwischen 400h und 43Fh liegen, sind bitadressierbar. Die Namen der Bits, wie sie im Assembler zu verwenden sind, sind vorstehend bei den bitadressierbaren SFRs aufgeführt.


Bus Configuration Register, BCR
Das Bus Configuration Register, BCR
Bits:	---	---	---	WAITD	BUSD	BC2	BC1	BC0

Resetwert: 0000 0x11, x = BUSW-Pin

Adresse: 46Ah,	nicht bitadressierbar

---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

WAITD	Wait Disable ignoriert mit einer Eins Wait-Anforderungen, die von der externen Peripherie am Eingang Wait (=EA) an den XA-Controller gestellt werden. Das Beschreiben mit einer Eins ist in Controllern mit internem ROM notwendig, da Low-Pegel am Eingang EA/Wait einen externen Speicherzugriff erzwingen würde.

BUSD	Bus Disable verhindert mit einer Eins den Zugriff auf den externen Bus, der automatisch ausgeführt wird, wenn der interne Programmspeicherbereich überschritten wird. Da der XA 16-Bytes im voraus liest, kann dieser Fall auch eintreten, wenn Programmcode gegen Ende des internen ROMs ausgeführt wird.

BC2, BC1 und BC0 wählen die Zahl von Datenbits und die Zahl der Adressleitungen aus.

BC2	BC1	BC0	Auswahl

0	0	0	8-Bit Datenbus, 12 Adressleitungen

0	0	1	8-Bit Datenbus, 16 Adressleitungen

0	1	0	8-Bit Datenbus, 20 Adressleitungen

0	1	1	8-Bit Datenbus, 24 Adressleitungen

1	0	0	reservierte Einstellung

1	0	1	reservierte Einstellung

1	1	0	16-Bit Datenbus, 20 Adressleitungen

1	1	1	16-Bit Datenbus, 24 Adressleitungen

Siehe auch SFR-Übersicht


Bus Timing Register High, BTRH
Das Bus Timing Register High-Byte, BTRH
Bits:	DW1	DW0	DWA1	DWA0	DR1	DR0	DRA1	DRA0

Resetwert: 1111 1111

Adresse: 469h,	nicht bitadressierbar

Mit den Bus-Timing Registern BTRH und BTRL kann der XA-Controller an verschiedene Zugriffszeiten von externen Speichern angepasst werden.

DW1 und DW0 steuern die Zeitdauer des kompletten Schreibevorgangs für das zweite Byte von Word-Daten im 8-Bit-Bus, der ohne ALE-Signal vorgenommen wird.

DW1	DW0	Aktion

0	0	1 Takt für das Schreiben

0	1	2 Takte für das Schreiben

1	0	3 Takte für das Schreiben

1	1	4 Takte für das Schreiben

DWA1 und DWA0 wählen die Zeitdauer des kompletten Schreibvorgangs von Daten mit ALE-Signal.

DWA1	DWA0	Aktion

0	0	2 Takte für das Schreiben

0	1	3 Takte für das Schreiben

1	0	4 Takte für das Schreiben

1	1	5 Takte für das Schreiben

DR1 und DR0 steuern die Zeitdauer des kompletten Lesevorgangs für das zweite Byte von Word-Daten aus dem RAM im 8-Bit-Bus, der ohne ALE-Signal vorgenommen wird.

DR1	DR0	Aktion

0	0	1 Takt für das Lesen

0	1	2 Takte für das Lesen

1	0	3 Takte für das Lesen

1	1	4 Takte für das Lesen

DRA1 und DRA0 wählen die Zeitdauer des kompletten Lesevorgangs von Daten aus dem RAM mit ALE-Signal.

DRA1	DRA0	Aktion

0	0	2 Takte für das Lesen

0	1	3 Takte für das Lesen

1	0	4 Takte für das Lesen

1	1	5 Takte für das Lesen

Siehe auch SFR-Übersicht


Takt bezeichnet die Oszillatorperiodendauer, die der CPU als Takt zugeführt wird. Es ist nicht die Länge eines Maschinenzyklus. Dieser Takt wird im System Configuration Register, SCR mit den Bits PT0 und PT1 dividiert und der Peripherie (Timer, Watchdog) zugeführt.


Address Latch Enable ALE ist ein Signal, mit dessen Hilfe die gerade auf dem Bus ausgegebene Adresse in einem Zwischenspeicher (74373, 74573) aufgefangen werden kann.


Bus Timing Register Low, BTRL
Das Bus-Timing Register Low-Byte, BTRL
Bits:	WM1	WM0	ALEW	---	CR1	CR0	CRA1	CRA0

Resetwert: 1110 1111

Adresse: 468h,	nicht bitadressierbar

Mit den Bus-Timing Registern BTRH und BTRL kann der XA-Controller an verschiedene Zugriffszeiten von externen Speichern angepasst werden.

WM1	Write Mode 1 bestimmt die Länge des Write-Signals WR.
0: WR dauert 1 Takt.
1: WR dauert 2 Takte.

WM0	Write Mode 0 bestimmt die Zeitdauer der Daten auf dem Bus.
0: Minimale Zeit.
1: Zeit ist ein CPU-Takt.

ALEW	ALE width selection bestimmt die Breite des ALE-Signals.
0: ALE-Breite ist 0,5 CPU-Takte.
1: ALE-Breite ist 1,5 CPU-Takte.

---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

CR1, CR0 Code Read wählt die Zeitdauer eines Lesevorgangs für Befehle/Daten aus dem ROM, wenn das ALE-Signal nicht verwendet wird.

CR1	CR0	Aktion

0	0	1 Takt für das Lesen

0	1	2 Takte für das Lesen

1	0	3 Takte für das Lesen

1	1	4 Takte für das Lesen

CRA1, CRA0 Code Read with ALE wählt die Zeitdauer eines Lesevorgangs für Befehle/Daten aus dem ROM, wenn das ALE-Signal verwendet wird.

CRA1	CRA0	Aktion

0	0	2 Takt für das Lesen

0	1	3 Takte für das Lesen

1	0	4 Takte für das Lesen

1	1	5 Takte für das Lesen

Siehe auch SFR-Übersicht


Segment Register CS, DS, ES
Die Segment Register

Code Segment, CS

Resetwert: 0000 0000

Adresse: 443h,	nicht bitadressierbar

Das Segmentregister CS bildet die obersten 8 Bits der 24-Bit Adresse beim Zugriff auf den externen Programmspeicher (16MB). Mit dem MOVC-Befehl werden Tabellendaten aus dem ROM gelesen. Die unteren 16 Bits stehen in einem der Zeigeregister R0 bis R6 (R7 ist der Stackpointer), die obersten 8 Bits stammen entweder aus dem Programmzähler PC oder aus dem Code Segment CS. Die Auswahl darüber wird im Segment Select Register SSEL getroffen.

Daten Segment, DS

Resetwert: 0000 0000

Adresse: 441h,	nicht bitadressierbar

Extra Segment, ES

Resetwert: 0000 0000

Adresse: 442h,	nicht bitadressierbar

Die Segmentregister DS und ES bilden die obersten 8 Bits der 24-Bit Adresse beim Zugriff auf den externen Datenspeicher (16MB). Der Datenzugriff erfolgt immer indirekt über die Register R0 bis R6 (R7 ist der Stackpointer). Daher kann jedem Register im Segment Select Register SSEL das DS- oder das ES-Segment zugeordnet werden. Da der User-Stack immer das DS-Segment benutzt, wird man wohl das ES-Segment für den Datentransfer benutzen.

Siehe auch SFR-Übersicht


Segment Select Register, SSELL
Das Segment Select Register, SSEL

Bits:	ESWEN	R6SEG	R5SEG	R4SEG	R3SEG	R2SEG	R1SEG	R0SEG
Adr.:	21F	21E	21D	21C	21B	21A	219	218

Resetwert: 0000 0000

Adresse: 403h,	bitadressierbar

Das Segment Select Register SSEL weist den einzelnen Registern beim Zugriff auf das externe RAM als oberste 8 Bits der 24-Bit-Adresse entweder das Daten Segment DS oder das Extra Segment ES zu. Beim Auslesen von Tabellendaten mit dem MOVC-Befehl entscheidet es zwischen Programmzähler PC oder Code Segment CS.

ESWEN	Extra Segment Write Enable erlaubt mit einer Eins Schreibzugriffe auf das Extra Segment ES.

RxSEL	Register x Select (x = 0 - 6).

Externes RAM

Eine Null wählt das Daten Segment DS, eine Eins das Extra Segment ES für das betreffende Pointer-Register.

Externes ROM (MOVC)

Eine Null wählt den Programmzähler PC, eine Eins das Code Segment CS für das betreffende Pointer-Register.

Siehe auch SFR-Übersicht


System Configuration Register, SCR
Bits:	---	---	---	---	PT1	PT0	CM	PZ

Resetwert: 0000 0000

Adresse: 440h,	nicht bitadressierbar

Das System Configuration Register SCR setzt die Modi für die globale Operation des XA-Controllers. Das Register sollte einmal beim Start beschrieben werden. In ihm finden sich vier Bits.

 ---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

PT1 und PT0 wählen den Frequenzteiler für den Systemtakt für sämtliche interne periphere Einrichtungen wie Timer, Watchdog etc.

PT1	PT0	Takt

0	0	f(Osc) : 4

0	1	f(Osc) : 16

1	0	f(Osc) : 64

1	1	reserviert

CM	0: Controller operiert im XA-Modus. XA-PSW = PSWH + PSWL
1: Controller operiert im MCS51-Modus. MCS51-PSW = PSW51

PZ	Zero Page.
0: Large Memory Modus mit 24 Bit Adressierung
1: Page 0 Modus mit 16 Bit Adressierung. Dieser Modus benötigt weniger Stack-Platz und verbessert die Interrupt-Reaktion in Systemen mit weniger als 64K Programmgröße.

Siehe auch SFR-Übersicht


Power Control Register, PCON
Das Power Control Register, PCON

Bits:	---	---	---	---	---	---	PD	IDL
Adr.:	227	226	225	224	223	222	221	220

Resetwert: 0000 0000

Adresse: 404h,	bitadressierbar

Das Power Control Register PCON steuert die Modi für die Leistungsreduzierung des XA-Controllers.

 ---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

PD	Power Down. Nach dem Setzen des Bits werden die Programmausführung und der Oszillator gestoppt. Die Inhalte der Register, SFRs, Port-Pins und des internen RAMs bleiben erhalten. Der Power Down kann nur durch einen Reset oder einen externen Interrupt abgebrochen werden.

IDL	Idle Modus. Nach dem Setzen des Bits wird die Programmausführung gestoppt. Der Oszillator und alle internen Peripherieeinrichtungen bleiben aber aktiv. Der Idle Modus wird nach einen internen oder externen Interrupt verlassen.

Siehe auch SFR-Übersicht


Programm Status Word high, PSWH
Das Programmstatuswort High, PSWH

Bits:	SM	TM	RS1	RS0	IM3	IM2	IM1	IM0
Adr.:	20F	20E	20D	20C	20B	20A	209	208

Resetwert: PSWH wird mit Inhalt der Adresse 0001 geladen.

Adresse: 401h,	bitadressierbar

Im Programmstatuswort High PSWH sind wichtige Arbeitsmodi und Parameter des XA-Controllers abgelegt. Im Systemmodus können alle Bits verändert werden, im Usermodus nur die Register Select Bits RS0 und RS1. Das Programmstauswort wird beim Reset und bei Interrupts mit Inhalten aus der Vektortabelle beschrieben.

SM	System Modus.
0: User Modus. Das aktuelle Programm hat nicht mehr den vollen Zugriff auf alle Bits, die das System beeinflussen.
1: System Modus. Das aktuelle Programm hat den vollen Zugriff auf alle Bits, die das System beeinflussen

TM	Trace Modus.
0: XA-Debugging Eigenschaften sind abgeschaltet.
1: XA-Debugging Eigenschaften sind freigegeben.

RS1 und RS0 wählen eine von vier Registerbänken aus. Eine Registerbank beinhaltet die Register R0 bis R3. Diese Register liegen in vierfacher Version getrennt vom RAM-Bereich vor, jedoch kann immer nur auf die mit RS1 und RS0 ausgewählten Bank zugegriffen werden.

RS1	RS0	Auswahl

0	0	Bank 0

0	1	Bank 1

1	0	Bank 2

1	1	Bank 3

IM3 bis IM0	Interrupt Mask. Diese Bits definieren die Priorität des gerade laufenden Programmteils. Der Ereignis-Interrupt-Controller vergleicht die IM-Bits mit der Priorität des aufgetretenen Interrupts um zu entscheiden, ob der aktuelle Programmteil unterbrochen werden kann oder nicht. Ein Wert von 0 in den IM-Bits legt die niedrigste Priorität fest, d.h. es kann von jedem Interrupt unterbrochen werden. Ein Wert von 1111 (Fh) wählt die höchste Priorität, so dass das Programm durch keinen Ereignis-Interrupt unterbrochen werden kann.

Siehe auch Interruptpriorität IPAn-Register

SFR-Übersicht


Programm Status Word low, PSWL
Das Programmstatuswort Low, PSWL

Bits:	C	AC	---	---	---	V	N	Z
Adr.:	207	206	205	204	203	202	201	200

Resetwert: PSWL wird mit Inhalt der Adresse 0000 geladen.

Adresse: 400h,	bitadressierbar

Im Programmstatuswort Low PSWL sind die Status-Flags zu finden, die nach jeder Befehlsausführung aktualisiert werden.

C	Carry. Zahlreiche Befehle - vor allem aber arithmetische und logische - verändern das Carry. Der Assembler gibt Ihnen die Möglichkeit, das Carry mit If C then oder mit If not C then zu testen.

AC	Auxiliary Carry. Dieses Bit wird durch die Befehle ADD, ADDC, CMP, SUB und SUBB tangiert, wenn eine Übertrag vom Low-Nibble ins High-Nibble erfolgt. Es dient in erster Line für die richtige Arbeitsweise des DA-Befehls.

 ---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

V	Overflow Flag. Dieses Bit wird beim Überlauf eines arithmetischen Befehls (ADD, ADDC, CMP, NEG, SUB, SUBB) von signierten Zahlen gesetzt. Es wird auch bei einer Division durch Null gesetzt oder, wenn das Divisionsergebnis die Größe des Ziel-Registers überschreitet. Bei der Multiplikation wird dieses Bit gesetzt, wenn das Produkt die Größe des Quellregisters übersteigt. Das Overflow-Bit wird somit als Indikator zur Zahlenbereichsüberschreitung genutzt. Im Programm testen Sie es mit If OV then bzw. If not OV then.

N	Das Negativ Flag ist mit dem MSB des Ergebnisses eines arithmetischen Befehls oder dem MSB eines Wertes bei einem MOV-Befehl identisch. PUSH und POP ändern das Bit nicht.

Z	Das Zero Flag wird gesetzt, wenn das Ergebnis einer Berechnung oder die transferrierten Daten Null sind, andernfalls wird es gelöscht. PUSH, POP und XCH ändern das Bit nicht.

Siehe auch SFR-Übersicht


MCS51 kompatibles PSW, PSW51

Bits:	C	AC	F0	RS1	RS0	V	F1	P
Adr.:	217	216	215	214	213	212	211	210

Resetwert: xx0x xx00, x-Bits werden mit dem Inhalt des Resetvektors beschrieben.

Adresse: 402h,	bitadressierbar

Wenn das Bit CM im System Configuration Register SCR gesetzt ist, operiert der XA-Controller im MCS51-Modus und benutzt das MCS51 kompatible Programmstatuswort PSW51. Mit CM = 0 ist werden die Flags im Programm Status Word low PSWL benutzt! Im Programmstatuswort PSW51 sind die Status-Flags zu finden, die nach jeder Befehlsausführung aktualisiert werden.

C	Carry. Zahlreiche Befehle - vor allem aber arithmetische und logische - verändern das Carry. Der Assembler gibt Ihnen die Möglichkeit, das Carry mit If C then oder mit If not C then zu testen.

AC	Auxiliary Carry. Dieses Bit wird durch die Befehle ADD, ADDC, CMP, SUB und SUBB tangiert, wenn eine Übertrag vom Low-Nibble ins High-Nibble erfolgt. Es dient in erster Line für die richtige Arbeitsweise des DA-Befehls.

F0	ist ein Bit zur allgemeinen Verwendung. Es kann jederzeit beschrieben und gelesen werden. Der Assembler testet es mit If bit F0 then bzw. If not Bit F0 then.

RS1 und RS0 wählen eine von vier Registerbänken aus. Eine Registerbank beinhaltet die Register R0 bis R3. Diese Register werden im MCS51-Modus in den RAM-Bereich kopiert und belegen dort wie im 8051 die Adressen von 0000 bis 001Fh. Sie sind somit direct-adressierbar.

RS1	RS0	Auswahl

0	0	Bank 0, Adressen 00h bis 07h

0	1	Bank 1, Adressen 08h bis 0Fh

1	0	Bank 2, Adressen 10h bis 17h

1	1	Bank 3, Adressen 18h bis 1Fh

V	Overflow Flag. Dieses Bit wird beim Überlauf eines arithmetischen Befehls (ADD, ADDC, CMP, NEG, SUB, SUBB) von signierten Zahlen gesetzt. Es wird auch bei einer Division durch Null gesetzt oder, wenn das Divisionsergebnis die Größe des Ziel-Registers überschreitet. Bei der Multiplikation wird dieses Bit gesetzt, wenn das Produkt die Größe des Quellregisters übersteigt. Das Overflow-Bit wird somit als Indikator zur Zahlenbereichsüberschreitung genutzt. Im Programm testen Sie es mit If OV then bzw. If not OV then.

F1	ist ein Bit zur allgemeinen Verwendung. Es kann jederzeit beschrieben und gelesen werden. Der Assembler testet es mit If bit F1 then bzw. If not Bit F1 then.

P	Das Paritätsbit zeigt gerade Parität des Akkus = R4L an. Es kann für die serielle Datenübertragung als Prüfbit verwendet werden.

Siehe auch SFR-Übersicht


Watchdog Control Register, WDCON
Watchdog Control, WDCON

Bits:	PRE2	PRE1	PRE0	---	---	WDRUN	WDTOF	---
Adr.:	2FF	2FE	2FD	2FC	2FB	2FA	2F9	2F8

Einschalt-Reset: 1110 0100	Watchdog-Reset: 1110 0110

Adresse: 41Fh,	bitadressierbar

Zum Beschreiben oder Lesen des Registers bzw. dessen Bits muss eine Watchdog Feed Sequenz unmittelbar vorausgehen, z.B. WFEED1=#a5h: WFEED2=#5ah: clr PRE2.

PRE2 bis PRE0	Watchdog-Vorteiler. In den Versionen mit maskenprogrammiertem ROM werden diese Bits aus dem ROM gelesen (mit EA = 1) und können daher nicht geändert werden. In den ROM-losen und EPROM-Versionen oder in der ROM-Version mit EA = 0 werden diese Bits dem Watchdog Control Register WDCON entnommen und können auch geändert werden.

PRE2	PRE1	PRE0	Teiler

0	0	0	Systemtakt × 32 × 2

0	0	1	Systemtakt × 32 × 4

0	1	0	Systemtakt × 32 × 8

0	1	1	Systemtakt × 32 × 16

1	0	0	Systemtakt × 32 × 32

1	0	1	Systemtakt × 32 × 64

1	1	0	Systemtakt × 32 × 128

1	1	1	Systemtakt × 32 × 256

 ---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

WDRUN	Watchdog Run. Eine Eins startet den Watchdog, eine Null stoppt ihn.
Achtung! Nach einem Einschaltreset ist der Watchdog immer aktiv. Wenn Sie ihn nicht benötigen, sollten Sie ihn unmittelbar nach der Systemkonfigurierung abschalten mit WFEED1=#a5h: WFEED2=#5ah: clr WDRUN.

WDTOF	Am Watchdog Time Out Flag kann die Software die Herkunft eines Resets erkennen. 0: Einschalt-Reset, 1: Watchdog-Reset, es sollte sogleich gelöscht werden mit WFEED1=#a5h: WFEED2=#5ah: clr WDTOF.

Siehe auch SFR-Übersicht


Watchdog Feed Register, WFEED1, WFEED2
Die Watchdog Feed Register

WFEED1

Resetwert: xxxx xxxx

Adresse: 45Dh,	nicht bitadressierbar

WFEED2

Resetwert: xxxx xxxx

Adresse: 45Eh,	nicht bitadressierbar

Diese beiden Register dienen nur der Ausführung einer Watchdog Feed Sequenz, die unmittelbar jedem Lese- oder Schreibzugriff auf das Watchdog Control Register WDCON vorausgehen muss. Auch das Nachladen des Watchdog Timers aus dem Watchdog Timer Reload Register WDL, um ihn am Unterlauf zu hindern, erfolgt mit einer Watchdog Feed Sequenz: WFEED1=#a5h: WFEED2=#5ah

Siehe auch SFR-Übersicht


Watchdog Timer Reload, WDL
Watchdog Relaod, WDL

Reset: 0000 0000

Adresse: 45Fh,	nicht bitadressierbar

Der Watchdog Timer ist ein Abwärtszähler, der nicht direkt nachgeladen werden kann. Er übernimmt lediglich den Wert aus dem Watchdog Reload Register WDL. Sein Inhalt kann jederzeit neu beschrieben werden. Die Übernahme in den Watchdog Timer erfolgt jedoch erst nach einer Watchdog Feed Sequenz, die in regelmäßigen Zeitabständen ausgeführt werden muß, damit der Watchdog keinen Reset auslöst: WFEED1=#a5h: WFEED2=#5ah

Siehe auch SFR-Übersicht


Unter der Watchdog Feed Sequenz versteht man das Beschreiben des Registers WFEED1 mit dem Wert A5h und das unmittelbar folgende Beschreiben des Registers WFEED2 mit dem Wert 5Ah. Tritt beim Schreiben des zweiten Bytes ein Fehler auf, wird sofort ein Watchdog Reset ausgelöst.


Oszillatortakt, der mit den Bits PT1 und PT0 im System Configuration Register SCR geteilt wird. Er ist der Basistakt für alle peripheren Einrichtungen im XA-Controller.


Ports 0 und 2, P0, P2
Port 0 und 2

Port 0, P0

Resetwert: 1111 1111

Adresse: 430h,	bitadressierbar. Bitadressen P0.0: 380h bis P0.7: 387h

Port 0 ist nur in den Bausteinen mit internem ROM bzw. EPROM(und ohne externes RAM) ein konfigurierbarer 8-Bit I/O-Port, dessen Pins einzeln als Aus- oder Eingänge konfiguriert werden können. Bei der Benutzung des externen Programm-/Datenbus führt Port 0 das gemultiplexte Low-Befehls-/Datenbyte sowie die Adressleitungen 4 bis 11. Der Port darf in diesem Fall nicht mit einer Null beschrieben werden! Die Konfiguration des I/O-Ports erfolgt mit den Registern P0FGA und P0FGB.

Port 2, P2

Resetwert: 1111 1111

Adresse: 432h,	bitadressierbar. Bitadressen P2.0: 390h bis P2.7: 397h

Port 2 ist ein konfigurierbarer 8-Bit I/O-Port, dessen Pins einzeln als Aus- oder Eingänge konfiguriert werden können. Bei der Benutzung des externen Programm-/Datenbus im 16-Bit Modus führt Port 2 das gemultiplexte High-Befehls-/Datenbyte sowie die Adressleitungen 12 bis 19. Der Port darf in diesem Fall nicht mit einer Null beschrieben werden! Im 8-Bit-Modus kann die Zahl der Adressleitungen an Port 2 programmiert werden. Die Konfiguration des I/O-Ports erfolgt mit den Registern P2FGA und P2FGB.

Siehe auch SFR-Übersicht


Port 1, P1

Bits:	T2EX	T2	TxD1	RxD1	P1.3	P1.2	P1.1	WRH
Adr.:	38F	38E	38D	38C	38B	38A	389	388

Reset: 1111 1111

Adresse: 431h,	bitadressierbar

Port 1 ist den Bausteinen mit internem ROM bzw. EPROM(und ohne externes RAM) ein konfigurierbarer 8-Bit I/O-Port, dessen Pins einzeln als Aus- oder Eingänge konfiguriert werden können. Die Konfiguration des I/O-Ports erfolgt mit den Registern P1FGA und P1FGB. Die Zweitfunktionen von Port 1 sind:

P1.3 bis P1.0	Adressleitungen A0 bis A3 bei externem Programm- oder Datenspeicher. Diese Leitungen sind nicht mit Daten gemultiplext, so dass bei Änderungen an diesen Pins kein ALE-Signal aktiv wird. Der Controller holt sich damit bis zu 16 Bytes im voraus (Prefetch).

T2EX	Timer/Zähler 2 Reload/Capture/Direction Steuerung.

T2	Timer/Zähler 2 externer Zähleingang/Taktausgang.

TxD1	Transmit external Data 1. Datenausgang des seriellen Ports 1.

RxD1	Receive external Data 1. Dateneingang des seriellen Ports 1.

P1.3 bis P1.1 Adressbits A3 bis A1 des externen Adressbusses.

WRH	Im 8-Bit Bus ist dieser Pin die Adressleitung A0, im 16-Bit Bus gibt dieser Pin das Schreibsignal für das High-Byte aus.

Siehe auch SFR-Übersicht


Port 3, P3

Bits:	RD	WR	T1	T0	INT1	INT0	TxD0	RxD0
Adr.:	39F	39E	39D	39C	39B	39A	399	398

Reset: 1111 1111

Adresse: 433h,	bitadressierbar

Port 3 ist Systemen ohne externem RAM ein konfigurierbarer 8-Bit I/O-Port, dessen Pins einzeln als Aus- oder Eingänge konfiguriert werden können. Für die Kommunikation mit einem externen RAM werden die Bits P3.7 = RD und P3.6 = WR verwendet. Die Konfiguration des I/O-Ports erfolgt mit den Registern P3FGA und P3FGB. Die Zweitfunktionen von Port 1 sind:

RD	Lesesignal für den externen Datenspeicher.

WR(L)	Schreibsignal für den externen Datenspeicher (Low-Byte).

T1/BUSW	Externer Eingang für Zähler 1 oder Überlaufausgang für Timer 1. Ferner wird der logische Pegel an diesem Pin bei einem Reset gespeichert, mit dem dann die externe Datenbusbreite festgelegt wird. 0: 8-Bit Datenbus, 1: 16-Bit-Datenbus. Danach hat der Pin die übliche I/O-Funktion.

T0	Externer Eingang für Zähler 0 oder Überlaufausgang für Timer 0.

INT1	Eingang für externen Interrupt 1.

INT0	Eingang für externen Interrupt 0.

TxD0	Transmit external Data 0. Datenausgang des seriellen Ports 0.

RxD0	Receive external Data 0. Dateneingang des seriellen Ports 0.

Siehe auch SFR-Übersicht


Portkonfigurationsregister A und B, PnCFGA/B
Portkonfigurationsregister, PnCFG

Reset:	PnCFGA: 1111 1111,  PnCFGB: 0000 0000

Adressen:	nicht bitadressierbar

P0CFGA: 470h

P1CFGA: 471h

P2CFGA: 472h

P3CFGA: 473h

P0CFGB: 4F0h

P1CFGB: 4F1h

P2CFGB: 4F2h

P3CFGB: 4F3h

Die Portkonfigurationsregister legen die elektrischen Eigenschaften der einzelnen Pins fest. Jede Bitnummer in diesen Registern entspricht der Pinnummer des betreffenden Ports.

PnCFGB	PnCFGA	Port Output Modus

0	0	Open Drain

0	1	Quasi-bidirectional (Resetwert)

1	0	High Impedance (Tri State)

1	1	Push-Pull

Open Drain (I/O)

Schreibt man eine Null an den Pin, so führt er Masse, schreibt man eine Eins, so führt er keine Spannung. Die Verwendung als Dateneingang bleibt hiervon unberührt. Will man den Open Drain Modus als logischen Ausgang verwenden, ist ein Pullup-Widerstand notwendig. Gedacht ist dieser Modus für eine negative ODER-Verdrahtung mit mehreren Pins oder Bausteinen.

Quasi-bidirectional (I/O)

Die Reseteinstellung der Ports ist die quasi-bidirectionale Konfiguration, die mit den Ports der MCS51-Familie identisch ist. Dieser Typ kann mit einer Eins beschrieben sowohl als Ein- oder Ausgang benutzt werden, ohne dass man den Port neu konfiguriert. Durch eine interne Rückkopplung des High-Pegels kann der Pin einige TTL-Lasten treiben. Wird der Pin an Masse gezogen, wird die Rückkopplung unwirksam, und es ist nur noch die schwache Last des Pullups zu treiben.

High Impedance (Input)

Im High Impedance gibt der Pin weder Plus noch Minus aus, der Pin hängt in der Luft. Bei dieser Beschaltung ist der Pin nur als Eingang wirksam.

Push-Pull (Output)

Im Push-Pull-Zustand liegt der Pin mit einer Eins an Plus und mit einer Null an Masse, und es kann ihm bei beiden Pegeln ein kräftiger Strom (ca. 15 mA) entnommen werden. Der Pin hat nur noch Output-Funktion.

Siehe auch SFR-Übersicht


Timer Control Register, TCON

Bits:	TF1	TR1	TF0	TR0	IE1	IT1	IE0	IT0
Adr.:	287	286	285	284	283	282	281	280

Reset: 0000 0000

Adresse: 410h,	bitadressierbar

TF1	Timer 1 Überlauf. Bei einem Zählerüberlauf (FFFF → 0000) wird das Bit gesetzt. Das Bit wird entweder durch einen Befehl (clr TF1) oder beim Sprung in den Timer 1 Interrupt gelöscht.

TR1	Timer 1 Run. Eine Eins startet den Timer 1, eine Null stoppt ihn.

TF0	Timer 0 Überlauf. Bei einem Zählerüberlauf (FFFF → 0000) wird das Bit gesetzt. Das Bit wird entweder durch einen Befehl (clr TF0) oder beim Sprung in den Timer 0 Interrupt gelöscht.

TR0	Timer 0 Run. Eine Eins startet den Timer 0, eine Null stoppt ihn.

IE1	Interrupt 1 Edge. Eine Eins zeigt an, dass am INT1-Pin ein Interrupt-Signal erkannt wurde. Durch den Sprung in die Interrupt-Routine wird das Bit gelöscht..

IT1	Interrupt 1 Type. Mit einer Eins löst eine negative Flanke, mit einer Null löst Low-Pegel am INT1-Eingang einen Interrupt aus.

IE0	Interrupt 0 Edge. Eine Eins zeigt an, dass am INT0-Pin ein Interrupt-Signal erkannt wurde. Durch den Sprung in die Interrupt-Routine wird das Bit gelöscht..

IT0	Interrupt 0 Type. Mit einer Eins löst eine negative Flanke, mit einer Null löst Low-Pegel am INT0-Eingang einen Interrupt aus.

Siehe auch Interrupt Enable Register IEL

SFR-Übersicht


Timer Modus Register, TMOD
Bits:	GATE	C/T	M1	M0	GATE	C/T	M1	M0

Resetwert: 0000 0000

Adresse: 45Ch,	nicht bitadressierbar

Die Bits 0 bis 3 beziehen sich auf Timer 0, die Bits 4 bis 7 auf Timer 1.

GATE	Mit einer Eins läuft der Timer bzw. Zähler nur dann, wenn der INTn-Pin high und das Bit TRn gesetzt sind. Mit Gate = 0 läuft der Timer/Zähler, wenn das Bit TRn gesetzt ist.

C/T	Eine Null wählt den Timer-Betrieb (Takt kommt vom internen Systemtakt), eine Eins wählt den Zählerbetrieb (Takt kommt vom Pin Tn).

M1 und M0 legen den Arbeitsmodus der Timer 0 und 1 fest.

M1	M0	Modus

0	0	16-Bit Nachlademodus. Der Nachladewert steht in den Reload Timer Registern RTL0/RTH0 bzw. RTL1/RTH1. Ein Überlauf des Timers bewirkt das Setzen des TFn-Bits im TCON-Register und das Laden des Timers mit den Werten aus den RTL/H-Registern.

0	1	16-Bit Timer/Zähler

1	0	8-Bit Nachlademodus. Es läuft nur das Low-Byte des Timers. Ein Überlauf setzt nicht nur das TFn-Bit, sondern schreibt den Inhalt des Reload Timer Register Low RTLn in das Low-Byte des Timers TLn.

1	1	Timer 0 bildet zwei 8-Bit Timer; Timer 1 steht. Die Bits für Timer 0 steuern nun das Low-Byte, die Bits für Timer 1 steuern das High-Byte von Timer 0.

Siehe auch SFR-Übersicht


Timer Status Register, TSTAT

Bits:	---	---	---	---	T1RD	T1OE	T0RD	T0OE
Adr.:	28F	28E	28D	28C	28B	28A	289	288

Resetwert: 0000 0000

Adresse: 411h,	bitadressierbar

 ---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

T1RD	Wenn Timer 1 gelesen wird und dabei gerade ein Überlauf vom Low-Byte ins High-Byte erfolgt, wird dieses Bit gesetzt. Die Software kann daran erkennen, dass das Leseergebnis eventuell fehlerhaft ist.

T1OE	Eine Null gestattet das Takten von Timer 1 über den Eingang T1, sofern der Zählerbetrieb mit C/T = 1 gewählt ist. Eine Eins invertiert mit jedem Überlauf des Timer 1 den Pegel am Pin T1. Das ergibt durch Änderung der Nachladewerte eine Pulsweitenmodulation.

T0RD	Wenn Timer 0 gelesen wird und dabei gerade ein Überlauf vom Low-Byte ins High-Byte erfolgt, wird dieses Bit gesetzt. Die Software kann daran erkennen, dass das Leseergebnis eventuell fehlerhaft ist.

T0OE	Eine Null gestattet das Takten von Timer 0 über den Eingang T0, sofern der Zählerbetrieb mit C/T = 1 gewählt ist. Eine Eins invertiert mit jedem Überlauf des Timer 0 den Pegel am Pin T0. Das ergibt durch Änderung der Nachladewerte eine Pulsweitenmodulation.

Siehe auch SFR-Übersicht


Timer 2 Control Register, T2CON

Bits:	TF2	EXF2	RCLK0	TCLK0	EXEN2	TR2	C/T2	CP/RL2
Adr.:	28F	28E	28D	28C	28B	28A	289	288

Resetwert: 0000 0000

Adresse: 418h,	bitadressierbar

TF2	Timer 2 Überlauf. Bei einem Zählerüberlauf wird das Bit gesetzt und beim Eintritt in die Interruptroutine gelöscht. TF2 wird nicht gesetzt, wenn die Bits RCLK0, TCLK0, RCLK1, TCLK1 oder T2OE gesetzt sind.

EXF2	Das Bit wird bei einem Capture- oder Reloadvorgang mit einer negativen Flanke am Eingang T2EX (mit EXEN = 1) gesetzt. Dieses Bit kann einen Interrupt auslösen. EXF2 wird nicht automatisch gelöscht, das muss durch die Software erfolgen (clr EXF2).

RCLK0	Receive Clock Flag.

TCLK0	Transmit Clock Flag. RCLK0 und TCLK0 werden benutzt, um den Timer 2 Überlauf als Taktquelle für den seriellen Port 0 (UART0) zu wählen.

EXEN2	Dieses Bit gibt mit einer Eins den Capture- oder Reloadvorgang frei, wenn an T2EX eine negative Flanke auftritt.

TR2	Eine Eins startet den Timer 2, eine Null stoppt ihn.

C/T2	0: Taktquelle ist der interne Systemtakt (Timer).
1: Taktquelle ist der externe Takt am Pin T2.

CP/RL2	Capture/Reload Flag. Mit CP/RL2 = 1 und EXEN2 = 1 wird ein Capture-Vorgang bei einer negativen Flanke an T2EX ausgelöst; mit CP/RL2 = 0 und EXEN2 = 1 wird ein Reload-Vorgang erzeugt, wenn entweder Timer 2 überläuft oder eine negative Flanke an T2EX auftritt. Mit RCLK = 1 oder TCLK = 1 wird Timer 2 in den Reload-Modus versetzt und CP/RL2 hat keinen Effekt mehr.

Siehe auch Interrupt Enable Register IEL

SFR-Übersicht


Timer 2 Modus Register, T2MOD

Bits:	---	---	RCLK1	TCLK1	---	TR2RD	T2OE	DCEN
Adr.:	2CF	2CE	2CD	2CC	2CB	2CA	2C9	2C8

Resetwert: 0000 0000

Adresse: 419h,	bitadressierbar

 ---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

RCLK1	Receive Clock Flag.

TCLK1	Transmit Clock Flag. RCLK1 und TCLK1 werden benutzt, um den Timer 2 Überlauf als Taktquelle für den seriellen Port 1 (UART1) zu wählen.

T2RD	Wenn Timer 2 gelesen wird und dabei gerade ein Überlauf vom Low-Byte ins High-Byte erfolgt, wird dieses Bit gesetzt. Die Software kann daran erkennen, dass das Leseergebnis eventuell fehlerhaft ist.

T2OE	Eine Null gestattet das Takten von Timer 2 über den Eingang T2, sofern der Zählerbetrieb mit C/T2 = 1 gewählt ist. Eine Eins invertiert mit jedem Überlauf des Timer 2 den Pegel am Pin T2. Das ergibt durch Änderung der Nachladewerte eine Pulsweitenmodulation.

DCEN	0: Timer 2 zählt abwärts. 1: Timer 2 zählt aufwärts.

Siehe auch SFR-Übersicht


Die Timer und ihre Register
Timer - Register

Die XA-Controller verfügen alle über drei Timer (Taktquelle ist intern), die auch als Zähler (Taktquelle ist extern) betrieben werden können. Alle Timer sind 16-Bit Timer und zählen standardmäßig aufwärts. Timer 2 kann auch abwärts zählen. Alle Timer verfügen über einen Nachlademodus, mit dessen Hilfe eine Digital/Analog-Wandlung möglich ist (Pulsweitenmodulation PWM). Für Timer 2 steht auch ein Capture-Betrieb zur Verfügung. Timer 2 kann ferner die Quelle für die Baudratenerzeugung für beide seriellen Ports sein.

Zu jedem Timer gehören je zwei 8-Bit-Register, die mit dem Nachladewert beschrieben werden. Timer 2 benutzt diese Register auch zum Auffangen des aktuellen Zählerstandes im Capture-Modus. Somit belegen die Timer mit ihren Hilfsregistern zwölf SFR-Plätze.

Resetwert: 0000 0000 alle Timer und ihre Nachladeregister, nicht bitadressierbar.

Adresse	SFR	Beschreibung

450h	TL0	Timer 0 Low-Byte

451h	TH0	Timer 0 High-Byte

454h	RTL0	Reload Timer 0 Low-Byte

455h	RTH0	Reload Timer 0 High-Byte

452h	TL1	Timer 1 Low-Byte

453h	TH1	Timer 1 High-Byte

456h	RTL1	Reload Timer 1 Low-Byte

457h	RTH1	Reload Timer 1 High-Byte

458h	TL2	Timer 2 Low-Byte

459h	TH2	Timer 2 High-Byte

45Ah	T2CAPL	Capture/Reload Timer 2 Low-Byte

45Bh	T2CAPH	Capture/Reload Timer 2 High-Byte

Die Einstellungen für die Timer 0 und 1 finden sich in den Registern TCON, TMOD und TSTAT, die Einstellungen für Timer 2 in den Registern T2CON und T2MOD. Der interne Systemtakt für alle Timer inklusive Watchdog wird im System Configuration Register SCR festgelegt. Die Interrupts werden im Interrupt Enable Register IE freigegeben.

Siehe auch SFR-Übersicht


Serial Control Register, S0CON und S1CON
Serial Control Register, SnCON

Bits:	SM0_n	SM1_n	SM2_n	REN_n	TB8_n	RB8_n	TI_n	RI_n
n = 0 oder 1

Die Bit-Bezeichnungen für den seriellen Port 0 lauten SM0_0 etc., die für Port 1 SM0_1 etc., z.B. setb SM0_1. Die Bitadressen sind 300h bis 307h für den seriellen Port 0 bzw. 320h bis 327h für den seriellen Port 1.

Resetwert: 0000 0000 für beide Register

Adresse S0CON: 420h; S1CON: 424h, bitadressierbar

SM2 und SM1 wählen einen der vier Modi für die seriellen Ports. In allen vier Modi wird das Senden der Daten durch Beschreiben des seriellen Buffers SBUF gestartet.

SM2	SM1	Modus

0	0	Modus 0, 8-Bit Schieberegister. Baudrate ist fOsc/16. Die seriellen Daten werden über Pin RxD gesendet oder empfangen. Am Pin TxD wird der Schiebetakt ausgegeben.

0	1	Modus 1, 8-Bit UART. Zehn Bits werden über Pin TxD gesendet oder über RxD empfangen: ein Start-Bit low, acht Datenbits mit LSB zuerst und ein Stopbit high. Beim Empfang geht das Stopbit nach RB8. Die Baudrate ist variabel.

1	0	Modus 2, 9-Bit UART. Elf Bits werden über Pin TxD gesendet oder über RxD empfangen: ein Start-Bit low, acht Datenbits mit LSB zuerst, das Bit TB8 und ein Stopbit high. Das Bit TB8 kann als Paritätsbit ein Kontrolle der übermittelten Daten geben. Beim Empfang geht das neunte Bit nach RB8. Die Baudrate kann bis zu 1/32 der Oszillatorfrequenz programmiert werden.

1	1	Modus 3, 9-Bit UART. Elf Bits werden über Pin TxD gesendet oder über RxD empfangen: ein Start-Bit low, acht Datenbits mit LSB zuerst, das Bit TB8 und ein Stopbit high. Somit entspricht Modus 3 dem Modus 2 bis auf die Baudrate, sie ist variabel.

SM2	0: Keine Multiprozessorkommunikation.
1: Freigabe der Multiprozessorkommunikation. Im Modus 2 und 3 wird das Receive Interrupt Bit RI nicht gesetzt, wenn das empfangene neunte Bit eine Null ist. In Modus 1 wird das Receive Interrupt Bit RI nicht gesetzt, wenn ein ungültiges Stopbit erkannt wurde, d.h. wenn RB8 = 0. In Modus 1 sollte SM2 immer null sein.

REN	0: serieller Datenempfang gesperrt.
1: serieller Datenempfang freigegeben.

TB8	Neuntes Sendebit in den Modi 2 und 3. In den Modi 0 und 1 keine Funktion.

RB8	Neuntes Empfangsbit in den Modi 2 und 3. Im Modus 1 ist es das empfangene Stopbit, im Modus 0 ohne Funktion.

TI	Transmit Interrupt. Wird nach dem Senden der Daten gesetzt und kann den seriellen Sendeinterrupt auslösen. Es muß durch die Software gelöscht werden, z.B. clr TI_0.

RI	Receive Interrupt. Wird nach dem Empfang der Daten gesetzt und kann den seriellen Empfangsinterrupt auslösen. Es muß durch die Software gelöscht werden, z.B. clr RI_0.

Siehe auch Interrupt Enable Register IEH

SFR-Übersicht


Serial Status Register, S0STAT und S1STAT
Serial Status Register, SnSTAT

Bits:	---	---	---	---	FEn	BRn	OEn	STINTn
n = 0 oder 1

Die Bit-Bezeichnungen für den seriellen Port 0 lauten FE0 etc., die für Port 1 FE1 etc., z.B. setb FE1. Die Bitadressen sind 308h bis 30Fh für den seriellen Port 0 bzw. 328h bis 32Fh für den seriellen Port 1.

Resetwert: 0000 0000 für beide Register

Adresse S0STAT: 421h; S1STAT: 425h, bitadressierbar

FE	Das Framing Error Bit wird bei einem falschen Stopbit am Ende einer seriellen Datenübertragung gesetzt.

BR	Das Break Detect Bit wird gesetzt, wenn alle eingehenden seriellen Bits inklusive Stopbit Nullen sind.

OE	Das Overrun Error Bit wird beim Eingang eines Zeichens gesetzt, wenn das Bit Receive Interrupt RI im Register SCON gesetzt ist, wenn also das letzte Byte wahrscheinlich noch nicht gelesen wurde.

STINT	Die drei zuvor genannten Bits können nur dann einen Interrupt auslösen, wenn STINT = 1.

Siehe auch Interrupt Enable Register IEH

SFR-Übersicht


Serial Buffer, S0BUF und S1BUF
Serial Buffer, SnBUF

Resetwert: xxxx xxxx für beide Register

Adresse S0BUF: 460h; S1BUF: 464h, nicht bitadressierbar

Der serielle Buffer besitzt zwar für jeden seriellen Port dieselbe SFR-Adresse, besteht aber aus zwei physikalisch getrennten Registern. Auf das eine wird beim Lesen, auf das andere beim Schreiben zugegriffen. Somit ist es möglich, Daten zu empfangen und gleichzeitig zu senden.

Der serielle Sendevorgang wird durch das Beschreiben des SBUF gestartet, z.B. S0BUF = #´a´. Das Ende des Sendens wird durch eine Eins im Bit TI im Register SCON angezeigt.

Der Datenempfang muss hingegen durch Setzen des Bits REN im Register SCON ermöglicht werden. Die Empfangsdaten stehen im gleichnamigen Register SBUF, was durch eine Eins im Bit RI (SCON) angezeigt wird. Sie werden gelesen mit z.B. R2L = S1BUF. Kommen neue Daten an, ohne dass die alten gelesen wurden, wird das durch eine Eins im Bit OE im Serial Status Register SnSTAT angezeigt.

Die seriellen Interrupts sind (Symbol verwendet der Assembler zur Kennzeichnung des Interrupts):

Symbol	Vektor	Freig.-Bit	Interrupt

RI0	A0h	ERI0	Empfang ser. Port 0

TI0	A4h	ETI0	Senden ser. Port 0

RI1	A8h	ERI1	Empfang ser. Port 1

TI1	ACh	ETI1	Senden ser. Port 1

Siehe auch Interrupt Enable Register IEH

SFR-Übersicht


Serielle Adressregister, SnADDR und SnADEN
SnADDR, SnADEN

Resetwert: 0000 0000 für alle Register

Adressen:	nicht bitadressierbar

S0ADDR: 461h

S0ADEN: 462h

S1ADDR: 465h

S1ADEN: 466h

Die Register SnADDR und SnADEN werden paarweise für die automatische Adresserkennung in der Multiprozessorkommunikation in den seriellen Modi 2 und 3 verwendet (Setzen von Bit SM2 im Register SnCON). In SnADDR schreibt die Software ihre eigene Prozessoradresse und in SnADEN eine Bitmaske, mit deren Hilfe der Controller auf einen gewissen Adressbereich reagieren kann. Eine Null in SnADEN bewirkt, dass das korrespondierende, einkommende Bit der Prozessoradresse ignoriert wird, d.h. für den Adressvergleich immer gültig ist.

Beispiel

In S0ADDR steht	1111 0000,

in S0ADEN	1111 1010.

Dann werden die folgenden eingehenden Adressen als gültig erkannt:

1111 0000

1111 0001

1111 0100

1111 0101

Ungültige Adressen wären z.B.

1111 0010

1111 1001

1110 0111

Stehen in S0ADEN acht Einsen, ist genau eine Adresse - hier 1111 0000 - gültig. Stehen in S0ADEN acht Nullen, ist jede Adresse gültig.

Siehe auch SFR-Übersicht


Interruptfreigabe, IEH und IEL
Interrupt Enable Register

Interrupt Enable Register Low, IEL

Bits:	EA	---	---	ET2	ET1	EX1	ET0	EX0

Adr.:	337	336	335	334	333	332	331	330

Resetwert: 0000 0000

Adresse: 426h	bitadressierbar

Eine Eins in dem betreffendem Bit gibt den Interrupt frei, eine Null sperrt ihn.

EA	Enable All ist die globale Interruptfreigabe. Einige Operation dürfen durch keinen Interrupt gestört werden wie z.B. eine Watchdog Feed Sequenz. Für solche Fälle sperrt man jeglichen maskierbaren Interrupt mit clr EA und gibt die Interrupts anschließend wieder frei mit setb EA.

 ---	Bit ohne Funktion. Es sollte jedoch von der Software nicht beschrieben werden, um Konflikte mit künftigen XA-Derivaten zu vermeiden, bei denen dieses Bit eine Funktion hat.

ET2	Enable Timer 2 gibt den Interrupt für Timer 2 frei. Auslösende Bits sind TF2 oder EXF2 im Register T2CON.

ET1	Enable Timer 1 gibt den Interrupt für Timer 1 frei. Auslösendes Bit ist TF1 im Register TCON.

EX1	Enable External Interrupt 1 gibt den externen Interrupt 1 frei. Auslösendes Bit ist IE1 im Register TCON

ET0	Enable Timer 0 gibt den Interrupt für Timer 0 frei. Auslösendes Bit ist TF0 im Register TCON.

EX0	Enable External Interrupt 0 gibt den externen Interrupt 0 frei. Auslösendes Bit ist IE1 im Register TCON

Interrupt Enable Register High, IEH

Bits:	---	---	---	---	ETI1	ERI1	ETI0	ERI0

Adr.:	33F	33E	33D	33C	33B	33A	339	338

Resetwert: 0000 0000

Adresse: 427h	bitadressierbar

Eine Eins in dem betreffendem Bit gibt den Interrupt frei, eine Null sperrt ihn.

ETI1	Enable Serial Port 1 Transmit Interrupt gibt den Sende-Interrupt für den seriellen Port 1 frei. Auslösendes Bit ist TI_1 im Serial Control Register S1CON.

ERI1	Enable Serial Port 1 Receive Interrupt gibt den Empfangs-Interrupt für den seriellen Port 1 frei. Auslösendes Bit ist RI_1 im Serial Control Register S1CON.

ETI0	Enable Serial Port 0 Transmit Interrupt gibt den Sende-Interrupt für den seriellen Port 0 frei. Auslösendes Bit ist TI_0 im Serial Control Register S0CON.

ERI0	Enable Serial Port 0 Receive Interrupt gibt den Empfangs-Interrupt für den seriellen Port 0 frei. Auslösendes Bit ist RI_0 im Serial Control Register S0CON.

Siehe auch Serial Control Register SnCON und Serial Status Register SnSTAT

Interrupt-Tabelle

SFR-Übersicht


Interruptpriorität, IPAn
Interrupt Priority Register, IPAn

Resetwert: 0000 0000 alle Register

Adressen:	nicht bitadressierbar

Interruptprioritätsregister 0, IPA0:  4A0h

Interruptprioritätsregister 1, IPA1:  4A1h

Interruptprioritätsregister 2, IPA2:  4A2h

Interruptprioritätsregister 4, IPA4:  4A4h

Interruptprioritätsregister 5, IPA5:  4A5h

Es gilt folgende Zuordnung:

Register	Bit 7 - 4	Bit 3 - 0

IPA0:	PT0	PX0

IPA1:	PT1	PX1

IPA2:	---	PT2

IPA4:	PTI0	PRI0

IPA5:	PTI1	PRI1

PT0: Priorität für Timer 0,  PX0: Priorität für externen Interrupt 0

PT1: Priorität für Timer 1,  PX1: Priorität für externen Interrupt 1

PT2: Priorität für Timer 2

PTI0: Priorität für seriellen Sende-Interrupt 0,  PRI0: Priorität für seriellen Empfangs-Interrupt 0

PTI1: Priorität für seriellen Sende-Interrupt 1,  PRI1: Priorität für seriellen Empfangs-Interrupt 1

Beispiel:

mov IPA0,#3Bh legt für Timer 0 Priorität 3 und für den externen Interrupt 0 Priorität 11 fest.

Die Prioritäten eines Interrupts spielen nur dann eine Rolle, wenn gleichzeitig mehrere Interrupts auftreten oder wenn eine Routine zu Ende ist und der nächste Interrupt aus der Interrupt-Warteliste bedient werden soll.

Jeder aktuell ausgeführte Programmteil besitzt ebenfalls eine Priorität, die in den Bits IM des Programmstatuswort PSWH festgelegt ist. Hat der aufgetretene Interrupt eine niedrigere oder gleiche Priorität, kommt er auf die Warteliste, hat er eine höhere Priorität, wird der aktuelle Programmteil unterbrochen.

Siehe auch Programmstatuswort High und Interrupt Enable Register IEH und IEL

Interrupt-Tabelle

SFR-Übersicht


Software-Interrupts, SWE und SWR
Software Interrupt Register, SWE / SWR

Software Interrupt Enable Register, SWE

Bits:	---	SWE7	SWE6	SWE5	SWE4	SWE3	SWE2	SWE1

Resetwert: 0000 0000

Adresse: 47Ah,	nicht bitadressierbar

Eine Eins in dem betreffenden Bit gibt den Interrupt frei, eine Null sperrt ihn.

Software Interrupt Request Register, SWR

Bits:	---	SWR7	SWR6	SWR5	SWR4	SWR3	SWR2	SWR1

Adr.:	357	356	355	354	353	352	351	350

Resetwert: 0000 0000

Adresse: 42Ah,	bitadressierbar

Eine Eins in dem betreffenden Bit fordert den Interrupt an, wenn das zugehörige Bit im Freigaberegister SWE gesetzt ist, eine Null nicht.

Software Interrupts haben fest Prioritäten: SWI1 = 1, .. , SWI7 = 7. Ein Verwendungszweck dieser Interrupts ist die Freigabe eines laufenden, wichtigen Interrupts, wenn er seine Hauptaufgabe verrichtet hat. Ein Timer Interrupt dient z.B. dazu, in regelmäßigen Abständen Meßwerte zu erfassen. Dabei darf keiner vergessen werden. In derselben Timer Routine wird ein Display gemultiplext. Dieser Vorgang ist unkritisch und kann auch später erst bedient werden. Also wird zu Beginn des Timer Interrupts ein Software Interrupt angefordert, der aber wegen seiner niedrigen Priorität zunächst nicht bedient wird. Nachdem die zeitkritische Messung vorbei ist, setzt der Timer Interrupt seine Interrupt Mask Bits IM im PSWH auf einen niedrigeren Level als der Software Interrupt, und kann sogleich durch den anhängenden Software Interrupt unterbrochen werden, in dem nun andere, wichtigere Dinge erledigt werden können als die noch anstehenden Aufgaben des Timer Interrupts.

Siehe auch Interrupt-Tabelle

SFR-Übersicht


Interrupts, Tabelle
Die XA-Interrupts, I

CPU-Interrupts (Exceptions, nicht maskierbar)

Name	Vektoradresse	Reihenfolge

Reset	0000 - 0003	0

Breakpoint	0004 - 0007	1

Trace	0008 - 000B	1

Stack Overflow	000C - 000F	1

Divide by Zero	0010 - 0013	1

User Reti	0014 - 0017	1

Trap 0	0040 - 0043	1

Trap 1	0044 - 0047	1

. . . .	. . . 	1

Trap 15	007C - 007F	1

Ereignis-Interrupts (maskierbar, variable Priorität)

Herkunft	Name	Vektoradresse	Reihenfolge

externer Interrupt 0	EX0	0080 - 0083	2

Timer 0	Timer 0	0084 - 0087	3

externer Interrupt 1	EX1	0088 - 008B	4

Timer 1	Timer 1	008C - 008F	5

Timer 2	Timer 2	0090 - 0093	6

serieller Empfang 0	RI0	00A0 - 00A3	7

serielles Senden 0	TI0	00A4 - 00A7	8

serieller Empfang 1	RI1	00A8 - 00AB	9

serielles Senden 1	TI1	00AC - 00AF	10

Software-Interrupts (maskierbar)

Herkunft	Name	Vektoradresse	feste Priorität

SWR1	SWI1	0100 - 0103	1

SWR2	SWI2	0104 - 0107	2

SWR3	SWI3	0108 - 010B	3

SWR4	SWI4	010C - 010F	4

SWR5	SWI5	0110 - 0113	5

SWR6	SWI6	0114 - 0117	6

SWR7	SWI7	0118 - 011B	7

Verwenden Sie als Interruptbezeichnung das Symbol unter Name in vorstehender Tabelle, z.B. Divide By Zero(008F): . Treten Interrupts derselben Priorität gleichzeitig auf oder stehen einige gleicher Priorität auf der Warteliste, so gibt die unter Reihenfolge genannte niedrigste Zahl dem betreffenden Interrupt Vorrang.

Siehe auch Interruptpriorität, IPA-Register

Interruptfreigaberegister, IEH und IEL

Software Interrupt Register, SWE und SWR

Srungziele, Labels

Spezialfunktionsregister

Interrupt-Beschreibung


Interrupts, Beschreibung
Die XA-Interrupts, II

Die XA-Controller besitzen eine Vektortabelle, in der die Interruptadressen und das Programmstatuswort abgelegt sind. Dort hat jeder Interrupt seinen festen Platz. Die Tabelle umfasst den Adressbereich von 0000h bis 011Bh. In diesem Bereich sollte kein Programmcode stehen. Beim Sprung in die Interruptroutine holt sich der Controller die Adresse und das Programmstatuswort aus der Tabelle. Somit gehören zu jedem Interrupt vier Bytes: das erste ist das PSW Low, das zweite das PSW High, das dritte die Adresse Low, das vierte die Adresse High. Zuvor aber werden die aktuelle Adresse und das aktuelle Programmstatuswort auf dem Stack abgelegt. Der Reset wird wie ein Interrupt behandelt.

Bei der Erstellung des Programmcodes nehmen Sie bitte keine Eintragungen in die Vektortabelle vor. Das erledigt der Assembler für Sie. An der Stelle, wo die Interruptroutine bzw. der Reseteinsprung beginnen soll, nennen Sie den Namen des Interrupts und das PSW in Klammern gefolgt von einem Doppelpunkt.

Beispiel

Timer 1 (008F):

Der Assembler erkennt am Doppelpunkt, dass es sich um ein Label handelt, und an der Klammer, dass es ein Interrupt ist. Nun nimmt er das PSW und die aktuelle Adresse und schreibt beide in die Vektortabelle an den richtigen Platz und in der richtigen Reihenfolge. Sie müssen sich darüber keine Gedanken machen. Beim Disassemblieren erkennen Sie die Arbeitsweise.

Der XA-Controller unterschiedet CPU-, Ereignis- und Software-Interrupts.

CPU-Interrupts werden auf Grund wichtiger Ereignisse in der CPU ausgelöst und werden immer sofort nach ihrem Auftreten bedient. Sie haben also die höchste Priorität und sind nicht abschaltbar. Daher sollten in jedem Programm diese Vektoren belegt sein und zumindest auf einen RETI-Befehl zeigen. Bleibt der Platz nämlich unbeschrieben, so wird sich das Programm mit Sicherheit verabschieden, wenn doch unvorhergesehen ein solcher Interrupt auftritt.

Ereignis-Interrupts werden von integrierten Peripherieeinrichtungen, wie Timer, ser. Port, oder externen Ereignissen an den Interrupt-Pins ausgelöst. Ein Ereignis-Interrupt wird nur dann ausgeführt, wenn seine Priorität höher ist als die Priorität der augenblicklich ausgeführten Routine (vgl. Programmstatuswort High). Da das Programmstatuswort aus der Vektortabelle geholt wird, kann die Priorität der Interrupt-Routine eine andere sein als die Priorität der Interrupt-Anforderung.

Software-Interrupts werden wie ein Ereignis-Interrupt behandelt mit der Ausnahme, dass das auslösende Ereignis das Setzen eines Bits ist und keine Prioritätswahl möglich ist.

Siehe auch Label

System Configuration Register, SCR

Interruptpriorität, IPA-Register

Software Interrupt Register, SWE und SWR

Interrupt-Tabelle

Spezialfunktionsregister