Befehlsliste der 8051-Mikrocontroller

Abkürzungen Befehlsübersicht Befehlsbeschreibungen

Befehlsübersicht

Transport- befehle	Arithmetische Operationen	Logische Operationen	Programm- Steuerung
General Purpose	Addition	Ein Operand	Unbedingt
MOV	ADD	CLR	ACALL
PUSH	ADDC		LCALL
POP	INC	SETB	RET
Akkumulator spezifisch	DA	CPL	AJMP
XCH	Subtraktion	RL	LJMP
XCHD	SUBB	RLC	SJMP
MOVX	DEC	RR	JMP
MOVC	Multiplikation / Division	RRC	Bedingt
Adress Objekt	MUL	SWAP	JZ / JNZ
MOV DPTR	DIV	Zwei Operanden	JC / JNC
		ANL	JB / JNB
		ORL	JBC
NOP		XRL	CJNE
			DJNZ
			Interrupt
			RETI

Befehlsbeschreibungen

MOV Zielbyte,Quellbyte
(MOVe data)
Der Mov-Befehl dient zum Datentransport. Der erste Operand verweist Intel-like immer immer auf das Transportziel, der zweite Operand auf die Datenquelle. Die Datenquelle kann dabei eine Konstante, ein Register, eine RAM-Speicherstelle (8-Bit-Adresse) oder das Carry-Flag sein. Viele Kombinationen sind erlaubt. Konstanten werden mit # (Gartenzaun; Raute) bezeichnet. @ (at) steht für eine registerindirekte Adressierung.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
mov A,Rn	[A] <-- [Rn] (n=0...7)	E8..EF	1	1	x	x	x
mov A,adr	[A] <-- [adr]	E5	2	1	x	x	x
mov A,@Ri	[A] <-- [[Ri]] (i=0;1)	E6; E7	1	1	x	x	x
mov A,#data	[A] <-- #data	74	2	1	x	x	x
mov Rn,A	[Rn] <-- [A] (n=0...7)	F8..FF	1	1	x	x	x
mov Rn,adr	[Rn] <-- [adr] (n=0...7)	A8..AF	2	2	x	x	x
mov Rn,#data	[Rn] <-- #data (n=0...7)	78..7F	2	1	x	x	x
mov adr,A	[adr] <-- [A]	F5	2	1	x	x	x
mov adr,Rn	[adr] <-- [Rn] (n=0...7)	88..8F	2	2	x	x	x
mov adr,adr	[adr] <-- [adr]	85	3	2	x	x	x
mov adr,@Ri	[adr] <-- [Ri] (i=0;1)	86; 87	2	2	x	x	x
mov adr,#data	[adr] <-- #data	75	3	2	x	x	x
mov @Ri,A	[[Ri]] <-- [A] (i=0;1)	F6; F7	1	1	x	x	x
mov @Ri,adr	[[Ri]] <-- [adr] (i=0;1)	A6; A7	2	2	x	x	x
mov @Ri,#data	[[Ri]] <-- #data (i=0;1)	76; 77	2	1	x	x	x
mov C,bit	[C] <-- [bit]	A2	2	1		x	x
mov bit,C	[bit] <-- [C]	92	2	2	x	x	x

Bsp.:	mov A,#6Fh	; Die Hexzahl 6Fwird in den Akku ; kopiert
	mov A,6Fh	; Der Inhalt der Speicherstelle mit der ; Adresse 6F wird in den Akku kopiert
	mov C,6Fh	; Das Bit mit der Bitadresse 6F wird ; ins Carry-Flag kopiert
	mov 7Eh,@R0	; Der Inhalt der Speicherzelle, deren ; Adresse in Register R0 steht, wird ; auf die Speicherzelle 7Eh des int. ; RAM kopiert.

Zurück zur Übersicht

PUSH Quellbyte
(PUSH onto stack)
Der Stapelzeiger (Stackpointer) wird um 1 erhöht. Anschließend wird der Inhalt des Quellbyte in die vom Stackpointer adressierte Speicherstelle kopiert.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
push adr	[SP] <-- [SP] + 1 [[SP]] <-- [adr]	C0	2	2	x	x	x

Bsp.:

push acc

; Der Akku wird in den Stapelspeicher ; geschrieben. (ACC = E0h)

Zurück zur Übersicht

POP Zielbyte
(POP from stack)
Holt das oberste Datum vom Stapelspeicher (Stack) und kopiert es iins Zielbyte. Anschließend wird der Stapelzeiger um 1 erniedrigt.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
pop adr	[adr] <-- [[SP]] [SP] <-- [SP] -1	D0	2	2	x	x	x

Bsp.:

pop acc

; Der Akku wird wiederhergestellt.

Zurück zur Übersicht

XCH A,Quellbyte
(eXCHange acumulator whit bytevariable)
Mit dem XCH-Befehl wird der Akku mit einem Quellbyte ausgetauscht. Dieses Byte kann direkt, register oder register indirekt adressiert sein.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
xch A,Rn	[A] <--> [Rn] (n=0..7)	C8-CF	1	1	x	x	x
xch A,adr	[A] <--> [adr]	C5	2	1	x	x	x
xch A,@Ri	[A] <--> [[Ri]] (i=0;1)	C6; C7	1	1	x	x	x

Bsp.:

xch A,@R0

; Tausch den Inhalt des Akkus mit
; dem Inhalt der über R1 indirekt
; adressierten Speicherstelle aus.

Zurück zur Übersicht

XCHD A,@Ri
(eXCHange Digit)
Mit dem XCHD-Befehl (eXCHange Digit) wird das Low-Nibble (untere 4 Bit) des Akku mit dem Low-Nibble des registerindirekt adressierten Speicherbytes ausgetauscht.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
xchd A,@Ri	[A3-0] <--> [[Ri]3-0] (i=0;1)	D6; D7	1	1	x	x	x

Bsp.:

xchd A,@R0

; Tausch das Low-Nibble des Akkus
; mit dem Low-Nibble der
; register-indirekt adressierten
; Speicherstelle.

Zurück zur Übersicht

MOVX Zielbyte,Quellbyte
(MOVe eXternal)
Der Movx-Befehl dient zum Transfer von Daten zum bzw. vom eXternen RAM. Der Zugriff aufs eXterne RAM erfolgt immer Registerindirekt. Dabei kann mit R0 oder R1 als 8-Bit-Adressregister ein 256 Byte grosser Bereich adressiert werden. Port 0 wird dabei als gemultiplexter Daten- und Adressbus verwendet. Mit dem Datenzeiger (DPTR) als 16-Bit Adressregister kann der komplette 64 kByte grosse eXterne Adressraum genutzt werden. Jedoch wird Port 2 als Adressbus A8..A15 (MSB) benötigt

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
movx A,@Ri	[A] <-- [[Ri]] (i=0;1)	E2; E3	1	2	x	x	x
movx A,@DPTR	[A] <-- [[DPTR]]	E0	1	2	x	x	x
movx @Ri,A	[[Ri]] <-- [A] (i=0;1)	F2; F3	1	2	x	x	x
movx @DPTR,A	[[DPTR]] <-- [A]	F0	1	2	x	x	x

Bsp.:

mov DPTR,#23DAh
movx A,@DPTR

; Liest die eXterne Speicherstelle
; 23DAh aus. Dabei wird der externe
; Adress- und Datenbus sowie die
; Steuerleitungen RD/ und ALE
; verwendet.

Zurück zur Übersicht

MOVC A,@A+Basisregister
(MOVe Code byte))
Der Movc-Befehl dient zum Lesen von Daten aus dem Programmspeicher (Code). Die Datenquelle (=16-Bit Adresse im Programmspeicher) wird gebildet durch den Inhalt eines Basisregisters (DPTR oder PC) und eines Offsetwertes im Akku.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
movc A,@A+DPTR	[A] <-- [[A] + [DPTR]]	93	1	2	x	x	x
movc A,@A+PC	[PC] <-- [PC] + 1 [A] <-- [[A] + PC]]	83	1	2	x	x	x

Bsp.:	mov DPTR,#tabelle mov A,#2 movc A,@A+DPTR * *	; Die Adresskonstante "tabelle" wird ; in den Datenpointer geladen und ; der Tabellenwert mit der Adresse ; #tabelle+2 wird in den Akku kopiert ; ([A] = 12)
	tabelle: db 98,23,12	; Mit der Assemblerdirektive db ; werden Daten im Code abgelegt

Zurück zur Übersicht

MOV DPTR,#adr16
(Load datapointer whit a 16-bit constant)
Mit dem Datenzeiger (DataPoinTeR) wird auf eine 16 Bit-Adresse im eXtended RAM oder im Programmspeicher verwiesen. Die Adresskonstante wird in zwei aufeinanderfolgenden Zugriffen aus dem Programmspeicher geholt und im Datenzeiger (DPH und DPL) abgelegt.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
mov DPTR,#adr16	[DPTR] <-- #data16	90	3	2	x	x	x

Bsp.:

mov DPTR,#E600h

; Die Adresskonstante E600h wird
; in den Datenpointer geladen

Zurück zur Übersicht

NOP
(No OPeration)
Der NOP-Befehl führt keine Operation durch. Er benötigt aber einen Maschinenzyklus (MZ). Dadurch können kurze Wartezeiten realisiert werden, z.B. um Schnittstellen-Timings einzuhalten.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
nop	mache nichts	00	1	1	x	x	x

Bsp.:

nop

; nichts tun (t = 1 MZ)

Zurück zur Übersicht

ADD A,Summand
(ADD)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
add A,Rn	[A] <-- [A] + [Rn] (n = 0..7)	28-2F	1	1
add A,adr	[A] <-- [A] + [adr]	25	2	1
add A,@Ri	[A] <-- [A] + [[Ri]] (i = 0; 1)	26; 27	1	1
add A,#data	[A] <-- [A] + #data	24	2	1

Bsp.:

;

Zurück zur Übersicht

ADDC A,Summand
(ADD with Carry)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
addc A,Rn	[A] <-- [A] + [C] + [Rn] (n = 0..7)	38-3F	1	1
addc A,adr	[A] <-- [A] + [C] + [adr]	35	2	1
addc A,@Ri	[A] <-- [A] + [C] + [[Ri]] (i = 0; 1)	36; 37	1	1
addc A,#data	[A] <-- [A] + [C] + #data	34	2	1

Bsp.:

;

Zurück zur Übersicht

INC byte
(INCrement)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
inc A	[A] <-- [A] + 1	04	1	1	x	x	x
inc Rn	[Rn] <-- [Rn] + 1 (n = 0..7)	08-0F	1	1	x	x	x
inc adr	[adr] <-- [adr] + 1	05	2	1	x	x	x
inc @Ri	[[Ri]] <-- [[Ri]] + 1	06; 07	1	1	x	x	x
inc DPTR	[DPTR] <-- [DPTR] + 1	A3	1	2	x	x	x

Bsp.:

mov R0,43h
inc @R0
inc R0
inc @R0

;

Zurück zur Übersicht

DA
(Decimal Adjust)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
da	wenn (([A3-0] > 9 v ([AC] = 1)) dann [A3-0] <-- [A3-0] + 6 ^ wenn (([A7-4] > 9 v ([C] = 1)) dann [A7-4] <-- [A7-4] + 6	D4	1	1		x	x

Bsp.:

add A,#99h
da

;

Zurück zur Übersicht

SUBB A,Subtrahend
(SUBtract with Borrow)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
subb A,Rn	[A] <-- [A] - [C] - [Rn] (n = 0..7)	98-9F	1	1
subb A,adr	[A] <-- [A] - [C] - [adr]	95	2	1
subb A,@Ri	[A] <-- [A] - [C] - [[Ri]] (i = 0;1)	96; 97	1	1
subb A,#data	[A] <-- [A] - [C] - #data	94	2	1

Bsp.:

subb A,R2

;

Zurück zur Übersicht

DEC byte
(Decrement)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
dec A	[A] <-- [A] - 1	14	1	1	x	x	x
dec Rn	[Rn] <-- [Rn] - 1 (n=0..7)	18-1F	1	1	x	x	x
dec adr	[adr] <-- [adr] - 1	15	2	1	x	x	x
dec @Ri	[[Ri]] <-- [[Ri]] - 1 (i=0;1)	16-17	1	1	x	x	x

Bsp.:

;

Zurück zur Übersicht

MUL AB
(MULtiply)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
mul AB	[A] <-- [A] * [B]	A4	1	4			x

Bsp.:

;

Zurück zur Übersicht

DIV AB
(DIVide)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
div AB	[A] <-- [A] / [B]	84	1	4			x

Bsp.:

;

Zurück zur Übersicht

CLR
(CLeaR)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
clr A	[A] <-- 0	E4	1	1	x	x	x
clr C	[C] <-- 0	C3	1	1	0	x	x
clr bit	[bit] <-- 0	C2	2	1	x	x	x

Bsp.:

clr P1.2

;

Zurück zur Übersicht

SETB bit
(SET Bit)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
setb C	[C] <-- 1	D3	1	1	1	x	x
setb bit	[bit] <-- 1	D2	2	1	x	x	x

Bsp.:

setb C
setb P0.1

;

Zurück zur Übersicht

CPL bit or byte
(ComPLement)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
cpl A	[A] <-- /[A]	F4	1	1	x	x	x
cpl C	[C] <-- /[C]	B3	1	1		x	x
cpl bit	[bit] <-- /[bit]	B2	2	1	x	x	x

Bsp.:

setb P1.1
cpl P1.1

;

Zurück zur Übersicht

RL A
(Rotate accumulator Left)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
rl A	[An+1] <-- [An] (n=0...6) [A0] <-- [A7]	23	1	1	x	x	x

Bsp.:

rl A

; [A] = 11000101b
; <<
; [A] = 10001011b

Zurück zur Übersicht

RLC A
(Rotate accumulator Left through Carry flag)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
rlc A	[An+1] <-- [An] (n=0...6) [A0] <-- [C] [C] <-- [A7]	33	1	1		x	x

Bsp.:

rlc A

; [A] = 11000101b [C] = 0
; <<
; [A] = 10001010b [C] = 1

Zurück zur Übersicht

RR A
(Rotate accumulator Right)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
rr A	[An] <-- [An+1] (n=0...6) [A7] <-- [A0]	03	1	1	x	x	x

Bsp.:

rr A

; [A] = 11000101b
; >>
; [A] = 11100010b

Zurück zur Übersicht

RRC A
(Rotate accumulator Right through Carry flag)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
rrc A	[An] <-- [An+1] (n=0...6) [A7] <-- [C] [C] <-- [A0]	13	1	1		x	x

Bsp.:

rrc A

; [A] = 11000101b [C] = 0
; >>
; [A] = 01100010b [C] = 1

Zurück zur Übersicht

SWAP A
(SWAP nibbles within the accumulator)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
swap A	[A3-0] <--> [A7-4]	C4	1	1	x	x	x

Bsp.:

swap A

;     [A] = 1010 0110
;   <-->
;     [A] = 0110 1010

Zurück zur Übersicht

ANL Zielbyte, Quellbyte
(ANd Logical)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
anl A,Rn	[A] <-- [A] ^ [Rn] (n=0..7)	58-5F	1	1	x	x	x
anl A,adr	[A] <-- [A] ^ [adr]	55	2	1	x	x	x
anl A,@Ri	[A] <-- [A] ^ [[Ri]] (i=0;1)	56; 57	1	1	x	x	x
anl A, #data	[A] <-- [A] ^ #data	44	2	1	x	x	x
anl adr,A	[adr] <-- [adr] ^ [A]	52	2	1	x	x	x
anl adr,#data	[adr] <-- [adr] ^ #data	53	3	2	x	x	x
anl C,bit	[C] <-- [C] ^ [bit]	82	2	2		x	x
anl C,/bit	[C] <-- [C] ^ /[bit]	B0	2	2		x	x

Bsp.:

anl A,#00111100b

;     [A] = 11011011
;           ^ 00111100
;     [A] = 00011000

Zurück zur Übersicht

ORL Ziellbyte,Quellbyte
(OR Logical)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
orl A,Rn	[A] <-- [A] v [Rn] (n=0..7)	48-4F	1	1	x	x	x
orl A,adr	[A] <-- [A] v [adr]	45	2	1	x	x	x
orl A,@Ri	[A] <-- [A] v [[Ri]] (i=0;1)	46; 47	1	1	x	x	x
orl A,#data	[A] <-- [A] v #data	44	2	1	x	x	x
orl adr,A	[adr] <-- [adr] v [A]	42	2	1	x	x	x
orl adr,#data	[adr] <-- [adr] v #data	43	3	2	x	x	x
orl C,bit	[C] <-- [C] v [bit]	72	2	2		x	x
orl C,/bit	[C] <-- [C] v /[bit]	A0	2	2		x	x

Bsp.:

orl A,#00111100b

;     [A] = 11011011
;           v 00111100
;     [A] = 11111111

Zurück zur Übersicht

XRL Zielbyte,Quellbyte
(eXclusive oR Logical)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
xrl A,Rn	[A] <-- [A] xor [Rn] (n=0..7)	68-6F	1	1	x	x	x
xrl A,adr	[A] <-- [A] xor [adr]	65	2	1	x	x	x
xrl A,@Ri	[A] <-- [A] xor [[Ri]] (i=0;1)	66; 67	1	1	x	x	x
xrl A,#data	[A] <-- [A] xor #data	64	2	1	x	x	x
xrl adr,A	[adr] <-- [adr] xor [A]	62	2	1	x	x	x
xrl adr,#data	[adr] <-- [adr] xor #data	63	3	2	x	x	x

Bsp.:

xrl A,#00111100b

;     [A] = 11011011
;        xor 00111100
;     [A] = 11100111

Zurück zur Übersicht

ACALL adr11
(Absolut CALL)
Führt einen Unterprogrammaufruf im aktuellen 2k-Codesegment durch. Das Codesegment 0-31 wird bestimmt durch die höherwertigen 5 Bits des Programmzählers. Die Adressbits A8,A9und A10 sind im Highnibble des Opcdes codiert. Der Befehl benötigt daher nur 2 Byte.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
acall adr11	[PC] <-- [PC] + 2 [SP] <-- [SP] + 1 [[SP]] <-- [PC7-0] [SP] <-- [SP] + 1 [[SP]] <-- [PC15-8] [PC10-0] <-- adr11	11 31 51 ... F1	2	2	x	x	x

Bsp.:

acall subrtn

; Aufruf des Unterprogramms subrtn

Zurück zur Übersicht

LCALL adr16
(Long CALL)
Führt einen Unterprogrammaufruf im gesamten 64k-Codesegment durch.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
lcall adr16	[PC] <-- [PC] + 3 [SP] <-- [SP] + 1 [[SP]] <-- [PC7-0] [SP] <-- [SP] + 1 [[SP]] <-- [PC15-8] [PC] <-- adr16	12	3	2	x	x	x

Bsp.:

lcall subrtn

; Aufruf des Unterprogramms subrtn

Zurück zur Übersicht

RET
(RETurn from Subroutine)
Holt nacheinander das Highbyte und das Lowbyte der Rücksprungadresse aus einem Unterprogramm vom Stack. Der Stackpointer wird dabei um 2 erniedrigt. Das Programm wird dann von dieser Adresse aus fortgesetzt. Der RET-Befehl folgt immer auf einen LCALL oder ACALL.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
ret	[PC15-8] <-- [[SP]] [SP] <-- [SP] - 1 [PC7-0] <-- [[SP]] [SP] <-- [SP] - 1	22	1	2	x	x	x

Bsp.:

UP: mov P1,A
ret

;

Zurück zur Übersicht

AJMP adr11
(Absolute JuMP)
Führt einen Sprung im aktuellen 2k-Codesegment durch. Das Codesegment 0-31 wird bestimmt durch die höherwertigen 5 Bits des Programmzählers. Die Adressbits A8,A9und A10 sind im Highnibble des Opcdes codiert. Der Befehl benötigt daher nur 2 Byte.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
ajmp adr11	[PC] <-- [PC] + 2 [PC10-0] <-- addr11	01 21 41 61 81 ... E1	2	2	x	x	x

Bsp.:

ajmp 23F8h

; Das Programm verzweigt zur
; Adresse 23F8h. Die Oberen 5
; Adressbits müssen mit dem Inhalt der
; entsprechenden Bits des
; Programmcounters übereinstimmen!

Zurück zur Übersicht

LJMP adr16
(Long JuMP)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
ljmp adr16	[PC] <-- adr16	02	3	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

SJMP rel
(Short JuMP)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
sjmp rel	[PC] <-- [PC] + 2 [PC] <-- [PC] + rel	80	2	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

JMP @A+DPTR
(JuMP indirect)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
jmp @A+DPTR	[PC] <-- [A] + [DPTR]	73	1	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

JZ rel / JNZ rel
(Jump if Akku is (Not) Zero)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
jz rel	[PC] <-- [PC] + 2 wenn [A] = 0 dann [PC] <-- [PC] + rel	60	2	2	x	x	x
jnz rel	[PC] <-- [PC] + 2 wenn [A] <> 0 dann [PC] <-- [PC] + rel	70	2	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

JC rel / JNC rel
(Jump if Carry is (Not) set)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
jc rel	[PC] <-- [PC] + 2 wenn [C] = 1 dann [PC] <-- [PC] + rel	40	2	2	x	x	x
jnc rel	[PC] <-- [PC] + 2 wenn [C] = 0 dann [PC] <-- [PC] + rel	50	2	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

JB bit,rel / JNB bit,rel
(Jump if Bit is (Not) set)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
jb bit,rel	[PC] <-- [PC] + 3 wenn [bit] = 1 dann [PC] <-- [PC] + rel	20	3	2	x	x	x
jnb bit,rel	[PC] <-- [PC] + 3 wenn [bit] = 0 dann [PC] <-- [PC] + rel	30	3	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

JBC bit,rel
(Jump if Bit is set and Clear bit)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
jbc bit,rel	[PC] <-- [PC] + 3 wenn [bit] = 1 dann [bit] <-- 0 [PC] <-- [PC] + rel	10	3	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

CJNE Zielbyte,Quellbyte,rel
(Compare and Jump if Not Equal)
Vergleicht das Zielbyte mit dem Quellbyte und springt bei Ungleichheit (!=) auf das angegebene relative Sprungziel. Dort kann eine weitere Überprüfung auf kleiner als und größer gleich (>) mit JC (<), bzw. JNC (>=) erfolgen.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
cjne A,adr,rel	[PC] <-- [PC] + 3 wenn [A] <> adr dann [PC] <-- [PC] + rel wenn [A] < adr dann [C] <-- 1 sonst [C] <-- 0	B5	3	2		x	x
cjne A,#data,rel	[PC] <-- [PC] + 3 wenn [A] <> #data dann [PC] <-- [PC] + rel wenn [A] < #data dann [C] <-- 1 sonst [C] <-- 0	B4	3	2		x	x
cjne Rn,#data,rel	[PC] <-- [PC] + 3 wenn [Rn] <> #data (n=0...7) dann [PC] <-- [PC] + rel wenn [Rn] < #data dann [C] <-- 1 sonst [C] <-- 0	B8..BF	3	2		x	x
cjne @Ri,#data,rel	[PC] <-- [PC] + 3 wenn [[Ri]] <> #data dann [PC] <-- [PC] + rel wenn [[Ri]] < #data dann [C] <-- 1 sonst [C] <-- 0 (i=0;1)	B6; B7	3	2		x	x

Bsp.:

           cjne a,00h,Ungleich

Gleich: ....
            sjmp weiter
Ungleich: ....
            jc   kleiner
Größer: ....
            sjmp weiter
Kleiner: ...

weiter: ....

; Vergleicht den Inhalt von Akku
; und Register R0 (Adresse 00h)

Zurück zur Übersicht

DJNZ byte,rel
(Decrement and Jump if Not Zero)

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
djnz Rn,rel	[PC] <-- [PC] + 2 [Rn] <-- [Rn] + 1 (n=0...7) wenn [Rn] <> 0 dann [PC] <-- [PC] + rel	D8..DF	2	2	x	x	x
djnz adr,rel	[PC] <-- [PC] + 2 [adr] <-- [adr] + 1 wenn [adr] <> 0 dann [PC] <-- [PC] + rel	D5	3	2	x	x	x

Bsp.:

mov R2,#8
toggle: cpl P1.7
djnz R2,toggle

; Port 1.7 wird 8 mal getoggelt

Zurück zur Übersicht

RETI
(RETurn from Interrupt)
Holt nacheinander das Highbyte und das Lowbyte der Rücksprungadresse vom Stack. Der Stackpointer wird dabei um 2 erniedrigt. Gleichzeitig wird die Interruptlogik zurückgesetzt, so dass Interrupts der gleichen Prioritätsebene wieder zugelassen sind. Das Programm wird an der nächsten resultierenden Adresse fortgesetzt, die auf die Anweisung folgt, an der der Interrupt angefordert wurde.

Mnemonic	Operation	Opcode	WB	MZ	Flags CY OV AC
reti	[PC15-8] <-- [[SP]] [SP] <-- [SP] - 1 [PC7-0] <-- [[SP]] [SP] <-- [SP] - 1	32	1	2	x	x	x

Bsp.:

;

Zurück zur Übersicht

31.10.2005

Befehlsliste der 8051-Mikrocontroller

Abkürzungen Befehlsübersicht Befehlsbeschreibungen

Befehlsübersicht

Transport- befehle

Arithmetische Operationen

Logische Operationen

Programm- Steuerung

Abkürzungen

Befehlsbeschreibungen

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Flags CY OV AC

Mnemonic

Operation

Opcode

WB

MZ

Transport-
befehle

Arithmetische
Operationen

Logische
Operationen

Programm-
Steuerung

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC

Flags
CY OV AC