GPIO ARM MONTERING - T.I. ROBOTICS SYSTEM LÄRNINGSKIT - LAB 6: 3 Steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

Hej, I en tidigare instruktion om hur man lär sig ARM-montering med Texas Instruments TI-RSLK (använder MSP432-mikrokontrollern), aka Lab 3 om du gör T. I. Naturligtvis gick vi igenom några mycket grundläggande instruktioner som att skriva till ett register och villkorlig looping. Vi gick igenom utförandet med hjälp av Eclipse IDE.

De små program som vi körde gjorde inget för att interagera med omvärlden.

Lite tråkigt.

Låt oss försöka ändra det lite idag genom att lära oss lite om in-/utgångsportarna, specifikt de digitala GPIO -stiften.

Det händer så att denna MSP432 kommer på ett utvecklingskort som redan har två tryckknappar, en RGB-LED och en röd LED, som alla är kopplade till några GPIO-portar.

Det betyder att när vi lär oss att konfigurera och manipulera dessa stift via montering kan vi visuellt se dessa effekter.

Mycket mer intressant än att bara gå igenom felsökaren.

(Vi går fortfarande till steg - det här kommer att vara vår "fördröjnings" -funktion):-D

Steg 1: Låt oss försöka skriva till / läsa från RAM

Innan vi går till att komma åt och kontrollera GPIO, bör vi ta ett litet steg.

Låt oss börja med att bara läsa och skriva till en standardminnesadress. Vi vet från föregående Instructable (se bilder där) att RAM börjar vid 0x2000 0000, så låt oss använda den adressen.

Vi ska flytta data mellan ett kärnregister (R0) och 0x2000 0000.

Vi börjar med en grundläggande filstruktur eller innehåll i ett monteringsprogram. Se denna instruktionsbok för att skapa ett monteringsprojekt med TI: s Code Composer Studio (CCS) och några exempelprojekt.

.tumme

.text.align 2.global main.thumbfunc main main:.asmfunc; ---------------------------------- -----------------------------------------------; (vår kod kommer att gå här); ------------------------------------------ ---------------------------------------.endasmfunc.end

Jag vill lägga till något nytt i det övre avsnittet, om det fanns några deklarationer (direktiv). Det blir tydligare senare.

ACONST.set 0x20000000; vi kommer att använda detta längre ner (det är en konstant)

; uppenbarligen, '0x' betecknar det som följer är ett hex -värde.

Så vårt startfilinnehåll ser nu ut så här:

.tumme

.text.align 2 ACONST.set 0x20000000; vi kommer att använda detta längre ner (det är en konstant); uppenbarligen, '0x' betecknar det som följer är ett hex -värde..global main.thumbfunc main main:.asmfunc; --------------------------------------- -------------------------------------------------- (vår kod kommer hit); ------------------------------------------ ---------------------------------------.endasmfunc.end

Nu när vi har ovanstående, låt oss lägga till kod mellan de streckade linjerna.

Vi börjar med att skriva till en RAM -plats. Först kommer vi att fastställa datamönstret, ett värde, som vi kommer att skriva in i RAM -minnet. Vi använder ett kärnregister för att fastställa detta värde eller data.

Observera: kom ihåg att i koden betyder alla rader som har ett semikolon (';') att allt är en kommentar efter den semikolon.

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

; SKRIFT;------------------------------------------------ ----------------------------------------------- MOV R0, #0x55; kärnregistret R0 innehåller den data vi vill skriva till RAM -platsen.; uppenbarligen, '0x' betecknar det som följer är ett hex -värde.

Låt oss sedan ta en titt på påståenden som INTE fungerar.

; MOV MOV är inte användbart för att skriva data till en RAM -plats.

; MOV är endast för omedelbar data i registret; eller från ett register till ett annat; dvs MOV R1, R0.; STR måste använda STR.; STR R0, = KONTO; Dålig term i uttrycket ('='); STR R0, 0x20000000; Olagligt adresseringsläge för butiksinstruktion; STR R0, ACONST; Olagligt adresseringsläge för butiksinstruktion

Utan att förklara för mycket försökte vi använda den "AKONST" ovan. I huvudsak är det en stand-in eller konstant istället för att använda ett bokstavligt värde som 0x20000000.

Vi kunde inte skriva för att skriva till RAM -platsen med ovanstående. Låt oss prova något annat.

; verkar vi måste använda ett annat register som innehåller RAM -platsen i

; för att lagra till den RAM -platsen MOV R1, #0x20000000; ställ in RAM -plats (inte dess innehåll, men plats) till R1.; uppenbarligen, '0x' betecknar det som följer är ett hex -värde. STR R0, [R1]; skriv vad som finns i R0 (0x55) till RAM (0x20000000) med R1.; vi använder ett annat register (R1) som har RAM -platsadress; för att skriva till den RAM -platsen.

Ett annat sätt att göra ovanstående, men att använda 'ACONST' istället för det bokstavliga adressvärdet:

; låt oss göra ovanstående igen, men låt oss använda en symbol istället för ett bokstavligt RAM -platsvärde.

; vi vill använda 'ACONST' som en stand-in för 0x20000000.; vi måste fortfarande göra "#" för att markera ett omedelbart värde; så (se överst), vi var tvungna att använda ".set" -direktivet.; För att bevisa detta, låt oss ändra datamönstret i R0. MOV R0, #0xAA; ok, vi är redo att skriva till RAM med symbolen istället för det bokstavliga adressvärdet MOV R1, #ACONST STR R0, [R1]

Videon går in i mer detalj, samt går igenom läsning från minnesplatsen.

Du kan också se den bifogade källan.asm -filen.

Steg 2: Lite grundläggande portinformation

Nu när vi har en bra idé om hur man skriver till / läser från en RAM -plats, hjälper det oss att bättre förstå hur man styr och använder GPIO -stiftet

Så hur interagerar vi med GPIO -stiften? Från vår tidigare titt på denna mikrokontroller och dess ARM -instruktioner vet vi hur vi ska hantera dess interna register och vi vet hur vi interagerar med minnesadresser (RAM). Men GPIO -stift?

Det händer att dessa stift är minneskartade, så vi kan behandla dem ungefär som minnesadresser.

Det betyder att vi behöver veta vilka dessa adresser är.

Nedan visas portens startadresser. Förresten, för MSP432 är en "port" en samling stift, och inte bara en stift. Om du är bekant med Raspberry Pi tror jag att det är annorlunda än situationen här.

De blå cirklarna i bilden ovan visar texten på tavlan för de två omkopplarna och lysdioderna. De blå linjerna pekar på de faktiska lysdioderna. Vi kommer inte att behöva röra på hopphopparna.

Jag gjorde de portar vi är bekymrade över med fet stil nedan.

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

Vi är inte klara än. Vi behöver mer information.

För att styra en port behöver vi flera adresser. Det är därför i listan ovan vi ser "jämna adresser" eller "udda adresser".

I/O -registeradressblock

Vi kommer att behöva andra adresser, till exempel:

• Port 1 Inmatningsregisteradress = 0x40004C00
• Port 1 Utgångsregisteradress = 0x40004C02
• Port 1 Riktning Registeradress = 0x40004C04
• Port 1 Välj 0 Registeradress = 0x40004C0A
• Port 1 Välj 1 Registrera adress = 0x40004C0C

Och vi kan behöva andra.

Ok, vi vet nu utbudet av GPIO -registeradresser för att styra den enda röda lysdioden.

En mycket viktig anteckning: Varje I/O -port på MSP432 LaunchPad -kortet är en samling av flera (vanligtvis 8) stift eller linjer, och var och en kan ställas in individuellt som en ingång eller utgång.

Detta betyder till exempel att om du anger värden för "Port 1 Direction Register Address" måste du vara orolig för vilken bit (eller bitar) du ställer in eller ändrar på den adressen. Mer om detta senare.

GPIO -portprogrammeringssekvens

Den slutliga biten som vi behöver är en process eller algoritm att använda för att styra lysdioden.

Engångsinitialisering:

• Konfigurera P1.0 (P1SEL1REG: P1SEL0REG-register) <--- 0x00, 0x00 för normal GPIO-funktion.
• Ställ in riktningsregistrets bit 1 på P1DIRREG som utgång eller HÖG.

Slinga:

Skriv HÖG till bit 0 i P1OUTREG -registret för att slå på den röda lysdioden

• Ring en fördröjningsfunktion
• Skriv LÅG till bit 0 i P1OUTREG -registret för att stänga av den röda lysdioden
• Ring en fördröjningsfunktion
• Upprepa loop

Vilken ingångs- / utmatningsfunktion (konfigurera SEL0 och SEL1)

Många av stiften på LaunchPad har flera användningsområden. Exempelvis kan samma stift vara standard digital GPIO, eller så kan den också användas i UART- eller I2C -seriekommunikation.

För att kunna använda någon specifik funktion för den stiftet måste du välja den funktionen. Du måste konfigurera stiftets funktion.

Det finns en bild ovan för detta steg som försöker förklara detta koncept i visuell form.

SEL0- och SEL1 -adresserna bildar en parkombination som fungerar som ett slags val av funktioner / funktioner.

För våra ändamål vill vi ha standard digital GPIO för bit 0. Det betyder att vi behöver bit 0 för SEL0 och SEL1 för att vara en LÅG.

Portprogrammeringssekvens (igen)

1. Skriv 0x00 till P1 SEL 0 Register (adress 0x40004C0A). Detta sätter en LÅG för bit 0

2. Skriv 0x00 till P1 SEL 1 Register (adress 0x40004C0C). Detta anger en LÅG för bit 0, inställning för GPIO.

3. Skriv 0x01 till P1 DIR -register (adress 0x40004C04). Detta ställer in en HIGH för bit 0, vilket betyder OUTPUT.

4. Slå på lysdioden genom att skriva ett 0x01 till P1 OUTPUT -register (adress 0x40004C02)

5. Gör någon form av fördröjning (eller bara ett steg genom att felsöka)

6. Stäng av lysdioden genom att skriva ett 0x00 till P1 OUTPUT -register (adress 0x40004C02)

7. Gör någon form av fördröjning (eller bara ett steg genom att felsöka)

8. Upprepa steg 4 till 7.

Den associerade videon för detta steg tar oss igenom hela processen i en live-demo, när vi går igenom och pratar igenom varje monteringsinstruktion och visar LED-åtgärden. Ursäkta längden på videon.

Steg 3: Fick du den enda bristen i videon?

I videon som går igenom hela processen med att programmera och tända lysdioden, var det ett extra steg i huvudslingan, som kunde ha flyttats upp till en gångs initialisering.

Tack för att du tog dig tid att gå igenom denna instruerbara.

Nästa utvidgar vad vi har börjat här.