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 ontwikkelingM.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 manierVolg 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 ab
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
ORGoorsprong): 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
DBdefinië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 equ09h
MOVreg# 2 uur
EINDE De END-richtlijn wordt gebruikt om het einde van het programma aan te geven.
Syntaxis:
reg equ09h
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<—R015] +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 A20h // 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 ... TOE07h // 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 OPGEEN P
2. Syntaxis:
ORG 0000 uur
LCALL, label
SJMP STOP
Label: - - - - - - - -
Rechtsaf
HOU OPGEEN 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 biedenB.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.