Edit v5.010 from 2005-01-21 to 2024-04-10 by HSc

    ORG     4200H           ; Programm steht ab 4200H

Microcontroller 8051

Hier erfahren Sie genaueres über die uns bekannte Ausstattung des Microcontrollers 8051 mit seiner Hard- und Software. Diese dienen als Grundlage für alle weiteren Projekte mit dem MC8051 die bei uns vorgestellt werden.

Das 1. Programm mit seinem Quelltext, dessen Umsetzung in ein lauffähiges Programm und das Ergebnis dieser Arbeit.
Lektionen zum Thema

Grundlagen;
Quellcode-Beispiele zu den Elementen der Programmiersprache;
Konsole mit Eingaben über die Tastatur und Ausgabe auf den Monitor;
Interrupt und dessen Nutzung,
KVM mit der Nutzung von Keyboard (auch prellende Taster), Videomonitor und Mouse für die Ein- und Ausgabe und
Clock mit Messung, Reduzierung und Ausgabe eines proportionalen Taktsignales.

Die Hardware für die die Programme entwickelt und eingesetzt worden. Dazu gehört

die Speicherorganisation und
der Systembus. An diesen wird dann später der User-Bus angeschlossen.

Werkzeuge

Um ein lauffähiges Programm zu erstellen, sind die im folgende beschriebenen Werkzeuge nützlich!

Entwicklungsumgebung

Diese kann alle Werkzeuge enthalten und in der benötigten Reihenfolge aufrufen. Das spart viel Tip-Arbeit und Zeit.
Bei uns ist daß das Betriebssystem MS−DOS und eine Batch-Datei, welche die Werkzeuge in der Reihnenfolge Editor, Assembler, Loader und Terminalprogramm aufruft! Elektro liefert mit seinem EASM51 auch den Loader, das Terminalprogramm und ein Menüprogramm zum komfortablen Aufruf der selbigen mit.

Editor

Ein Editor, um das Programm (????????.A51) zu schreiben und welche unter DOS lauffähig ist!
Welches ist Ihr Lieblings-Texteditor? Den sollten sie einsetzen. Bei uns ist dies der Norton Editor NED.COM, da er trotz seiner kleinen Größe alles minimal Notwendige enthält. Den Namen der Datei (EQU02.A51) kann er aus dem Übergabeparameter entnehmen.

    NED.COM EQU02.A51

Assembler

Ein Assembler, um die mit dem Editor geschriebene Mnemonik, auf deren richtige Schreibweise zu überprüfen und wenn diese gültig ist, eine Listing-Datei erstellt und des Weiteren ihn in ein Intel−Hex−File übersetz.

Wir benutzen hier den Elektro Assembler EASM.EXE mit dem Aufruf

   EASM.EXE EQU02.A51

Terminalprogramm

Das Terminalprogramm stelle die Verbindung zwischen Computer und dem Microcontroller, über die serielle Schnittstelle, her. Die in Ihm gemachte Eingaben verarbeitet er und kommuniziert entsprechend mit dem Microcontroller. So gibt er die vom Microcontroller versandten Zeichen auf den Bildschirm des Computers aus. Elektro lieferte mit seinem 8051er-System das Terminalprogramm V24COM.EXE mit. Diese erwartet als Übergabeparameter den Namen des Intel−Hex−Files und den Namen der seriellen Schnittstelle.

   V24COM.EXE EQU02.HEX -COM1

Das 1. Programm

Wenn diese grundsätzliche Notwendigkeit nicht geklärt ist und funktioniert, kann der Rest vergessen werden. Denn Übung macht den Meister!
Wir haben uns für den Norton-Editor, den 8051−Assembler von Elektor EASM51 und dessen Transferprogramm V24COM.EXE entschieden. Im ersten Programm wollen wir den Befehl EQU (equal zu Deutsch gleich) ausprobieren

Der Quelltext

Der Inhalt dieses Quelltextes

;***************************************************************
;* Zuweisung eines Namens "P1" zur Adresse "90H",              *
;* wo Port 1 liegt.                                            *
;* Frage:                                                      *
;* - Wie sind die Auswirkung auf die Listing-Datei?            *
;* Ziel:                                                       *
;* - Wenn alles geklappt hat und                               *
;*   nach einem Reset das Programm auf den Microcontroller     *
;*   ausgefuehrt wird,                                         *
;*   sollten sich einige Bits am Port 1 von 0 auf 5 Volt und   *
;*   umgekehrt aendern.                                        *
;* =========================================================== *
;* Copyright by Hilfe & Service von EDV-Fachleuten             *
;*              Reilstr. 6, D-06114 Halle (Saale)              *
;*              Tel. (0345) 521 13 40                          *
;*              Fax  (0345) 521 13 41                          *
;*              eM   Info@HuSvEDVF.de                          *
;* Edit v1.010 from 2006-01-12 to 2011-06-10 by HSc            *
;* ----------------------------------------------------------- *
;* Input                                                       *
;* Process                                                     *
;* + Constant                                                  *
;* - P1      = 90H, die Adresse des Port Eins.                 *
;* + Variable                                                  *
;* Output                                                      *
;***************************************************************

;******* Definition von Konstanten *****************************
P1	EQU	90H

;******* Hauptprogramm *****************************************
	ORG	04100H		;Programm steht ab 4100H

	MOV	P1,#15		;Lade auf die Adresse
				;vom Port 1 die 15
	RET			;Ende des Hauptprogramms

	END			;Ende des Programms
;******* EOF ***************************************************

Wenn alles geklappt hat, sollte das Ziel erreicht worden sein.

Die Umsetzung

Wie sind wir vorgegangen, um ein Programm zu erstellen, zu testen und es auf dem Zielsystem laufen zu lassen? Dazu ist als Entwicklungsumgebung ein Computer mit einem DOS−Betriebssystem notwendig, wo das Programm erstellt, assembliert (Übersetzt) und über die serielle Schnittstelle eine Verbindung zum MC8051-Board hergestellt und damit das HEX-File übertragen werden kann; In dieser Entwicklungsumgebung sind zur Überführung in ein lauffähiges Programm 4 bis maximal 5 Schritten notwendig.

Erstellen bzw. Editieren des Quelltextes mit einem Editor.
```
     NED.COM EQU02.A51
     
```
Wir setzen hier den Norton Editor ein.
Assemblieren zum Überpürfen des Quelltextes auf Fehlerfreiheit und Umwandeln dessen in das Intel-Hex-Format (*.HEX) plus der Ausgabe des Quelltextes in Form einer Listingdatei (*.LST).
```
     EASM.EXE EQU02.A51
     
```
Ist der Quelltext syntaktisch nicht fehlerfrei, wird auf die entsprechende Zeile verwiesen. Dann ist eine Korrektur mittels Editor angesagt.
Übertragung der Intel-Hex-Datei über die serielle Schnittstelle 1 zum MC8051-Board, wo es vom Monitorprogramm empfangen und entsprechend der Angaben in der Datei abgespeichert wird;
```
     V24COM.EXE EQU02.HEX -COM1
     
```
Ausführen des erstellten Programms durch seinen Aufruf an der Konsole des MC5051-Board's.
Debuggen bzw. Analysieren ist mit dem Monitor−Programm des MC8051−Board möglich.

Diese Schritte wiederholt man solange bis man mit dem Ergebnis zufrieden ist.

Das Ergebnis

Nach Aufruf des Befehles

dir EQU02.*

erhält man folgende Dateien aufgelistet:

```
EQU02.A51
```
= Der eingegebenen Quellcode;
```
EQU02.LST
```
= Vom Assembler erstelle Listing-Datei mit Zusatzinformationen;
```
EQU02.HEX
```
= Das vom Assembler erstellte Programm im Intel-Hex-Format.

Wovon EQU02.HEX dass in den Microcontroller hochladbare Programm ist!

Lektionen

Übungen für jede einzelne Befehlsgruppe, angefangen mit der

Vorstellung vom Aufbau eines Quelltextes,
über Konstanten und Variablen,
Speichermanipulationen,

und vieles andere mehr. Dabei sind die Lektionen von 0. bis 4. bei jeder Programmiersprache enthalten!

Zustandsanzeige

Im folgendem wird, wenn es um die Anzeige des Zustandes geht, in dem sich der MC befindet, wird folgende Darstellung für die Anzeige verwendet:

Tabelle 1: Zustand des MC **vor** Ausführung
des Befehles "MOV 70H,A" im Hochformat
CPU	A	B	SP		PC		DPTR
8051	15	xx	81		4202		xxxx
PSW	CV	AC	F0	RS1	RS0	OV	F1	P
D0	x	x	x	x	x	x	x	x
Bank	R0	R1	R2	R3	R4	R5	R6	R7
00	00	00	00	00	00	00	00	00
SP	+00	+01	+02	+03	+04	+05	+06	+07
03	00	00	00	00	00	00	00	00
SFR
88H = TSCON 89H = TMOD 98H = SCON				00H = 0000 0000B 00H = 0000 0000B 00H = 0000 0000B
Code
4200 74 15 [1]: MOV A,#15H 4202 F5 70 [1]> MOV 70H,A 4204 22 __ [2]: RET

Das Debug-Fenster im Hochformat. Was kann man im Einzelnen in der Ansicht des Zustandes ablesen:

In dem ersten Zeilenpaar den Derivat-Namen der CPU, wichtig da jedes Derivat andere Möglichkeiten (Ports's, A/D-Wandler, etc.) besitzt. Des Weiteren den Inhalt der Arbeitsregister A und B, sowie den Stack-Pointer SP, Program-Counter PC und den Daten-Pointer DPTR.
Im mittleren Zeilenpaar ist das Program-Status-Word, welches eine entscheidende Rolle bei den bedingten Sprüngen spielt, mit seinen Bit's
- Carry−Flag CV,
- Half-Carry-Flag AC,
- Register−Bank−Bit 0 RS0 und 1 RS1,
- OV,
- F1 und
- Paritäts−Bit P bzgl. des Inhaltes vom Akkumulator.
dargestellt.
Im letzten Zeilenpaar ist die Differenz zwischen Startwert und aktuellen Wert im Stackpointer SP zu sehen. Oder anders ausgedrückt, die Anzahl der auf dem Stack abgelegten Bytes. Daneben sind die alle abgelegten Bytes aufgelistet und durch nummeriert.
Einen Auszug aus der Liste der Spezial-Funktions-Register SFR, die für die Abarbeitung der unmittelbaren folgenden Befehls von Bedeutung sind.

Tabelle 2: Zustand des MC **vor** Ausführung des Befehles "MOV 70H,A" im Querformat.
CPU	A	B	SP		PC		DPTR		PSW	CV	AC	F0	RS1	RS0	OV	F1	P
8051	15	xx	81		4202		xxxx		D0	x	x	x	x	x	x	x	x
Bank	R0	R1	R2	R3	R4	R5	R6	R7	SP	+00	+01	+02	+03	+04	+05	+06	+07
00	00	00	00	00	00	00	00	00	03	00	00	00	00	00	00	00	00
Code									SFR
4200 74 15 [1]: MOV A,#15H 4202 F5 70 [1]> MOV 70H,A 4204 22 __ [2]: RET									88 = TSCON 89 = TMOD 98 = SCON				00 = 0000 0000B 00 = 0000 0000B 00 = 0000 0000B

Das Debug-Fenster im Querformat ist in Tabelle 2 zu sehen.

0. Grundlagen

Zur Aufzeigung von allen grundsätzlich in einen Quelltext vorhandenen Elementen bei diesem Programm-System. Dazu gehören:

Das 1. Programm incl. seiner Kommentare.
Grundsätzliche Struktur des Quelltextes mit möglichen Inhalt bzgl. Speichermodel, Prozessormodel, Beginn und Ende.
Konstanten, Variablen, Marken und deren Verwendung.
Deklarieren von Funktionen und Prozeduren, und deren Aufruf und Nutzung.

Dies mündet in einem Quelltext (Grl*.A51), worin alle grundsätzlichen Elemente vorhanden sind. Dieser ist auch als Muster geeignet, wenn es um die Erstellung von neuen Quelltexten geht.

1. Befehlsbeispiele

Beispiele zu den Elementen der Operationscodes, der Mnemonik, der Programmiersprache, etc. Diese Beispiele sollten immer, wenn es eine Frage zu einem Befehl gibt, erstellt werden und damit sie leichter gefunden werden, auch dessen Namen tragen.

2. Konsole

Eingabe über die Tastatur und Ausgabe über den Bildschirm, die klassischen Elemente einer Konsole. Das Programm soll ja auch steuerbar sein!

3. Interrupt

Wo befindet sich Interrupt-Tabelle und wie ist sie aufgebaut. Einstellen der Adresse füer das Interrupt. Schreiben einer Interrupt-Funktion. Interrupt freigeben und sperren. Auslösen eins Interrupt und dessen Nutzung. Durch die Nutzung von Interruptus kann das Programm kann auf Ereignisse reagieren und diese zwischendurch abarbeiten.

4. Keyboard Video Mouse

Nutzung von Keyboard, Monitor und Mouse für die Ein- und Ausgabe. Dazu gehören Funktionen zur Verarbeitung von

Zahlen,
Texten,
Datum,
Uhrzeit und

die Konvertierung in andere Formate. Hier besonders das Format der BCD- und der Gleitkomma-Zahl.

Befehls-Code

Tabelle 3: 255 Befehls-Codes für 8051 in hexadezimaler Darstellung von 16x16
Code	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
00H	NOP	AJMP page 0	LJMP adr16	RR A	INC A	INC adr16	INC A,@R0	INC A,@R1	INC R0	INC R1	INC R2	INC R3	INC R4	INC R5	INC R6	INC R7
10H	JBC badr, radr08	ACALL page 0	LCALL adr16	RRC A	DEC A	DEC adr16	DEC @R0	DEC @R1	DEC R0	DEC R1	DEC R2	DEC R3	DEC R4	DEC R5	DEC R6	DEC R7
20H	JB badr, radr08	AJMP page 1	RET	RL A	ADD A,#c08	ADD A,adr16	ADD A,@R0	ADD A,@R1	ADD A,R0	ADD A,R1	ADD A,R2	ADD A,R3	ADD A,R4	ADD A,R5	ADD A,R6	ADD A,R7
30H	JNB badr, radr08	ACALL page 1	RETI	RLC A	ADDC A,#08	ADDC A,#16	DEC @R0	DEC @R1	DEC R0	DEC R1	DEC R2	DEC R3	DEC R4	DEC R5	DEC R6	DEC R7
40H	JC radr08	AJMP page 2	ORL adr16,A	ORL #c08,A	ORL A,#c08	ORL A,adr16	ORL A,@R0	ORL A,@R1	ORL A,R0	ORL A,R1	ORL A,R2	ORL A,R3	ORL A,R4	ORL A,R5	ORL A,R6	ORL A,R7
50H	JNC radr08	ACALL page 2	ANL adr16,A	ANL adr16, #c08	ANL A,#c08	ANL A,adr16	ANL A,@R0	ANL A,@R1	ANL A,R0	ANL A,R1	ANL A,R2	ANL A,R3	ANL A,R4	ANL A,R5	ANL A,R6	ANL A,R7
60H	JZ radr08	AJMP page 3	XRL adr16,A	XRL #c08,A	XRL A,#c08	XRL A,adr16	XRL A,@R0	XRL A,@R1	XRL A,R0	XRL A,R1	XRL A,R2	XRL A,R3	XRL A,R4	XRL A,R5	XRL A,R6	XRL A,R7
70H	JNZ radr08	ACALL page 3	ORL C,badr	JMP @A+ DTPR	MOV A,#c08	MOV adr16, #c08	MOV @R0, #c08	MOV @R1, #c08	MOV R0, #c08	MOV R1, #c08	MOV R2, #c08	MOV R3, #c08	MOV R4, #c08	MOV R5, #c08	MOV R6, #c08	MOV R7, #c08

80H	SJMP radr08	AJMP page 4	ANL C,badr	MOVC A, @A+PC	DIV AB	MOV adr08, adr08	MOV adr08, @R0	MOV adr08, @R1	MOV adr08, R0	MOV adr08, R1	MOV adr08, R2	MOV adr08, R3	MOV adr08, R4	MOV adr08, R5	MOV adr08, R6	MOV adr08, R7
90H	MOV DPTR, #c16	ACALL page 4	MOV badr,C	MOVC A, @A+DPTR	SUBB A,#c08	SUBB A,adr16	SUBB A,@R0	SUBB A,@R1	SUBB A,R0	SUBB A,R1	SUBB A,R2	SUBB A,R3	SUBB A,R4	SUBB A,R5	SUBB A,R6	SUBB A,R7
A0H	ORL C, badr	AJMP page 5	MOV C, badr	INC DPTR	MUL AB	-	MOV @R0, adr08	MOV @R1, adr08	MOV R0, adr08	MOV R1, adr08	MOV R2, adr08	MOV R3, adr08	MOV R4, adr08	MOV R5, adr08	MOV R6, adr08	MOV R7, adr08
B0H	ANL C, badr	ACALL page 5	CPL badr	CPL C	CJNE A,#c08, radr	CJNE A,adr16, radr	CJNE @R0, #c08, radr	CJNE @R1, #c08, radr	CJNE R0, #c08, radr	CJNE R1, #c08, radr	CJNE R2, #c08, radr	CJNE R3, #c08, radr	CJNE R4, #c08, radr	CJNE R5, #c08, radr	CJNE R6, #c08, radr	CJNE R7, #c08, radr
C0H	PUSH adr08	AJMP page 6	CLR badr	CLR C	SWAP A	XCH A, adr08	XCH A,@R0	XCH A,@R1	XCH A,R0	XCH A,R1	XCH A,R2	XCH A,R3	XCH A,R4	XCH A,R5	XCH A,R6	XCH A,R7
D0H	POP adr08	ACALL page 6	SETB badr	SETB C	DA A	DJNZ adr16, radr	XCHD A,@R0	XCHD A,@R1	DJNZ R0,radr	DJNZ R1,radr	DJNZ R2,radr	DJNZ R3,radr	DJNZ R4,radr	DJNZ R5,radr	DJNZ R6,radr	DJNZ R7,radr
E0H	MOVX A, @DPTR	AJMP page 7	MOVX A,@R0	MOVX A,@R1	CLR A	MOV A, adr08	MOV A,@R0	MOV A,@R1	MOV A,R0	MOV A,R1	MOV A,R2	MOV A,R3	MOV A,R4	MOV A,R5	MOV A,R6	MOV A,R7
F0H	MOVX @DTPR, A	ACALL page 7	MOVX @R0,A	MOVX @R1,A	CPL A	MOV adr08, A	MOV @R0,A	MOV @R1,A	MOV R0,A	MOV R1,A	MOV R2,A	MOV R3,A	MOV R4,A	MOV R5,A	MOV R6,A	MOV R7,A
Code	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F

In der Zeile 60H und der Spalte 01H steht die Mnemonik AJMP page 3 für den Befehls-Code 61H.

Flags

Befehle hinterlassen neben dem Ergebnis auch Informationen wie es dazu kam. Z. Bsp. gab es einen Übertrag, änderte sich das Vorzeichen, usw. Für solche Informationen wurde die Flags eingeführt, die hier im Programmstatusword enthalten sind.

Mnemonik

(/313/ S. 265: Befehls-Code für 8051 …) Ist eine von Menschen mit wenigen Buchstaben umschriebenen Aufgabe des Operations-Codes. Die folgende Auflistung enthält neben der Bezeichnung der Mnemonik, ihren zugehörigen Befehls-Codes, den dazugehörigen Erläuterungen wie der verwendeten Bezeichnungen, die Dauer, die Taktzyklen, auch die gesetzte bzw. ausgewerteten Flags. Unterteile haben wir die Befehle in die Bereiche

Datentransfer, mit grünen Hintergrund,
Arithmetischen, mit roten Hintergrund,
Logischen, mit gelben Hintergrund, und
Sprung Operationen, mit blauen Hintergrund.

Teileweise gibt es eine Verweis zu einer Lektion, wo der Befehl eingesetzt wurde und um seine Funktion schneller verstehen zu können.

Vorab einige Erläuterungen zu den verwendeten Abkürzungen:

@: Indirekte Adressierung, d.h. nicht der Inhalt verweist auf das Ziel, sondern der Inhalt verweist auf eine Adresse, welche dann auf das Ziel verweist;
adr08 und adr16: Absolute 8- und 16 Bit große Adresse; um auf deren Daten zuzugreifen;
badr: Absolute Adresse von 0 bis 127, welche auf ein Bit verweist im Adressbereich von 20H bis 2FH. 0 bis 127 Bits entspricht einem Speicherbereich von 20H plus 0/8=00H bis 127/8=0FH Bytes;
#c08 und #c16: Konstanten mit einer Größe von 8 und 16 Bit;
radr08: Relativen 8 Bit-Adresse mit einen Bereich von -128, …, +127 Bytes. Dies entspricht einer Größe von 8 Bit im Zweierkomplement.
Ri: Eines von den R0 und R1 Registern;
Rr: Eines von den R0 bis R7 Registern;

Ein Abarbeitungszyklus umfast i.d.R. 12 Takte.

Datentransfer

Tabelle 4: Assembler Mnemonik zum Thema "Datentransfer".
Mnemonik und Befehl-Code	Zyklen	Beschreibung mit Verweis auf ein Beispiel
1 Befehl zum nichts tun (no operation)
NOP 00	1	Es wird nichts getan, außer Zeit verbraucht. Dies kann manchmal wichtig sein, beim Warten und Zeitmessungen.

Die 4+2+2 Befehle mit MOV A,… bzw. MOVC A,… bzw. MOVX A,…
MOV A,adr08 E5 ??	1	Kopiere den Inhalt der RAM-Adresse "adr08=??H" in den Akkumulator. Da die Adresse mittels eines Bytes beschrieben wird, reicht diese von Null (00H) bis 255 (0FFH)!
MOV A,#c08 74 ??	1	Trage den 8 Bit-Wert "#c08=??H" in den Akkumulator ein.
MOV A,Rr E8/E9/EA/EB/EC/ED/EE/EF	1	Kopiere den Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7) in den Akkumulator.
MOV A,@Ri E6/E7	1	Kopiere den Inhalt der 8 Bit-RAM-Adresse, welche im Register i=(0, 1) steht, in den Akkumulator.
MOVC A,@A+DTPR 93	2	Kopiere den Inhalt der externen 16 Bit-RAM-Adresse, welche sich aus der Addition vom Daten-Pointer und Akkumulator ergibt, in den Akkumulator und überschreibt damit diesen.
MOVC A,@A+PC 83	2	Kopiere den Inhalt der externen 16 Bit-RAM-Adresse, welche sich aus der Addition vom Programm-Counter und Akkumulator ergibt, in den Akkumulator und überschreibt damit diesen.
MOVX A,@DPTR E0	2	Kopiere den Inhalt der externen 16 Bit-RAM-Adresse, welche im Daten-Pointer steht, in den Akkumulator.
MOVX A,@Ri E2/E3	2	Kopiere den Inhalt der externen 8 Bit-RAM-Adresse, welche im Register i=(0, 1) steht, in den Akkumulator.

Die 5 Befehle mit MOV adr08, …
MOV adr08a,A F5 ??	1	Kopiere den Inhalt des Akkumulators an die 8 Bit-RAM-Adresse "adr08a=??".
MOV adr08a,adr08b 85 ?? ??	2	Kopiere den Inhalt der 8 Bit-RAM-Adresse "adr08b=??" an die Stelle der 8 Bit-RAM-Adresse "adr08a=??".
MOV adr08a,#c08 75 ?? ??	2	Trage den 8 Bit-Wert "#c08" in die 8 Bit-RAM-Adresse "adr08a" ein.
MOV adr08a,Rr 88 ??/89 ??/8A ??/8B ??/ 8C ??/8D ??/8E ??/8F ??	2	Kopiere den Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7) an die 8 Bit-RAM-Adresse "adr08a".
MOV adr08a,@Ri 86 ??/87 ??	2	Kopiere den Inhalt der 8 Bit-RAM-Adresse "adr08", welche im Register i=(0, 1) steht, an die RAM-Adresse "adr08a".

Die 1+1 Befehle mit MOV und Carry-Flag
MOV badr,C 92 ??	2	Kopiert den Wert des Carry-Flags auf die Stelle, auf welche die Bit-Adresse "badr" verweist.
MOV C,badr A2 ??	1	Kopiert den Wert auf welche die Bit-Adresse "badr" verweist in das Carry-Flag.

Der 1 Befehl mit MOV DPTR, …
MOV DPTR,#data16 90 ?? ??	2	Beschreibt den Daten-Pointer mit einer 16 Bit-Konstante "data16". Der Daten-Pointer verweist dann, auf eine Stelle im externen Datenspeicher, welcher mit der Adresse übereinstimmt, welche durch die 16 Bit-Konstante gebildet wurde.

Der 1 Befehl mit MOVX @DPTR, …
MOVX @DPTR,A F0	2	Beschreibt den externen Datenspeichers an der 16 Bit-Adresse, welche im Daten-Pointer steht, mit dem 8 Bit-Wert aus dem Akkumulator.

Die 3 Befehle mit MOV Rr,…
MOV Rr,A F8/F9/FA/FB/FC/FD/FE/FF	1	Kopiere den Inhalt des Akkumulators in das Register r=(0, 1, 2, 3, 4, 5, 6, 7).
MOV Rr,adr08 A8 ??/A9 ??/AA ??/AB ??/ AC ??/AD ??/AE ??/AF ??	2	Kopiere den Inhalt der 8 Bit-RAM-Adresse "adr08=??" in das Register r=(0, 1, 2, 3, 4, 5, 6, 7).
MOV Rr,#c08 78 ??/79 ??/7A ??/7B ??/ 7C ??/7D ??/7E ??/7F ??	1	Trage den 8 Bit-Wert "#c08=??" in das Register r=(0, 1, 2, 3, 4, 5, 6, 7) ein.

Die 3+1 Befehle mit MOV @Rr,… bzw. MOVX @Rr, …
MOV @Ri,A F6/F7	1	Kopiere den Akkumulator-Inhalt an die RAM-Adresse "adr08", welche im Register i=(0, 1) steht.
MOV @Ri,adr08b A6 ??/A7 ??	2	Kopiere den den Inhalt der 8 Bit-RAM-Adresse "adr08b=??" in die RAM-Adresse, welche im Register i=(0, 1) steht.
MOV @Ri,#c08 76 ??/77 ??	1	Kopiere das Daten-Byte "c08" in die 8 Bit-RAM-Adresse, welche im Register i=(0, 1) steht.
MOVX @Ri,A F2/F3	2	Kopiere den Akkumulator-Inhalt an die externe RAM-Adresse "adr08", welche im Register i=(0, 1) steht.

Die 1+1 Befehle mit POP und PUSH
POP adr08 D0 ??	2	Entfernt ein Byte vom Stack, weist es der direkten Adresse zu und vermindert den Stack-Pointer um 1. Diese direkte Adresse könnte ein Register, ein Counter oder etwas sonstiges direkt adressierbares sein.
PUSH adr08 C0 ??	2	Legt das Byte, worauf die direkten Adresse weist, auf den Stack und erhöht den Stack-Pointer um 1. Diese direkte Adresse könnte ein Register, ein Counter oder etwas sonstiges direkt adressierbares sein.

Die 4 Befehle mit XCH …
XCH A,adr08 C5 ??	1	Tauscht den Inhalt des Akkumulators mit dem Inhalt, worauf die 8 Bit-RAM-Adresse verweist.
XCH A,Rr C8/C9/CA/CB/CC/CD/CE/CF	1	Tauscht den Inhalt des Akkumulators mit dem Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7).
XCH A,@Ri C6/C7	1	Tauscht den Inhalt des Akkumulators mit dem Inhalt der 8 Bit-RAM-Adresse, welche im Register i=(0, 1) steht.
XCHD A,@Ri D6/D7	1	Tauscht das untere Halbbyte des Akkumulators mit dem unteren Halbbyte, worauf die 8 Bit-RAM-Adresse verweist, welche im Register i=(0, 1) steht.

Beim Datentransfer werden die Daten kopiert und nicht verschoben. D.h sie werden

aus der rechts vom Komma stehenden Quelle
in die links vom Komma stehenden Ziel

übertragen.

Die unterschiedlichen MOV-Befehle werden benötigt um auf die unterschiedlichen, internen (MOV) und externen (MOVX), Speicherbereiche zugreifen zu können.

Arithmetische Befehle

Tabelle 5: Assembler Mnemonik zum Thema "Arithmetischen Operationen".
Mnemonik und Befehl-Code	Zyklen	Beschreibung mit Verweis auf ein Beispiel
Die 8 Befehle mit ADD …
ADD A,adr08 25 ??	1	Addiert den Inhalt der angegebenen 8 Bit-RAM-Adresse "adr08" zum Akkumulator hinzu. Formel: A=A+adr08
ADD A,#c08 24 ??	1	Addiert die 8 Bit-Konstante "c08"" zum Akkumulator hinzu. Formel: A=A+#c08
ADD A,Rr 28/29/2A/2B/2C/2D/2E/2F	1	Addiert den Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7) zum Akkumulator hinzu. Formel: A=A+Rr
ADD A,@Ri 26/27	1	Addiert den Inhalt der 8 Bit-RAM-Adresse, welche im Register i=0, 1) angegebnenen ist, zum Akkumulator hinzu. Formel: A=A+@Ri
ADDC A,adr08 35 ??	1	Addiert den Inhalt der angegebenen 8 Bit-RAM-Adresse "adr08" und den Übertrage (Carry) zum Akkumulator hinzu. Formel: A=A-adr08+CF
ADDC A,#c08 34 ??	1	Addiert die 8 Bit-Konstante "c08"" und den Übertrage (Carry) zum Akkumulator hinzu. Formel: A=A-#c08+CF
ADDC A,Rr 38/39/3A/3B/3C/3D/3E/3F	1	Addiert den Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7) und den Übertrage (Carry) zum Akkumulator hinzu. Formel: A=A+Rr+CF
ADDC A,@Ri 36/37	1	Addiert den Inhalt der 8 Bit-RAM-Adresse, welche im Register i=0, 1) angegebnenen ist, und den Übertrage (Carry) zum Akkumulator hinzu. Formel: A=A+@Ri+CF

Die 4 Befehle mit SUBB …
SUBB A,adr08 95 ??	1	Subtrahiere den Inhalt der 8 Bit-Adressese und den Übertrag (Carryflag, hier Borrowflag) vom Akkumulator. Formel: A=A-adr08-CF
SUBB A,#c08 94 ??	1	Subtrahiere die 8 Bit-Konstante "c08" und den Übertrag (Carryflag, hier Borrowflag) vom Akkumulator. Formel: A=A-#c08-CF
SUBB A,Rr 98/99/9A/9B/9C/9D/9E/9F	1	Subtrahiere den Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7) und den Übertrag (Carryflag, hier Borrowflag) vom Akkumulator. Formel: A=A-Rr-CF
SUBB A,@Ri 96/97	1	Subtrahiere den Inhalt der 8 Bit-RAM-Adresse, welche im Register i=(0, 1) steht und den Übertrag (Carryflag, hier Borrowflag) vom Akkumulator. Formel: A=A-@Ri-CF

Die 5 Befehle mit INC …
INC A 04	1	Inkrementiere (Erhöhen um Eins) den Akkumulator. Formel: A=A+1
INC adr08 05 ??	1	Inkrementiere den Inhalt der Speicherstelle, worauf die 8 Bit-RAM-Adresse hinweist. Formel: adr08=adr08+1
INC DPTR C3	2	Inkrementiere den Datenzeiger (DPTR). Formel: DPTR=DPTR+1
INC Rr 08/09/0A/0B/0C/0D/0E/0F	1	Inkrementiere den 8Bit-Wert im Register r=(0, 1, 2, 3, 4, 5, 6, 7). Formel: Rr=Rr+1
INC @Ri 06/07	1	Inkrementiere den Inhalt der Speicherstelle, worauf die 8 Bit-RAM-Adresse im Register i=0, 1) hinweist. Formel: @Ri=@Ri+1

Die 4 Befehle mit DEC …
DEC A 14	1	Dekrementiere (Verminderte um Eins) den Akkumulator. Formel: A=A-1
DEC adr08 15 ??	1	Dekrementiere den Inhalt der Speicherstelle, worauf die 8 Bit-RAM-Adresse hinweist. Formel: adr08=adr08-1
DEC Rr 18/19/1A/1B/1C/1D/1E/1F	1	Dekrementiere den 8Bit-Wert im Register r=(0, 1, 2, 3, 4, 5, 6, 7). Formel: Rr=Rr-1
DEC @Ri 16/17	1	Dekrementiere den Inhalt der Speicherstelle, worauf die 8 Bit-RAM-Adresse im Register i=(0, 1) hinweist. Formel: @Ri=@Ri-1

Die 2 Befehle mit Punktrechnung
DIV AB 84	4	Dividieren den Akkumulator durch den Inhalt des Registers B. Formel: A=A</B
MUL AB A4	4	Multipliziere den Akkumulator mit dem Inhalt des Registers B. Formel: A=A*B

Der 1 Befehle mit DA
DA A D4	1	Dezimalkorrektur des Inhaltes vom Akkumulator. Formel: ???

Wenn nicht anders vermerkt, steht das Ergebnis der arithmetischen Operation im Akkumulator und überschreibt damit den vorherrigen Inhalt!

Logische Befehle

Tabelle 6: Assembler Mnemonik zum Thema "Logische Operationen".
Mnemonik und Befehl-Code	Zyklen	Beschreibung mit Verweis auf ein Beispiel
Die 4+2+2 Befehle mit ANL …
ANL A,adr08 55 ??	1	Vernüpft den Inhalt von der Adresse "adr08"" durch logisches UND mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A & adr08
ANL A,#c08 54 ??	1	Vernüpft die Konstante "#c08" durch logisches UND mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A & #c08
ANL A,Rr 58/59/5A/5B/5C/5D/5E/5F	1	Vernüpft den Inhalt vom Register r=(0, 1, 2, 3, 4, 5, 6, 7) durch logisches UND mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A & Rr
ANL A,@Ri 56/57	1	Vernüpft den Inhalt von der Adresse die im Register i=(0, 1) steht durch logisches UND mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A & @Ri
ANL adr08,A 52 ??	1	Vernüpft den Inhalt von der angegebnenen Adresse durch logisches UND mit dem Akkumulator und legt das Ergebnis an der angegebnen Adresse wieder ab. Formel: adr08=adr08 & A
ANL adr08,#c08 53 ?? ??	2	Vernüpft den Inhalt von der angegebnenen Adresse durch logisches UND mit der Konstante "#c08" und legt das Ergebnis an der angegebnen Adresse wieder ab. Formel: adr08=adr08 & #c08
ANL C,badr 82 ??	2	Vernüpft das Bit vom Carry-Flag durch logisch UND mit dem der angegebnenen Bit-Adresse und legt das Ergebnis im Carry-Flag wieder ab. Formel: CF=CF & badr
ANL C,/badr B0 ??	2	Vernüpft das Bit vom Carry-Flag durch logisch UND mit dem negierten Bit der angegebnenen Bit-Adresse und legt das Ergebnis im Carry-Flag wieder ab. Formel: CF=CF & !badr

Die 3 Befehle mit CLR …
CLR A E4	1	Löscht den Inhalt vom Akkumulator. Formel: A=00H
CLR badr C2 ??	1	Lösche das direkt Bit mit der angegebnene Nummer. Formel: ???
CLR C C3	1	Lösche das Carry-Flag (Übertrag). Formel: CF=00H

Die 3 Befehle mit CPL …
CPL A F4	1	Komplementiere (Einer-Komplement?) den Inhalt vom Akkumulator. Formel: A=0FFH-A=!A
CPL badr B2 ??	1	Komplementiere (Einer-Komplement?) das Bit auf der angegebenen Adressse. Formel: Bit(badr)=!Bit(bdr)
CPL C B3	1	Komplementiere (Einer-Komplement?) das Carry-Flag. Formel: CF=!CF

Die 4+2 Befehle mit ORL …
ORL A,adr08 45 ??	1	Vernüpft den Inhalt von der Adresse "adr08" durch logisches ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A \| adr08
ORL A,#c08 44 ??	1	Vernüpft die Konstante "#c08" durch logisches ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A \|#c08
ORL A,Rr 48/49/4A/4B/4C/4D/4E/4F	1	Vernüpft den Inhalt vom Register r=(0, 1, 2, 3, 4, 5, 6, 7) durch logisches ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A \| Rr
ORL A,@Ri 46/47	1	Vernüpft den Inhalt von der Adresse die im Register i=(0, 1) steht durch logisches ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A \| @Ri
ORL adr08,A 42 ??	1	Vernüpft den Inhalt von der angegebnenen Adresse durch logisches ODER mit dem Akkumulator und legt das Ergebnis an der angegebnen Adresse wieder ab. Formel: adr08=adr08 \| A
ORL adr08,#c08 43 ?? ??	2	Vernüpft den Inhalt von der angegebnenen Adresse durch logisches ODER mit der Konstante "#c08" und legt das Ergebnis an der angegebnen Adresse wieder ab. Formel: adr08=adr08 \| #c08
ORL C,badr 72 ??	2	Vernüpft das Bit vom Carry-Flag durch logisches ODER mit dem der angegebnenen Bit-Adresse und legt das Ergebnis im Carry-Flag wieder ab. Formel: CF=CF \| badr
ORL C,/badr A0 ??	2	Vernüpft das Bit vom Carry-Flag durch logisches ODER mit dem negierten Bit der angegebnenen Bit-Adresse und legt das Ergebnis im Carry-Flag wieder ab. Formel: CF=CF \| !badr

Die 4 Befehle mit R …
RL A 23	1	Schiebe den Inhalt vom Akkumulator um eine Stelle nach links. Formel: A=A<-1=A*2, aber maximal 0FFH, sonst abzgl. 100H!
RLC A 33	1	Schiebe den Inhalt vom Akkumulator über das Carry-Flag um eine Stelle nach links. Das obere Bit wird dabei vom Carry-Flag übernommen und das unterste Bit des Akkumulators übernimmt dabei den alten Bit-Wert vom Carry-Flag. Formel: A=(A<-1)+CF=(A*2)+CF, aber maximal 0FFH, sonst abzgl. 100H!
RR A 03	1	Schiebe den Inhalt vom Akkumulator um eine Stelle nach rechts. Das Bit 0 des Akkumulators erhält den Wert vom Bit 7. In etwa wie eine Division durch 2. Formel: A=A>-1=A/2
RRC A 13	1	Schiebe den Inhalt vom Akkumulator über das Carry-Flag um eine Stelle nach rechts. Das untere Bit wird dabei vom Carry-Flag übernommen und als oberstes Bit erhält den alten Wert vom Carry-Flag. Formel: A=(A>-1)+(CF*80H)!

Die 2 Befehle mit SETB …
SETB badr D2 ??	1	Setze das Bit auf Eins, welche in der Adresse angegeben worden ist. Formel: Bit(badr)=1
SETB C D3	1	Setze das Carry-Flag (Übertrag). Formel: CF=1

Der 1 Befehl bzgl. SWAP
SWAP A C4	1	Vertausch das obere Halb-Byte mit dem unteren Halb-Byte. Formel: A=(A & 0FH)*10H + (A& 0F0H)/10H

Die 4+2 Befehle mit XRL …
XRL A,adr08 65 ??	1	Vernüpft den Inhalt von der Adresse "adr08"" durch logisches Exklusiv-ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A ^ adr08
XRL A,#c08 64 ??	1	Vernüpft die Konstante "#c08" durch logisches Exklusiv-ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A ^ #c08
XRL A,Rr 68/69/6A/6B/6C/6D/6E/6F	1	Vernüpft den Inhalt vom Register r=(0, 1, 2, 3, 4, 5, 6, 7) durch logisches Exklusiv-ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A ^ Rr
XRL A,@Ri 66/67	1	Vernüpft den Inhalt von der Adresse die im Register i=(0, 1) steht durch logisches Exklusiv-ODER mit dem Akkumulator und legt das Ergebnis im Akkumulator ab. Formel: A=A ^ @Ri
XRL adr08,A 62 ??	1	Vernüpft den Inhalt von der angegebnenen Adresse durch logisches Exklusiv-ODER mit dem Akkumulator und legt das Ergebnis an der angegebnen Adresse wieder ab. Formel: adr08=adr08 ^ A
XRL adr08,#c08 63 ?? ??	1	Vernüpft den Inhalt von der angegebnenen Adresse durch logisches Exklusiv-ODER mit der Konstante "#c08" und legt das Ergebnis an der angegebnen Adresse wieder ab. Formel: adr08=adr08 \| #c08

Das Ergebnis der logischen Operation steht im Gegensatz zu den arithmetischen Operation nicht immer im Akkumulator, sondern im linken Operanten.

Sprung-Befehle

Tabelle 7: Assembler Mnemonik zum Thema "Sprungbefehle".
Mnemonik und Befehl-Code	Zyklen	Beschreibung mit Verweis auf ein Beispiel
2 Befehle mit ?CALL …
ACALL adr11 11/31/51/71/91/B1/D1/F1 ??	2	Aufruf eines Unterprogrammes, welches in den ersten 2 kBytes abgelegt ist. Dies entspricht einer Größe von 11 Bit. Davon sind die oberen 3 Bit, dies ermöglicht 8 verschiedenen Werte, die man als Speicherseite 0 bis 7 mit einer Güße von 255 Byte interpretiert kann, im Befehl selbst enthalten. Der Assembler wählt automatisch den Operationscode aus, welcher zu der Speicherseite des Zieles passt! Spart gegenüber LCALL ein Byte Programmcode ein!
LCALL adr16 12 ?? ??	2	Aufruf eines Unterprogrammes im gesamten söglichen Speicherbereich von 64 kByte. Dies entspricht einer Größe von 16 Bit mit 65535 Möglichkeiten der Adressierung.

4 Befehle mit CJNE … (compare jump not even)
CJNE A,adr08,radr08 B5 ?? ??	2	Vergleiche den Akkumulator-Inhalt mit dem Inhalt der RAM-Zelle, die in der Adresse "adr08" angegeben wurde, und springe um "radr08", wenn diese ungleich ist.
CJNE A,#c08,radr08 B4 ?? ??	2	Vergleiche den Akkumulator-Inhalt mit der Konstante "c08" und springe um "radr08", wenn diese ungleich ist.
CJNE @Ri,#c08,radr08 B6/B7 ?? ??	2	Vergleiche den Inhalt der RAM-Adresse die im Register i=(0, 1) steht mit der Konstante "c08" und springe um "radr08", wenn diese ungleich ist.
CJNE Rr,#c08,radr08 B8/B9/BA/BC/BD/BE/BF ?? ??	2	Vergleiche den Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7) mit der Konstante "c08" und springe um "radr08", wenn diese ungleich ist.

2 Befehle mit DJNZ … (decrement jump not zero)
DJNZ adr08,radr08 D5 ?? ??	2	Dekrementiere den Inhalt an der RAM-Adresse "adr08" und wenn dieser nicht Null geworden ist, springe um "radr08" Bytes.
DJNZ Rr,radr08 D8/D9/DA/DB/DC/DE/DF ?? ?? Wirklich 2 zusätzliche Adress-Bytes???	2	Dekrementiere den Inhalt des Registers r=(0, 1, 2, 3, 4, 5, 6, 7) und wenn dieser nicht Null geworden ist, springe um "radr08" Bytes.

1+1+1+1 Befehle mit ?JMP … (jump)
AJMP adr11 01/21/41/61/81/A1/C1/E1 ??	2	Unbedingter Sprung zu einer Adresse, welche in den ersten 2 kBytes vorhanden ist. Dies entspricht einer Größe von 11 Bit. Davon sind die oberen 3 Bit, dies ermöglicht 8 verschiedenen Werte, die man als Speicherseite 0 bis 7 mit einer Güße von 255 Byte interpretiert kann, im Befehl selbst enthalten. Der Assembler wählt automatisch den Operationscode aus, welcher zu der Speicherseite des Zieles passt! Spart gegenüber LJUMP ein Byte Programmcode ein!
JMP @A+DPTR 73	2	Unbedingter Sprung zu einer Adresse, welche sich im Datenpointer DPTR befindet und um den Wert im Akkumulator durch Addition erhöht wird. Dies entspricht einer Größe von 16 Bit mit 65535 Möglichkeiten der Adressierung.
LJMP adr16 02 ?? ??	2	Unbedingter Sprung zu einer Adresse, welche sich im gesamten söglichen Speicherbereich von 64 kByte, befinden kann. Dies entspricht einer Größe von 16 Bit mit 65535 Möglichkeiten der Adressierung.
SJMP radr08 80 ?? ??	2	Unbedingter Sprung zu einer Adresse innerhalb von -128, …, +127 Bytes Speicherbereich. Spart gegenüber LJUMP ein Byte Programmcode ein und im Gegensatz von AJUMP im gesamten Speicherbereich von 64 kByte einsetzbar!

2 Befehle mit J?C … (jump not carry)
JC radr08 40 ??	2	Springe zur Adresse "radr08" relativ zur aktuellen Position, wenn das Carry-Flag gesetzt ist. Formel: 1 == CF ? Sprung um radr08 Bytes.
JNC radr08 50 ??	2	Springe zur Adresse "radr08" relativ zur aktuellen Position, wenn das Carry-Flag nicht gesetzt ist. Formel: 0 == CF ? Sprung um radr08 Bytes.

3 Befehle mit J?B … (jump not bit set)
JB badr08,radr08 20 ?? ??	2	Springe zur Adresse "radr08" relativ zur aktuellen Position, wenn das angegebenen Bit gesetzt ist. Formel: 1 == badr08 ? Sprung um radr08 Bytes.
JBC badr08,radr08 10 ?? ??	2	Springe zur Adresse "radr08" relativ zur aktuellen Position, wenn das angegebenen Bit gesetzt ist und lösche das Bit. Formel: 1 == badr08 ? Bit(badr08)=0 & Sprung um radr08 Bytes.
JNB badr08,radr08 30 ?? ??	2	Springe zur Adresse "radr08" relativ zur aktuellen Position, wenn das angegebene Bit nicht gesetzt ist. Formel: 0 == badr08 ? Sprung um radr08 Bytes.

2 Befehle mit J?Z … (jump not zero)
JZ radr08 60 ??	2	Springe zur Adresse "radr08" relativ zur aktuellen Position, wenn der Akkumulatorinhalt Null ist. Formel: 0 == A ? Sprung um radr08 Bytes.
JNZ radr08 70 ??	2	Springe zur Adresse "radr08" relativ zur aktuellen Position, wenn der Akkumulatorinhalt nicht Null ist. Formel: 0 <> A ? Sprung um radr08 Bytes.

2 Befehle mit RET …
RET 22	2	Rücksprung aus einem Unterprogramm.
RETI 32	2	Rückspung aus einer Interrupt-Routine.

Die Sprungbefehle teilen sich bei der Sprungweite in 3 Gruppen.

8Bit−Sprünge um eine Weite von ±128Byte.
11Bit−Sprünge um eine Weite von ±1.024Byte.
16Bit−Sprünge um eine Weite von ±32.768Byte.

Hardware

Wie ist nun die Hardware verdrahtet? Der Microcontroller selbst intern und die Platine. Als Platine verwenden wir unter anderen eine von Elektor entwickelte, welche wir mit den zukünftigen Programmen benutzen wollen?

Speicherorganisation

Es gibt 2 verschiedene Arten von Speicher, den Programmspeicher und den Datenspeicher. Der Programmspeicher wird durch den Programm-Counter adressiert und der Datenspeicher durch die MOV−Befehle benutzt.

Programmspeicher

Tabelle 8: Belegung und Adressierung
der Programmspeicher
Adresse	Interner Programmspeicher	Externer Programmspeicher
0FFFFH … 01000H		(/EA = 0)
00FFFH … 00000H	(/EA = 1)	(/EA = 0)

Der zur Verfügung stehende Programmspeicher unterteilt sich in 2 Bänke, die parallel nebeneinander existieren können und ab Adresse 0000H beginnen. Um in diesen Bereich zwischen interen und externen Programmspeicher umschalten zu können, wird das Pin /EA genutzt. Ist dieser mit 1 belegt, kann auf den internen, und ist dieser mit 0 belegt, kann auf den externen Programmspeicher zugegriffen werden. Da der interne Programmspeicher zur Zeit maximal 4kByte groß sein kann und wird oberhalb dessen generell auf den externen Programmspeicher zugegriffen.

Datenspeicher

Der zur Verfügung stehende Datenspeicher unterteilt sich, ähnlich wie der Programmspeicher, in 2 Bänke.

Tabelle 9: Belegung und Adressierung
der Datenspeicher

Adresse	Interner Datenspeicher	Externer Datenspeicher
0FFFFH … 0100H
0FFH … 080H	Spezielle Funktionsregister
07FH … 00H	Adressierbare Bits, Registerbänke

In den internen Speicher, welche bis 4kByte, und den externen Speicher, welcher bis 64kByte groß sein kann und adressierbar ist. Der Zuggriff auf den

internen RAM erfolgt mit MOV und
externen RAM mit MOVX.

Interner Datenspeicher

Tabelle 10b: Belegung des internen Speichers von 080H bis 0FFH vom MC 8051/8031

Adresse	Registeradresse								Funktion
Adresse	+00H	+01H	+02H	+03H	+04H	+05H	+06H	+07H	Funktion
0F8H	P5								Erweiterter interner Datenspeicher, in dem auch spezielle Funktionsregister, wie Akkumulator, enthalten sind.
0F0H	B
0E8H	P4
0E0H	ACC
0D8H	ADCON	ADDATADDAT	DAPR	P6
0D0H
0C8H	T2CON		CRCL	CRCH	TL2	TH2
0C0H	IRCON	CCEN	CCL1	CCH1	CCL2	CCH2	CCL3	CCH3
0B8H	IEN1	IP1
0B0H	P3
0A8H	IEN0
0A0H	P2
098H	SCON	SBUF
090H	P1
088H	TCON	TMOD	TL0	TL1	TH0	TH1
080H	P0		DPL	DPH				PCON

Tabelle 10a: Belegung des internen Speichers von 000H bis 07FH vom MC 8051/8031

Adresse	Register- bzw. Bitadresse	Funktion
07FH … 030H		Byteadressierbarer interner Datenspeicher
02FH	7FH 7EH 7DH 7CH - 7BH 7AH 79H 78H	Die 128 adressierbare Bits im interenen RAM
02EH	77H 76H 75H 74H - 73H 72H 71H 70H
02DH	6FH 6EH 6DH 6CH - 6BH 6AH 69H 68H
02CH	67H 66H 65H 64H - 63H 62H 61H 60H
02BH	5FH 5EH 5DH 5CH - 5BH 5AH 59H 58H
02AH	57H 56H 55H 54H - 53H 52H 51H 50H
029H	4FH 4EH 4DH 4CH - 4BH 4AH 49H 48H
028H	47H 46H 45H 44H - 43H 42H 41H 40H
027H	3FH 3EH 3DH 3CH - 3BH 3AH 39H 38H
026H	37H 36H 35H 34H - 33H 32H 31H 30H
025H	2FH 2EH 2DH 2CH - 2BH 2AH 29H 28H
024H	27H 26H 25H 24H - 23H 22H 21H 20H
023H	1FH 1EH 1DH 1CH - 1BH 1AH 19H 18H
022H	17H 16H 15H 14H - 13H 12H 11H 10H
021H	0FH 0EH 0DH 0CH - 0BH 0AH 09H 08H
020H	07H 06H 05H 04H - 03H 02H 01H 00H
01FH … 018H	R7 … R0	Registerbank 3
017H … 010H	R7 … R0	Registerbank 2
0FH … 08H	R7 … R0	Registerbank 1
07H … 00H	R7 … R0	Registerbank 0

Der Speicherbereich des internen RAM unterteilt sich in:

Speziellen Funktionsregister (SFR).
Einen 80Byte großen Bereich welcher byteadressierbar ist.
Einen 128Byte großen Bereich welcher bitadressierbar ist.
Die 4 Registerbänke mit Register 0 bis 7, welche sich über R0 bis R7 ansprechen lassen. Um welche Registerbank es sich handelt, die angesprochen wird, ist über die 2 Bit im Programm-Statuswort einstellbar.

Die speziellen Funktionsregister (SFR) sind

ACC=Akkumulator

Das Ort für den aktuellen Wert, die Stelle wo fast alles drüber läuft.

ADAT=???

ADCON=???

B=Register B

CCEN=???

CCL1=???, CCL2=???, CCL3=???

CCH1=???, CCH2=???, CCH3=???,

CRCL=???

CRCH=???

DAPR=???

DPL=???

DPH=???

IEN0=???, IEN1=???

IP0=???, IP1=???

IRCON=???

P0=Port 0, P1=Port 1, P2=Port 2, P3=Port 3, P4=Port 4, P5=Port 5, P6=Port 6

PCON=???

PSW = Programmstatuswort

Es ist ein Byte, welches 7 von den möglichen 8 Statusbit's zur Nutzung anbietet. Diese sind

MSB	…						LSB
PSW.7	PSW.6	PSW.5	PSW.4	PSW.3	PSW.2	PSW.1	PSW.0
CY	AC	F0	RS1	RS0	OV	-	P

Dabei ist Most Signifikant Bit (MSB) ist die Bezeichnung für das högstwertige Bit (Bit-Nr. 7) und Lost Signifikant Bit (LSB) ist die Bezeichnung für das niedrigstwertigste Bit (Bit-Nr. 0) des Datenbytes. Die enthaltenen Flags und deren Bedeutung sind

AC: Hilfesübertragungsbit z.B für BCD−Operationen.
CY
F0
OV
P
RSx mit x=0…1

SBUF=???

SCON=???

T2CON=???

TCON=???

TMOD=???

TL0=???, TL1=???, TL2=???

TH0=???, TH1=???, TH2=???

Elektor MC 8051 - Systembus

Tabelle 11: Belegung des Systembus
vom MC8051-System von Elektor
Pos.	Verwendung
Pos.	a	b	c
1	GND	GND	GND
2	GND		RD
3	GND		INT0
4	GND		WR
5	GND		INT1
6	GND		IOAD
7	GND		Rx
8	GND		Tx
9	GND
10	GND
11	ALDIS		/RES
12	PRG		GND
13	P1.7		P1.7
14	P1.6		P1.6
15	P1.5		P1.5
16	P1.4		P1.4
17	P1.3		P1.3
18	P1.2		P1.2
19	P1.1		P1.1
20	P1.0		P1.0
21	P1DIR		P1DIR
22	GND		GND
23	GND		GND
24	/A0		D0
25	/A1		D1
26	/A2		D2
27	/A3		D3
28	/A4		D4
29	/A5		D5
30	/A6		D6
31	/A7		D7
32	/GND		+5V

Der Systembus ist auf einer 3*32 poligen Steckerleister nach außen geführt und kann von hier auf eine System-Bus-Platine zu anderen Steckkarten weiter geführt und genutzt werden!

Verwendete Signalnamen:

+5V = Betriebsspannung plus 5 Volt
/Ai = /Adress-Bit i, z.dt. Low aktives Signal der Adressleitung i=0, …, 7;
ALDIS = ???, z.dt. ???;
Di = Daten-Bit i, Signal der Datenleitung i=0, …, 7;
GND = Ground, z.dt. Masse;
INT0/1 = Interrupt 0 bzw. 1, z.dt. Unterbrechungsanforderun 0 bzw. 1;
IOAD = Input/Output-Adress, z.dt. Ein-/Ausgabe-Adressbereich wird angespochen;
P1DIR = Port 1 Direction, z.dt. Signal-Richtung, d.h. Port 1 gibt etwas aus oder liest etwas ein;
P1.x = Port 1.x, z.dt. der Aus-/Eingang des Pins x von Port 1;
PRG = ???, z.dt. ???;
RD = Read, z.dt. Lesen von aktueller Adresse;
/RES = /Reset, z.dt. Low aktive Reset-Leitung;
Rx = RS232 Read, z.dt. Leseleitung der seriellen Schnittstelle;
WR = Write, z.dt. Schreiben auf aktuelle Adresse;
Tx = RS232 Transfer, z.dt. Übertragungsleitung der seriellen Schnittstelle;

Mo.	10:00−18:00
Di.	09:00−18:00
Mi.	09:00−18:00
Do.	09:00−18:00
Fr.	09:00−17:00
Sa.	Geschlossen
So.	Geschlossen