GPIO ARM ASSEMBLY - T.I. KIT DE ÎNVĂȚARE SISTEM ROBOTICĂ - LAB 6: 3 Pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Buna ziua, Într-un Instructable anterior despre învățarea ansamblului ARM folosind Texas Instruments TI-RSLK (utilizează microcontrolerul MSP432), alias Lab 3 dacă faceți T. I. bineînțeles, am parcurs câteva instrucțiuni de bază, cum ar fi scrierea într-un registru și ciclarea condiționată. Am parcurs execuția folosind Eclipse IDE.

Programele mici pe care le-am executat nu au făcut nimic pentru a interacționa cu lumea exterioară.

Cam plictisitor.

Să încercăm să schimbăm puțin astăzi învățând puțin despre porturile de intrare / ieșire, în special pinii GPIO digitali.

Se întâmplă că acest MSP432 vine pe o placă de dezvoltare are deja două comutatoare cu buton, un LED RGB și un LED roșu, toate acestea fiind legate de unele porturi GPIO.

Aceasta înseamnă că, pe măsură ce învățăm să configurăm și să manipulăm acești pini prin asamblare, putem vedea vizual aceste efecte.

Mult mai interesant decât să pășești prin depanator.

(Vom continua să facem un pas - aceasta va fi funcția noastră de „întârziere”):-D

Pasul 1: Să încercăm să scriem / să citim din RAM

Înainte de a trece la accesarea și controlul GPIO, ar trebui să facem un mic pas.

Să începem doar citind și scriind pe o adresă de memorie standard. Știm din versiunea Instructable anterioară (vezi imaginile de acolo) că memoria RAM începe de la 0x2000 0000, deci să folosim acea adresă.

Vom muta datele între un registru de bază (R0) și 0x2000 0000.

Începem cu o structură de bază a fișierului sau conținutul unui program de asamblare. Vă rugăm să consultați acest Instructable pentru a crea un proiect de asamblare utilizând Code Composer Studio (CCS) al TI și câteva exemple de proiecte.

.deget mare

.text.align 2.global main.thumbfunc main main:.asmfunc; ---------------------------------- -----------------------------------------------; (codul nostru va merge aici); ------------------------------------------ ---------------------------------------.endasmfunc.end

Vreau să adaug ceva nou în secțiunea de sus, în cazul în care există unele declarații (directive). Va deveni mai clar mai târziu.

ACONST.set 0x20000000; vom folosi acest lucru mai jos (este o constantă)

; evident, „0x” denotă ceea ce urmează este o valoare hexagonală.

Deci, conținutul fișierului nostru inițial arată acum așa:

.deget mare

.text.align 2 ACONST.set 0x20000000; vom folosi acest lucru mai jos (este o constantă); evident, „0x” denotă ceea ce urmează este o valoare hexagonală..global main.thumbfunc main main:.asmfunc; --------------------------------------- ------------------------------------------; (codul nostru va merge aici); ------------------------------------------ ---------------------------------------.endasmfunc.end

Acum că avem cele de mai sus, să adăugăm cod între liniile întrerupte.

Începem cu scrierea într-o locație RAM. Mai întâi vom stabili modelul de date, o valoare, pe care o vom scrie în RAM. Folosim un registru de bază pentru a stabili acea valoare sau date.

Notă: amintiți-vă că în cod, orice linie care are un punct și virgulă (';') înseamnă că totul este un comentariu după acel punct și virgulă.

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

; SCRIERE; ------------------------------------------------ ----------------------------------------------- MOV R0, # 0x55; registrul de bază R0 va conține datele pe care dorim să le scriem în locația RAM.; evident, „0x” denotă ceea ce urmează este o valoare hexagonală.

În continuare, să aruncăm o privire asupra afirmațiilor care NU funcționează.

; MOV MOV nu este utilizabil pentru a scrie date într-o locație RAM.

; MOV este doar pentru date imediate în registru; sau de la un registru la altul; adică MOV R1, R0.; STR trebuie să utilizeze STR.; STR R0, = ACONST; Termen greșit în expresie („=”); STR R0, 0x20000000; Mod de adresare ilegal pentru instruirea magazinului; STR R0, ACONST; Mod de adresare ilegal pentru instrucțiuni de magazin

Fără a explica prea multe, am încercat să folosim acel „ACONST” de mai sus. În esență, este un stand-in sau o constantă în loc să folosească o valoare literală ca 0x20000000.

Nu am putut scrie pentru a scrie pe locația RAM folosind cele de mai sus. Să încercăm altceva.

; se pare că trebuie să folosim un alt registru care conține locația RAM în

; pentru a stoca în acea locație RAM MOV R1, # 0x20000000; setați locația RAM (nu conținutul său, ci locația) în R1.; evident, „0x” denotă ceea ce urmează este o valoare hexagonală. STR R0, [R1]; scrieți ce este în R0 (0x55) în RAM (0x20000000) folosind R1.; folosim un alt registru (R1) care are adresa de localizare RAM; pentru a scrie în acea locație RAM.

Un alt mod de a face cele de mai sus, dar folosind „ACONST” în loc de valoarea literală a adresei:

; să facem din nou cele de mai sus, dar să folosim un simbol în loc de o valoare literală a locației RAM.

; vrem să folosim „ACONST” ca stand-in pentru 0x20000000.; încă trebuie să facem „#” pentru a semnifica o valoare imediată; deci (a se vedea în partea de sus), a trebuit să folosim directiva „.set”.; pentru a demonstra acest lucru, să schimbăm modelul de date din R0. MOV R0, # 0xAA; ok suntem gata să scriem pe RAM folosind simbolul în loc de valoarea literală a adresei MOV R1, #ACONST STR R0, [R1]

Videoclipul intră în mai multe detalii, precum și parcurgerea lecturii din locația memoriei.

De asemenea, puteți vizualiza fișierul.asm sursă atașat.

Pasul 2: Unele informații de bază despre port

Acum că avem o idee bună despre cum să scriem / citim dintr-o locație RAM, acest lucru ne va ajuta să înțelegem mai bine cum să controlăm și să folosim pinul GPIO

Deci, cum interacționăm cu pinii GPIO? Din privirea noastră anterioară la acest microcontroler și instrucțiunile sale ARM, știm cum să ne ocupăm de registrele sale interne și știm cum să interacționăm cu adresele de memorie (RAM). Dar pinii GPIO?

Se întâmplă ca acei pini să fie mapați de memorie, deci îi putem trata la fel ca adresele de memorie.

Aceasta înseamnă că trebuie să știm care sunt acele adrese.

Mai jos sunt adresele de pornire ale portului. Apropo, pentru MSP432, un „port” este o colecție de pini și nu doar un pini. Dacă sunteți familiarizat cu Raspberry Pi, cred că este diferit de situația de aici.

Cercurile albastre din imaginea de mai sus arată scrierea de pe tablă pentru cele două comutatoare și LED-uri. Liniile albastre indică LED-urile reale. Nu va trebui să atingem jumperii de antet.

Mai jos am făcut porturile cu care ne preocupăm.

• GPIO P1: 0x4000 4C00 + 0 (adrese pare)
• GPIO P2: 0x4000 4C00 + 1 (adrese impare)
• GPIO P3: 0x4000 4C00 + 20 (adrese pare)
• GPIO P4: 0x4000 4C00 + 21 (adrese impare)
• GPIO P5: 0x4000 4C00 + 40 (adrese pare)
• GPIO P6: 0x4000 4C00 + 41 (adrese impare)
• GPIO P7: 0x4000 4C00 + 60 (adrese pare)
• GPIO P8: 0x4000 4C00 + 61 (adrese impare)
• GPIO P9: 0x4000 4C00 + 80 (adrese par)
• GPIO P10: 0x4000 4C00 + 81 (adrese impare)

Nu am terminat încă. Avem nevoie de mai multe informații.

Pentru a controla un port, avem nevoie de mai multe adrese. De aceea, în lista de mai sus, vedem „adrese pare” sau „adrese impare”.

Blocuri de adrese de înregistrare I / O

Vom avea nevoie de alte adrese, cum ar fi:

• Port 1 Adresa registru de intrare = 0x40004C00
• Adresa registrului de ieșire port 1 = 0x40004C02
• Adresa registrului de direcție port 1 = 0x40004C04
• Port 1 Selectați 0 Adresă înregistrare = 0x40004C0A
• Port 1 Selectați 1 Adresă de înregistrare = 0x40004C0C

Și s-ar putea să avem nevoie de alții.

Ok, acum cunoaștem gama de adrese de registre GPIO pentru a controla singurul LED roșu.

O notă foarte importantă: Fiecare port I / O de pe placa MSP432 LaunchPad este o colecție de mai mulți (de obicei 8) pini sau linii și fiecare poate fi setat individual ca intrare sau ieșire.

Aceasta înseamnă, de exemplu, că, dacă setați valori pentru „Adresa de înregistrare a direcției 1 port”, trebuie să vă preocupați ce bit (sau biți) setați sau schimbați la adresa respectivă. Mai multe despre asta mai târziu.

Secvența de programare a portului GPIO

Piesa finală de care avem nevoie este un proces sau algoritm de utilizat, pentru a controla LED-ul.

Inițializare unică:

• Configurați P1.0 (P1SEL1REG: P1SEL0REG Register) <--- 0x00, 0x00 pentru funcționalitatea GPIO normală.
• Setați bitul registrului de direcție 1 al P1DIRREG ca ieșire sau HIGH.

Buclă:

Scrieți HIGH la bitul 0 din registrul P1OUTREG pentru a porni LED-ul roșu

• Apelați o funcție de întârziere
• Scrieți LOW pe bitul 0 din registrul P1OUTREG pentru a opri LED-ul roșu
• Apelați o funcție de întârziere
• Repetați bucla

Care funcție de intrare / ieșire (configurați SEL0 și SEL1)

Multe dintre pini de pe LaunchPad au utilizări multiple. De exemplu, același pin ar putea fi GPIO digital standard sau poate fi utilizat și în comunicații seriale UART sau I2C.

Pentru a utiliza orice funcție specifică pentru acel pin, trebuie să selectați acea funcție. Trebuie să configurați funcția pinului.

Există o imagine de mai sus pentru acest pas care încearcă să explice acest concept în formă vizuală.

Adresele SEL0 și SEL1 formează o combinație de perechi care acționează ca un fel de selecție de funcții / caracteristici.

În scopurile noastre, dorim GPIO digital standard pentru bitul 0. Asta înseamnă că avem nevoie de bitul 0 pentru ca SEL0 și SEL1 să fie LOW.

Secvența de programare a portului (din nou)

1. Scrieți 0x00 în P1 SEL 0 Register (adresa 0x40004C0A). Aceasta setează un LOW pentru bitul 0

2. Scrieți 0x00 în P1 SEL 1 Register (adresa 0x40004C0C). Aceasta setează un LOW pentru bitul 0, setare pentru GPIO.

3. Scrieți 0x01 în Registrul DIR P1 (adresa 0x40004C04). Aceasta setează un HIGH pentru bitul 0, adică OUTPUT.

4. Porniți LED-ul scriind un registru de ieșire 0x01 la P1 (adresa 0x40004C02)

5. Faceți un fel de întârziere (sau doar printr-un singur pas în timp ce depanați)

6. Opriți LED-ul scriind un registru de ieșire 0x00 la P1 (adresa 0x40004C02)

7. Faceți un fel de întârziere (sau doar printr-un singur pas în timp ce depanați)

8. Repetați pașii de la 4 la 7.

Videoclipul asociat pentru acest pas ne duce prin întregul proces într-o demonstrație live, pe măsură ce parcurgem un singur pas și vorbim prin fiecare instrucțiune de asamblare și afișăm acțiunea LED. Vă rugăm să scuzați durata videoclipului.

Pasul 3: Ai prins singurul defect din videoclip?

În videoclipul care parcurge întregul proces de programare și aprindere a LED-ului, a existat un pas suplimentar în bucla principală, care ar fi putut fi mutat până la inițializarea unică.

Vă mulțumim că ați făcut timp pentru a trece prin acest instructabil.

Următorul se extinde pe ceea ce am început aici.