Kabanata 4: Ang 6502 Microprocessor Assembly Language Tutorial

Kabanata 4: Ang 6502 Microprocessor Assembly Language Tutorial

4.1 Panimula

Ang 6502 microprocessor ay inilabas noong 1975. Ito ay ginamit bilang microprocessor para sa ilang mga personal na computer noon tulad ng Apple II, Commodore 64, at BBC Micro.

Ang 6502 microprocessor ay ginagawa pa rin sa malaking bilang ngayon. Ito ay hindi na isang central processing unit na ginagamit sa mga personal na computer (laptops) ngayon, ngunit ito ay ginagawa pa rin sa maraming bilang at ginagamit sa mga electronic at electrical appliances ngayon. Upang maunawaan ang mas modernong mga arkitektura ng computer, napakalaking tulong na suriin ang isang mas luma ngunit medyo matagumpay na microprocessor tulad ng 6502.

Dahil ito ay simpleng unawain at iprograma, ito ay isa sa pinakamahusay (kung hindi man ang pinakamahusay) microprocessor na gagamitin para sa pagtuturo ng assembly language. Ang wika ng pagpupulong ay isang mababang antas ng wika na maaaring magamit sa pagprograma ng isang computer. Tandaan na ang assembly language para sa isang microprocessor ay iba sa assembly language ng isa pang microprocessor. Ang 6502 microprocessor assembly language ay itinuro sa kabanatang ito. Mas tiyak, ito ay ang 65C02 na itinuro, ngunit simpleng tinutukoy, bilang 6502.

Ang isang sikat na computer sa nakaraan ay tinatawag na commodore_64. Ang 6502 ay isang microprocessor ng 6500 na pamilya. Ang commodore_64 computer ay gumagamit ng 6510 microprocessor. Ang 6510 microprocessor ay nasa 6500 µP. Ang set ng pagtuturo ng 6502 µP ay halos lahat ng mga tagubilin ng 6510 µP. Ang kaalaman sa kabanatang ito at sa susunod ay batay sa commodore_64 computer. Ginagamit ang kaalamang ito bilang mga batayan upang ipaliwanag ang mga modernong arkitektura ng computer at modernong operating system sa bahaging ito ng kursong online na karera.

Ang arkitektura ng computer ay tumutukoy sa mga bahagi ng motherboard ng computer at isang paliwanag kung paano dumadaloy ang data sa loob ng bawat bahagi, lalo na ang microprocessor, kung paano dumadaloy ang data sa pagitan ng mga bahagi, at gayundin kung paano nakikipag-ugnayan ang data. Ang isahan para sa data ay datum. Ang isang epektibong paraan upang pag-aralan ang arkitektura ng computer ng isang computer ay ang pag-aaral ng assembly language ng motherboard.

Ang commodore_64 computer ay sinasabing isang computer ng 8-bit na computer word. Nangangahulugan ito na ang impormasyon ay iniimbak, inililipat, at minamanipula sa anyo ng walong-bit na mga binary code.

Block Diagram ng Commodore 64 Motherboard
Ang block diagram ng commodore 64 motherboard ay:

Fig 4.1 Block Diagram ng Commodore_64 System Unit

Isipin ang 6510 microprocessor bilang 6502 microprocessor. Ang kabuuang memorya ay isang serye ng mga byte (8-bit bawat byte). Mayroong random-access (read/write) memory kung saan maaaring isulat o burahin ang mga byte. Kapag ang kapangyarihan ng computer ay naka-off, ang lahat ng impormasyon sa random-access memory (RAM) ay mabubura. Mayroon ding read-only memory (ROM). Kapag ang power ng computer ay naka-off, ang impormasyon sa ROM ay nananatili (ay hindi nabubura).

Mayroong input/output port (circuit) na tinutukoy bilang input/output device sa diagram. Ang port na ito ay hindi dapat malito sa mga port na nakikita sa kaliwa-at-kanan o harap-at-likod na patayong mga ibabaw ng unit ng computer system. Dalawang magkaibang bagay iyon. Ang mga koneksyon mula sa panloob na port na ito sa mga peripheral tulad ng hard-disk (o floppy-disk), keyboard, at monitor ay hindi ipinapakita sa diagram.

Mayroong tatlong mga bus (mga grupo ng mga electrical very small wire conductor) sa diagram. Ang bawat wire ay maaaring maglipat ng kaunti 1 o bit 0. Ang data bus, para sa paglipat ng walong-bit na byte sa isang pagkakataon (isang clock pulse) sa RAM at input/output port (input/output device) ay bidirectional. Ang data bus ay walong bits ang lapad.

Ang lahat ng mga bahagi ay konektado sa address bus. Ang address bus ay unidirectional mula sa microprocessor. Mayroong labing-anim na konduktor para sa address bus, at bawat isa ay nagdadala ng isang bit (1 o 0). Labing-anim na bit ay ipinapadala sa isang pulso ng orasan.

Nandiyan ang control bus. Ang ilan sa mga konduktor ng control bus ay maglilipat ng tig-iisang bit mula sa microprocessor patungo sa iba pang mga bahagi. Ang ilang mga linya ng kontrol ay nagdadala ng mga bit mula sa input/output (IO) port patungo sa microprocessor.

Memorya ng Computer
Ang RAM at ROM ay itinuturing bilang isang pagpupulong ng memorya. Ang pagpupulong na ito ay kinakatawan nang diagrama tulad ng sumusunod kung saan ang mga hexadecimal na numero ay may prefix na '$':

Fig 4.11 Memory Layout para sa Commodore 64 Computer

Ang RAM ay mula sa 0000 ₁₆ sa DFFF ₁₆ na nakasulat bilang mula $0000 hanggang $DFFF. Gamit ang 6502 µP assembly language, ang isang hexadecimal na numero ay may prefix na “$” at hindi nilagyan ng suffix (naka-subscript) na may 16 o H o hex. Ang anumang impormasyon sa RAM ay napupunta kapag ang computer ay naka-off. Nagsisimula ang ROM mula $E000 hanggang $FFFF. Mayroon itong mga subroutine na hindi napupunta kapag naka-off ang computer. Ang mga subroutine na ito ay ang karaniwang ginagamit na mga gawain na tumutulong sa programming. Ang programa ng gumagamit ay tumatawag sa kanila (sumangguni sa susunod na kabanata).

Ang espasyo (bytes) mula $0200 hanggang $D000 ay para sa mga program ng user. Ang espasyo mula $D000 hanggang $DFFF ay para sa impormasyong direktang nauugnay sa mga peripheral (input/output device). Ito ay bahagi ng operating system. Kaya, ang operating system ng commodore-64 na computer ay nasa dalawang pangunahing bahagi: ang bahagi sa ROM na hindi kailanman mawawala at ang bahagi mula $D000 hanggang $DFFF na napupunta kapag ang power ay naka-off. Ang data ng IO (input/output) na ito ay kailangang i-load mula sa isang disk sa tuwing bubuksan ang computer. Ngayon, ang naturang data ay tinatawag na peripheral driver. Ang mga peripheral ay nagsisimula mula sa port ng Input/Output Device sa pamamagitan ng mga koneksyon sa motherboard hanggang sa mga makikilalang port sa mga patayong ibabaw ng computer kung saan nakakonekta ang monitor, keyboard, atbp. at sa mga peripheral mismo (monitor, keyboard, atbp. .).

Ang memorya ay binubuo ng 2 ¹⁶ = 65,536 byte na lokasyon. Sa hexadecimal form, ito ay 10000 ₁₆ = 10000 _H = 10000 _hex = $10000 na lokasyon. Sa pag-compute, ang pagbibilang sa base two, base ten, base sixteen, atbp. ay nagsisimula sa 0 at hindi mula sa 1. Kaya, ang unang lokasyon ay talagang ang numero ng lokasyon na 0000000000000000 ₂ = 0 ₁₀ = 0000 ₁₆ = $0000. Sa 6502 µP assembly language, ang pagkakakilanlan ng lokasyon ng address ay may prefix na $ at walang suffix o subscript. Ang huling lokasyon ay ang numero ng lokasyon ng 11111111111111111 ₂ = 65,535 ₁₀ = FFFF ₁₆ = $FFFF at hindi 10000000000000000 ₂ , o 65,536 ₁₀ , o 10000 ₁₆ , o $10000. Ang 10000000000000000 ₂ , 65,536 ₁₀ , 10000 ₁₆ , o $10000 ay nagbibigay ng kabuuang bilang ng mga byte na lokasyon.

Dito, 2 ¹⁶ = 65,536 = 64 x 1024 = 64 x 2 ¹⁰ = 64 Kbytes (Kilobytes). Ang suffix ng 64 sa pangalang Commodore-64 ay nangangahulugang 64KB ng kabuuang memorya (RAM at ROM). Ang isang byte ay 8 bits, at ang 8 bits ay mapupunta sa isang byte na lokasyon sa memorya.

Ang 64 Kbytes ng memorya ay nahahati sa mga pahina. Ang bawat pahina ay may 0100 ₁₆ = 256 ₁₀ mga byte na lokasyon. Ang unang 256 ₁₀ = unang 0100 ₁₆ ang mga lokasyon ay pahina 0. Ang pangalawa ay pahina 1, ang pangatlo ay pahina 2, at iba pa.

Upang matugunan ang 65,536 na lokasyon, 16 bits ay kinakailangan para sa bawat lokasyon (address). Kaya, ang address bus mula sa microprocessor hanggang sa memorya ay binubuo ng 16 na linya; isang linya para sa isang bit. Ang kaunti ay alinman sa 1 o 0.

Ang 6502 µP Registers
Ang isang rehistro ay tulad ng mga byte na cell para sa isang byte na lokasyon ng memorya. Ang 6502 µP ay may anim na rehistro: limang 8-bit na rehistro at isang 16-bit na rehistro. Ang 16-bit na rehistro ay tinatawag na Program Counter na dinaglat bilang PC. Hawak nito ang memory address para sa susunod na pagtuturo. Ang isang programa sa wika ng pagpupulong ay binubuo ng mga tagubilin na inilalagay sa memorya. Labing-anim (16) na iba't ibang mga bit ang kailangan upang matugunan ang isang partikular na lokasyon ng byte sa memorya. Sa isang partikular na pulso ng orasan, ang mga bit na ito ay ipinapadala sa 16-bit na mga linya ng address ng address bus para sa pagbabasa ng isang pagtuturo. Ang lahat ng mga rehistro para sa 6502 µP ay inilalarawan tulad ng sumusunod:

Fig. 4.12 6502 µP Mga Rehistro

Ang Program Counter o PC ay makikita bilang isang 16-bit na rehistro sa diagram. Ang mas mababang makabuluhang walong bit ay may label na PCL para sa Program Counter Low. Ang mas mataas na makabuluhang walong bits ay may label na PCH para sa Program Counter High. Ang isang pagtuturo sa memorya para sa Commodore-64 ay maaaring binubuo ng isa, dalawa, o tatlong byte. Ang 16 bits sa PC ay tumuturo sa susunod na pagtuturo na isasagawa, sa memorya. Kabilang sa mga circuit sa microprocessor, dalawa sa kanila ang tinatawag na Arithmetic Logic Unit at Instruction Decoder. Kung ang kasalukuyang pagtuturo na pinoproseso sa µP (microprocessor) ay isang byte ang haba, ang dalawang circuit na ito ay nagpapataas ng PC para sa susunod na pagtuturo ng 1 unit. Kung ang kasalukuyang pagtuturo na pinoproseso sa µP ay dalawang byte ang haba, ibig sabihin ay sumasakop ito ng dalawang magkasunod na byte sa memorya, ang dalawang circuit na ito ay nagpapataas ng PC para sa susunod na pagtuturo ng 2 unit. Kung ang kasalukuyang pagtuturo na pinoproseso sa µP ay tatlong byte ang haba, ibig sabihin ay sumasakop ito ng tatlong magkakasunod na byte sa memorya, ang dalawang circuit na ito ay nagpapataas ng PC para sa susunod na pagtuturo ng 3 unit.

Ang accumulator na 'A' ay isang walong-bit na pangkalahatang layunin na rehistro na nag-iimbak ng resulta ng karamihan sa mga operasyon ng arithmetic at logic.

Ang 'X' at 'Y' na mga rehistro ay bawat isa ay ginagamit upang mabilang ang mga hakbang ng programa. Ang pagbibilang sa programming ay nagsisimula mula sa 0. Kaya, ang mga ito ay tinatawag bilang index registers. Mayroon silang ilang iba pang mga layunin.

Bagama't ang Stack Pointer na rehistro, ang 'S' ay may 9 bits na itinuturing na isang walong-bit na rehistro. Ang nilalaman nito ay tumuturo sa isang byte na lokasyon sa pahina 1 ng Random Access Memory (RAM). Ang pahina 1 ay nagsisimula sa byte na $0100 (256 ₁₀ ) sa byte $01FF (511 ₁₀ ). Kapag tumatakbo ang isang programa, lumilipat ito mula sa isang pagtuturo patungo sa susunod na magkakasunod na pagtuturo sa memorya. Gayunpaman, hindi ito palaging nangyayari. May mga pagkakataon na tumalon ito mula sa isang lugar ng memorya patungo sa isa pang lugar ng memorya upang magpatuloy sa pagpapatakbo ng mga tagubilin doon, nang magkakasunod. Ang Page 1 sa RAM ay ginagamit bilang stack. Ang stack ay isang malaking lugar ng memorya ng RAM na may mga susunod na address para sa pagpapatuloy ng code mula sa kung saan mayroong pagtalon. Ang mga code na may mga tagubilin sa paglukso ay wala sa stack; nasa ibang lugar sila sa alaala. Gayunpaman, pagkatapos maisakatuparan ang jump-to na mga tagubilin, ang mga address ng pagpapatuloy (hindi mga segment ng code) ay nasa stack. Sila ay itinulak doon bilang resulta ng pagtalon o mga tagubilin sa sangay.

Ang eight-bit Processor Status register ng P ay isang espesyal na uri ng rehistro. Ang mga indibidwal na bit ay hindi nauugnay o konektado sa isa't isa. Ang bawat bit doon ay tinatawag na bandila at pinahahalagahan nang nakapag-iisa sa iba. Ang mga kahulugan ng mga watawat ay ibinibigay sa mga sumusunod kung kinakailangan.

Ang una at huling bit index para sa bawat rehistro ay ipinahiwatig sa itaas ng bawat rehistro sa nakaraang diagram. Ang bit index (posisyon) na nagbibilang sa isang rehistro ay nagsisimula sa 0 sa kanan.

Mga Memory Page sa Binary, Hexadecimal, at Decimal
Ipinapakita ng sumusunod na talahanayan ang simula ng mga pahina ng memorya sa binary, hexadecimal, at decimal:

Ang bawat pahina ay may 1,0000,0000 ₂ bilang ng mga byte na kapareho ng 100 _H bilang ng mga byte na kapareho ng 256 ₁₀ bilang ng mga byte. Sa nakaraang memory diagram, ang mga pahina ay ipinahiwatig na umaakyat mula sa pahina 0 at hindi bumababa tulad ng ipinahiwatig sa talahanayan.

Ang binary, hexadecimal, at decimal na mga column ng talahanayang ito ay nagbibigay ng memory byte na mga address ng lokasyon sa kanilang iba't ibang base. Pansinin na para sa page zero, ang mga bit lang para sa mas mababang byte ang kailangan para mag-type kapag nagco-coding. Ang mga bit para sa mas mataas na byte ay maaaring tanggalin dahil sila ay palaging mga zero (para sa pahina ng zero). Para sa natitirang bahagi ng mga pahina, ang mga bit para sa mas mataas na byte ay dapat gamitin.

Ang natitirang bahagi ng kabanatang ito ay nagpapaliwanag sa 6502 µP Assembly Language gamit ang lahat ng nakaraang impormasyon. Upang mabilis na maunawaan ang wika, ang mambabasa ay kailangang magdagdag at magbawas sa batayang labing-anim sa halip na batayan sampu. Ito ay talagang dapat na base two, ngunit ang pagkalkula sa base two ay mahirap. Tandaan na kapag nagdadagdag ng dalawang numero sa base two, ang carry ay 1 pa rin tulad ng sa base ten. Ngunit kapag binabawasan ang dalawang numero sa base two, ang isang hiram ay dalawa at hindi sampu gaya ng sa base ten. Kapag nagdadagdag ng dalawang numero sa base labing-anim, ang isang carry ay 1 pa rin tulad ng sa base sampu. Ngunit kapag ang pagbabawas ng dalawang numero sa batayang labing-anim, ang isang hiram ay labing-anim at hindi sampu gaya ng sa batayang sampu.

4.2 Mga Tagubilin sa Paglilipat ng Data

Isaalang-alang ang sumusunod na talahanayan ng mga tagubilin sa paglilipat ng data ng wika ng assembly para sa 6502 µP:

Kapag ang isang byte (8-bits) ay kinopya mula sa isang memory byte na lokasyon patungo sa Accumulator Register, X Register, o Y Register, iyon ay naglo-load. Kapag ang isang byte ay kinopya mula sa alinman sa mga register na ito sa isang memory byte na lokasyon, iyon ay paglilipat. Kapag ang isang byte ay kinopya mula sa isang rehistro patungo sa isa pa, iyon ay naglilipat pa rin. Sa pangalawang column ng talahanayan, ipinapakita ng arrow ang direksyon ng kopya para sa isang byte. Ang iba sa apat na column ay nagpapakita ng iba't ibang addressing mode.

Ang isang entry sa column ng addressing mode ay ang aktwal na byte code para sa kaukulang mnemonic na bahagi ng pagtuturo sa hexadecimal. Ang AE, halimbawa, ay ang aktwal na byte code para sa LDX na mag-load ng isang byte mula sa memorya patungo sa X register sa absolute addressing mode tulad ng AE ₁₆ = 10101110 ₂ . Kaya, ang mga bit para sa LDX sa isang lokasyon ng memory byte ay 10101110.

Pansinin na para sa LDX mnemonic na bahagi ng pagtuturo, mayroong tatlong posibleng byte na A2, AE, at A6, at bawat isa ay para sa isang partikular na addressing mode. Kapag ang byte na naglo-load sa X register ay hindi dapat kopyahin mula sa isang memory byte na lokasyon, ang halaga ay kailangang i-type gamit ang (pagkatapos lamang) ng LDX mnemonic sa pagtuturo sa hexadecimal o decimal. Sa kabanatang ito, ang mga naturang halaga ay nai-type sa hexadecimal. Ito ay agarang pagtugon, kaya ang aktwal na byte sa memorya upang kumatawan sa LDX ay A2 ₁₆ = 10100010 ₂ at hindi AE ₁₆ na katumbas ng 10101110 ₂ .

Sa talahanayan, ang lahat ng mga byte sa ilalim ng mga heading ng addressing mode ay tinatawag na Operation Codes na dinaglat bilang opcodes. Maaaring mayroong higit sa isang opcode para sa isang mnemonic, depende sa addressing mode.

Tandaan: Ang salitang 'load' sa unit ng computer system ay maaaring magkaroon ng dalawang kahulugan: maaari itong tumukoy sa paglo-load ng isang file mula sa isang disk patungo sa memorya ng computer o maaari itong sumangguni sa paglilipat ng isang byte mula sa isang lokasyon ng memory byte patungo sa isang rehistro ng microprocessor .

Mayroong higit pang mga mode ng pagtugon kaysa sa apat sa talahanayan para sa 6502 µP.

Maliban kung iba ang sinabi, lahat ng user programming code sa kabanatang ito ay magsisimula sa address 0200 ₁₆ na siyang simula ng lugar ng gumagamit sa memorya.

Memory M at Accumulator A

Memory sa Accumulator

Agarang Pag-address
Ang sumusunod na tagubilin ay nag-iimbak ng numerong FF ₁₆ = 255 ₁₀ sa accumulator:

LDA #$FF

Ang '$' ay hindi lamang ginagamit upang tukuyin ang isang memory address. Sa pangkalahatan, ginagamit ito upang ipahiwatig na ang susunod na numero ay hexadecimal. Sa kasong ito, ang $FF ay hindi ang address ng anumang lokasyon ng memory byte. Ito ang numerong 255 ₁₀ sa hexadecimal. Ang base 16 o alinman sa iba pang katumbas na mga subscript nito ay hindi dapat isulat sa pagtuturo ng wikang assembly. Ang “#” ay nagsasaad na anuman ang susunod ay ang halaga na ilalagay sa rehistro ng nagtitipon. Ang halaga ay maaari ding isulat sa batayang sampu, ngunit hindi iyon ginagawa sa kabanatang ito. Ang ibig sabihin ng “#” ay agarang pagtugon.

Ang isang mnemonic ay may ilang pagkakahawig sa katumbas nitong pariralang Ingles. Ang ibig sabihin ng “LDA #$FF” ay i-load ang numerong 255 ₁₀ sa accumulator A. Dahil ito ay agarang addressing mula sa nakaraang talahanayan, ang LDA ay A9 at hindi AD o A5. Ang A9 sa binary ay 101010001. Kaya, kung ang A9 para sa LDA ay nasa $0200 na address sa memorya, ang $FF ay nasa $0301 = 0300 + 1 address. Ang #$FF ay tiyak na operand para sa LDA mnemonic.

Absolute Addressing
Kung ang halaga ng $FF ay nasa $0333 na lokasyon sa memorya, ang nakaraang pagtuturo ay:

LDA $0333

Tandaan ang kawalan ng #. Sa kasong ito, ang kawalan ng # ay nangangahulugan na ang sumusunod ay isang memory address at hindi ang halaga ng interes (hindi ang halaga na ilalagay sa accumulator). Kaya, ang opcode para sa LDA, sa pagkakataong ito, ay AD at hindi A9 o A5. Ang operand para sa LDA dito ay ang $0333 na address at hindi ang $FF na halaga. Ang $FF ay nasa $0333 na lokasyon na medyo malayo. Ang pagtuturo na 'LDA $0333' ay sumasakop sa tatlong magkakasunod na lokasyon sa memorya, at hindi dalawa, tulad ng ginawa ng nakaraang ilustrasyon. Ang “AD” para sa LDA ay nasa $0200 na lokasyon. Ang mas mababang byte ng 0333 na 33 ay nasa $0301 na lokasyon. Ang mas mataas na byte ng $0333 na 03 ay nasa $0302 na lokasyon. Ito ay maliit na endianness na ginagamit ng 6502 assembly language. Ang mga wika ng pagpupulong ng iba't ibang microprocessor ay iba.

Ito ay isang halimbawa ng ganap na pagtugon. Ang $0333 ay ang address ng lokasyon na mayroong $FF. Ang pagtuturo ay binubuo ng tatlong magkakasunod na byte at hindi kasama ang $FF o ang aktwal na lokasyon ng byte nito.

Zero-Page Addressing

Ipagpalagay na ang halaga ng $FF ay nasa $0050 na lokasyon ng memorya sa page zero. Ang mga byte na lokasyon para sa zero-page ay nagsisimula sa $0000 at nagtatapos sa $00FF. Ito ay 256 ₁₀ mga lokasyon sa kabuuan. Ang bawat pahina ng Commodore-64 memory ay 256 ₁₀ mahaba. Pansinin na ang mas mataas na byte ay zero para sa lahat ng posibleng lokasyon sa zero-page space sa memorya. Ang zero-page addressing mode ay kapareho ng absolute addressing mode, ngunit ang mas mataas na byte na 00 ay hindi nai-type sa pagtuturo. Kaya, upang i-load ang $FF mula sa $0050 na lokasyon papunta sa accumulator, ang pagtuturo ng zero-page addressing mode ay:

LDA $50

Sa pagiging A5 ng LDA at hindi A9 o AD, A5 ₁₆ = 10100101 ₂ . Tandaan na ang bawat byte sa memorya ay 8 mga cell, at ang bawat cell ay may kaunti. Ang pagtuturo dito ay binubuo ng dalawang magkasunod na byte. Ang A5 para sa LDA ay nasa $0200 na lokasyon ng memorya at ang $50 na address, na walang mas mataas na byte na 00, ay nasa $0301 na lokasyon. Ang kawalan ng 00, na kumonsumo sana ng isang byte sa kabuuang 64K na memorya, ay nakakatipid sa espasyo ng memorya.

Accumulator sa Memory

Absolute Addressing
Ang sumusunod na pagtuturo ay kinokopya ang isang byte na halaga, anuman ito, mula sa nagtitipon hanggang sa lokasyon ng memorya na $1444:

SILA AY $1444

Ito ay sinasabing paglilipat mula sa nagtitipon sa memorya. Hindi ito naglo-load. Ang paglo-load ay ang kabaligtaran. Ang opcode byte para sa STA ay 8D ₁₆ = 10001101 ₂ . Ang pagtuturo na ito ay binubuo ng tatlong magkakasunod na byte sa memorya. Ang 8D ₁₆ ay nasa $0200 na lokasyon. Ang 44 ₁₆ ng $1444 na address ay nasa $0201 na lokasyon. At 14 ₁₆ ay nasa $0202 na lokasyon – maliit na endianness. Ang aktwal na byte na kinopya ay hindi bahagi ng pagtuturo. 8D at hindi 85 para sa zero-page addressing (sa talahanayan) ay ginagamit dito para sa STA.

Zero Page Addressing
Ang sumusunod na tagubilin ay kinokopya ang isang byte na halaga, anuman ito, mula sa nagtitipon hanggang sa lokasyon ng memorya na $0050 sa page zero:

STA $0050

Ang opcode byte para sa STA dito ay 85 ₁₆ = 10000101 ₂ . Ang pagtuturo na ito ay binubuo ng dalawang magkasunod na byte sa memorya. Ang 85 ₁₆ ay nasa lokasyong $0200. Ang 50 ₁₆ ng $0050 na address ay nasa lokasyong $0201. Ang isyu ng endianness ay hindi lumabas dito dahil ang address ay mayroon lamang isang byte na mas mababang byte. Ang aktwal na byte na kinopya ay hindi bahagi ng pagtuturo. 85 at hindi 8D para sa zero-page addressing ang ginagamit dito para sa STA.

Hindi makatuwirang gamitin ang agarang pag-address para ilipat ang isang byte mula sa nagtitipon sa isang lokasyon sa memorya. Ito ay dahil ang aktwal na halaga tulad ng $FF ay kailangang ma-quote sa pagtuturo sa agarang pagtugon. Kaya, ang agarang pagtugon ay hindi posible para sa paglipat ng isang byte na halaga mula sa isang rehistro sa µP sa anumang lokasyon ng memorya.

LDX, STX, LDY, at STY Mnemonics
Ang LDX at STX ay katulad ng LDA at STA, ayon sa pagkakabanggit. Pero dito, X register ang ginagamit at hindi A (accumulator) register. Ang LDY at STY ay katulad ng LDA at STA, ayon sa pagkakabanggit. Ngunit dito, Y register ang ginagamit at hindi ang A register. Sumangguni sa Talahanayan 4.21 para sa bawat opcode sa hexadecimal na tumutugma sa isang partikular na mnemonic at isang partikular na mode ng pagtugon.

Register-to-Register Transfers
Ang nakaraang dalawang set ng mga tagubilin sa Talahanayan 4.21 ay tumatalakay sa memory/microprocessor-register copying (transfer) at register/register copying (transfer). Ang TAX, TXA, TAY, TYA, TSX at TXS na mga tagubilin ay gumagawa ng pagkopya (paglipat) mula sa rehistro sa microprocessor patungo sa isa pang rehistro ng parehong microprocessor.

Upang kopyahin ang byte mula A hanggang X, ang pagtuturo ay:

BUWIS

Upang kopyahin ang byte mula sa X hanggang A, ang pagtuturo ay:

TX

Upang kopyahin ang byte mula A hanggang Y, ang pagtuturo ay:

KAMAY

Upang kopyahin ang byte mula sa Y hanggang A, ang pagtuturo ay:

TYA

Para sa commodore 64 computer, ang stack ay pahina 1 pagkatapos lamang ng pahina 0 sa memorya. Tulad ng bawat ibang pahina, binubuo ito ng 25610 ₁₀ byte na lokasyon, mula $0100 hanggang $01FF. Karaniwan, ang isang programa ay nagpapatupad mula sa isang pagtuturo hanggang sa susunod na magkakasunod na pagtuturo sa memorya. Paminsan-minsan, mayroong pagtalon sa isa pang memory code (set ng mga tagubilin) ​​na segment. Ang stack area sa memorya (RAM) ay may susunod na mga address ng pagtuturo mula sa kung saan ang mga jumps (o mga sanga) ay tumigil para sa pagpapatuloy ng programa.

Ang stack pointer na 'S' ay isang 9-bit na rehistro sa 6502 µP. Ang unang bit (pinakaliwa) ay palaging 1. Ang lahat ng byte na address ng lokasyon sa unang pahina ay nagsisimula sa 1 na sinusundan ng 8 magkakaibang mga bit para sa 256 ₁₀ mga lokasyon. Ang stack pointer ay may address ng lokasyon sa pahina 1 na mayroong address ng susunod na pagtuturo na kailangang ibalik at ipagpatuloy ng programa pagkatapos isagawa ang kasalukuyang (jumped-to) na segment ng code. Dahil ang unang bit ng lahat ng mga address ng stack (page one) ay nagsisimula sa 1, ang stack pointer register ay kailangan lamang na hawakan ang natitirang walong bits. Pagkatapos ng lahat, ang unang bit nito, na siyang pinakakaliwa-bit (ang ikasiyam na bit na binibilang mula sa kanan nito), ay palaging 1.

Upang kopyahin ang byte mula sa S hanggang X, ang pagtuturo ay:

TSX

Upang kopyahin ang byte mula sa X hanggang S, ang pagtuturo ay:

TXT

Ang mga tagubilin sa pagpaparehistro para magparehistro ay hindi kumukuha ng anumang operand. Ang mga ito ay binubuo lamang ng mnemonic. Ang bawat mnemonic ay may opcode nito sa hexadecimal. Ito ay nasa implied addressing mode dahil walang operand (walang memory address, walang value).

Tandaan: Walang X to Y o Y to X transfer (pagkopya).

4.3 Arithmetic Operations

Ang circuit, Arithmetic Logic Unit sa 6502 µP, ay maaari lamang magdagdag ng dalawang walong-bit na numero sa isang pagkakataon. Hindi ito nagbabawas, hindi dumarami, at hindi naghahati. Ipinapakita ng sumusunod na talahanayan ang mga opcode at addressing mode para sa mga pagpapatakbo ng arithmetic:

Tandaan: Lahat ng mnemonics para sa arithmetic operations at iba pang uri ng operations (i.e. lahat ng 6502 mnemonics) ay tumatagal ng isang byte of operation (op) code. Kung mayroong higit sa isang addressing mode para sa mnemonic, magkakaroon ng iba't ibang opcode para sa parehong mnemonic: isa sa bawat addressing mode. Ang C, D, at V sa talahanayan ay ang mga flag ng status register. Ang kanilang mga kahulugan ay ibibigay sa ibang pagkakataon kung kinakailangan.

Pagdaragdag ng Unsigned Numbers
Gamit ang 6502 µP, ang mga nilagdaang numero ay complement number ng dalawa. Ang mga unsigned na numero ay mga ordinaryong positibong numero na nagsisimula sa zero. Kaya, para sa isang byte ng walong-bit, ang pinakamaliit na unsigned na numero ay 00000000 ₂ = 0 ₁₀ = 00 ₁₆ at ang pinakamalaking unsigned number ay 11111111 ₂ = 255 ₁₀ = FF ₁₆ . Para sa dalawang hindi nakapirmang numero, ang karagdagan ay:

A+M+C→A

Nangangahulugan iyon na ang 8-bit na nilalaman ng accumulator ay idinagdag ng arithmetic logic unit sa isang byte (8-bits) mula sa memorya. Pagkatapos ng pagdaragdag ng A at M, ang carry sa ika-siyam na bit ay mapupunta sa carry flag cell sa rehistro ng status. Anumang nakaraang bitbit na bit mula sa nakaraang karagdagan na nasa carry flag cell pa rin sa rehistro ng status ay idinaragdag din sa kabuuan ng A at M, na ginagawang A+M+C→A. Ang resulta ay ibabalik sa accumulator.

Kung ang pagdaragdag ng interes ay:

A + M

At hindi na kailangang magdagdag ng anumang naunang carry, kailangang i-clear ang carry flag na ginawang 0, upang ang karagdagan ay:

A+M+0→A katulad ng A+M→A

Tandaan: Kung idinagdag ang M sa A, at magkakaroon ng carry na 1 dahil mas malaki ang resulta sa 255 ₁₀ = 11111111 ₂ = FF ₁₆ , ito ay isang bagong carry. Ang bagong carry na 1 na ito ay awtomatikong ipinadala sa carry flag cell kung sakaling kailanganin ito ng susunod na pares ng walong-bit na susumahin (isa pang A + M).

Code para Magdagdag ng Dalawang Hindi Nalagdaan na Eight-Bits
00111111 ₂ +00010101 ₂ ay kapareho ng 3F ₁₆ + 15 ₁₆ na kapareho ng 63 ₁₀ +21 ₁₀ . Ang resulta ay 010101002 ₂ na kapareho ng 54 ₁₆ at 84 ₁₀ . Ang resulta ay hindi lampas sa maximum na bilang para sa walong bits na 255 ₁₀ = 11111111 ₂ = FF ₁₆ . Kaya, walang resultang carry na 1. Sa ibang paraan, ang resultang carry ay 0. Bago ang karagdagan, walang dating carry na 1. Sa madaling salita, ang dating carry ay 0. Ang code para gawin ang karagdagan na ito ay maaaring maging:

CLC
LDA#$3F
ADC #$15

Tandaan: Habang nagta-type ng assembly language, ang 'Enter' key ng keyboard ay pinindot sa dulo ng bawat pagtuturo. Mayroong tatlong mga tagubilin sa code na ito. Ang unang tagubilin (CLC) ay nag-clear sa carry flag kung sakaling ang isang nakaraang karagdagan ay may 1. Ang CLC ay maaari lamang gawin sa ipinahiwatig na addressing mode. Ang mnemonic para sa implied addressing mode ay hindi tumatagal ng operand. Ni-clear nito ang carry cell ng status register ng P. Ang ibig sabihin ng clearing ay pagbibigay ng bit ng 0 sa carry flag cell. Ang susunod na dalawang tagubilin sa code ay gumagamit ng agarang addressing mode. Sa agarang pag-address, mayroon lamang isang operand para sa mnemonic na isang numero (at hindi isang memorya o isang address ng rehistro). At kaya, ang numero ay dapat na unahan ng '#'. Ang “$” ay nangangahulugan na ang sumusunod na numero ay hexadecimal.

Ang pangalawang tagubilin ay naglo-load ng numero 3F ₁₆ sa accumulator. Para sa ikatlong pagtuturo, kinukuha ng arithmetic logic unit circuit ng µP ang naunang (cleared) carry na 0 (forced to 0) ng carry flag cell, ng status register at idinaragdag ito sa 15 ₁₆ pati na rin sa halaga na nasa 3F na ₁₆ accumulator at ibinalik ang kumpletong resulta sa accumulator. Sa kasong ito, mayroong resultang carry na 0. Ang ALU (Arithmetic Logic Unit) ay nagpapadala (naglalagay) ng 0 sa carry flag cell ng status register. Ang rehistro ng katayuan ng processor at ang rehistro ng katayuan ay nangangahulugan ng parehong bagay. Kung nagresulta ang isang carry ng 1, ang ALU ay nagpapadala ng 1 sa carry flag ng rehistro ng status.

Ang tatlong linya ng nakaraang code ay kailangang nasa memorya bago sila maisakatuparan. Ang opcode 1816 para sa CLC (implied addressing) ay nasa $0200 byte na lokasyon. Ang opcode A9 ₁₆ para sa LDA (kaagad na pag-address) ay nasa $0201 byte na lokasyon. Ang numero 3F ₁₀ ay nasa $0202 byte na lokasyon. Ang opcode 69 ₁₆ para sa LDA (kaagad na pag-address) ay nasa $0203 byte na lokasyon. Ang numero 15 ₁₀ ay nasa $0204 byte na lokasyon.

Tandaan: Ang LDA ay isang transfer (load) na pagtuturo at hindi isang aritmetika na pagtuturo (mnemonic).

Code para Magdagdag ng Dalawang Hindi Nilagdaan na Labing-anim na Bit
Ang lahat ng mga rehistro sa 6502 µP ay mahalagang eight-bit register, maliban sa PC (Program Counter) na 16-bits. Kahit na ang rehistro ng status ay 8-bits ang lapad, kahit na ang walong bits nito ay hindi gumagana nang magkasama. Sa seksyong ito, ang pagdaragdag ng dalawang 16 unsigned bits, na may carry mula sa unang pares ng walong bits hanggang sa pangalawang pares ng walong bits, ay isinasaalang-alang. Ang carry ng interes dito ay ang carry mula sa ikawalong bit na posisyon hanggang sa siyam na bit na posisyon.

Hayaan ang mga numero na 0010101010111111 ₂ = 2ABF16 ₁₆ = 10,943 ₁₀ at 0010101010010101 ₂ = 2A95 ₁₆ = 10,901 ₁₀ . Ang kabuuan ay 0101010101010100 ₂ = 5554 ₁₆ = 21,844 ₁₀ .

Ang pagdaragdag ng dalawang unsigned number na ito sa base two ay ang mga sumusunod:

Ang sumusunod na talahanayan ay nagpapakita ng parehong karagdagan sa pagdala ng 1 mula sa ikawalong bit hanggang sa ika-siyam na bit na posisyon, simula sa kanan:

Sa coding na ito, ang dalawang mas mababang byte ay idinagdag muna. Pagkatapos, ang ALU (Arithmetic Logic Unit) ay nagpapadala ng carry ng 1 mula sa ikawalong bit na posisyon hanggang sa ika-siyam na bit na posisyon, sa carry flag cell sa status register. Ang resulta ng 0 1 0 1 0 1 0 0 na walang dala ay napupunta sa accumulator. Pagkatapos, ang pangalawang pares ng mga byte ay idinagdag sa carry. Ang ADC mnemonic ay nangangahulugan ng awtomatikong pagdaragdag sa nakaraang carry. Sa kasong ito, ang nakaraang carry, na 1, ay hindi dapat baguhin bago ang pangalawang karagdagan. Para sa unang karagdagan, dahil ang anumang naunang dala ay hindi bahagi ng kumpletong karagdagan na ito, dapat itong i-clear (ginawa 0).

Para sa kumpletong pagdaragdag ng dalawang pares ng byte, ang unang karagdagan ay:

A + M + 0 -> A

Ang pangalawang karagdagan ay:

A + M + 1 -> A

Kaya, ang carry flag ay kailangang i-clear (ibinigay na halaga ng 0) bago ang unang karagdagan. Ang sumusunod na programa kung saan dapat basahin ng mambabasa ang kasunod na paliwanag ay gumagamit ng absolute addressing mode para sa pagbubuod na ito:

CLC
LDA $0213
ADC $0215
; walang clearing dahil kailangan ang carry flag value
STA $0217
LDA $0214
ADC $0216
STA $0218

Tandaan na sa 6502 assembly language, nagsisimula ang isang tuldok-kuwit ng komento. Nangangahulugan ito na sa pagpapatupad ng programa, ang semicolon at lahat ng nasa kanan nito ay hindi pinapansin. Ang program na dati nang nakasulat ay nasa isang text file ay nai-save gamit ang pangalan ng pinili ng programmer at may extension na '.asm'. Ang nakaraang programa ay hindi ang eksaktong programa na napupunta sa memorya para sa pagpapatupad. Ang kaukulang programa sa memorya ay tinatawag na isinalin na programa kung saan ang mga mnemonic ay pinapalitan ng mga opcode (bytes). Ang anumang komento ay nananatili sa text file ng wika ng pagpupulong, at aalisin bago maabot ng isinaling programa ang memorya. Sa katunayan, mayroong dalawang file na naka-save sa disk ngayon: ang '.asm' na file at ang '.exe' na file. Ang '.asm' na file ay ang isa sa nakaraang paglalarawan. Ang '.exe' na file ay ang '.asm' na file na ang lahat ng komento ay tinanggal, at ang lahat ng mnemonics ay pinalitan ng kanilang mga opcode. Kapag binuksan sa isang text editor, ang '.exe' na file ay hindi nakikilala. Maliban kung iba ang sinabi, para sa layunin ng kabanatang ito, ang '.exe' na file ay kinokopya sa memorya simula sa $0200 na lokasyon. Ito ang ibang kahulugan ng loading.

Ang dalawang 16-bit na numero na idaragdag ay sumasakop sa apat na byte sa memorya para sa ganap na pagtugon: dalawang byte bawat numero (ang memorya ay isang pagkakasunud-sunod ng mga byte). Sa ganap na pagtugon, ang operand sa opcode ay nasa memorya. Ang resulta ng summing ay dalawang bytes ang lapad at dapat ding ilagay sa memorya. Nagbibigay ito ng kabuuang 6 ₁₀ = 6 ₁₆ bytes para sa mga input at output. Ang mga input ay hindi mula sa keyboard at ang output ay hindi mula sa monitor o printer. Ang mga input ay nasa memorya (RAM) at ang output (summing result) ay babalik sa memorya (RAM) sa sitwasyong ito.

Bago isagawa ang isang programa, ang isinaling bersyon ay kailangang nasa memorya muna. Sa pagtingin sa nakaraang code ng programa, makikita na ang mga tagubilin na walang komento ay bumubuo 19 ₁₀ = 13 ₁₆ byte. Kaya, ang programa ay tumatagal mula sa $0200 byte na lokasyon sa memorya hanggang $0200 + $13 – $1 = $0212 byte na lokasyon (nagsisimula sa $0200 at hindi $0201 na nagpapahiwatig – $1). Ang pagdaragdag ng 6 na byte para sa mga numero ng input at output ay magtatapos sa lahat ng programa sa $0212 + $6 = $0218. Ang kabuuang haba ng programa ay 19 ₁₆ = 25 ₁₀ .

Ang mas mababang byte ng augend ay dapat nasa $0213 na address, at ang mas mataas na byte ng parehong augend ay dapat nasa $0214 na address – maliit na endianness. Katulad nito, ang mas mababang byte ng addend ay dapat nasa $0215 na address, at ang mas mataas na byte ng parehong addend ay dapat nasa $0216 na address – maliit na endianness. Ang mas mababang byte ng resulta (sum) ay dapat nasa $0217 na address, at ang mas mataas na byte ng parehong resulta ay dapat nasa $0218 na address – maliit na endianness.

Ang opcode 18 ₁₆ para sa CLC (implied addressing) ay nasa byte na lokasyon na $0200. Ang opcode para sa “LDA $0213”, ibig sabihin, AD ₁₆ para sa LDA (absolute addressing), ay nasa byte na lokasyon na $0201. Ang mas mababang byte ng augend na 10111111 ay nasa memory byte na lokasyon na $0213. Tandaan na ang bawat opcode ay sumasakop ng isang byte. Ang '$0213' na address ng 'LDA $0213' ay nasa byte na lokasyon ng $0202 at $0203. Nilo-load ng tagubiling 'LDA $0213' ang mas mababang byte ng augend sa accumulator.

Ang opcode para sa 'ADC $0215', ibig sabihin, 6D ₁₆ para sa ADC (absolute addressing), ay nasa byte na lokasyon na $0204. Ang mas mababang byte ng addend na 10010101 ay nasa byte na lokasyon na $0215. Ang '$0215' na address ng 'ADC $0215' ay nasa byte na lokasyon ng $0205 at $0206. Ang pagtuturo na 'ADC $0215' ay nagdaragdag ng mas mababang byte ng addend sa mas mababang byte ng augend na nasa accumulator na. Ang resulta ay inilagay pabalik sa nagtitipon. Anumang carry pagkatapos ng ikawalong bit ay ipapadala sa carry flag ng status register. Hindi dapat i-clear ang carry flag cell bago ang pangalawang pagdaragdag ng mas mataas na byte. Ang carry na ito ay awtomatikong idinaragdag sa kabuuan ng mas mataas na byte. Sa katunayan, ang isang carry na 0 ay idinaragdag sa kabuuan ng mas mababang byte nang awtomatiko sa simula (katumbas ng walang idinagdag na carry) dahil sa CLC.

Ang komento ay tumatagal ng susunod na 48 ₁₀ = 30 ₁₆ byte. Gayunpaman, nananatili lamang ito sa '.asm' na text file. Hindi ito umabot sa alaala. Ito ay tinanggal sa pamamagitan ng pagsasalin na ginagawa ng assembler (isang programa).

Para sa susunod na pagtuturo na 'STA $0217', ang opcode ng STA na 8D ₁₆ (absolute addressing) ay nasa byte na lokasyon ng $0207. Ang '$0217' na address ng 'STA $0217' ay nasa mga lokasyon ng memorya ng $0208 at $0209. Kinokopya ng tagubiling 'STA $0217' ang walong-bit na nilalaman ng nagtitipon sa lokasyon ng memorya na $0217.

Ang mas mataas na byte ng augend na 00101010 ay nasa lokasyon ng memorya na $0214, at ang mas mataas na byte ng addend na 00101010 ay nasa byte na lokasyon ng $02 ₁₆ . Ang opcode para sa 'LDA $0214' na AD16 para sa LDA (absolute addressing) ay nasa byte na lokasyon na $020A. Ang '$0214' na address ng 'LDA $0214' ay nasa mga lokasyon ng $020B at $020C. Ang 'LDA $0214' na pagtuturo ay naglo-load ng mas mataas na byte ng augend sa accumulator, binubura ang anumang nasa accumulator.

Ang opcode para sa 'ADC $0216' na 6D ₁₆ para sa ADC (absolute addressing) ay nasa byte na lokasyon ng $020D. Ang '$0216' na address ng 'ADC 0216' ay nasa byte na lokasyon ng $020E at $020F. Ang pagtuturo na 'ADC $0216' ay nagdaragdag ng mas mataas na byte ng addend sa mas mataas na byte ng augend na nasa accumulator na. Ang resulta ay inilagay pabalik sa nagtitipon. Kung mayroong carry na 1, para sa pangalawang karagdagan na ito, awtomatiko itong inilalagay sa carry cell ng status register. Kahit na ang carry na lampas sa panlabing-anim na bit (kaliwa) ay hindi kinakailangan para sa problemang ito, magandang tingnan kung ang carry ng 1 ay nangyari sa pamamagitan ng pagsuri kung ang carry flag ay naging 1.

Para sa susunod at huling pagtuturo na 'STA $0218', ang opcode ng STA na 8D16 (absolute addressing) ay nasa byte na lokasyon ng $0210. Ang '$0218' na address ng 'STA $0218' ay nasa mga lokasyon ng memorya ng $0211 at $0212. Kinokopya ng tagubiling 'STA $0218' ang walong-bit na nilalaman ng nagtitipon sa lokasyon ng memorya na $0218. Ang resulta ng pagdaragdag ng dalawang labing-anim na bit na numero ay 0101010101010100, na may mas mababang byte na 01010100 sa lokasyon ng memorya na $0217 at ang mas mataas na byte ng 01010101 sa lokasyon ng memorya na $0218 – maliit na endianness.

Pagbabawas
Gamit ang 6502 µP, ang mga nilagdaang numero ay complement number ng dalawa. Ang complement number ng dalawa ay maaaring walong-bit, labing-anim na bit, o anumang multiple ng walong bits. Sa two's complement, ang unang bit mula sa kaliwa ay ang sign bit. Para sa isang positibong numero, ang unang bit na ito ay 0 upang ipahiwatig ang tanda. Ang natitirang mga bit ay bumubuo ng numero sa normal na paraan. Upang makuha ang dalawa ng complement ng isang negatibong numero, baligtarin ang lahat ng mga bit para sa katumbas na positibong numero, at pagkatapos ay magdagdag ng 1 sa resulta mula sa kanang dulo.

Upang ibawas ang isang positibong numero mula sa isa pang positibong numero, ang subtrahend ay iko-convert sa isang negatibong numero ng complement ng dalawa. Pagkatapos, ang minuend at ang bagong negatibong numero ay idinaragdag sa normal na paraan. Kaya, ang walong-bit na pagbabawas ay nagiging:

Kung saan ang carry ay ipinapalagay bilang 1. Ang resulta sa accumulator ay ang pagkakaiba sa dalawang's complement. Kaya, para ibawas ang dalawang numero, dapat itakda ang carry flag (ginawa sa 1).

Kapag binabawasan ang dalawang labing anim na bit na numero, ang pagbabawas ay ginagawa nang dalawang beses tulad ng pagdaragdag ng dalawang labing anim na bit na numero. Dahil ang pagbabawas ay isang anyo ng karagdagan na may 6502 µP, kapag binabawasan ang dalawang labing-anim na bit na numero, ang carry flag ay nakatakda nang isang beses lamang para sa unang pagbabawas. Para sa pangalawang pagbabawas, awtomatikong ginagawa ang anumang setting ng carry flag.

Ang pagprograma ng pagbabawas para sa walong-bit na mga numero o labing-anim na bit na mga numero ay ginagawa nang katulad sa pagprograma ng karagdagan. Gayunpaman, ang carry flag ay dapat na nakatakda sa pinakadulo simula. Ang mnemonic para gawin ito ay:

Pagbabawas na may Labing-anim na bit na Positibong Numero
Isaalang-alang ang pagbabawas na may mga sumusunod na numero:

Ang pagbabawas na ito ay hindi nagsasangkot ng dalawang's complement. Dahil ang pagbabawas sa 6502 µP ay ginagawa sa two's complement, ang pagbabawas sa base two ay ginagawa tulad ng sumusunod:

Ang resulta ng complement ng dalawa ay pareho sa resulta na nakuha mula sa ordinaryong pagbabawas. Gayunpaman, tandaan na ang 1 na napupunta sa ikalabimpitong bit na posisyon mula sa kanan ay binabalewala. Ang minuend at ang subtrahend ay nahahati sa dalawang eights bit bawat isa. Ang complement ng dalawa ng 10010110 ng mas mababang byte ng subtrahend ay independiyenteng tinutukoy ng mas mataas na byte nito at ng anumang carry. Ang complement ng dalawa ng 11101011 ng mas mataas na byte ng subtrahend ay independiyenteng tinutukoy ng mas mababang byte nito at ng anumang carry.

Ang 16-bits ng minuend ay nasa two's complement na, simula sa 0 mula sa kaliwa. Kaya, hindi ito nangangailangan ng anumang pagsasaayos sa mga bit. Gamit ang 6502 µP, ang mas mababang byte ng minuend na walang anumang pagbabago ay idinaragdag sa mas mababang byte ng complement ng dalawa sa subtrahend. Ang mas mababang byte ng minuend ay hindi nako-convert sa two's complement dahil ang labing-anim na bits ng buong minuend ay dapat na nasa two's complement (na may 0 bilang unang bit sa kaliwa). Sa unang karagdagan na ito, ang isang sapilitang pagdala ng 1 ay idinagdag dahil sa pagtuturo ng 1=0 SEC.

Sa kasalukuyang epektibong pagbabawas, mayroong carry na 1 (ng karagdagan) mula sa ikawalong bit hanggang sa ikasiyam na bit (mula sa kanan). Dahil ito ay epektibong pagbabawas, kahit anong bit na dapat na nasa carry flag sa status register ay kinukumpleto (inverted). Kaya, ang carry ng 1 ay nagiging 0 sa C flag. Sa pangalawang operasyon, ang mas mataas na byte ng minuend ay idinaragdag sa mas mataas na dalawang complement byte ng subtrahend. Ang awtomatikong kinukumpleto na bitbit na bitbit ng bitbit ng status register (sa kasong ito ay 0) ay idinaragdag din (sa mas mataas na byte). Anumang 1 na lumampas sa panlabing-anim na bit mula sa kanan ay binabalewala.

Ang susunod na bagay ay i-code lamang ang lahat ng scheme na iyon tulad ng sumusunod:

SINASABI ni SEC
LDA $0213
SBC $0215
; walang clearing dahil kailangan ang inverted carry flag value
STA $0217
LDA $0214
SBC $0216
STA $0218

Tandaan na sa 6502 assembly language, nagsisimula ang isang semicolon ng komento na hindi kasama sa isinaling bersyon ng programa sa memorya. Ang dalawang 16-bit na numero para sa pagbabawas ay sumasakop sa apat na byte ng memorya na may ganap na pagtugon; dalawa sa bawat numero (ang memorya ay isang serye ng mga byte). Ang mga input na ito ay hindi mula sa keyboard. Ang resulta ng summing ay dalawang byte at kailangan ding ilagay sa memorya sa ibang lugar. Ang output na ito ay hindi napupunta sa monitor o printer; napupunta ito sa alaala. Nagbibigay ito ng kabuuang 6 ₁₀ = 6 ₁₆ bytes para sa mga input at output na ilalagay sa memorya (RAM).

Bago isakatuparan ang isang programa, dapat muna itong nasa memorya. Sa pagtingin sa code ng programa, makikita na ang mga tagubilin na walang komento ay bumubuo 19 ₁₀ = 13 ₁₆ byte. Dahil ang lahat ng mga programa sa kabanatang ito ay nagsisimula mula sa lokasyon ng memorya na $0200, ang program ay tumatagal mula sa $0200 byte na lokasyon sa memorya hanggang sa $0200 + $13 – $1 = $0212 byte na lokasyon (nagsisimula sa $0200 at hindi $0201). Ang hanay na ito ay hindi kasama ang rehiyon para sa input at output byte. Ang dalawang input number ay tumatagal ng 4 byte at ang isang output number ay tumatagal ng 2 byte. Ang pagdaragdag ng 6 na byte para sa mga numero ng input at output ay gumagawa ng hanay para sa programa na nagtatapos sa $0212 + $6 = $0218. Ang kabuuang haba ng programa ay 19 ₁₆ = 25 ₁₀ .

Ang mas mababang byte ng minuend ay dapat nasa $0213 na address, at ang mas mataas na byte ng parehong minuend ay dapat nasa $0214 na address – maliit na endianness. Katulad nito, ang mas mababang byte ng subtrahend ay dapat nasa $0215 na address, at ang mas mataas na byte ng parehong subtrahend ay dapat nasa $0216 na address – maliit na endianness. Ang mas mababang byte ng resulta (pagkakaiba) ay dapat nasa $0217 na address, at ang mas mataas na byte ng parehong resulta ay dapat nasa $0218 na address – maliit na endianness.

Ang opcode ng 38 ₁₆ para sa SEC (implied addressing) ay nasa $0200 na address. Ang lahat ng mga programa sa kabanatang ito ay ipinapalagay na magsisimula sa lokasyon ng memorya na $0200, na nagpapawalang-bisa sa anumang programa na naroon sana; maliban kung hindi nakasaad. Ang opcode para sa “LDA $0213”, ibig sabihin, AD ₁₆ , para sa LDA (absolute addressing) ay nasa $0201 byte na lokasyon. Ang mas mababang byte ng minuend na 10111111 ay nasa memory byte na lokasyon na $0213. Tandaan na ang bawat opcode ay sumasakop ng isang byte. Ang '$0213' na address ng 'LDA $0213' ay nasa byte na lokasyon ng $0202 at $0203. Nilo-load ng tagubiling 'LDA $0213' ang mas mababang byte ng minuend sa accumulator.

Ang opcode para sa “SBC $0215”, ibig sabihin, ED ₁₆ , para sa SBC (absolute addressing) ay nasa $0204 byte na lokasyon. Ang mas mababang byte ng subtrahend na 01101010 ay nasa $0215 byte na lokasyon. Ang '$0215' na address ng 'ADC $0215' ay nasa byte na lokasyon ng $0205 at $0206. Ibinabawas ng pagtuturo ng 'SBC $0215' ang lower byte ng subtrahend mula sa lower byte ng minuend na nasa accumulator na. Ito ay complement subtraction ng dalawa. Ang resulta ay inilagay pabalik sa nagtitipon. Ang complement (inversion) ng anumang carry pagkatapos ng ikawalong bit ay ipinadala sa carry flag ng status register. Ang carry flag na ito ay hindi dapat i-clear bago ang pangalawang pagbabawas na may mas mataas na byte. Ang carry na ito ay awtomatikong idinaragdag sa pagbabawas ng mas mataas na byte.

Ang komento ay tumatagal ng susunod na 57 ₁₀ = 3916 ₁₆ byte. Gayunpaman, nananatili lamang ito sa '.asm' na text file. Hindi ito umabot sa alaala. Ito ay tinanggal sa pamamagitan ng pagsasalin na ginagawa ng assembler (isang programa).

Para sa susunod na pagtuturo na 'STA $0217', ang opcode ng STA, ibig sabihin, 8D ₁₆ (absolute addressing), ay nasa $0207 byte na lokasyon. Ang '$0217' na address ng 'STA $0217' ay nasa mga lokasyon ng memorya ng $0208 at $0209. Kinokopya ng tagubiling 'STA $0217' ang walong-bit na nilalaman ng nagtitipon sa lokasyon ng memorya na $0217.

Ang mas mataas na byte ng minuend na 00101010 ay nasa lokasyon ng memorya na $0214, at ang mas mataas na byte ng subtrahend na 00010101 ay nasa byte na lokasyon na $0216. Ang opcode para sa “LDA $0214”, ibig sabihin, AD ₁₆ para sa LDA (absolute addressing), ay nasa $020A byte na lokasyon. Ang '$0214' na address ng 'LDA $0214' ay nasa mga lokasyon ng $020B at $020C. Ang pagtuturo na 'LDA $0214' ay naglo-load ng mas mataas na byte ng minuend sa accumulator, na binubura ang anumang nasa accumulator.

Ang opcode para sa 'SBC $0216', ibig sabihin, ED ₁₆ para sa SBC (absolute addressing), ay nasa $020D byte na lokasyon. Ang '$0216' na address ng 'SBC $0216' ay nasa mga byte na lokasyon ng $020E at $020F. Ibinabawas ng pagtuturo na 'SBC $0216' ang mas mataas na byte ng subtrahend mula sa mas mataas na byte ng minuend (two's complement) na nasa accumulator na. Ang resulta ay inilagay pabalik sa nagtitipon. Kung mayroong carry na 1 para sa pangalawang pagbabawas na ito, ang pandagdag nito ay awtomatikong inilalagay sa carry cell ng status register. Kahit na ang carry na lampas sa panlabing-anim na bit (kaliwa) ay hindi kinakailangan para sa problemang ito, magandang tingnan kung ang complement carry ay nangyayari sa pamamagitan ng pagsuri sa carry flag.

Para sa susunod at huling pagtuturo na 'STA $0218', ang opcode ng STA, ibig sabihin, 8D ₁₆ (absolute addressing), ay nasa $0210 byte na lokasyon. Ang '$0218' na address ng 'STA $0218' ay nasa mga lokasyon ng memorya ng $0211 at $0212. Kinokopya ng tagubiling 'STA $0218' ang walong-bit na nilalaman ng nagtitipon sa lokasyon ng memorya na $0218. Ang resulta ng pagbabawas na may dalawang labing-anim na bit na numero ay 0001010101010101 na may mas mababang byte na 01010101 sa lokasyon ng memorya na $0217 at ang mas mataas na byte ng 00010101 sa lokasyon ng memorya na $0218 – maliit na endianness.

Ang 6502 µP ay may circuitry para lamang sa karagdagan, at hindi direkta para sa complement subtraction ng dalawa. Wala itong circuitry para sa multiplikasyon at paghahati. Upang gawin ang pagpaparami at paghahati, isang programa sa wika ng pagpupulong na may mga detalye, kabilang ang paglilipat ng mga bahagyang produkto at bahagyang dibidendo, ay dapat na nakasulat.

4.4 Mga Lohikal na Operasyon

Sa 6502 µP, ang mnemonic para sa OR ay ORA at ang mnemonic para sa eksklusibong OR ay EOR. Pansinin na ang mga lohikal na operasyon ay walang ipinahiwatig na pagtugon. Ang ipinahiwatig na addressing ay hindi tumatagal ng operand. Ang bawat isa sa mga lohikal na operator ay dapat kumuha ng dalawang operand. Ang una ay nasa accumulator, at ang pangalawa ay nasa memorya o sa pagtuturo. Ang resulta (8-bits) ay bumalik sa accumulator. Ang una sa accumulator ay maaaring ilagay doon sa pamamagitan ng isang agarang pagtuturo o kinopya mula sa memorya na may ganap na pagtugon. Sa seksyong ito, ang zero-page addressing lamang ang ginagamit para sa paglalarawan. Ang mga lohikal na operator na ito ay lahat ng Bitwise operator.

AT
Ang sumusunod na talahanayan ay naglalarawan ng Bitwise AT sa binary, hexadecimal, at decimal:

Ang lahat ng mga programa sa kabanatang ito ay dapat magsimula sa lokasyon ng memory byte na $0200. Gayunpaman, ang mga programa sa seksyong ito ay nasa page zero, na may layuning ilarawan ang paggamit ng page zero nang walang mas mataas na byte na 00000000 ₂ . Ang nakaraang ANDing ay maaaring ma-code tulad ng sumusunod:

LDA #$9A ; hindi mula sa memorya – agarang pagtugon
AT #$CD ; hindi mula sa memorya – agarang pagtugon
STA $30 ; nag-iimbak ng $88 sa zero-based na $0030

O
Ang sumusunod na talahanayan ay naglalarawan ng Bitwise OR sa binary, hexadecimal, at decimal:

LDA #$9A ; hindi mula sa memorya – agarang pagtugon
ORA #$CD ; hindi mula sa memorya – agarang pagtugon
STA $30 ; nag-iimbak ng $CF sa zero-based na $0030

LIBRE
Ang sumusunod na talahanayan ay naglalarawan ng Bitwise XOR sa binary, hexadecimal, at decimal:

LDA #$9A ; hindi mula sa memorya – agarang pagtugon
EOR #$CD ; hindi mula sa memorya – agarang pagtugon
STA $30 ; nag-iimbak ng $57 sa zero-based na $0030

4.5 Shift at Rotate Operations

Ang mga mnemonic at opcode para sa shift at rotate operator ay:

ASL: Shift kaliwa ng isang bit ng accumulator o lokasyon ng memorya, na naglalagay ng 0 sa bakanteng pinakakanang cell.

LSR: Lumipat pakanan ng isang bit ng accumulator o lokasyon ng memorya, na naglalagay ng 0 sa bakanteng kaliwang cell.
ROL: I-rotate ang isang bit sa kaliwa ng accumulator o lokasyon ng memorya, ipinapasok ang bit na nalaglag sa kaliwa sa bakanteng pinakakanang cell.
ROR: I-rotate ang isang bit sa kanan ng accumulator o lokasyon ng memory, na ipinapasok ang bit na na-drop out sa kanan sa bakanteng kaliwang cell.

Upang gumawa ng shift o pag-ikot sa nagtitipon, ang pagtuturo ay isang bagay na tulad nito:

LSR A

Gumagamit ito ng isa pang addressing mode na tinatawag na accumulator addressing mode.

Upang gumawa ng shift o pag-ikot na may lokasyon ng memorya ng byte, ang pagtuturo ay katulad nito:

ROR $2BCD

Kung saan ang 2BCD ay ang lokasyon ng memorya.

Tandaan na walang agarang o ipinahiwatig na mode ng pagtugon para sa paglilipat o pag-ikot. Walang agarang addressing mode dahil walang punto sa paglilipat o pag-ikot ng numero na nananatili lamang sa pagtuturo. Walang ipinahiwatig na mode ng pag-address dahil ang mga taga-disenyo ng 6502 µP ay nais lamang na ang nilalaman ng nagtitipon (Isang rehistro) o isang lokasyon ng memory byte na ilipat o iikot.

4.6 Relative Addressing Mode

Palaging dinadagdagan ng microprocessor (ng 1, 2, o 3 unit) ang Program Counter (PC) upang ituro ang susunod na pagtuturo na isasagawa. Ang 6502 µP ay may pagtuturo na ang mnemonic ay BVS na nangangahulugang Branch on Overflow Set. Ang PC ay binubuo ng dalawang byte. Ang pagtuturo na ito ay nagiging sanhi ng PC na magkaroon ng ibang memory address para sa susunod na pagtuturo na isasagawa na hindi nagreresulta mula sa isang normal na pagtaas. Ginagawa ito sa pamamagitan ng pagdaragdag o pagbabawas ng halaga, na tinatawag na offset, sa nilalaman ng PC. At kaya, ang PC pagkatapos ay tumuturo sa ibang (branched) na lokasyon ng memorya para sa computer upang magpatuloy sa pagpapatupad mula doon. Ang offset ay isang integer mula sa -128 ₁₀ sa +127 ₁₀ (pagpupuno ng dalawa). Kaya, ang offset ay maaaring gawin ang pagtalon magpatuloy sa memorya. Kung ito ay positibo o nasa likod ng memorya, o kung ito ay negatibo.

Ang pagtuturo ng BVS ay tumatagal lamang ng isang operand na siyang offset. Ginagamit ng BVS ang relative addressing. Isaalang-alang ang sumusunod na tagubilin:

BVS $7F

Sa base two, 7F _H ay 01111111 ₂ = 127 ₁₀ . Ipagpalagay na ang nilalaman sa PC para sa susunod na pagtuturo ay $0300. Ang pagtuturo ng BVS ay nagsasanhi ng $7F (isang positibong numero na nasa dalawang complement) na idagdag sa $0300 upang magbigay ng $037F. Kaya, sa halip na ang susunod na pagtuturo na isasagawa sa lokasyon ng memorya na $0300, ito ay nasa lokasyon ng memorya na $037F (humigit-kumulang kalahating pagkakaiba ng pahina).

Mayroong iba pang mga tagubilin sa sangay, ngunit ang BVS ay isang napakahusay na gamitin upang ilarawan ang kamag-anak na pagtugon. Ang kamag-anak na pagtugon ay tumatalakay sa mga tagubilin ng sangay.

4.7 Naka-index na Pag-address at Hindi Direktang Pag-address nang Hiwalay

Ang mga addressing mode na ito ay nagbibigay-daan sa 6502 µP na pangasiwaan ang napakalaking dami ng data sa maikling panahon na may pinababang bilang ng mga tagubilin. Mayroong 64KB na mga lokasyon para sa buong Comodore-64 memory. Kaya, upang ma-access ang anumang lokasyon ng byte, ng 16 bits, kailangan ang paggawa ng dalawang byte. Ang tanging pagbubukod sa pangangailangan ng dalawang byte ay para sa page zero kung saan ang mas mataas na byte na $00 ay tinanggal upang matipid ang espasyo na kinukuha ng pagtuturo sa memorya. Sa isang non-page-zero addressing mode, ang mas mataas at mas mababang byte ng 16-bit na memory address ay kadalasang ipinapahiwatig kahit papaano.

Pangunahing Indexed Addressing

Absolute Index Addressing
Tandaan na ang X o Y register ay tinatawag na index register. Isaalang-alang ang sumusunod na tagubilin:

LDA $C453,X

Ipagpalagay na ang halaga ng 6 _H ay nasa X register. Tandaan na ang 6 ay hindi nai-type saanman sa pagtuturo. Idinaragdag ng tagubiling ito ang halaga ng 6H sa C453 _H na bahagi ng nai-type na pagtuturo sa text file na dapat pa ring i-assemble – C453 _H + 6 _H = C459 _H . Ang ibig sabihin ng LDA ay mag-load ng isang byte sa accumulator. Ang byte na ilo-load sa accumulator ay mula sa $C459 na address. Ang $C459 na siyang kabuuan ng $C453 na nai-type kasama ang pagtuturo at 6 _H na matatagpuan sa X register ay nagiging epektibong address kung saan nagmumula ang byte na ilalagay sa accumulator. Kung 6 _H ay nasa Y rehistro, ang Y ay nai-type sa lugar ng X sa pagtuturo.

Sa nai-type na pahayag ng pagtuturo, ang $C453 ay kilala bilang base address at ang 6 _H sa X o Y na rehistro ay kilala bilang bahagi ng pagbibilang o index para sa epektibong address. Ang base address ay maaaring sumangguni sa anumang byte address sa memorya, at ang susunod na 256 ₁₀ maaaring ma-access ang mga address, sa pag-aakalang ang sinimulang index (o bilang) sa X o Y na rehistro ay 0. Tandaan na ang isang byte ay maaaring magbigay ng tuluy-tuloy na hanay na hanggang 256 ₁₀ mga numero (ibig sabihin, 00000000 ₂ sa 11111111 ₂ ).

Kaya, ang absolute addressing ay nagdaragdag ng anumang nailagay na (nailagay na ng isa pang tagubilin) ​​sa X o Y na rehistro sa 16 na mga address na nai-type kasama ang pagtuturo upang makuha ang epektibong address. Sa nai-type na pagtuturo, ang dalawang rehistro ng index ay nakikilala sa pamamagitan ng X o Y na na-type pagkatapos ng kuwit. Alinman sa X o Y ay nai-type; Wala sa dalawa.

Matapos ang lahat ng programa ay nai-type sa isang text editor at nai-save gamit ang '.asm' extension filename, ang assembler, na isa pang programa, ay kailangang isalin ang nai-type na programa sa kung ano ang (na-load) sa memorya. Ang nakaraang pagtuturo, na 'LDA $C453,X', ay sumasakop sa tatlong byte na lokasyon sa memorya, at hindi lima.

Tandaan na ang isang mnemonic tulad ng LDA ay maaaring magkaroon ng higit sa isang opcode (iba't ibang byte). Ang opcode para sa pagtuturo na gumagamit ng X register ay iba sa opcode na gumagamit ng Y register. Alam ng assembler kung anong opcode ang gagamitin batay sa nai-type na pagtuturo. Ang isang byte opcode para sa 'LDA $C453,X' ay iba sa isang byte na opcode para sa 'LDA $C453,Y.' Sa katunayan, ang opcode para sa LDA sa “LDA $C453,X” ay BD, at ang opcode para sa LDA sa “LDA $C453,9” ay BD.

Kung ang opcode para sa LDA ay nasa $0200 byte na lokasyon. Pagkatapos, ang 16-bit na address ng $C453 ay tumatagal sa tabi ng mga byte na lokasyon sa memorya na $0201 at $0202. Ang partikular na opcode byte ay nagpapahiwatig kung ito ay ang X register o ang Y register na kasangkot. Kaya, ang pinagsama-samang pagtuturo ng wika na 'LDA $C453,X' o 'LDA $C453,Y' ay sumasakop ng tatlong magkakasunod na byte sa memorya, at hindi apat o lima.

Zero-Page Indexed Addressing
Ang zero-page index addressing ay katulad ng absolute index addressing na inilarawan dati, ngunit ang target na byte ay dapat nasa page zero lamang (mula $0000 hanggang $00FF). Ngayon, kapag nakikitungo sa zero page, ang mas mataas na byte na palaging 00 _H para sa mga lokasyon ng memorya ay karaniwang iniiwasan. Kaya, karaniwang binabanggit na ang page zero ay nagsisimula mula $00 hanggang FF. Kaya, ang nakaraang tagubilin ng 'LDA $C453,X' ay:

LDA $53.X

Ang $C4, isang mas mataas na byte na tumutukoy sa isang page sa itaas ng page zero, ay hindi magagamit sa pagtuturong ito dahil inilalagay nito ang inaasahang target na byte na ilo-load sa accumulated byte sa labas at sa itaas ng page zero.

Kapag ang value na nai-type sa pagtuturo ay idinagdag sa value sa index register, ang kabuuan ay hindi dapat magbigay ng resulta sa itaas ng page zero (FF _H ). Kaya, wala sa tanong na magkaroon ng isang pagtuturo tulad ng 'LDA $FF, X' at isang halaga tulad ng FF _H sa index register kasi FF _H + FF _H = 200 _H na ang unang byte ($0200) na lokasyon ng pahina 2 (ikatlong pahina) sa memorya, ay isang malaking distansya mula sa pahina 0. Kaya, sa zero-page na naka-index na pag-address, ang epektibong address ay dapat nasa page zero.

Hindi Direktang Pag-address

Tumalon Absolute Addressing
Bago talakayin ang Absolute Indirect Addressing, magandang tingnan muna ang JMP absolute addressing. Ipagpalagay na ang address na may halaga ng interes (target byte) ay $8765. Ito ay 16-bit na binubuo ng dalawang byte: ang mas mataas na byte na 87 _H at ang mas mababang byte na 65 _H . Kaya, ang dalawang byte para sa $8765 ay inilalagay sa PC (program counter) para sa susunod na pagtuturo. Ano ang nai-type sa programa ng wika ng pagpupulong (file) ay:

JMP $8765

Ang executing program sa memorya ay tumalon mula sa anumang address na na-access nito sa $8765. Ang JMP mnemonic ay may tatlong opcode na 4C, 6C, at 7C. Ang opcode para sa absolute addressing na ito ay 4C. Ang opcode para sa JMP absolute indirect addressing ay 6C (sumangguni sa mga sumusunod na larawan).

Absolute Indirect Addressing
Ito ay ginagamit lamang sa pagtuturo ng jump (JMP). Ipagpalagay na ang address na may byte ng interes (target byte) ay $8765. Ito ay 16-bit na binubuo ng dalawang byte: ang mas mataas na byte na 87 _H at ang mas mababang byte na 65 _H . Sa ganap na hindi direktang pagtugon, ang dalawang byte na ito ay aktwal na matatagpuan sa dalawang magkasunod na lokasyon ng byte sa ibang lugar sa memorya.

Ipagpalagay na ang mga ito ay matatagpuan sa mga lokasyon ng memorya ng $0210 at $0211. Pagkatapos, ang mas mababang byte ng address ng interes na 65 _H ay nasa $0210 na address, at ang mas mataas na byte na 87 _H ay nasa $0211 na address. Nangangahulugan iyon na ang mas mababang memory byte ng interes ay napupunta sa mas mababang magkakasunod na address, at ang mas mataas na memory byte ng interes ay napupunta sa mas mataas na magkakasunod na address - maliit na endianness.

Ang 16-bit na address ay maaaring sumangguni sa dalawang magkasunod na address sa memorya. Sa ganoong paraan, ang $0210 na address ay tumutukoy sa mga address na $0210 at $0211. Ang address pair na $0210 at $0211 ay may hawak na ultimate address (16-bits ng dalawang byte) ng target na byte, na may mas mababang byte na 65 _H sa $0210 at ang mas mataas na byte na 87 _H sa $0211. Kaya, ang jump instruction na nai-type ay:

JMP ($0210)

Ang JMP mnemonic ay may tatlong opcode na 4C, 6C, at 7C. Ang opcode para sa absolute indirect addressing ay 6C. Ang naka-type sa text file ay “JMP ($0210)”. Dahil sa mga panaklong, ginagamit ng assembler (translator) ang opcode 6C para sa JMP, at hindi 4C o 7C.

Sa ganap na hindi direktang pagtugon, mayroon talagang tatlong mga rehiyon ng memorya. Ang unang rehiyon ay maaaring binubuo ng mga byte na lokasyon na $0200, $0201, at $0202. Mayroon itong tatlong byte para sa pagtuturo na 'JMP ($0210)'. Ang pangalawang rehiyon, na hindi kinakailangang katabi ng una, ay binubuo ng dalawang magkasunod na byte na lokasyon na $0210 at $0211. Ito ang mas mababang byte dito ($0210) na nai-type sa pagtuturo ng programa sa wika ng pagpupulong. Kung ang address ng interes ay $8765, ang mas mababang byte ng 65 _H ay nasa $0210 byte na lokasyon, at ang mas mataas na byte na 87 _H ay nasa $0211 byte na lokasyon. Ang ikatlong rehiyon ay binubuo lamang ng isang byte na lokasyon. Ito ay mula sa $8765 na address para sa target na byte (ultimate byte ng interes). Ang pares ng magkakasunod na address, $0210 at $0211, ay mayroong $8765 pointer na siyang address ng interes. Pagkatapos ng interpretasyon sa pag-compute, $8765 ang napupunta sa PC (Program Counter) para ma-access ang target na byte.

Hindi Direktang Pag-address ng Zero Page
Ang pag-address na ito ay kapareho ng ganap na hindi direktang pag-address, ngunit ang pointer ay dapat nasa page zero. Ang mas mababang byte na address ng pointer na rehiyon ay kung ano ang nasa nai-type na pagtuturo tulad ng sumusunod:

JMP ($50)

Ang mas mataas na byte ng pointer ay nasa $51 byte na lokasyon. Ang epektibong address (pointed) ay hindi kailangang nasa page zero.

Kaya, sa index addressing, ang halaga sa isang index register ay idinaragdag sa base address na ibinigay sa pagtuturo upang magkaroon ng epektibong address. Ang hindi direktang pagtugon ay gumagamit ng isang pointer.

4.8 Indexed Indirect Addressing

Absolute Indexed Indirect Addressing
Ang addressing mode na ito ay ginagamit lamang sa pagtuturo ng JMP.
Sa ganap na hindi direktang pag-address, mayroong pointed value (byte) na may sarili nitong dalawang magkasunod na byte na address. Ang dalawang magkasunod na address na ito ay bumubuo ng pointer na nasa pointer region ng dalawang magkasunod na byte sa memorya. Ang mas mababang byte ng pointer na rehiyon ay kung ano ang nai-type sa pagtuturo sa mga panaklong. Ang pointer ay ang address ng pointed value. Sa nakaraang sitwasyon, $8765 ang address ng pointed value. Ang $0210 (sinusundan ng $0211) ay ang address na ang nilalaman ay $8765 na siyang pointer. Gamit ang absolute indirect addressing mode, ito ay ($0210) na nai-type sa program (text file), kasama ang mga panaklong.

Sa kabilang banda, gamit ang Absolute Indexed Indirect Addressing Mode, ang mas mababang address byte para sa pointer region ay nabuo sa pamamagitan ng pagdaragdag ng value sa X register sa nai-type na address. Halimbawa, kung ang pointer ay nasa lokasyon ng address na $0210, ang nai-type na pagtuturo ay maaaring ganito:

JMP ($020A,X)

Kung saan ang X register ay may halaga na 6 _H . 020A _H + 6 _H = 0210 _H . Ang Y register ay hindi ginagamit sa addressing mode na ito.

Hindi Direktang Pag-address na Na-index ng Zero Page
Ginagamit ng addressing mode na ito ang X register at hindi ang Y register. Sa addressing mode na ito, mayroon pa ring pointed value at pointer sa two-byte address pointer region nito. Dapat mayroong dalawang magkasunod na byte sa page zero para sa pointer. Ang address na nai-type sa pagtuturo ay isang one byte address. Idinaragdag ang value na ito sa value sa X register at itatapon ang anumang carry. Ang resulta ay tumuturo sa pointer region sa page 0. Halimbawa, kung ang address ng interes (pointed) ay $8765 at ito ay nasa byte na lokasyon na $50 at $51 ng page 0, at ang value sa X register ay $30, ang ang nai-type na pagtuturo ay katulad nito:

LDA ($20.X)

Dahil $20 + $30 = $50.

Hindi Direktang Naka-index na Pag-address
Ginagamit ng addressing mode na ito ang Y register at hindi ang X register. Sa addressing mode na ito, mayroon pa ring pointed value at pointer region, ngunit ang nilalaman ng pointer region ay gumagana nang iba. Dapat mayroong dalawang magkasunod na byte sa page zero para sa pointer region. Ang mas mababang address ng pointer region ay nai-type sa pagtuturo. Ang numerong ito (pares ng byte) na nasa pointer region ay idinaragdag sa value sa Y register para magkaroon ng totoong pointer. Halimbawa, hayaan ang address ng interes (itinuro) ay $8765, ang halaga ng 6H ay nasa Y register, at ang numero (dalawang byte) ay nasa address na 50 _H at 51 _H . Ang dalawang byte na magkasama ay $875F mula noong $875F + $6 = $8765. Ang nai-type na pagtuturo ay katulad nito:

LDA ($50),Y

4.9 Pagtaas, Pagbawas, at Mga Tagubilin sa Test-BIT

Ipinapakita ng sumusunod na talahanayan ang mga pagpapatakbo ng mga tagubilin sa pagtaas at pagbaba:

Ang INA at DEA ay nagdaragdag at nagpapababa sa nagtitipon, ayon sa pagkakabanggit. Iyon ay tinatawag na accumulator addressing. Ang INX, DEX, INY, at DEY ay para sa X at Y na mga rehistro, ayon sa pagkakabanggit. Hindi sila kumukuha ng anumang operand. Kaya, ginagamit nila ang ipinahiwatig na mode ng pagtugon. Ang pagdaragdag ay nangangahulugan ng pagdaragdag ng 1 sa rehistro o memory byte. Ang pagbabawas ay nangangahulugan ng pagbabawas ng 1 mula sa rehistro o memory byte.

Ang INC at DEC ay nagdaragdag at nagpapababa ng isang memory byte, ayon sa pagkakabanggit (at hindi isang rehistro). Ang paggamit ng zero page addressing sa halip na ang absolute addressing ay upang matipid ang memorya para sa pagtuturo. Ang zero page addressing ay isang byte na mas mababa kaysa sa absolute addressing para sa pagtuturo sa memorya. Gayunpaman, ang zero page addressing mode ay nakakaapekto lamang sa page zero.

Ang pagtuturo ng BIT ay sumusubok sa mga piraso ng isang byte sa memorya na may 8 bits sa nagtitipon, ngunit hindi nagbabago. Ilang flag lang ng Processor Status Register 'P' ang nakatakda. Ang mga piraso ng tinukoy na lokasyon ng memorya ay lohikal na ANDed kasama ng mga ng accumulator. Pagkatapos, ang mga sumusunod na bit ng katayuan ay itinakda:

• N na bit 7 at ang huling bit (kaliwa) ng status register, ay tumatanggap ng bit 7 ng lokasyon ng memorya bago ang ANDing.
• Ang V na bit 6 ng status register ay tumatanggap ng bit 6 ng lokasyon ng memorya bago ang ANDing.
• Ang Z flag ng status register ay nakatakda (ginawa 1) kung ang resulta ng AND ay zero (00000000 ₂ ). Kung hindi, ito ay na-clear (ginawa 0).

4.10 Paghambingin ang mga Tagubilin

Ang paghahambing ng mga mnemonic ng pagtuturo para sa 6502 µP ay CMP, CPX, at CPY. Pagkatapos ng bawat paghahambing, ang mga flag ng N, Z, at C ng rehistro ng status ng processor na 'P' ay apektado. Ang N flag ay nakatakda (ginawa 1) kapag ang resulta ay isang negatibong numero. Ang Z flag ay nakatakda (ginawa 1) kapag ang resulta ay isang zero (000000002). Ang C flag ay naka-set (ginawa 1) kapag may carry mula sa walo hanggang sa siyam na bit. Ang sumusunod na talahanayan ay nagbibigay ng isang detalyadong paglalarawan

Ang ibig sabihin ay 'mas malaki kaysa'. Sa pamamagitan nito, ang paghahambing na talahanayan ay dapat na maliwanag.

4.11 Paglukso at Mga Tagubilin sa Sangay

Ang sumusunod na talahanayan ay nagbubuod sa mga tagubilin sa pagtalon at sangay:

Ang pagtuturo ng JMP ay gumagamit ng ganap at hindi direktang pagtugon. Ang natitirang mga tagubilin sa talahanayan ay mga tagubilin sa sangay. Ginagamit lang nila ang relative addressing gamit ang 6502 µP. Sa pamamagitan nito, ang talahanayan ay nagiging maliwanag kung ito ay babasahin mula kaliwa hanggang kanan at itaas hanggang ibaba.

Tandaan na ang mga sangay ay maaari lamang ilapat sa mga address sa loob ng -128 hanggang +127 byte mula sa ibinigay na address. Ito ay kamag-anak na pagtugon. Para sa parehong mga tagubilin ng JMP at sangay, direktang apektado ang Program Counter (PC). Hindi pinapayagan ng 6502 µP ang mga branch sa isang ganap na address, kahit na ang pagtalon ay maaaring gawin ang ganap na pagtugon. Ang pagtuturo ng JMP ay hindi isang pagtuturo ng sangay.

Tandaan: Ang relatibong addressing ay ginagamit lamang sa mga tagubilin ng sangay.

4.12 Ang Stack Area

Ang isang subroutine ay tulad ng isa sa mga nakaraang maikling programa upang magdagdag ng dalawang numero o ibawas ang dalawang numero. Ang stack area sa memorya ay nagsisimula sa $0100 hanggang $01FF kasama. Ang lugar na ito ay tinatawag na stack. Kapag ang microprocessor ay nagpatupad ng isang pagtalon sa subroutine na pagtuturo (JSR - sumangguni sa sumusunod na talakayan), kailangan nitong malaman kung saan babalik kapag natapos na. Pinapanatili ng 6502 µP ang impormasyong ito (return address) sa mababang memory mula $0100 hanggang $01FF (ang stack area) at ginagamit ang stack pointer register content na “S” sa microprocessor bilang pointer (9 bits) hanggang sa huling ibinalik na address na nakaimbak sa pahina 1 ($0100 hanggang $01FF) ng memorya. Bumababa ang stack mula sa $01FF at ginagawang posible na i-nest ang mga subroutine hanggang sa 128 na antas ang lalim.

Ang isa pang paggamit ng stack pointer ay upang mahawakan ang mga pagkagambala. Ang 6502 µP ay may mga pin na may label na IRQ at NMI. Posible para sa ilang maliliit na signal ng kuryente na mailapat sa mga pin na ito at maging sanhi ng paghinto ng 6502 µP sa pagsasagawa ng isang programa at simulan itong magsagawa ng isa pa. Sa kasong ito, ang unang programa ay nagambala. Tulad ng mga subroutine, maaaring ma-nest ang mga segment ng interrupt code. Ang interrupt processing ay tinalakay sa susunod na kabanata.

Tandaan : Ang stack pointer ay may 8 bits para sa mas mababang byte na address sa pagtugon sa mga lokasyon mula $0100 hanggang $01FF. Ang mas mataas na byte ng 00000001 ₂ ay ipinapalagay.

Ang sumusunod na talahanayan ay nagbibigay ng mga tagubilin na nauugnay sa stack pointer na 'S' sa A, X, Y, at P na mga rehistro sa stack area sa memorya:

4.13 Subroutine na Tawag at Pagbabalik

Ang subroutine ay isang set ng mga tagubilin na nakakamit ng isang partikular na layunin. Ang nakaraang programa ng karagdagan o pagbabawas ay isang napakaikling subroutine. Ang mga subroutine ay kung minsan ay tinatawag na mga gawain. Ang tagubilin sa pagtawag ng subroutine ay:

JSR : Tumalon sa SubRoutine

Ang pagtuturo upang bumalik mula sa isang subroutine ay:

RTS : Bumalik mula sa Subroutine

Ang microprocessor ay may tendensiya na patuloy na isagawa ang mga tagubilin sa memorya, isa-isa. Ipagpalagay na ang microprocessor ay kasalukuyang nagsasagawa ng isang segment ng code at nakatagpo ito ng isang jump (JMP) na pagtuturo upang pumunta at magsagawa ng isang segment ng code na naka-code sa likod na maaaring naisakatuparan na nito. Isinasagawa nito ang segment ng code sa likod at patuloy na isinasagawa ang lahat ng segment ng code (mga tagubilin) ​​kasunod ng segment ng code sa likod, hanggang sa muling isagawa nitong muli ang kasalukuyang segment ng code at magpatuloy sa ibaba. Hindi itinulak ng JMP ang susunod na pagtuturo sa stack.

Hindi tulad ng JMP, itinutulak ng JSR ang address ng susunod na pagtuturo pagkatapos mismo mula sa PC (program counter) papunta sa stack. Ang posisyon ng stack ng address na ito ay inilalagay sa stack pointer na 'S'. Kapag ang isang pagtuturo ng RTS ay nakatagpo (naisakatuparan) sa subroutine, ang address na itinutulak sa stack ay humihila sa stack at ang programa ay magpapatuloy sa pull-off na address na iyon na ang susunod na address ng pagtuturo bago ang subroutine na tawag. Ang huling address na aalisin sa stack ay ipapadala sa program counter. Ang sumusunod na talahanayan ay nagbibigay ng mga teknikal na detalye ng JSR at RTS na mga tagubilin:

Tingnan ang sumusunod na paglalarawan para sa paggamit ng JSR at RTS:

4.14 Isang Halimbawa ng Count Down Loop

Ang sumusunod na subroutine ay nagbibilang pababa mula $FF hanggang $00 (kabuuan ng 256 ₁₀ binibilang):

simulan ang LDX #$FF ; i-load ang X na may $FF = 255
loop DEX ; X = X – 1
BNE loop ; kung X hindi zero pagkatapos ay goto loop
RTS ; bumalik

Bawat linya ay may komento. Ang mga komento ay hindi kailanman napupunta sa memorya para sa pagpapatupad. Ang assembler (tagasalin) na nagko-convert ng isang programa sa kung ano ito sa memorya para sa pagpapatupad (tumatakbo) ay palaging inaalis ang mga komento. Nagsisimula ang komento sa ';' . Ang 'simula' at 'loop' sa programang ito ay tinatawag na mga label. Tinutukoy ng isang label ang (pangalan) para sa address ng pagtuturo. Kung ang pagtuturo ay iisang byte na pagtuturo (implied addressing), ang label ay ang address ng instruction na iyon. Kung ang pagtuturo ay isang multibyte na pagtuturo, tinutukoy ng label ang unang byte para sa multibyte na pagtuturo. Ang unang pagtuturo para sa program na ito ay binubuo ng dalawang byte. Ipagpalagay na ito ay nagsisimula sa $0300 na address, ang $0300 na address ay maaaring palitan ng 'simula' pababa sa programa. Ang pangalawang tagubilin (DEX) ay isang solong byte na tagubilin, at dapat ay nasa $0302 na address. Nangangahulugan ito na ang $0302 na address ay maaaring palitan ng 'loop', pababa sa programa, na talagang ganoon sa 'BNE loop'.

Ang ibig sabihin ng “BNE loop” ay ang branch sa ibinigay na address kapag ang Z flag ng status register ay 0. Kapag ang value sa A o X o Y register ay 00000000 ₂ , dahil sa huling operasyon, ang Z flag ay 1 (set). Kaya, habang ito ay 0 (hindi 1), ang pangalawa at pangatlong mga tagubilin sa programa ay inuulit sa pagkakasunud-sunod na iyon. Sa bawat paulit-ulit na pagkakasunud-sunod, ang halaga (buong numero) sa X register ay nababawasan ng 1. DEX ay nangangahulugang X = X – 1. Kapag ang halaga sa X register ay $00 = 00000000 ₂ , ang Z ay nagiging 1. Sa puntong iyon, wala nang pag-uulit ng dalawang tagubilin. Ang huling pagtuturo ng RTS sa programa, na isang solong byte na pagtuturo (implied addressing), ay bumabalik mula sa subroutine. Ang epekto ng pagtuturo na ito ay gawin ang program counter address sa stack para sa code na isasagawa bago ang subroutine na tawag at bumalik sa program counter (PC). Ang address na ito ay ang address ng pagtuturo na isasagawa bago tawagin ang subroutine.

Tandaan: Kapag nagsusulat ng isang programa sa wika ng pagpupulong para sa 6502 µP, isang label lamang ang dapat magsimula sa simula ng isang linya; anumang iba pang code ng linya ay dapat ilipat ng kahit isang puwang sa kanan.

Pagtawag ng Subroutine
Hindi pinapansin ang memory space na kinukuha ng mga nakaraang label, ang program ay tumatagal ng 6 byte ng magkakasunod na lokasyon sa memory (RAM) mula $0300 hanggang $0305. Sa kasong ito, ang programa ay:

LDX #$FF ; i-load ang X na may $FF = 255
DEX ; X = X – 1
BNE $0302 ; kung X hindi zero pagkatapos ay goto loop
RTS ; bumalik

Simula sa $0200 na address sa memorya ay maaaring tawagan para sa subroutine. Ang tagubilin sa tawag ay:

pagsisimula ng JSR; ang simula ay ang address na $0300, ibig sabihin, JSR $0300

Ang subroutine at ang tawag nito na wastong nakasulat sa text editor file ay:

simulan ang LDX #$FF; i-load ang X na may $FF = 255
loop DEX ; X = X – 1

BNE loop ; kung X hindi zero pagkatapos ay goto loop
RTS ; bumalik

Simula ng JSR : tumalon sa routine simula sa $0300

Ngayon, maaaring maraming subroutine sa isang mahabang programa. Lahat sila ay hindi maaaring magkaroon ng pangalang 'simula'. Dapat magkaiba sila ng pangalan. Sa katunayan, wala sa kanila ang maaaring may pangalang 'simula'. Ang 'Start' ay ginagamit dito para sa mga dahilan ng pagtuturo.

4.15 Pagsasalin ng Programa

Ang pagsasalin ng isang programa o pag-assemble nito ay pareho ang ibig sabihin. Isaalang-alang ang sumusunod na programa:

simulan ang LDX #$FF : i-load ang X na may $FF = 255
loop DEX : X = X – 1
BNE loop : kung X hindi zero pagkatapos ay goto loop
RTS : bumalik
Simula ng JSR : tumalon sa routine simula sa $0300

Ito ang program na dati nang nakasulat. Binubuo ito ng subroutine, simula, at ang tawag sa subroutine. Ang programa ay nagbibilang mula sa 255 ₁₀ sa 0 ₁₀ . Magsisimula ang program sa simula ng user address na $0200 (RAM). Ang programa ay nai-type sa isang text editor at nai-save sa disk. Mayroon itong pangalan tulad ng 'sample.asm' kung saan ang 'sample' ay ang pangalan ng pinili ng programmer ngunit ang extension na '.asm' para sa assembly language ay dapat na nauugnay sa filename.

Ang binuong programa ay ginawa ng isa pang programa na tinatawag na assembler. Ang assembler ay ibinibigay ng tagagawa ng 6502 µP o ng isang third party. Ang assembler ay muling gumagawa ng programa sa paraang ito ay nasa memorya (RAM) habang ito ay nagpapatakbo (run).

Ipagpalagay na ang pagtuturo ng JSR ay nagsisimula sa $0200 na address at ang subroutine ay nagsisimula sa $0300 na address. Tinatanggal ng assembler ang lahat ng komento at puting espasyo. Ang mga komento at puting espasyo ay nagsasayang ng memorya na laging kulang. Ang posibleng blangkong linya sa pagitan ng nakaraang subroutine code segment at subroutine na tawag ay isang halimbawa ng whitespace. Ang naka-assemble na file ay naka-save pa rin sa disk, at pinangalanan ito tulad ng 'sample.exe'. Ang 'sample' ay ang pangalan ng pinili ng programmer, ngunit ang '.exe' na extension ay dapat naroroon upang ipahiwatig na ito ay isang executable na file.

Ang binuong programa ay maaaring idokumento tulad ng sumusunod:

Ang paggawa ng isang dokumento tulad nito ay sinasabing pag-assemble sa pamamagitan ng kamay. Tandaan na ang mga komento sa dokumentong ito ay hindi lumalabas sa memorya (para sa pagpapatupad). Ang hanay ng address sa talahanayan ay nagpapahiwatig ng mga panimulang address ng mga tagubilin sa memorya. Tandaan na ang 'JSR start' na 'JSR $0300', na inaasahang ma-code bilang '20 03 00', ay aktwal na naka-code bilang '20 00 03' na may mas mababang memory byte address na kumukuha ng mas mababang byte sa memory at ang mas mataas na memory byte address na kumukuha ng mas mataas na byte sa memory – maliit na endianness. Ang opcode para sa JSR ay 20 ₁₆ .

Tandaan na ang offset sa isang pagtuturo ng sangay gaya ng BNE ay isang numerong pandagdag ng dalawa sa hanay na 128 ₁₀ hanggang + 127 ₁₀ . Kaya, 'BNE loop' ay nangangahulugang 'BNE -1 ₁₀ ” na talagang “D0 FF” sa code form ng FF ₁₆ ay -1 sa dalawang's complement na nakasulat bilang = 11111111 sa base two. Pinapalitan ng assembler program ang mga label at field sa aktwal na mga numerong hexadecimal (ang mga hexadecimal na numero ay mga binary na numero na naka-grupo sa apat na bits). Ang aktwal na mga address kung saan magsisimula ang bawat pagtuturo ay aktwal na kasama.

Tandaan: Ang pagtuturo ng 'pagsisimula ng JSR' ay pinalitan ng mas maiikling mga tagubilin na nagpapadala ng kasalukuyang nilalaman (mataas at mababang byte) ng counter ng program sa stack na may stack pointer na binawasan ng dalawang beses (isang beses para sa mataas na byte at isang beses para sa mababang byte) at pagkatapos ay i-reload ang PC gamit ang $0300 na address. Ang stack pointer ngayon ay tumuturo sa $00FD, sa pag-aakalang ito ay nasimulan sa $01FF.

Gayundin, ang pagtuturo ng RTS ay pinapalitan ng ilang mas maiikling mga tagubilin na nagdaragdag sa stack pointer na 'S' ng dalawang beses (isang beses para sa mababang byte at isang beses para sa mataas na byte) at hinihila ang katumbas na dalawang byte ng address mula sa stack pointer patungo sa PC para sa ang susunod na tagubilin.

Tandaan: Ang text ng label ay hindi dapat magkaroon ng higit sa 8 character.

Ginagamit ng “BNE loop” ang relative addressing. Ibig sabihin magdagdag ng -3 ₁₀ sa susunod na nilalaman ng counter ng programa na $0305. Ang mga byte para sa 'BNE loop' ay 'D0 FD' kung saan ang FD ay ang pandagdag ng dalawa ng -3 ₁₀ .

Tandaan: Ang kabanatang ito ay hindi nagpapakita ng lahat ng mga tagubilin para sa 6502 µP. Ang lahat ng mga tagubilin at ang kanilang mga detalye ay makikita sa dokumentong pinamagatang 'SY6500 8-Bit Microprocessor Family'. Mayroong PDF file na may pangalang '6502.pdf' para sa dokumentong ito na malayang makukuha sa Internet. Ang 6502 µP na inilalarawan sa dokumentong ito ay 65C02.

4.16 Pagkagambala

Ang mga signal ng anumang device na nakakonekta sa panlabas (vertical surface) port ng Commodore 64 ay kailangang dumaan sa alinman sa CIA 1 o CIA 2 circuits (ICs) bago maabot ang 6502 microprocessor. Ang mga signal mula sa data-bus ng 6502 µP ay kailangang dumaan sa CIA 1 o CIA 2 chip bago maabot ang anumang panlabas na device. Ang ibig sabihin ng CIA ay Complex Interface Adapter. Sa Fig 4.1 “Block Diagram of the Commodore_64 Motherboard”, kinakatawan ng block input/output device ang CIA 1 at ang CIA 2. Kapag tumatakbo ang isang program, maaari itong maantala upang magpatakbo ng ibang piraso ng code bago magpatuloy. Mayroong pagkagambala sa hardware at pagkagambala ng software. Para sa pagkagambala ng hardware, mayroong dalawang input signal pin sa 6502 µP. Ang mga pangalan ng mga pin na ito ay IRQ at NMI . Hindi ito mga linya ng data ng µP. Ang mga linya ng data para sa µP ay D7, D6, D5, D4, D3, D2, D1 at D0; na may D0 para sa hindi bababa sa makabuluhang bit at D7 para sa pinaka makabuluhang bit.

IRQ nangangahulugang mababa ang Interrupt ReQuest na 'aktibo'. Ang input line na ito sa µP ay karaniwang mataas, sa humigit-kumulang 5 volts. Kapag bumaba ito sa humigit-kumulang 0 volt, iyon ay isang interrupt na kahilingan na nagpapahiwatig ng µP. Sa sandaling maibigay ang kahilingan, babalik nang mataas ang linya. Ang pagbibigay ng interrupt request ay nangangahulugan na ang µP ay sumasanga sa code (subroutine) na humahawak sa interrupt.

NMI nangangahulugang mababa ang Non-Maskable Interrupt na 'aktibo'. Habang ang code para sa IRQ ay pinapatay NMI maaaring bumaba. Sa kasong ito, NMI ay pinangangasiwaan (ang sariling code ay naisakatuparan). Pagkatapos nito, ang code para sa IRQ nagpapatuloy. Pagkatapos ng code para sa IRQ magtatapos, ang pangunahing code ng programa ay nagpapatuloy. Yan ay, NMI nakakaabala sa IRQ handler. Ang hudyat para sa NMI maaari pa ring ibigay sa µP kahit na ang µP ay idle at hindi humahawak ng anuman o hindi nagpapatakbo ng pangunahing programa.

Tandaan: Ito ay talagang ang paglipat mula sa mataas hanggang sa mababa, ng NMI , iyon ay ang NMI signal - higit pa sa na mamaya. IRQ karaniwang nagmumula sa CIA 1 at NMI karaniwang nagmumula sa CIA 2. NMI , na nangangahulugang Non-Maskable Interrupt, ay maaaring ituring bilang non-stoppable interrupt.

Paghawak ng mga Interrupt
Kung ang kahilingan ay mula sa IRQ o NMI , dapat makumpleto ang kasalukuyang pagtuturo. Ang 6502 ay mayroon lamang A, X, at Y na mga rehistro. Habang gumagana ang isang subroutine, maaaring ginagamit nito ang tatlong rehistrong ito nang magkasama. Ang isang interrupt handler ay isang subroutine pa rin, kahit na hindi nakikitang ganoon. Matapos makumpleto ang kasalukuyang pagtuturo, ang mga nilalaman ng A, X, at Y na mga rehistro para sa 65C02 µP ay nai-save sa stack. Ang address ng susunod na pagtuturo ng Program Counter ay ipinapadala din sa stack. Ang µP pagkatapos ay sumasanga sa code para sa interrupt. Pagkatapos nito, ang mga nilalaman ng A, X, at Y na mga rehistro ay ibabalik mula sa stack sa reverse order kung saan sila ipinadala.

Halimbawa ng Coding para sa isang Interrupt
Para sa pagiging simple, ipagpalagay na ang routine para sa µP IRQ Ang interrupt ay para lamang idagdag ang mga numerong $01 at $02 at i-save ang resulta ng $03 sa memory address na $0400. Ang code ay:

ISR PHA
PHX
PHY
;
LDA #$01
ADC #$02
NAGHALAGA SILA ng $0400
;
PLY
PLX
PLA
RTI

Ang ISR ay isang label at kinikilala ang memory address kung saan ang pagtuturo ng PHA. Ang ibig sabihin ng ISR ay Interrupt Service Routine. Ipinapadala ng PHA, PHX, at PHY ang mga nilalaman ng A, X, at Y na mga rehistro sa stack na may pag-asang kakailanganin ang mga ito ng anumang code (program) na tumatakbo bago ang pagkaantala. Ang susunod na tatlong tagubilin ay bumubuo sa core ng interrupt handler. Ang mga tagubilin ng PLY, PLX, at PLA ay kailangang nasa ganoong pagkakasunud-sunod, at ibinabalik nila ang mga nilalaman ng Y, X, at A na mga rehistro. Ang huling pagtuturo, na RTI, (nang walang operand) ay nagbabalik ng pagpapatuloy ng pagpapatupad sa anumang code (program) na isinasagawa bago maputol. Kinukuha ng RTI ang address ng susunod na pagtuturo ng code na ini-execute mula sa stack pabalik sa program counter. Ang ibig sabihin ng RTI ay Return from Interrupt. With that, tapos na ang interrupt handling (subroutine).

Pagkagambala ng Software
Ang pangunahing paraan upang magkaroon ng interrupt na software para sa 6502 µP ay sa paggamit ng BRK na ipinahiwatig na pagtuturo ng address. Ipagpalagay na ang pangunahing programa ay tumatakbo at nakatagpo ito ng pagtuturo ng BRK. Mula sa puntong iyon, ang address ng susunod na pagtuturo sa PC ay dapat ipadala sa stack habang ang kasalukuyang pagtuturo ay nakumpleto. Ang isang subroutine upang pangasiwaan ang pagtuturo ng software ay dapat na tinatawag na 'susunod'. Ang interrupt subroutine na ito ay dapat itulak ang A, X, at Y na mga nilalaman ng rehistro sa stack. Matapos maisakatuparan ang core ng subroutine, ang mga nilalaman ng A, X, at Y na mga rehistro ay dapat ibalik mula sa stack patungo sa kanilang mga rehistro sa pamamagitan ng pagkumpleto ng subroutine. Ang huling pahayag sa routine ay RTI. Ang nilalaman ng PC ay awtomatikong hinila pabalik mula sa stack patungo sa PC dahil sa RTI.

Paghahambing at Pag-contrasting ng Subroutine at Interrupt Service Routine
Ang sumusunod na talahanayan ay naghahambing at nagkukumpara sa Subroutine at Interrupt Service Routine:

4.17 Buod ng 6502 Main Addressing Modes

Ang bawat tagubilin para sa 6502 ay isang byte, na sinusundan ng zero o higit pang mga operand.

Mode ng Agarang Pag-address
Gamit ang agarang addressing mode, pagkatapos ng operand, ay ang halaga at hindi isang memory address. Ang halaga ay kailangang unahan ng #. Kung ang halaga ay nasa hexadecimal ang “#” ay kailangang sundan ng “$”. Ang mga agarang tagubilin sa pagtugon para sa 65C02 ay: ADC, AND, BIT, CMP, CPX, CPY, EOR, LDA, LDX, LDY, ORA, SBC. Dapat kumonsulta ang mambabasa sa dokumentasyon para sa 65C02 µP upang malaman kung paano gamitin ang mga tagubilin na nakalista dito na hindi ipinaliwanag sa kabanatang ito. Ang isang halimbawa ng pagtuturo ay:

LDA #$77

Absolute Addressing Mode
Sa absolute addressing mode, mayroong isang operand. Ang operand na ito ay ang address ng halaga sa memorya (karaniwan ay nasa hexadecimal o isang label). Mayroong 64K ₁₀ = 65,536 ₁₀ mga memory address para sa 6502 µP. Karaniwan, ang isang-byte na halaga ay nasa isa sa mga address na ito. Ang ganap na mga tagubilin sa pagtugon para sa 65C02 ay: ADC, AT, ASL, BIT, CMP, CPX, CPY, DEC, EOR, INC, JMP, JSR, LDA, LDX, LDY, LSR, ORA, ROL, ROR, SBC, STA , STX, STY, STZ, TRB, TSB. Dapat kumonsulta ang mambabasa sa dokumentasyon para sa 65C02 µP upang malaman kung paano gamitin ang mga tagubilin na nakalista dito, pati na rin para sa iba pang mga mode ng pagtugon na hindi ipinaliwanag sa kabanatang ito. Ang isang halimbawa ng pagtuturo ay:

SILA AY $1234

Implied Addressing Mode
Sa implied addressing mode, walang operand. Ang anumang rehistro ng µP na kasangkot ay ipinahiwatig ng pagtuturo. Ang ipinahiwatig na mga tagubilin sa pagtugon para sa 65C02 ay: BRK, CLC, CLD, CLI, CLV, DEX, DEY, INX, INY, NOP, PHA, PHP, PHX, PHY, PLA, PLP, PLX, PLY, RTI, RTS, SEC , SED, SEI, TAX, TAY, TSX, TXA, TXS, TYA. Ang isang halimbawa ng pagtuturo ay:

DEX : Bawasan ang X register ng isang unit.

Relative Addressing Mode
Ang relative addressing mode ay tumatalakay lamang sa mga tagubilin ng sangay. Sa relative addressing mode, mayroon lamang isang operand. Ito ay isang halaga mula sa -128 ₁₀ sa +127 ₁₀ . Ang halagang ito ay tinatawag na isang offset. Batay sa tanda, ang halagang ito ay idinaragdag o ibinabawas mula sa susunod na pagtuturo ng Program Counter upang magresulta sa address ng nilalayong susunod na pagtuturo. Ang mga tagubilin sa relative address mode ay: BCC, BCS, BEQ, BMI, BNE, BPL, BRA, BVC, BVS. Ang mga halimbawa ng pagtuturo ay:

BNE $7F : (sangay kung Z = 0 sa status register, P)

Na nagdaragdag ng 127 sa kasalukuyang program counter (address na isasagawa) at magsisimulang isagawa ang pagtuturo sa address na iyon. Katulad nito:

BEQ $F9 : (branch kung Z = : sa status register, P)

Na nagdaragdag ng isang -7 sa kasalukuyang counter ng programa at magsisimula sa pagpapatupad sa bagong address ng counter ng programa. Ang operand ay isang complement number ng dalawa.

Absolute Indexed Addressing
Sa absolute index addressing, ang nilalaman ng X o Y register ay idinaragdag sa ibinigay na absolute address (kahit saan mula $0000 hanggang $FFFF, ibig sabihin, mula sa 0 ₁₀ sa 65536 ₁₀ ) upang magkaroon ng tunay na address. Ang ibinigay na ganap na address na ito ay tinatawag na base address. Kung ginamit ang X register, ang pagtuturo ng pagpupulong ay ganito:

LDA $C453,X

Kung ang rehistro ng Y ay ginamit, ito ay tulad ng:

LDA $C453,Y

Ang halaga para sa X o Y na rehistro ay tinatawag na bilang o index na halaga, at maaari itong maging kahit saan mula sa $00 (0 ₁₀ ) hanggang $FF (250 ₁₀ ). Hindi ito tinatawag na offset.

Ang absolute index addressing instructions ay: ADC, AND, ASL (X lang), BIT (may accumulator at memory, na may X lang), CMP, DEC (memory at X lang), EOR, INC (memory at X lang), LDA , LDX, LDY, LSR (X lang), ORA, ROL (X lang), ROR (X lang), SBC, STA, STZ (X lang).

Absolute Indirect Addressing
Ito ay ginagamit lamang sa pagtuturo ng pagtalon. Sa pamamagitan nito, ang ibinigay na ganap na address ay may pointer address. Ang pointer address ay binubuo ng dalawang byte. Ang dalawang-bytes na pointer ay tumuturo sa (ay ang address ng) ang patutunguhang halaga ng byte sa memorya. Kaya, ang pagtuturo ng wika sa pagpupulong ay:

JMP ($3456)

Gamit ang mga panaklong, at ang $13 ay nasa lokasyon ng address na $3456 habang ang $EB ay nasa lokasyon ng address na $3457 (= $3456 + 1). Pagkatapos, ang patutunguhang address ay $13EB at $13EB ang pointer. Ang ganap na $3456 ay nasa panaklong sa pagtuturo kung saan 34 ang mas mababang byte at 56 ang mas mataas na byte.

4.18 Paglikha ng String gamit ang 6502 µP Assembly Language

Tulad ng ipinakita sa susunod na kabanata, pagkatapos lumikha ng isang file sa memorya, ang file ay maaaring i-save sa disk. Kailangang bigyan ng pangalan ang file. Ang pangalan ay isang halimbawa ng isang string. Mayroong maraming iba pang mga halimbawa ng mga string sa programming.

Mayroong dalawang pangunahing paraan ng paglikha ng isang string ng mga ASCII code. Sa parehong paraan, ang lahat ng ASCII code (mga character) ay kumukuha ng magkakasunod na byte na lokasyon sa memorya. Sa isa sa mga paraan, ang pagkakasunud-sunod na ito ng mga byte ay nauuna sa pamamagitan ng isang integer byte na kung saan ay ang haba (bilang ng mga character) sa sequence (string). Sa kabilang paraan, ang pagkakasunud-sunod ng mga character ay nagtagumpay (kaagad na sinundan) ng Null byte na 00 ₁₆ , ibig sabihin, $00. Ang haba ng string (bilang ng mga character) ay hindi ipinahiwatig sa ibang paraan. Ang Null na character ay hindi ginagamit sa unang paraan.

Halimbawa, isaalang-alang ang 'Mahal kita!' string na walang mga panipi. Ang haba dito ay 11; ang isang puwang ay binibilang bilang isang ASCII byte (character). Ipagpalagay na ang string ay kailangang ilagay sa memorya na ang unang character ay nasa address na $0300.

Ipinapakita ng sumusunod na talahanayan ang setting ng memorya ng string kapag ang unang byte ay 11 ₁₀ = 0B ₁₆ :

Ipinapakita ng sumusunod na talahanayan ang setting ng memorya ng string kapag ang unang byte ay 'I' at ang huling byte ay Null ($00):

Maaaring gamitin ang sumusunod na pagtuturo upang simulan ang paggawa ng string:

NAGHALAGA SILA ng $0300

Ipagpalagay na ang unang byte ay nasa accumulator na ipapadala sa lokasyon ng address na $0300. Ang pagtuturo na ito ay totoo para sa parehong mga kaso (parehong uri ng mga string).

Matapos mailagay ang lahat ng mga character sa mga cell ng memorya, isa-isa, mababasa ang string gamit ang isang loop. Para sa unang kaso, ang bilang ng mga character pagkatapos ng haba ay nabasa. Para sa pangalawang kaso, binabasa ang mga character mula sa 'I' hanggang sa matugunan ang Null character na 'Null'.

4.19 Paglikha ng Array gamit ang 6502 µP Assembly Language

Ang isang hanay ng mga single byte integer ay binubuo ng magkakasunod na memory byte na lokasyon kasama ang mga integer. Pagkatapos, mayroong isang pointer na tumuturo sa lokasyon ng unang integer. Kaya, ang hanay ng mga integer ay binubuo ng dalawang bahagi: ang pointer at ang serye ng mga lokasyon.

Para sa isang hanay ng mga string, ang bawat string ay maaaring nasa ibang lugar sa memorya. Pagkatapos, may mga magkakasunod na lokasyon ng memorya na may mga pointer kung saan ang bawat pointer ay tumuturo sa unang lokasyon ng bawat string. Ang isang pointer sa kasong ito ay binubuo ng dalawang byte. Kung ang isang string ay nagsisimula sa haba nito, ang katumbas na pointer ay tumuturo sa lokasyon ng haba na iyon. Kung ang isang string ay hindi nagsisimula sa haba nito ngunit nagtatapos sa isang null character, ang kaukulang pointer ay tumuturo sa lokasyon ng unang character ng string. At mayroong isang pointer na tumuturo sa mas mababang byte address ng unang pointer ng magkakasunod na pointer. Kaya, ang hanay ng mga string ay binubuo ng tatlong bahagi: ang mga string sa iba't ibang lugar sa memorya, ang katumbas na magkakasunod na pointer, at ang pointer sa unang pointer ng magkakasunod na pointer.

4.20 Mga Problema

Ang mambabasa ay pinapayuhan na lutasin ang lahat ng mga problema sa isang kabanata bago lumipat sa susunod na kabanata.

1. Sumulat ng isang programa sa wika ng pagpupulong na nagsisimula sa $0200 para sa 6502 µP at idinagdag ang mga hindi napirmahang numero ng 2A94 _H (idagdag) sa 2ABF _H (augend). Hayaan ang mga input at output ay nasa memorya. Gayundin, gawin ang naka-assemble na dokumento ng programa sa pamamagitan ng kamay.
2. Sumulat ng isang programa sa wikang pagpupulong na nagsisimula sa $0200 para sa 6502 µP at ibawas ang hindi napirmahang mga numero ng 1569 _H (subtrahend) mula sa 2ABF _H (minuend). Hayaan ang mga input at output ay nasa memorya. Gayundin, gawin ang naka-assemble na dokumento ng programa sa pamamagitan ng kamay.
3. Sumulat ng isang programa sa wika ng pagpupulong para sa 6502 µP na nagbibilang mula $00 hanggang $09 gamit ang isang loop. Ang programa ay dapat magsimula sa $0200. Gayundin, gawin ang naka-assemble na dokumento ng programa sa pamamagitan ng kamay.
4. Sumulat ng isang programa sa wika ng pagpupulong na nagsisimula sa $0200 para sa 6502 µP. Ang programa ay may dalawang subroutine. Ang unang subroutine ay nagdaragdag ng mga hindi napirmahang numero ng 0203 _H (augend) at 0102H (idagdag). Ang pangalawang subroutine ay nagdaragdag ng kabuuan mula sa unang subroutine na 0305H hanggang 0006 _H (augend). Ang huling resulta ay naka-imbak sa memorya. Tawagan ang unang subroutine na FSTSUB at ang pangalawang subroutine na SECSUB. Hayaan ang mga input at output ay nasa memorya. Gayundin, gumawa ng naka-assemble na dokumento ng programa para sa buong programa sa pamamagitan ng kamay.
5. Given na ang isang IRQ Ang handler ay nagdaragdag ng $02 hanggang $01 sa accumulator bilang pangunahing paghawak habang NMI ay inisyu at ang pangunahing paghawak para sa NMI nagdadagdag ng $05 hanggang $04 sa accumulator, sumulat ng assembly language para sa parehong mga humahawak kasama ang kanilang mga tawag. Ang tawag sa IRQ ang handler ay dapat nasa address na $0200. Ang IRQ dapat magsimula ang handler sa address na $0300. Ang NMI dapat magsimula ang handler sa address na $0400. Ang resulta ng IRQ ang handler ay dapat ilagay sa address na $0500, at ang resulta ng NMI ang handler ay dapat ilagay sa address na $0501.
6. Ipaliwanag nang maikli kung paano ginagamit ang pagtuturo ng BRK upang makagawa ng interrupt ng software sa isang 65C02 computer.
7. Gumawa ng isang talahanayan na naghahambing at nagkukumpara sa isang normal na subroutine sa isang naka-interrupt na routine ng serbisyo.
8. Ipaliwanag nang maikli ang mga pangunahing mode ng pag-address ng 65C02 µP na ibinigay sa mga halimbawa ng pagtuturo ng assembly language.
9. a) Sumulat ng 6502 machine language program para ilagay ang 'Mahal kita!' string ng mga ASCII code sa memorya, simula sa $0300 na address na may haba ng string. Dapat magsimula ang programa sa $0200 na address. Kunin ang bawat character mula sa accumulator nang paisa-isa, sa pag-aakalang ipinadala sila doon, ng ilang subroutine. Gayundin, tipunin ang programa sa pamamagitan ng kamay. (Kung kailangan mong malaman ang mga ASCII code para sa “I love you!”. Narito ang mga ito: ‘I’:49 ₁₆ , espasyo : 20 ₁₆ , ‘l’: 6C ₁₆ , ‘o’:6F ₁₆ , 'sa':76 ₁₆ , 'e':65, 'y':79 ₁₆ , 'sa':75 ₁₆ , at ‘!’:21 ₁₆ (Tandaan: ang bawat code ay sumasakop ng 1 byte).
   b) Sumulat ng 6502 machine language program para ilagay ang 'Mahal kita!' string ng mga ASCII code sa memorya, simula sa $0300 na address na walang haba ng string ngunit nagtatapos sa 00 ₁₆ . Dapat magsimula ang programa sa $0200 na address. Kunin ang bawat character mula sa accumulator, sa pag-aakalang ipinapadala sila doon, isa-isa, ng ilang subroutine. Gayundin, tipunin ang programa sa pamamagitan ng kamay.