Einführung in die 8051-Programmierung in Assembler

Die Assembler-Sprache ist eine einfache ProgrammierungSprache, in der Programmcode in Mnemonik geschrieben wird. Obwohl es derzeit eine hohe Nachfrage nach Sprachen mit hohem Schwellwert gibt, wird die Programmiersprache Assembly häufig in vielen Anwendungen verwendet. Sie kann für direkte Hardwaremanipulationen verwendet werden. Es wird auch verwendet, um den 8051-Programmiercode effizienter mit weniger Taktzyklen zu schreiben, indem weniger Speicherplatz verbraucht wird als bei den anderen Hochsprachen.

8051 Programmierung in Assembler

8051 Programmierung in Assembler

Die Assembler-Sprache ist vollständig hardwarebezogenProgrammiersprache. Die Embedded-Designer müssen vor dem Schreiben des Programms über ausreichende Hardware-Kenntnisse bestimmter Prozessoren oder Controller verfügen. Die Assembler-Sprache wird von Mnemonics entwickelt. Daher können Benutzer es nicht leicht verstehen, das Programm zu ändern.

8051 Programmierung in Assembler

Assembly-Programmiersprache wird von verschiedenen Compilern entwickelt.Keiluvison”Ist am besten geeignet für Mikrocontroller Programmierung Entwicklung. MMikrocontroller oder Prozessoren können nur binäre Sprache in der Form „0s oder 1s“ verstehen. Ein Assembler konvertiert die Assemblersprache in eine binäre Sprache und speichert sie dann in der Mikrocontroller Speicher, um die bestimmte Aufgabe auszuführen.

8051 Mikrocontroller-Architektur

Die 8051 Mikrocontroller ist die CISC-basierte Harvard-Architektur. Sie verfügt über Peripheriegeräte wie 32 E / A, Timer / Zähler, serielle Kommunikation und Speicher. Das Mikrocontroller Erfordert ein Programm, um die Vorgänge auszuführen, für deren Speicherung ein Speicher erforderlich ist, und zum Lesen der Funktionen. Die 8051 Mikrocontroller besteht aus RAM- und ROM-Speichern zum Speichern von Anweisungen.

8051 Mikrocontroller Arctitecuture

Ein Register ist der Hauptteil in den Prozessoren und Mikrocontroller welches in dem Speicher enthalten ist, der a liefertschnellere Methode zum Sammeln und Speichern der Daten. Die 8051-Assembler-Programmierung basiert auf den Speicherregistern. Wenn wir Daten an einem Prozessor oder Controller durch Subtraktion, Addition usw. bearbeiten möchten, können wir dies nicht direkt im Speicher durchführen, sondern es müssen Register zur Verarbeitung und Speicherung der Daten verwendet werden. Mikrocontroller enthalten mehrere Arten von Registern, die nach ihren Anweisungen oder Inhalten klassifiziert werden können.

8051 Mikrocontroller-Programme in Assembler

Die Assembler-Sprache besteht aus Elementen, in denen das Programm geschrieben wird sequentiell. Befolgen Sie die angegebenen Regeln, um die Programmierung in Assembler zu schreiben.

Regeln der Versammlungssprache

  • Der Montagecode muss in Großbuchstaben geschrieben werden
  • Den Labels muss ein Doppelpunkt folgen (Label :)
  • Alle Symbole und Beschriftungen müssen mit einem Buchstaben beginnen
  • Alle Kommentare werden in Kleinbuchstaben geschrieben
  • Die letzte Zeile des Programms muss die END-Direktive sein

Die Assembler-Mnemonics haben die Form von Op-Code, wie z. B. MOV, ADD, JMP usw., mit denen die Operationen ausgeführt werden.

Op-Code: Der Op-Code ist eine einzelne Anweisung, die von der CPU ausgeführt werden kann. Hier ist der Op-Code eine MOV-Anweisung.

Operanden: Die Operanden sind ein einzelnes Datenelement, das mit dem Op-Code bearbeitet werden kann. Beispielsweise wird die Multiplikationsoperation von den Operanden ausgeführt, die mit dem Operanden multipliziert werden.

Syntax: MUL a,b;

Die Elemente einer Assembler-Programmierung:

  • Assembler-Richtlinien
  • Befehlssatz
  • Adressierungsmodi

Assembler-Richtlinien:

Die Montagerichtlinien geben der CPU die Anweisungen. Die 8051 Mikrocontroller besteht aus verschiedenen Arten von Montagerichtlinien, um der Steuereinheit die Richtung zu geben. Die nützlichsten Direktiven sind die 8051-Programmierung, wie zum Beispiel:

  • ORG
  • DB
  • EQU
  • ENDE

ORG(Ursprung): Diese Direktive zeigt den Start des Programms an. Hiermit wird die Registeradresse während der Montage eingestellt. Zum Beispiel; ORG 0000h teilt dem Compiler alle nachfolgenden Codes ab Adresse 0000h mit.

Syntax: ORG 0000h

DB(Byte definieren): Das Definitionsbyte wird verwendet, um einen String von zuzulassenBytes. Drucken Sie beispielsweise "EDGEFX", wobei jedes Zeichen von der Adresse übernommen wird und schließlich die "Zeichenfolge" von der DB direkt in doppelte Anführungszeichen gesetzt wird.

Syntax:

ORG 0000h

MOV a, # 00h
————-
————-
DB "EDGEFX"

EQU (gleichwertig): Die gleichwertige Direktive wird verwendet, um die Adresse der Variablen gleichzusetzen.

Syntax:

reg equ,09h
—————–
—————–
MOV reg,# 2h

ENDE:Die END-Direktive wird verwendet, um das Ende des Programms anzuzeigen.

Syntax:

reg equ,09h

—————–
—————–
MOV reg,# 2h
ENDE

Adressierungsmodi:

Der Zugriff auf Daten wird als Adressierungsmodus bezeichnet. Die CPU kann auf verschiedene Weise auf die Daten zugreifen, indem Adressierungsmodi verwendet werden. Die 8051 Mikrocontroller besteht aus fünf Adressierungsmodi wie:

  • Sofortiger Adressierungsmodus
  • Registrieren Sie den Adressierungsmodus
  • Direkter Adressierungsmodus
  • Indirekter Adressierungsmodus
  • Adressierungsmodus für den Basisindex

Sofortiger Adressierungsmodus:

In diesem Adressierungsmodus muss die Quelle a seinWert, dem das '#' und das Ziel folgen können, müssen SFR-Register, Universalregister und Adresse sein. Es wird verwendet, um den Wert sofort in den Speicherregistern zu speichern.

Syntax:

MOV A, # 20h // A ist ein Akkumulatorregister, 20 wird in der A // gespeichert
MOV R0,# 15 // R0 ist ein Register für allgemeine Zwecke; 15 ist im R0-Register gespeichert //
MOV P0, # 07h // P0 ist ein SFR-Register; 07 ist in P0 gespeichert //
MOV 20h,# 05h // 20h ist die Adresse des Registers; 05 in der 20h gespeichert //

Ex:

MOV R0, # 1
MOV R0, # 20 // R0 <-R0[15] +20, der Endwert wird in R0 gespeichert //

Adressierungsmodus registrieren:

In diesem Adressierungsmodus müssen Quelle und Ziel ein Register sein, jedoch keine Universalregister. Die Daten werden also nicht innerhalb der Bankregister für allgemeine Zwecke verschoben.

Syntax:

MOV A, B; // A ist ein SFR-Register, B ist ein Universalregister //
MOV R0, R1 // Ungültiger Befehl, GPR zu GPR nicht möglich //

EX:

MOV R0, # 02h
MOV A, # 30h
ADD R0, A // R0 <—R0 + A, der Endwert wird im R0-Register gespeichert //

Direkter Adressierungsmodus

In diesem Adressierungsmodus muss die Quelle oder das Ziel (oder Quelle und Ziel) eine Adresse sein, aber kein Wert.

Syntax:

MOV A,20h // 20h ist eine Adresse; A ist ein Register //
MOV 00h, 07h // Beide werden von den GPS-Registern angesprochen //

Ex:

MOV 07h,# 01h
MOV A, # 08h
FÜGE HINZU EIN,07h // A <—A + 07h Der Endwert wird in A // gespeichert.

Indirekter Adressierungsmodus:

In diesem Adressierungsmodus muss die Quelle oder das Ziel (oder das Ziel oder die Quelle) sein ein indirekte Adresse, aber kein Wert. Dieser Adressierungsmodus unterstützt das Zeigerkonzept. Der Zeiger ist eine Variable, in der die Adresse der anderen Variablen gespeichert wird. Dieses Zeigerkonzept wird nur für R0- und R1-Register verwendet.

Syntax:

MOVR0, # 01h // 01 Wert wird im R0-Register gespeichert, R0-Adresse ist 08h //
MOV R1, # 08h // R1 ist die Zeigervariable Shops Adresse (08h) von R0 //
MOV 20h,@ R1 // 01 Wert wird in der 20-Stunden-Adresse des GP-Registers gespeichert //

Indirekter Adressierungsmodus

Basisindex-Adressierungsmodus:

Dieser Adressierungsmodus wird zum Lesen der Daten verwendetvom externen Speicher oder ROM-Speicher. Alle Adressierungsmodi können die Daten nicht aus dem Codespeicher lesen. Der Code muss das DPTR-Register durchlesen. Der DPTR wird verwendet, um die Daten im Code oder im externen Speicher zu zeigen.

Syntax:

MOVC A, @ A + DPTR // C zeigt den Codespeicher an. //
MOCX A, @ A + DPTR // X zeigen externen Speicher an //
EX: MOV A, # 00H // 00H wird im A-Register gespeichert //
MOV DPTR, # 0500H // DPTR zeigt 0500h Adresse im Speicher
MOVC A, @ A + DPTR // Sende den Wert zu das A-Register //
MOV P0, A // Datum von A an den PO-Registrar senden //

Befehlssatz:

Der Befehlssatz ist die Struktur derController oder Prozessor, der dem Controller Befehle gibt, um den Controller zur Datenverarbeitung zu führen. Der Befehlssatz besteht aus Anweisungen, nativen Datentypen, Adressierungsmodi, Interruptregistern, außergewöhnlicher Handhabung und Speicherarchitektur. Die 8051 Mikrocontroller kann CISC-Anweisungen mit Harvard-Architektur folgen. Bei der Programmierung des 8051 gehören zu den verschiedenen CISC-Anweisungen:

  • Datenübertragungsbefehlssatz
  • Sequenzieller Befehlssatz
  • Arithmetischer Befehlssatz
  • Verzweigung ichAnweisung einstellen
  • Loop Instrcution Set
  • Bedingter Befehlssatz
  • Bedingungsloser Befehlssatz
  • Logischer Befehlssatz
  • Boolescher Befehlssatz

Arithmetischer Befehlssatz:

Die arithmetischen Anweisungen führen die grundlegenden Operationen aus, wie:

  • Zusatz
  • Multiplikation
  • Subtraktion
  • Einteilung

Zusatz:

ORG 0000h
MOV R0, # 03H // Wert 3 in das Register R0 verschieben
MOV A, # 05H // Verschiebe den Wert 5 nach Akkumulator A
A, 00H hinzufügen // füge hinzu ein Wert mit R0-Wert und speichert das Ergebnis in einem//
ENDE

Multiplikation:

ORG 0000h
MOV R0, # 03H // Wert 3 in das Register R0 verschieben
MOV A, # 05H // Verschiebe den Wert 5 nach Akkumulator A
MUL A, 03H // Multipliziert Ergebnis wird im Akkumulator A gespeichert //
ENDE

Subtraktion:

ORG 0000h
MOV R0, # 03H // Verschiebe den Wert 3 ins Register R0 //
MOV A, # 05H // Verschiebe den Wert 5 nach Akkumulator A
SUBB A, 03H // Der Ergebniswert wird im Akkumulator A gespeichert. //
ENDE

Einteilung:

ORG 0000h
MOV R0, # 03H // Verschiebe den Wert 3 ins Register R0 //
MOV A, # 15H // Verschiebe den Wert 5 nach Akkumulator A
DIV A, 03H // Der Endwert wird im Akkumulator A // gespeichert.
ENDE

Bedingte Anweisungen

Die CPU führt die Anweisungen basierend auf der Bedingung aus, indem sie den Einzelbitstatus oder den Bytestatus überprüft. Die 8051 Mikrocontroller besteht aus verschiedenen bedingten Anweisungen wie:

  • JB -> Spring unten
  • JNB -> Jump wenn nicht darunter
  • JC -> Jump wenn Carry
  • JNC -> Sprung wenn nicht Tragen
  • JZ -> Sprung bei Null
  • JNZ -> Sprung wenn nicht Null
Bedingte Anweisungen

1. Syntax:

JB P1.0, Etikett
- - - - - - - -
- - - - - - - -
Etikette: - - - - - - - -
- - - - - - - -
ENDE

2. Syntax:

JNB P1.0, Etikett
- - - - - - - -
- - - - - - - -
Etikette: - - - - - - - -
- - - - - - - -
ENDE

3. Syntax:

JC, Label
- - - - - - - -
- - - - - - - -
Etikette: - - - - - - - -
- - - - - - - -
ENDE

4. Syntax:

JNC, Label
- - - - - - - -
- - - - - - - -
Etikette: - - - - - - - -
- - - - - - - -
ENDE
5. Syntax:

JZ, Label
- - - - - - - -
- - - - - - - -
Etikette: - - - - - - - -
- - - - - - - -
ENDE

6. Syntax:

JNZ, Label
- - - - - - - -
- - - - - - - -
Etikette: - - - - - - - -
- - - - - - - -
ENDE

Call- und Jump-Anweisungen:

Die Aufruf- und Sprunganweisungen werden verwendet, um die Codereplikation des Programms zu vermeiden. Wenn ein bestimmter Code an verschiedenen Stellen im Programm mehr als einmal verwendet wird, wenn wir das erwähnen spezifischer Name zu Code dann Wir könnten diesen Namen überall im Programm verwendenohne für jedes Mal einen Code einzugeben. Dies reduziert die Komplexität des Programms. Die 8051-Programmierung besteht aus Aufruf- und Sprungbefehlen wie LCALL, SJMP.

  • LCALL
  • EIN ANRUF
  • SJMP
  • LJMP

1. Syntax:

ORG 0000h
- - - - - - - -
- - - - - - - -
ACALL, beschriften
- - - - - - - -
- - - - - - - -
SJMP STOP
Etikette: - - - - - - - -
- - - - - - - -
- - - - - - - -
ret
HALT:NOP

2. Syntax:

ORG 0000h
- - - - - - - -
- - - - - - - -
LCALL, beschriften
- - - - - - - -
- - - - - - - -
SJMP STOP
Etikette: - - - - - - - -
- - - - - - - -
- - - - - - - -
ret
HALT:NOP

Call- und Jump-Anweisungen

Loop Anweisungen:

Die Schleifenanweisungen werden verwendet, um den Block jedes Mal zu wiederholen, während die Inkrementierungs- und Dekrementierungsoperationen ausgeführt werden. Die 8051 Mikrocontroller bestehen aus zwei Arten von Schleifenanweisungen:

  • CJNE -> vergleichen und springen, falls nicht gleich
  • DJNZ -> dekrementieren und springen, wenn nicht Null

1. Syntax:

von CJNE
MOV A, # 00H
MOV B, # 10H
Etikette:INC A
- - - - - -
- - - - - -
CJNE A, Etikett

2. Syntax:

von DJNE

MOV R0, # 10H
Etikette:- - - - - -
- - - - - -
DJNE R0, Label
- - - - - -
- - - - - -
ENDE

Logischer Befehlssatz:

Der 8051-Mikrocontroller-Befehlssatz stellt die AND-, OR-, XOR-, TEST-, NOT- und Boolean-Logikbefehle zum Setzen bereit und löscht die Bits je nach Bedarf im Programm.

Logischer Befehlssatz

1. Syntax:

MOV A, # 20H / 00100000 /
MOV R0, # 03H / 00000101 /
ORL A, R0 // 00100000/00000101 = 00000000 //

2. Syntax:

MOV A, # 20H / 00100000 /
MOV R0, # 03H / 00000101 /
ANL A, R0

3. Syntax:

MOV A, # 20H / 00100000 /
MOV R0, # 03H / 00000101 /
XRL A, R0

Operatoren verschieben

Die Schichtoperatoren werden zum effizienten Senden und Empfangen der Daten verwendet. Die 8051 Mikrocontroller besteht aus vier Schichtbedienern:

  • RR -> Nach rechts drehen
  • RRC -> Nach rechts drehen
  • RL -> Nach links drehen
  • RLC -> Nach links drehen

Nach rechts drehen (RR):

Bei dieser Verschiebungsoperation wird das MSB zum LSB, und alle Bits verschieben sich bitweise in Richtung zur rechten Seite.

Syntax:

MOV A, # 25h
RR A

Nach links drehen (RL):

Bei dieser Verschiebungsoperation wird das MSB zum LSB, und alle Bits verschieben sich seriell bitweise zur linken Seite.

Syntax:

MOV A, # 25h
RL A

RRC nach rechts drehen durch tragen:

Bei diesem Verschiebevorgang bewegt sich das LSB zum Übertragen, und der Übertrag wird zum MSB, und alle Bits werden Bit für Bit nach rechts verschoben.

Syntax:

MOV A, # 27h
RRC A

RLC nach links drehen durch tragen:

Bei diesem Verschiebevorgang bewegt sich das MSB zum Übertragen, und der Übertrag wird zum LSB, und alle Bits verschieben sich bitweise nach links.

Syntax:

MOV A, # 27h
RLC A

Grundlegende Embedded C-Programme:

Das Mikrocontroller Die Programmierung unterscheidet sich für jede Art von BetriebSystem. Es gibt viele Betriebssysteme wie Linux, Windows, RTOS usw. RTOS bietet jedoch mehrere Vorteile für die Entwicklung eingebetteter Systeme. Einige der Programmierbeispiele auf Baugruppenebene sind unten aufgeführt.

LED blinkt mit mit 8051 Mikrocontroller:

  • Nummer Anzeige auf 7-Segment-Anzeige mit 8051-Mikrocontroller
  • Timer / Zählerberechnungen und Programmieren mit 8051 Mikrocontroller
  • Berechnungen der seriellen Kommunikation und Programm mit 8051 Mikrocontroller

LED-Programme mit 8051 Microcontrller

1. WAP zum Umschalten der PORT1-LEDs

ORG 0000H
Umschalten: MOV P1, # 01 //Bewegung 00000001 zum p1-Register //
CALL DELAY // die Verzögerung ausführen //
MOV A, P1 // bewegen p1 Wert zum akkumulator //
CPL A // Wert A ergänzen //
MOV P1, A // 11111110 in das Register port1 // verschieben
CALL DELAY // die Verzögerung ausführen //
SJMP-SCHALTER
DELAY: MOV R5, # 10H // Register R5 mit 10 // laden
ZWEI: MOV R6, # 200 // Register R6 mit 200 // laden
EINS: MOV R7, # 200 // Register R7 mit 200 // laden
DJNZ R7, $ // R7 dekrementieren, bis es Null ist //
DJNZ R6, ONE // R7 dekrementieren, bis es Null ist //
DJNZ R5, TWO // Dekrementiere R7 bis Null
RET // zurück zum Hauptprogramm //
ENDE

Timer / Zählerberechnungen und Programmieren mit 8051 MMikrocontroller:

Die Verzögerung ist einer der wichtigen Faktoren bei der Entwicklung von Anwendungssoftware. Die Timer und Zähler sind Hardwarekomponenten des Mikrocontroller, die in vielen Anwendungen verwendet werden, um die genaue Zeitverzögerung mit Zählimpulsen bereitzustellen. BDie Aufgaben werden durch die Softwaretechnik implementiert.

1. WAP zur Berechnung der 500us-Zeitverzögerung.

MOV TMOD, # 10H // Auswahl des Timermodus über die Register //
MOV TH1, # 0FEH // speichere die Verzögerungszeit im höheren Bit //
MOV TL1, # 32H // Speichern der Verzögerungszeit im Low-Bit //
JNB TF1, $ // Dekrementiere den Wert des Timers, bis er Null ist //
CLR TF1 // Das Timer-Flag löschen bisschen//
CLR TR1 // den Timer ausschalten //

2. WAP zum Umschalten der LEDs mit dem 5 sek Zeitverzögerung

ORG 0000H
RETURN: MOV PO, # 00H
ACALL DELAY
MOV P0, # 0FFH
ACALL DELAY
SJUMP RETURN
DELAY: MOV R5, # 50H // Register R5 mit 50 // laden
DELAY1: MOV R6, # 200 // Register R6 mit 200 // laden
DELAY2: MOV R7, # 229 // Register R7 mit 200 laden //
DJNZ R7, $ // R7 dekrementieren, bis es Null ist //
DJNZ R6, DELAY2 // R6 dekrementieren, bis es Null ist //
DJNZ R5, DELAY1 // R5 dekrementieren, bis es Null ist //
RET // zurück zum Hauptprogramm //
ENDE

3. WAP, um die 250 Impulse unter Verwendung von mode0 count0 zu zählen

Syntax:

ORG 0000H
MOV TMOD, # 50H // den Zähler auswählen //
MOV TH0, # 15 // Zählimpulse höheres Bit //
MOV TH1, # 9FH //Bewegung die Zählimpulse, unteres Bit //
SET TR0 // ON der Timer //
JNB $ // Dekrementiere den Zählwert auf Null //
CLR TF0 // Zähler löschen, Flag bisschen//
CLR TR0 // Stoppen Sie den Timer //
ENDE

Serielle Kommunikationsprogrammierung mit 8051 MMikrocontroller:

Serielle Kommunikation wird üblicherweise zum Senden und Empfangen der Daten verwendet. Die 8051 Mikrocontroller bestehen aus serieller UART / USART-Kommunikation und die Signale werden von gesendet und empfangen Tx und Rx-Pins. Die UART-Kommunikation überträgt die Daten bitweise seriell. Das UART ist ein Halbduplex-Protokoll, das die Daten überträgt und empfängt, jedoch nicht gleichzeitig.

1. WAP zum Übertragen der Zeichen an das Hyper-Terminal

MOV SCON, # 50H // Einstellung der seriellen Kommunikation //
MOV TMOD, # 20H // Auswahl des Timermodus //
MOV TH1, # -3 // Baudrate einstellen //
SET TR1 // ON der Timer //
MOV SBUF, # ’S’ // S zum seriellen Fenster übertragen
JNB TI, $ // Wert des Zeitgebers dekrementieren, bis er Null ist //
CLR RI // Empfangsunterbrechung löschen //
CLR TR1 // Löschtimer //

2. WAP zum Übertragen des Charakters über das Hyper-Terminal

MOV SCON, # 50H // Einstellung der seriellen Kommunikation //
MOV TMOD, # 20H // Auswahl des Timermodus //
MOV TH1, # -6 // Baudrate einstellen //
SET TR1 // am Timer //
MOV SBUF, # ’S’ // S zum seriellen Fenster übertragen
JNB RI, $ // Wert des Zeitgebers dekrementieren, bis er Null ist //
CLR RI // Empfangsunterbrechung löschen //
MOV P0, SBUF // Sende den SBUF-Registerwert an den Port0 //
CLR TR1 // Löschtimer //

Hier geht es um die 8051-Programmierung inAssemblersprache in Kürze mit beispielhaften Programmen. Wir hoffen, dass diese adäquaten Informationen zur Assembler-Sprache sicherlich für die Leser hilfreich sind, und freuen uns auf wertvolle Kommentare in den Kommentaren unten.


Teile mit deinen Freunden