GPIO ARM MONTERING - T.I. ROBOTICS SYSTEM LÆRESETT - LAB 6: 3 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Hallo, I en tidligere instruks om hvordan du lærer ARM-montering ved hjelp av Texas Instruments TI-RSLK (bruker MSP432 mikrokontroller), også kjent som Lab 3 hvis du gjør T. I. selvfølgelig, gikk vi over noen helt grunnleggende instruksjoner som å skrive til et register og betinget looping. Vi gikk gjennom utførelsen ved å bruke Eclipse IDE.

De små programmene vi utførte, gjorde ingenting for å samhandle med omverdenen.

Litt kjedelig.

La oss prøve å endre det litt i dag ved å lære litt om input/output -portene, spesielt de digitale GPIO -pinnene.

Det hender at denne MSP432 kommer på et utviklingskort allerede har to trykknappbrytere, en RGB-LED og en rød LED, som alle er knyttet til noen GPIO-porter.

Dette betyr at når vi lærer å sette opp og manipulere disse pinnene via montering, kan vi visuelt se disse effektene.

Mye mer interessant enn bare å gå gjennom feilsøkingsprogrammet.

(Vi kommer fortsatt til å gå - dette vil være vår "forsinkelse" -funksjon):-D

Trinn 1: La oss prøve å skrive til / lese fra RAM

Før vi går til tilgang til og kontrollerer GPIO, bør vi ta et lite skritt.

La oss starte med å lese og skrive til en standard minneadresse. Vi vet fra forrige Instructable (se bilder der) at RAM starter på 0x2000 0000, så la oss bruke den adressen.

Vi skal flytte data mellom et kjerneregister (R0) og 0x2000 0000.

Vi begynner med en grunnleggende filstruktur eller innhold i et monteringsprogram. Se denne instruksjonsboken for å lage et monteringsprosjekt ved hjelp av TI's Code Composer Studio (CCS), og noen prøveprosjekter.

.tommel

.text.align 2.global main.thumbfunc main main:.asmfunc; ---------------------------------- -----------------------------------------------; (koden vår går her); ------------------------------------------ ---------------------------------------.endasmfunc.end

Jeg vil legge til noe nytt i den øverste delen, hvis det er noen erklæringer (direktiver). Det blir tydeligere senere.

ACONST. Sett 0x20000000; vi vil bruke dette lenger ned (det er en konstant)

; åpenbart, '0x' betegner det som følger er en heksverdi.

Så innholdet i startfilen ser nå slik ut:

.tommel

.text.align 2 ACONST.sett 0x20000000; vi vil bruke dette lenger ned (det er en konstant); åpenbart, '0x' betegner det som følger er en heksverdi..global main.thumbfunc main main:.asmfunc; --------------------------------------- ------------------------------------------; (koden vår går her); ------------------------------------------ ---------------------------------------.endasmfunc.end

Nå som vi har ovennevnte, la oss legge til kode mellom de stiplede linjene.

Vi begynner med å skrive til et RAM -sted. Først vil vi etablere datamønsteret, en verdi, som vi skal skrive inn i RAM. Vi bruker et kjerneregister for å fastslå den verdien eller dataene.

Merk: Husk at i koden betyr enhver linje som har semikolon (';') at det hele er en kommentar etter den semikolonnen.

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

; SKRIFT; ------------------------------------------------ ---------------------------------------------- MOV R0, #0x55; kjerneregister R0 vil inneholde dataene vi vil skrive til RAM -plassering.; åpenbart, '0x' betegner det som følger er en heksverdi.

La oss deretter se på utsagn som IKKE fungerer.

; MOV MOV kan ikke brukes til å skrive data til et RAM -sted.

; MOV er bare for umiddelbare data i registeret; eller fra et register til et annet; dvs. MOV R1, R0.; STR må bruke STR.; STR R0, = ACONST; Dårlig uttrykk i uttrykket ('='); STR R0, 0x20000000; Ulovlig adresseringsmodus for butikkinstruksjoner; STR R0, ACONST; Ulovlig adresseringsmodus for butikkinstruksjoner

Uten å forklare for mye, prøvde vi å bruke 'ACONST' ovenfor. I hovedsak er det en stand-in eller konstant i stedet for å bruke en bokstavelig verdi som 0x20000000.

Vi klarte ikke å skrive for å skrive til RAM -stedet ved å bruke ovenstående. La oss prøve noe annet.

; ser ut til at vi må bruke et annet register som inneholder RAM -stedet i

; for å lagre det RAM -stedet MOV R1, #0x20000000; sett RAM -plassering (ikke innholdet, men plasseringen) til R1.; åpenbart, '0x' betegner det som følger er en heksverdi. STR R0, [R1]; skriv hva som er i R0 (0x55) til RAM (0x20000000) ved hjelp av R1.; vi bruker et annet register (R1) som har RAM -plasseringsadresse; for å skrive til det RAM -stedet.

En annen måte å gjøre det ovennevnte, men å bruke 'ACONST' i stedet for den bokstavelige adressen:

; la oss gjøre det ovennevnte igjen, men la oss bruke et symbol i stedet for en bokstavelig verdi for RAM -plassering.

; vi ønsker å bruke 'ACONST' som en stand-in for 0x20000000.; vi må fortsatt gjøre "#" for å betegne en umiddelbar verdi; så (se øverst), vi måtte bruke '.set' -direktivet.; For å bevise dette, la oss endre datamønsteret i R0. MOV R0, #0xAA; ok, vi er klare til å skrive til RAM ved hjelp av symbolet i stedet for bokstavelig adresseverdi MOV R1, #ACONST STR R0, [R1]

Videoen går i mer detalj, i tillegg til å gå gjennom lesing fra minnestedet.

Du kan også se den vedlagte kilden.asm -filen.

Trinn 2: Litt grunnleggende portinformasjon

Nå som vi har en god idé om hvordan du skriver til / leser fra et RAM -sted, vil dette hjelpe oss med å bedre forstå hvordan vi kan kontrollere og bruke GPIO -pinnen

Så hvordan samhandler vi med GPIO -pinnene? Fra vårt tidligere blikk på denne mikrokontrolleren og dens ARM -instruksjoner, vet vi hvordan vi skal håndtere de interne registrene, og vi vet hvordan vi skal samhandle med minne (RAM) adresser. Men GPIO -pinner?

Det er slik at disse pinnene er minnekartede, så vi kan behandle dem på samme måte som minneadresser.

Dette betyr at vi må vite hva disse adressene er.

Nedenfor er portens startadresser. Forresten, for MSP432 er en "port" en samling pins, og ikke bare en pin. Hvis du er kjent med Raspberry Pi, tror jeg det er annerledes enn situasjonen her.

De blå sirklene i bildet ovenfor viser skriften på tavlen for de to bryterne og lysdiodene. De blå linjene peker på de faktiske lysdiodene. Vi trenger ikke å berøre hodehopperne.

Jeg lagde portene vi er opptatt av i fet skrift nedenfor.

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

Vi er ikke ferdige ennå. Vi trenger mer informasjon.

For å kontrollere en port trenger vi flere adresser. Det er derfor i listen ovenfor ser vi "like adresser" eller "oddetalladresser".

I/O -registeradresseblokker

Vi trenger andre adresser, for eksempel:

• Port 1 Inngangsregisteradresse = 0x40004C00
• Port 1 Utgangsregisteradresse = 0x40004C02
• Port 1 Retning Registeradresse = 0x40004C04
• Port 1 Velg 0 Registrer adresse = 0x40004C0A
• Port 1 Velg 1 Registrer adresse = 0x40004C0C

Og vi kan trenge andre.

Ok, vi kjenner nå rekkevidden av GPIO -registeradresser for å kontrollere den eneste røde LED -en.

En veldig viktig merknad: Hver I/O -port på MSP432 LaunchPad -kortet er en samling av flere (vanligvis 8) pinner eller linjer, og hver kan settes individuelt som inngang eller utgang.

Dette betyr for eksempel at hvis du angir verdier for "Port 1 Direction Register Address", må du være bekymret for hvilken bit (eller bits) du angir eller endrer på den adressen. Mer om dette senere.

GPIO portprogrammeringsrekkefølge

Det siste stykket vi trenger, er en prosess eller algoritme som skal brukes, for å kontrollere LED -en.

Engangs initialisering:

• Konfigurer P1.0 (P1SEL1REG: P1SEL0REG Register) <--- 0x00, 0x00 for normal GPIO-funksjonalitet.
• Angi retningsregisterbiten 1 på P1DIRREG som utgang, eller HØY.

Løkke:

Skriv HØY til bit 0 av P1OUTREG -registeret for å slå på den røde LED -en

• Ring en forsinkelsesfunksjon
• Skriv LOW til bit 0 av P1OUTREG -registeret for å slå av den røde LED -en
• Ring en forsinkelsesfunksjon
• Gjenta Loop

Hvilken inngang / utgangsfunksjon (konfigurer SEL0 og SEL1)

Mange av pinnene på LaunchPad har flere bruksområder. For eksempel kan den samme pinnen være standard digital GPIO, eller den kan også brukes i UART- eller I2C -seriekommunikasjon.

For å kunne bruke en bestemt funksjon for den pinnen, må du velge den funksjonen. Du må konfigurere pinnens funksjon.

Det er et bilde ovenfor for dette trinnet som prøver å forklare dette konseptet i visuell form.

SEL0- og SEL1 -adressene danner en parkombinasjon som fungerer som en slags funksjon / funksjonsvalg.

For våre formål ønsker vi standard digital GPIO for bit 0. Det betyr at vi trenger bit 0 for SEL0 og SEL1 for å være LAV.

Portprogrammeringsrekkefølge (igjen)

1. Skriv 0x00 til P1 SEL 0 Register (adresse 0x40004C0A). Dette setter en LAV for bit 0

2. Skriv 0x00 til P1 SEL 1 Register (adresse 0x40004C0C). Dette setter en LAV for bit 0, innstilling for GPIO.

3. Skriv 0x01 til P1 DIR Register (adresse 0x40004C04). Dette setter en HØY for bit 0, som betyr UTGANG.

4. Slå på LED -en ved å skrive et 0x01 til P1 OUTPUT Register (adresse 0x40004C02)

5. Gjør en eller annen forsinkelse (eller bare ett trinn gjennom feilsøking)

6. Slå av LED -en ved å skrive et 0x00 til P1 OUTPUT Register (adresse 0x40004C02)

7. Gjør en eller annen forsinkelse (eller bare ett trinn gjennom feilsøking)

8. Gjenta trinn 4 til 7.

Den tilhørende videoen for dette trinnet tar oss gjennom hele prosessen i en live demo, mens vi går gjennom og snakker gjennom hver monteringsinstruksjon og viser LED-handlingen. Unnskyld lengden på videoen.

Trinn 3: Fikk du den ene feilen i videoen?

I videoen som går gjennom hele prosessen med programmering og belysning av LED-en, var det et ekstra trinn i hovedsløyfen, som kunne vært flyttet opp til engangsinitialiseringen.

Takk for at du tok deg tid til å gå gjennom denne instruksen.

Den neste utvider hva vi har startet her.