Inleiding tot 8051 programmeren in assembleertaal

De assembleertaal is een programmeertaal op laag niveau die wordt gebruikt om programmacode te schrijven in termen van geheugensteuntjes. Hoewel er momenteel veel hoge-niveautalen zijn, wordt de programmeertaal voor assemblage in de volksmond in veel toepassingen gebruikt en kan het worden gebruikt voor directe hardwaremanipulaties. Het wordt ook gebruikt om het 8051 programmeercode efficiënt met minder klokcycli door minder geheugen te verbruiken in vergelijking met de andere hogere talen.

8051 Programmeren

8051 Programmeren in assembleertaal

De assembleertaal is een volledig hardware-gerelateerde programmeertaal. De embedded designers moeten voldoende kennis hebben van hardware van bepaalde processors of controllers alvorens het programma te schrijven. De assembleertaal is ontwikkeld door geheugensteuntjes, daarom kunnen gebruikers het niet gemakkelijk begrijpen om het programma te wijzigen.

8051 Programmeren in assembleertaal

Assembly-programmeertaal is ontwikkeld door verschillende compilers en de 'bowlingbaan​ is het meest geschikt voor microcontrollerprogrammeren ontwikkeling​M.icrocontrollersof processors kunnen alleen binaire taal begrijpen in de vorm van ‘0s of 1s’. Een assembler converteert de assembleertaal naar binaire taal en slaat deze vervolgens op in demicrocontrollergeheugen om de specifieke taak uit te voeren.

8051 Microcontrollerarchitectuur

De 8051microcontrolleris de Op CISC gebaseerde Harvard-architectuur , en het heeft randapparatuur zoals 32 I / O, timers / tellers, seriële communicatie en geheugens. Demicrocontrollervereist een programma om de bewerkingen uit te voeren die geheugen nodig hebben om de functies op te slaan en te lezen. De 8051microcontrollerbestaat uit RAM- en ROM-geheugens om instructies op te slaan.

8051 Microcontrollerarchitectuur

Een register is het belangrijkste onderdeel in de processors enmicrocontrollers die zich in het geheugen bevindt en een snellere manier biedt om de gegevens te verzamelen en op te slaan. De programmering van de 8051 assembleertaal is gebaseerd op de geheugenregisters. Als we gegevens naar een processor of controller willen manipuleren door aftrekken, optellen, etc., kunnen we dat niet rechtstreeks in het geheugen doen, maar het heeft registers nodig om de gegevens te verwerken en op te slaan.Microcontrollersbevatten verschillende soorten registers die kunnen worden geclassificeerd op basis van hun instructies of inhoud die erin wordt gebruikt.

8051 Microcontroller-programma's in assembleertaal

De assembleertaal bestaat uit elementen die allemaal worden gebruikt om het programma in te schrijvenopeenvolgende manier​Volg de gegeven regels om programmeren in assembleertaal te schrijven.

Regels van assembleertaal

• De montagecode moet in hoofdletters worden geschreven
• De labels moeten worden gevolgd door een dubbele punt (label :)
• Alle symbolen en labels moeten beginnen met een letter
• Alle opmerkingen worden in kleine letters getypt
• De laatste regel van het programma moet de END-richtlijn zijn

De geheugensteuntjes van de assembleertaal hebben de vorm van op-code, zoals MOV, ADD, JMP, enzovoort, die worden gebruikt om de bewerkingen uit te voeren.

Op-code: De op-code is een enkele instructie die kan worden uitgevoerd door de CPU. Hier is de op-code een MOV-instructie.

Operanden: De operanden zijn een enkel stuk gegevens dat kan worden bediend door de op-code. Een vermenigvuldigingsbewerking wordt bijvoorbeeld uitgevoerd door de operanden die worden vermenigvuldigd met de operand.

Syntaxis: MUL a​b

De elementen van een assembleertaalprogrammering:

• Stel richtlijnen samen
• Instructie set
• Adresseringsmodi

Monteer instructies:

De montage-instructies geven de aanwijzingen aan de CPU. De 8051microcontrollerbestaat uit verschillende soorten montagerichtlijnen om de besturing richting te geven. De handigste richtlijnen zijn 8051-programmering, zoals:

• ORG
• DB
• EQU
• EINDE

ORG​oorsprong): Deze richtlijn geeft de start van het programma aan. Dit wordt gebruikt om het registeradres in te stellen tijdens de montage. ORG 0000h vertelt de compiler bijvoorbeeld alle volgende code, beginnend bij adres 0000h.

Syntaxis: ORG 0000 uur

DB​definiëren byte): De definieerbyte wordt gebruikt om een ​​reeks bytes toe te staan. Druk bijvoorbeeld de 'EDGEFX' af, waarbij elk teken wordt genomen door het adres en tenslotte de 'string' door de DB rechtstreeks met dubbele aanhalingstekens wordt afgedrukt.

Syntaxis:

ORG 0000 uur

MOV a, # 00h
​
​
DB 'EDGEFX'

EQU (equivalent): De equivalente richtlijn wordt gebruikt om het adres van de variabele gelijk te stellen.

Syntaxis:

reg equ​09h
​
​
MOVreg​# 2 uur

EINDE​ De END-richtlijn wordt gebruikt om het einde van het programma aan te geven.

Syntaxis:

reg equ​09h

​
​
MOVreg​# 2 uur
EINDE

Adresseringsmodi:

De manier om toegang te krijgen tot gegevens wordt de adresseringsmodus genoemd. De CPU heeft op verschillende manieren toegang tot de gegevens door middel van adresseringsmodi. De 8051microcontrollerbestaat uit vijf adresseringsmodi, zoals:

• Onmiddellijke adresseringsmodus
• Registreer adresseringsmodus
• Directe adresseringsmodus
• Indirecte adresseringsmodus
• Basisindex-adresseringsmodus

Onmiddellijke adresseringsmodus:

In deze adresseringsmodus moet de bron een waarde zijn die kan worden gevolgd door de ‘#’ en moet de bestemming zijn SFR-registers, registers voor algemene doeleinden en adres. Het wordt gebruikt om de waarde onmiddellijk in de geheugenregisters op te slaan.

Syntaxis:

MOV A, # 20h // A iseenaccumulatorregister, wordt 20 opgeslagen in de A //
MOV R0​# 15 // R0 is een register voor algemene doeleinden 15 wordt opgeslagen in het R0-register //
MOV P0, # 07h // P0 is een SFR-register 07 wordt opgeslagen in de P0 //
MOV 20 uur​# 05h // 20h is het adres van het register 05 opgeslagen in de 20h //

Voormalig:

MOV R0, # 1
MOV R0, # 20 // R0<—R0​15] +20, de uiteindelijke waarde wordt opgeslagen in R0 //

Registreer adresseringsmodus:

In deze adresseringsmodus moeten de bron en bestemming een register zijn, maar geen registers voor algemene doeleinden. De gegevens worden dus niet verplaatst binnen het algemene bankregisters ​

Syntaxis:

MOV A, B // A is een SFR-register, B is een register voor algemene doeleinden //
MOV R0, R1 // Ongeldige instructie, GPR naar GPR niet mogelijk //

VOORMALIG:

MOV R0, # 02h
MOV A, # 30 uur
VOEG R0, A // R0<—R0+A, the final value is stored in the R0 register//

Directe adresseringsmodus

In deze adresseringsmodus moet de bron of bestemming (of zowel bron als bestemming) een adres zijn, maar geen waarde.

Syntaxis:

MOV A​20h // 20h is een adres A is een register //
MOV 00h, 07h // beide zijn geadresseerd van de GPS-registers //

Voormalig:

MOV 07 uur​# 01h
MOV A, # 08h
VOEG EEN ... TOE​07h // A<—A+07h the final value is stored in A//

Indirecte adresseringsmodus:

In deze adresseringsmodus moet de bron of bestemming (of bestemming of bron) zijnnaarindirect adres, maar geen waarde. Deze adresseringsmodus ondersteunt het aanwijzerconcept. De pointer is een variabele die wordt gebruikt om het adres van de andere variabele op te slaan. Dit pointerconcept wordt alleen gebruikt voor registers R0 en R1.

Syntaxis:

MOVR0, # 01h // 01-waarde wordt opgeslagen in het R0-register, R0-adres is 08h //
MOV R1, # 08h // R1 is de pointervariabele diewinkelsadres (08h) van R0 //
MOV 20 uur​@ R1 // 01 waarde wordt opgeslagen in het 20h-adres van het GP-register //

Indirecte adresseringsmodus

Basisindex-adresseringsmodus:

Deze adresseringsmodus wordt gebruikt om de gegevens van het extern geheugen of ROM-geheugen ​Alle adresseringsmodi kunnen de gegevens uit het codegeheugen niet lezen. De code moet door het DPTR-register worden gelezen. De DPTR wordt gebruikt om de gegevens in de code of het externe geheugen te verwijzen.

Syntaxis:

MOVC A, @ A + DPTR // C geeft codegeheugen aan //
MOCX A, @ A + DPTR // X geven extern geheugen //
EX: MOV A, # 00H // 00H wordt opgeslagen in het A-register //
MOV DPTR, # 0500H // DPTR wijst 0500h adres in het geheugen //
MOVC A, @ A + DPTR // stuur de waardenaarhet A-register //
MOV P0, A // datum van A verzonden naar de PO-registrar //

Instructie set:

De instructieset is de structuur van de controller of processor die opdrachten aan de controller geeft om de controller te begeleiden bij het verwerken van gegevens. De instructieset bestaat uit instructies, native gegevenstypen, adresseringsmodi, interruptregisters, uitzonderlijke verwerking en geheugenarchitectuur. De 8051microcontroller kan CISC-instructies volgen met de architectuur van Harvard. In het geval van de 8051-programmering omvatten verschillende soorten CISC-instructies:

• Instructieset voor gegevensoverdracht
• Opeenvolgende instructieset
• Rekenkundige instructieset
• Vertakking Iconstructieset
• Loop instructieset
• Voorwaardelijke instructieset
• Onvoorwaardelijke instructieset
• Logische instructieset
• Booleaanse instructieset

Rekenkundige instructieset:

De rekenkundige instructies voeren de basisbewerkingen uit zoals:

• Toevoeging
• Vermenigvuldiging
• Aftrekken
• Divisie

Toevoeging:

ORG 0000 uur
MOV R0, # 03H // verplaats de waarde 3 naar het register R0 //
MOV A, # 05H // verplaats de waarde 5 naar accumulator A //
Voeg A, 00H // toeVoeg een ... toewaarde met R0-waarde en slaat het resultaat opin een​
EINDE

Vermenigvuldiging:

ORG 0000 uur
MOV R0, # 03H // verplaats de waarde 3 naar het register R0 //
MOV A, # 05H // verplaats de waarde 5 naar accumulator A //
MUL A, 03H //Vermenigvuldigdresultaat wordt opgeslagen in de Accumulator A //
EINDE

Aftrekken:

ORG 0000 uur
MOV R0, # 03H // verplaats de waarde 3 om R0 te registreren //
MOV A, # 05H // verplaats de waarde 5 naar accumulator A //
SUBB A, 03H // Resultaatwaarde wordt opgeslagen in de Accumulator A //
EINDE

Divisie:

ORG 0000 uur
MOV R0, # 03H // verplaats de waarde 3 om R0 te registreren //
MOV A, # 15H // verplaats de waarde 5 naar accumulator A //
DIV A, 03H // eindwaarde wordt opgeslagen in de accumulator A //
EINDE

Voorwaardelijke instructies

De CPU voert de instructies uit op basis van de conditie door de enkele bitstatus of bytestatus te controleren. De 8051microcontrollerbestaat uit verschillende voorwaardelijke instructies zoals:

• JB -> Spring hieronder
• JNB -> Spring indien niet hieronder
• JC -> Jump if Carry
• JNC -> Springen alsnietDraag
• JZ -> Jump if Zero
• JNZ -> Springen alsnietNul

Voorwaardelijke instructies

1. Syntaxis:

JB P1.0, etiket
​
​
Label: - - - - - - - -
​
EINDE

2. Syntaxis:

JNB P1.0, etiket
​
​
Label: - - - - - - - -
​
EINDE

3. Syntaxis:

JC, label
​
​
Label: - - - - - - - -
​
EINDE

4. Syntaxis:

JNC, label
​
​
Label: - - - - - - - -
​
EINDE
5. Syntaxis:

JZ, label
​
​
Label: - - - - - - - -
​
EINDE

6. Syntaxis:

JNZ, label
​
​
Label: - - - - - - - -
​
EINDE

Bellen en springen instructies:

De oproep- en spronginstructies worden gebruikt om de codereplicatie van het programma te vermijden. Wanneer een specifieke code meer dan eens op verschillende plaatsen in het programma wordt gebruikt, als we het vermeldenspecifieke naamnaarcode danwe zouden die naam overal in het programma kunnen gebruiken zonder voor elke keer een code in te voeren. Dit vermindert de complexiteit van het programma. De 8051-programmering bestaat uit oproep- en spronginstructies zoals LCALL, SJMP.

• LCALL
• EEN TELEFOONTJE
• SJMP
• LJMP

1. Syntaxis:

ORG 0000 uur
​
​
ACALL, label
​
​
SJMP STOP
Label: - - - - - - - -
​
​
Rechtsaf
HOU OP​GEEN P

2. Syntaxis:

ORG 0000 uur
​
​
LCALL, label
​
​
SJMP STOP
Label: - - - - - - - -
​
​
Rechtsaf
HOU OP​GEEN P

Oproep- en springinstructies

Loop Instructies:

De lusinstructies worden gebruikt om het blok elke keer te herhalen tijdens het uitvoeren van de verhogings- en verlagingsbewerkingen. De 8051microcontrollerbestaan ​​uit twee soorten lusinstructies:

• CJNE -> vergelijk en spring zo niet gelijk
• DJNZ -> verlagen en springen indien niet nul

1. Syntaxis:

vanCJNE
MOV A, # 00H
MOV B, # 10H
Label​ INC A
​
​
CJNE A, etiket

2. Syntaxis:

vanDJNE

MOV R0, # 10H
Label: ​
​
DJNE R0, label
​
​
EINDE

Logische instructieset:

De 8051 microcontroller-instructieset biedt de EN-, OF-, XOR-, TEST-, NIET- en Booleaanse logische instructies voor het instellen en wist de bits op basis van de behoefte in het programma.

Logische instructieset

1. Syntaxis:

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

2. Syntaxis:

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

3. Syntaxis:

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

Verplaatsende operators

De ploegendienstmedewerkers worden gebruikt om de gegevens efficiënt te verzenden en te ontvangen. De 8051microcontrollerbestaan ​​uit vier ploegendienstmedewerkers:

• RR -> Rechts draaien
• RRC -> Rotate Right door carry
• RL -> Links draaien
• RLC -> Rotate Left door carry

Rechtsom draaien (RR):

Bij deze verschuivingsoperatie wordt de MSB LSB en alle bits verschuiven bit voor bit serieel naar de rechterkant.

Syntaxis:

MOV A, # 25 uur
RR A

Linksom draaien (RL):

Bij deze verschuivingsoperatie wordt de MSB LSB en alle bits verschuiven bit voor bit serieel naar de linkerkant.

Syntaxis:

MOV A, # 25 uur
RL A

RRC Rotate Right Through Carry:

Bij deze verschuivingsoperatie beweegt de LSB om te dragen en wordt de overdracht MSB, en alle bits worden bit voor bit naar de rechterkant verschoven.

Syntaxis:

MOV A, # 27h
RRC A

RLC linksom draaien door dragen:

Bij deze verschuivingsoperatie beweegt de MSB naar carry en de carry wordt LSB en alle bits verschuiven naar de linkerkant in een bit-voor-bit-positie.

Syntaxis:

MOV A, # 27h
RLC A

Basic Embedded C-programma's:

Demicrocontrollerprogrammering verschilt per type besturingssysteem. Er zijn veel besturingssystemen zoals Linux, Windows, RTOS enzovoort. RTOS heeft echter verschillende voordelen voor de ontwikkeling van embedded systemen. Enkele van de programmeervoorbeelden op montageniveau worden hieronder gegeven.

LED knippert met 8051microcontroller​

• Nummerweergave op 7-segment display met 8051 microcontroller
• Timer / tellerberekeningen en programma met behulp van 8051microcontroller
• Seriële communicatie berekeningen en programma met behulp van 8051microcontroller

LED-programma's met 8051 Microcontrller

1. WAP om de PORT1-LED's te wisselen

ORG 0000H
WISSELEN: MOV P1, # 01 //Actie00000001 naar het p1-register //
CALL DELAY // voer de vertraging uit //
MOV A, P1 // verplaatsp1-waardenaar de accumulator //
CPL A // complement A-waarde //
MOV P1, A // verplaats 11111110 naar het port1 register //
CALL DELAY // voer de vertraging uit //
SJMP TOGLE
DELAY: MOV R5, # 10H // laad register R5 met 10 //
TWEE: MOV R6, # 200 // laad register R6 met 200 //
ONE: MOV R7, # 200 // laad register R7 met 200 //
DJNZ R7, $ // verlaag R7 tot nul //
DJNZ R6, ONE // verlaag R7 tot nul //
DJNZ R5, TWEE // verlaag R7 tot nul //
RET // ga terug naar het hoofdprogramma //
EINDE

Timer / tellerberekeningen en programmeren met behulp van 8051 Microcontroller​

De vertraging is een van de belangrijkste factoren bij de ontwikkeling van applicatiesoftware. De timers en tellers zijn hardwarecomponenten van demicrocontroller, die in veel toepassingen worden gebruikt om de nauwkeurige tijdvertraging met telpulsen te bieden​B.Andere taken worden uitgevoerd door de softwaretechniek.

1. WAP om de vertraging van 500us te berekenen.

MOV TMOD, # 10H // selecteer de timermodus door de registers //
MOV TH1, # 0FEH // sla de vertragingstijd op in een hogere bit //
MOV TL1, # 32H // sla de vertragingstijd op in een lage bit //
JNB TF1, $ // verlaagt de waarde van de timer totdat deze nul is //
CLR TF1 // wis de timervlagbeetje​
CLR TR1 // UIT de timer //

2. WAP om de LED's te wisselenmet de5secvertraging

ORG 0000H
RETURN: MOV PO, # 00H
ACALL VERTRAGING
MOV P0, # 0FFH
ACALL VERTRAGING
SJUMP RETURN
DELAY: MOV R5, # 50H // laad register R5 met 50 //
DELAY1: MOV R6, # 200 // laad register R6 met 200 //
DELAY2: MOV R7, # 229 // laad register R7 met 200 //
DJNZ R7, $ // verlaag R7 tot nul //
DJNZ R6, DELAY2 // verlaag R6 tot nul //
DJNZ R5, DELAY1 // verlaag R5 tot nul //
RET // ga terug naar het hoofdprogramma //
EINDE

3. WAP om de 250 pulsen te tellen met mode0 count0

Syntaxis:

ORG 0000H
MOV TMOD, # 50H // selecteer de teller //
MOV TH0, # 15 // verplaats de telpulsen een hoger bit //
MOV TH1, # 9FH //Actiede telimpulsen, onderste bit //
SET TR0 // OP de timer //
JNB $ // verlaagt de telwaarde tot nul //
CLR TF0 // wis de teller, vlagbeetje​
CLR TR0 // stop de timer //
EINDE

Seriële communicatie programmeren met behulp van 8051 Microcontroller​

Seriële communicatie wordt vaak gebruikt voor het verzenden en ontvangen van de gegevens. De 8051microcontrollerbestaan ​​uit UART / USART seriële communicatie en de signalen worden verzonden en ontvangen doorTxen Rx-pinnen. De UART-communicatie draagt ​​de gegevens bit voor bit serieel over. De UART is een half-duplex protocol dat de gegevens verzendt en ontvangt, maar niet tegelijkertijd.

1. WAP om de tekens naar de Hyper Terminal te verzenden

MOV SCON, # 50H // stel de seriële communicatie in //
MOV TMOD, # 20H // selecteer de timermodus //
MOV TH1, # -3 // stel de baudrate in //
SET TR1 // OP de timer //
MOV SBUF, # ’S’ // verzend S naar het seriële venster //
JNB TI, $ // waarde van de timer verlagen tot nul //
CLR RI // duidelijke ontvangstonderbreking //
CLR TR1 // timer wissen //

2. WAP om het teken Ontvang het teken door de Hyper Terminal te verzenden

MOV SCON, # 50H // stel de seriële communicatie in //
MOV TMOD, # 20H // selecteer de timermodus //
MOV TH1, # -6 // stel de baudrate in //
SET TR1 // op de timer //
MOV SBUF, # ’S’ // verzend S naar het seriële venster //
JNB RI, $ // waarde van timer verlagen tot nul //
CLR RI // duidelijke ontvangstonderbreking //
MOV P0, SBUF // stuur de SBUF-registerwaarde naar de poort0 //
CLR TR1 // timer wissen //

Dit gaat allemaal over de 8051 Programming in Assembly-taal in het kort met op voorbeelden gebaseerde programma's. We hopen dat deze adequate informatie over assembleertaal zeker nuttig zal zijn voor de lezers en we kijken uit naar hun waardevolle opmerkingen in de commentaarsectie hieronder.