GPIO ARM MONTAGE - T.I. LEERKIT ROBOTICS-SYSTEEM - LAB 6: 3 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Hallo, In een eerdere Instructable over het leren van ARM-assemblage met behulp van de Texas Instruments TI-RSLK (gebruikt de MSP432-microcontroller), ook bekend als Lab 3 als je de T. I. natuurlijk hebben we enkele zeer basale instructies doorgenomen, zoals schrijven naar een register en voorwaardelijke looping. We zijn door de uitvoering gegaan met behulp van de Eclipse IDE.

De piepkleine programma's die we uitvoerden, hadden niets met de buitenwereld te maken.

Beetje saai.

Laten we proberen dat vandaag een beetje te veranderen door iets te leren over de input/output-poorten, met name de digitale GPIO-pinnen.

Het gebeurt zo dat deze MSP432 op een ontwikkelbord komt en al twee drukknopschakelaars, een RGB-led en een rode led heeft, die allemaal zijn gekoppeld aan enkele GPIO-poorten.

Dit betekent dat als we leren deze pinnen in te stellen en te manipuleren via montage, we die effecten visueel kunnen zien.

Veel interessanter dan alleen door de debugger te stappen.

(We gaan nog steeds stappen - dit wordt onze 'vertraging'-functie):-D

Stap 1: Laten we proberen te schrijven naar / lezen vanuit RAM

Voordat we overgaan tot toegang tot en besturing van de GPIO, moeten we een kleine stap zetten.

Laten we beginnen door gewoon te lezen en te schrijven naar een standaard geheugenadres. We weten uit de vorige Instructable (zie afbeeldingen daar) dat RAM begint bij 0x2000 0000, dus laten we dat adres gebruiken.

We gaan gegevens verplaatsen tussen een kernregister (R0) en 0x2000 0000.

We beginnen met een basisbestandsstructuur of inhoud van een assemblageprogramma. Raadpleeg deze Instructable om een montageproject te maken met behulp van TI's Code Composer Studio (CCS) en enkele voorbeeldprojecten.

.duim

.text.align 2.global main.thumbfunc main main:.asmfunc;---------------------------------- -----------------------------------------------; (onze code komt hier te staan);------------------------------------------ ---------------------------------------.endasmfunc.end

Ik wil iets nieuws toevoegen aan het bovenste gedeelte, waar er enkele verklaringen (richtlijnen) zijn. Het zal later duidelijker worden.

ACONST.set 0x20000000; we zullen dit verderop gebruiken (het is een constante)

; uiteraard geeft '0x' aan wat volgt is een hexadecimale waarde.

Dus de inhoud van ons startbestand ziet er nu als volgt uit:

.duim

.text.align 2 ACONST.set 0x20000000; we zullen dit verderop gebruiken (het is een constante); uiteraard geeft '0x' aan wat volgt is een hexadecimale waarde..global hoofd.thumbfunc hoofd hoofd:.asmfunc;--------------------------------------- ------------------------------------------; (onze code komt hier te staan);------------------------------------------ ---------------------------------------.endasmfunc.end

Nu we het bovenstaande hebben, laten we code tussen de stippellijnen toevoegen.

We beginnen met het schrijven naar een RAM-locatie. Eerst zullen we het gegevenspatroon, een waarde, vaststellen dat we in het RAM zullen schrijven. We gebruiken een kernregister om die waarde of gegevens vast te stellen.

Opmerking: onthoud dat in de code elke regel met een puntkomma (';') betekent dat het allemaal een opmerking is na die puntkomma.

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

; SCHRIJVEN;------------------------------------------------ ----------------------------------------------- MOV R0, #0x55; kernregister R0 bevat de gegevens die we naar de RAM-locatie willen schrijven.; uiteraard geeft '0x' aan wat volgt is een hexadecimale waarde.

Laten we vervolgens eens kijken naar uitspraken die NIET werken.

; MOV MOV kan niet worden gebruikt om gegevens naar een RAM-locatie te schrijven.

; MOV is alleen voor onmiddellijke gegevens in register,; of van het ene register naar het andere; d.w.z. MOV R1, R0.; STR moet STR gebruiken.; STR R0, =ACONST; Slechte term in uitdrukking (de '='); STR R0, 0x20000000; Illegale adresseringsmodus voor winkelinstructie; STR R0, ACONST; Illegale adresseringsmodus voor winkelinstructie

Zonder al te veel uit te leggen, hebben we geprobeerd die 'ACONST' hierboven te gebruiken. In wezen is het een stand-in of constante in plaats van een letterlijke waarde zoals 0x20000000 te gebruiken.

We konden niet schrijven om naar de RAM-locatie te schrijven met behulp van het bovenstaande. Laten we iets anders proberen.

; lijkt erop dat we een ander register moeten gebruiken met daarin de RAM-locatie in

; om op die RAM-locatie MOV R1, #0x20000000 op te slaan; stel de RAM-locatie in (niet de inhoud, maar de locatie) in R1.; uiteraard geeft '0x' aan wat volgt is een hexadecimale waarde. STR RO, [R1]; schrijf wat er in R0 (0x55) staat in RAM (0x20000000) met R1.; we gebruiken een ander register (R1) dat RAM-locatieadres heeft; om NAAR die RAM-locatie te schrijven.

Een andere manier om het bovenstaande te doen, maar met 'ACONST' in plaats van de letterlijke adreswaarde:

; laten we het bovenstaande nogmaals doen, maar laten we een symbool gebruiken in plaats van een letterlijke RAM-locatiewaarde.

; we willen 'ACONST' gebruiken als stand-in voor 0x20000000.; we moeten nog steeds de '#' doen om een onmiddellijke waarde aan te duiden,; dus (zie bovenaan), moesten we de '.set'-richtlijn gebruiken.; laten we om dit te bewijzen het gegevenspatroon in R0 veranderen. MOV R0, #0xAA; ok we zijn klaar om naar RAM te schrijven met het symbool in plaats van de letterlijke adreswaarde MOV R1, #ACONST STR R0, [R1]

De video gaat wat meer in detail, en stapt ook door het lezen vanaf de geheugenlocatie.

U kunt ook het bijgevoegde.asm-bronbestand bekijken.

Stap 2: Enkele basispoortinformatie

Nu we een goed idee hebben hoe we moeten schrijven naar / lezen van een RAM-locatie, zal dit ons helpen beter te begrijpen hoe we de GPIO-pin kunnen besturen en gebruiken

Dus hoe gaan we om met de GPIO-pinnen? Op basis van onze eerdere blik op deze microcontroller en zijn ARM-instructies, weten we hoe we met zijn interne registers moeten omgaan en weten we hoe we moeten omgaan met geheugen (RAM)-adressen. Maar GPIO-pinnen?

Het gebeurt zo dat die pinnen in het geheugen zijn toegewezen, dus we kunnen ze vrijwel hetzelfde behandelen als geheugenadressen.

Dit betekent dat we moeten weten wat die adressen zijn.

Hieronder staan de startadressen van de haven. Trouwens, voor de MSP432 is een "poort" een verzameling pinnen en niet slechts één pin. Als je bekend bent met de Raspberry Pi, denk ik dat dat anders is dan hier.

De blauwe cirkels in de bovenstaande afbeelding tonen de tekst op het bord voor de twee schakelaars en LED's. De blauwe lijnen wijzen naar de eigenlijke LED's. We hoeven de header-jumpers niet aan te raken.

Ik heb de poorten waar het ons om gaat hieronder vetgedrukt gemaakt.

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

We zijn nog niet klaar. We hebben meer informatie nodig.

Om een poort aan te sturen hebben we meerdere adressen nodig. Daarom zien we in de bovenstaande lijst "even adressen" of "oneven adressen".

I/O-registeradresblokken

We hebben andere adressen nodig, zoals:

• Poort 1 Invoer Register adres = 0x40004C00
• Poort 1 Uitgang Register adres = 0x40004C02
• Poort 1 Richting Register adres = 0x40004C04
• Poort 1 Selecteer 0 Registeradres = 0x40004C0A
• Poort 1 Selecteer 1 Registeradres = 0x40004C0C

En misschien hebben we anderen nodig.

Ok, we kennen nu het bereik van GPIO-registeradressen om de enkele rode LED te besturen.

Een zeer belangrijke opmerking: elke I/O-poort op het MSP432 LaunchPad-bord is een verzameling van verschillende (meestal 8) pinnen of lijnen, en elk kan afzonderlijk worden ingesteld als invoer of uitvoer.

Dit betekent bijvoorbeeld dat als u waarden instelt voor het "Port 1 Direction Register Address", u zich zorgen moet maken over welke bit (of bits) u op dat adres instelt of wijzigt. Hierover later meer.

Programmeervolgorde GPIO-poort

Het laatste stuk dat we nodig hebben, is een proces of algoritme om de LED te besturen.

Eenmalige initialisatie:

• Configureer P1.0 (P1SEL1REG:P1SEL0REG Register) <--- 0x00, 0x00 voor normale GPIO-functionaliteit.
• Stel de richtingsregisterbit 1 van P1DIRREG in als uitvoer of HOOG.

Lus:

Schrijf HIGH naar bit 0 van het P1OUTREG-register om de rode LED in te schakelen

• Een vertragingsfunctie oproepen
• Schrijf LOW naar bit 0 van het P1OUTREG-register om de rode LED uit te schakelen
• Een vertragingsfunctie oproepen
• Herhaal lus

Welke ingangs-/uitgangsfunctie (Configureer SEL0 en SEL1)

Veel van de pinnen op de LaunchPad hebben meerdere toepassingen. Dezelfde pin kan bijvoorbeeld een standaard digitale GPIO zijn, of hij kan ook worden gebruikt in UART- of I2C-seriële communicatie.

Om een specifieke functie voor die pin te gebruiken, moet u die functie selecteren. U moet de functie van de pin configureren.

Er is een afbeelding hierboven voor deze stap die probeert dit concept in visuele vorm uit te leggen.

De SEL0- en SEL1-adressen vormen een paarcombinatie die fungeert als een soort functie-/kenmerkselectie.

Voor onze doeleinden willen we standaard digitale GPIO voor bit 0. Dat betekent dat we bit 0 nodig hebben voor SEL0 en SEL1 om een LOW te zijn.

Poortprogrammeervolgorde (opnieuw)

1. Schrijf 0x00 naar P1 SEL 0 Register (adres 0x40004C0A). Dit stelt een LOW in voor bit 0

2. Schrijf 0x00 naar P1 SEL 1 Register (adres 0x40004C0C). Dit stelt een LOW in voor bit 0, instelling voor GPIO.

3. Schrijf 0x01 naar P1 DIR Register (adres 0x40004C04). Dit stelt een HIGH in voor bit 0, wat OUTPUT betekent.

4. Schakel de LED in door een 0x01 naar P1 OUTPUT Register te schrijven (adres 0x40004C02)

5. Voer een soort van vertraging uit (of voer een enkele stap door tijdens het debuggen)

6. Schakel de LED uit door een 0x00 naar P1 OUTPUT Register te schrijven (adres 0x40004C02)

7. Doe een soort van vertraging (of gewoon een stap door tijdens het debuggen)

8. Herhaal stap 4 tot en met 7.

De bijbehorende video voor deze stap leidt ons door het hele proces in een live demo, terwijl we elke montage-instructie één keer doornemen en doornemen en de LED-actie laten zien. Excuseer alstublieft de lengte van de video.

Stap 3: Heb je de enige fout in de video gezien?

In de video die het hele proces van programmeren en aansteken van de LED doorloopt, was er een extra stap in de hoofdlus, die naar de eenmalige initialisatie had kunnen worden verplaatst.

Bedankt dat je de tijd hebt genomen om deze Instructable door te nemen.

De volgende gaat dieper in op wat we hier zijn begonnen.