GPIO ARM ASSEMBLY - T.I. ROBOTICS SYSTEM LEARNING KIT - LAB 6: 3 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:14

Kamusta, Sa nakaraang Nakagagawa tungkol sa pag-aaral ng pagpupulong ng ARM gamit ang Texas Instruments TI-RSLK (gumagamit ng MSP432 microcontroller), aka Lab 3 kung ginagawa mo ang T. I. kurso, napunta kami sa ilang mga pangunahing panuto tulad ng pagsulat sa isang rehistro, at kondisyon na pag-loop. Tinagpasan namin ang pagpapatupad gamit ang Eclipse IDE.

Ang mga maliliit na programa na ipinatupad namin ay walang ginawa upang makipag-ugnay sa labas ng mundo.

Tipong nakakasawa.

Subukan nating baguhin iyon nang kaunti ngayon sa pamamagitan ng pag-alam ng kaunti tungkol sa mga input / output port, partikular, ang mga digital na GPIO pin.

Nangyayari na ang MSP432 na ito ay nagmumula sa isang board ng pag-unlad na mayroon nang dalawang mga switch ng pindutan ng pindutan, isang RGB LED, at isang pulang LED, lahat na nakatali sa ilang mga port ng GPIO.

Nangangahulugan ito na kapag natututo kaming mag-set up at manipulahin ang mga pin na ito sa pamamagitan ng pagpupulong, maaari naming makita ang mga epektong iyon.

Mas nakakainteres kaysa lamang sa pagtahak sa debugger.

(Pupunta pa rin kami sa hakbang - ito ang aming 'pagka-antala' na pag-andar):-D

Hakbang 1: Subukan Natin ang Pagsulat sa / Pagbasa Mula sa RAM

Bago kami tumalon sa pag-access at pagkontrol sa GPIO, dapat kaming gumawa ng isang maliit na hakbang.

Magsimula tayo sa pamamagitan lamang ng pagbabasa at pagsusulat sa isang karaniwang memorya. Alam namin mula sa nakaraang Instructable (tingnan ang mga imahe doon) na ang RAM ay nagsisimula sa 0x2000 0000, kaya't gamitin natin ang address na iyon.

Ililipat namin ang data sa pagitan ng isang pangunahing rehistro (R0) at 0x2000 0000.

Nagsisimula kami sa isang pangunahing istraktura ng file o mga nilalaman ng isang programa sa pagpupulong. Mangyaring mag-refer sa Instructable na ito upang lumikha ng isang proyekto sa pagpupulong gamit ang Code Composer Studio (CCS) ng TI, at ilang mga halimbawang proyekto.

.thumb

.text.align 2.global main.thumbfunc pangunahing pangunahing:.asmfunc; ---------------------------------- ----------------------------------------------; (pupunta ang aming code dito); -------------------------------------.endasmfunc.end

Nais kong magdagdag ng bago sa tuktok na seksyon, mayroong ilang mga deklarasyon (mga direktiba). Mas magiging malinaw ito mamaya.

ACONST.set 0x20000000; gagamitin namin ito sa karagdagang pababa (ito ay isang pare-pareho)

; malinaw naman, ang '0x' ay nangangahulugang kung ano ang sumusunod ay isang halaga ng hex.

Kaya't ang aming mga panimulang nilalaman ng file ay ganito ang hitsura:

.thumb

.text.align 2 ACONST.set 0x20000000; gagamitin namin ito sa karagdagang pababa (ito ay isang pare-pareho); malinaw naman, ang '0x' ay nangangahulugang kung ano ang sumusunod ay isang halaga ng hex..global main.thumbfunc pangunahing pangunahing:.asmfunc; ----------------- ------------------------------------------; (pupunta ang aming code dito); -------------------------------------.endasmfunc.end

Ngayon na mayroon kaming sa itaas, magdagdag tayo ng code sa pagitan ng mga dashing line.

Nagsisimula kami sa pagsusulat sa isang lokasyon ng RAM. Una naming itatatag ang pattern ng data, isang halaga, na sususulat namin sa RAM. Gumagamit kami ng isang pangunahing rehistro upang maitaguyod ang halagang iyon o data.

Tandaan: tandaan na sa code, ang anumang linya na mayroong semi-colon (';') ay nangangahulugang lahat ng ito ay isang komento pagkatapos ng semi-colon na iyon.

;-----------------------------------------------------------------------------------------------

; PAGSULAT; ----------------- ----------------------------------------------- MOV R0, # 0x55; ang pangunahing rehistro ng R0 ay naglalaman ng data na nais naming isulat sa lokasyon ng RAM.; malinaw naman, ang '0x' ay nangangahulugang kung ano ang sumusunod ay isang halaga ng hex.

Susunod, tingnan natin ang mga pahayag na gumagana ang DONT.

; Hindi magagamit ang MOV MOV upang magsulat ng data sa isang lokasyon ng RAM.

; Ang MOV ay para lamang sa agarang data sa pagrehistro,; o mula sa isang rehistro patungo sa iba pa; ibig sabihin, MOV R1, R0.; Dapat gumamit ang STR ng STR.; STR R0, = ACONST; Hindi magandang term sa pagpapahayag (ang '='); STR R0, 0x20000000; Ilegal na addressing mode para sa tagubilin sa tindahan; STR R0, ACONST; Ilegal na addressing mode para sa tagubilin sa tindahan

Nang hindi masyadong nagpapaliwanag, sinubukan naming gamitin ang 'ACONST' sa itaas. Mahalaga, ito ay isang stand-in o pare-pareho sa halip na gumamit ng isang literal na halaga tulad ng 0x20000000.

Hindi kami nakasulat upang sumulat sa lokasyon ng RAM gamit ang nasa itaas. Subukan natin ang iba pa.

; tila kailangan nating gumamit ng isa pang rehistro na naglalaman ng lokasyon ng RAM sa

; upang maiimbak sa lokasyon ng RAM na iyon na Mov R1, # 0x20000000; itakda ang lokasyon ng RAM (hindi ang mga nilalaman nito, ngunit ang lokasyon) sa R1.; malinaw naman, ang '0x' ay nangangahulugang kung ano ang sumusunod ay isang halaga ng hex. STR R0, [R1]; isulat kung ano ang nasa R0 (0x55) sa RAM (0x20000000) gamit ang R1.; gumagamit kami ng isa pang rehistro (R1) na may address ng lokasyon ng RAM; upang maisulat SA lokasyon ng RAM na iyon.

Isa pang paraan ng paggawa sa itaas, ngunit ang paggamit ng 'ACONST' sa halip na ang literal na halaga ng address:

; gawin natin muli ang nasa itaas, ngunit gumamit tayo ng isang simbolo sa halip na isang literal na halaga ng lokasyon ng RAM.

; nais naming gamitin ang 'ACONST' bilang isang stand-in para sa 0x20000000.; kailangan pa nating gawin ang '#' upang magpahiwatig ng isang agarang halaga,; kaya (tingnan sa tuktok), kailangan naming gamitin ang direktibong '.set'.; upang mapatunayan ito, baguhin natin ang pattern ng data sa R0. MOV R0, # 0xAA; ok handa na kaming sumulat sa RAM gamit ang simbolo sa halip na literal na halaga ng address na Mov R1, #ACONST STR R0, [R1]

Ang video ay napupunta sa ilang karagdagang detalye, pati na rin ang hakbang sa pagbabasa mula sa lokasyon ng memorya.

Maaari mo ring tingnan ang nakalakip na source.asm file.

Hakbang 2: Ilang Pangunahing Impormasyon sa Port

Ngayon na mayroon kaming magandang ideya kung paano sumulat sa / basahin mula sa isang lokasyon ng RAM, makakatulong ito sa amin na mas maunawaan kung paano makontrol at gamitin ang GPIO pin

Kaya paano kami makikipag-ugnay sa mga pin ng GPIO? Mula sa aming nakaraang pagtingin sa microcontroller na ito at mga tagubilin sa ARM, alam namin kung paano haharapin ang mga panloob na rehistro, at alam namin kung paano makipag-ugnay sa mga memorya (RAM) na mga address. Ngunit ang mga pin ng GPIO?

Nangyayari na ang mga pin na iyon ay naka-map sa memorya, kaya maaari nating tratuhin ang mga ito katulad ng mga memory address.

Nangangahulugan ito na kailangan nating malaman kung ano ang mga address na iyon.

Nasa ibaba ang mga pagsisimula ng address ng port. Sa pamamagitan ng paraan, para sa MSP432, ang isang "port" ay isang koleksyon ng mga pin, at hindi lamang isang pin. Kung pamilyar ka sa Raspberry Pi, naniniwala akong naiiba iyon kaysa sa sitwasyon dito.

Ang mga asul na bilog sa imahe sa itaas ay ipinapakita ang pagsusulat sa pisara para sa dalawang switch at LED. Ang mga asul na linya ay tumuturo sa aktwal na mga LED. Hindi namin kailangang hawakan ang mga header jumper.

Ginawa ko ang mga port na nag-aalala kami sa naka-bold sa ibaba.

• GPIO P1: 0x4000 4C00 + 0 (kahit mga address)
• GPIO P2: 0x4000 4C00 + 1 (kakaibang mga address)
• GPIO P3: 0x4000 4C00 + 20 (kahit mga address)
• GPIO P4: 0x4000 4C00 + 21 (kakaibang mga address)
• GPIO P5: 0x4000 4C00 + 40 (kahit mga address)
• GPIO P6: 0x4000 4C00 + 41 (kakaibang mga address)
• GPIO P7: 0x4000 4C00 + 60 (kahit mga address)
• GPIO P8: 0x4000 4C00 + 61 (kakaibang mga address)
• GPIO P9: 0x4000 4C00 + 80 (kahit mga address)
• GPIO P10: 0x4000 4C00 + 81 (kakaibang mga address)

Hindi pa tayo tapos. Kailangan namin ng karagdagang impormasyon.

Upang makontrol ang isang port, kailangan namin ng maraming mga address. Iyon ang dahilan kung bakit sa listahan sa itaas, nakikita namin ang "kahit na mga address" o "mga kakaibang address".

I / O Mga Rehistro sa Address ng Rehistro

Kakailanganin namin ng iba pang mga address, tulad ng:

• Address ng Rehistro sa Input ng Port 1 = 0x40004C00
• Port 1 Output Rehistro address = 0x40004C02
• Address ng Rehistro sa Port 1 Direksyon = 0x40004C04
• Port 1 Piliin ang 0 Rehistro address = 0x40004C0A
• Port 1 Piliin ang 1 Rehistro sa address = 0x40004C0C

At maaaring kailanganin natin ang iba.

Ok, alam na natin ngayon ang saklaw ng mga rehistro ng rehistro ng GPIO upang makontrol ang solong pulang LED.

Isang napakahalagang tala: Ang bawat I / O Port sa MSP432 LaunchPad board ay isang koleksyon ng maraming (karaniwang 8) mga pin o linya, at ang bawat isa ay maaaring isa-isang itakda bilang isang input o output.

Nangangahulugan ito, halimbawa, na kung nagtatakda ka ng mga halaga para sa "Port 1 Direksyon ng Rehistro sa Direksyon", kailangan mong mag-alala sa kung aling bit (o mga piraso) ang iyong itinatakda o binabago sa address na iyon. Higit pa rito

Sequence ng Programming ng GPIO

Ang huling piraso na kailangan namin, ay isang proseso o algorithm na gagamitin, upang makontrol ang LED.

Isang beses na pagsisimula:

• I-configure ang P1.0 (P1SEL1REG: P1SEL0REG Magrehistro) <--- 0x00, 0x00 para sa normal na pagpapaandar ng GPIO.
• Itakda ang Direksyon na magparehistro ng 1 ng P1DIRREG bilang output, o TAAS.

Loop:

Sumulat ng TAAS sa bit 0 ng rehistro ng P1OUTREG upang i-on ang Red LED

• Tumawag sa pagpapaandar na pagkaantala
• Sumulat ng LOW to bit 0 ng P1OUTREG magparehistro upang i-off ang Red LED
• Tumawag sa pagpapaandar na pagkaantala
• Ulitin ang Loop

Aling Input / Output Function (I-configure ang SEL0 at SEL1)

Marami sa mga pin sa LaunchPad ay maraming gamit. Halimbawa, ang parehong pin ay maaaring pamantayang digital GPIO, o maaari rin itong magamit sa UART, o I2C serial na mga komunikasyon.

Upang magamit ang anumang tukoy na pagpapaandar para sa pin na iyon, kailangan mong piliin ang pagpapaandar na iyon. Kailangan mong i-configure ang pagpapaandar ng pin.

Mayroong isang imahe sa itaas para sa hakbang na ito na sumusubok na ipaliwanag ang konseptong ito sa visual form.

Ang SEL0 at SEL1 na mga address ay bumubuo ng isang kumbinasyon ng pares na kumikilos bilang ilang uri ng pagpili ng function / tampok.

Para sa aming mga layunin, nais namin ang karaniwang digital GPIO para sa bit 0. Nangangahulugan iyon na kailangan namin ng bit 0 para sa SEL0 at SEL1 na maging isang LOW.

Sequence ng Programming sa Port (Muli)

1. Isulat ang 0x00 hanggang P1 SEL 0 Magrehistro (address 0x40004C0A). Nagtatakda ito ng isang LOW para sa bit 0

2. Isulat ang 0x00 hanggang P1 SEL 1 Magrehistro (address 0x40004C0C). Nagtatakda ito ng isang LOW para sa bit 0, setting para sa GPIO.

3. Isulat ang 0x01 hanggang P1 DIR Rehistro (address 0x40004C04). Nagtatakda ito ng isang TAAS para sa bit 0, nangangahulugang OUTPUT.

4. I-on ang LED sa pamamagitan ng pagsulat ng isang 0x01 hanggang P1 OUTPUT Rehistro (address 0x40004C02)

5. Gumawa ng isang uri ng pagkaantala (o iisang hakbang lamang habang naka-debug)

6. Patayin ang LED sa pamamagitan ng pagsulat ng 0x00 hanggang P1 OUTPUT Rehistro (address 0x40004C02)

7. Gumawa ng isang uri ng pagkaantala (o iisang hakbang lamang habang naka-debug)

8. Ulitin ang mga hakbang 4 hanggang 7.

Ang nauugnay na video para sa hakbang na ito ay magdadala sa amin sa buong proseso sa isang live na demo, habang isinasagawa namin ang isang hakbang sa pamamagitan at nakikipag-usap sa bawat tagubilin sa pagpupulong, at ipinapakita ang aksyon na LED. Mangyaring patawarin ang haba ng video.

Hakbang 3: Nakuha mo ba ang Isang Flaw sa Video?

Sa video na dumaan sa buong proseso ng pag-program at pag-iilaw sa LED, mayroong isang labis na hakbang sa pangunahing loop, na maaaring ilipat hanggang sa isang beses na pagsisimula.

Salamat sa paglalaan ng oras upang dumaan sa Instructable na ito.

Ang susunod ay lumalawak sa kung ano ang nasimulan namin dito.