Deel 3: GPIO: ARM-assemblage: lijnvolger: TI-RSLK: 6 stappen

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

Hallo. Dit is de volgende aflevering waarin we ARM-assemblage blijven gebruiken (in plaats van een taal op een hoger niveau). De inspiratie voor deze Instructable is Lab 6 van de Texas Instruments Robotics System Learning Kit, of TI-RSLK.

We gebruiken de microcontroller uit de kit, het MSP432 LaunchPad-ontwikkelbord, maar misschien vind je iets nuttigs om uit deze Instructable te halen, zelfs als je de LaunchPad niet gebruikt of de T. I. leerplan.

We zijn begonnen met een Instructable die ARM-assemblage, de ontwikkelomgeving en het maken van een project introduceert.

De volgende Instructable on ARM Assembly introduceerde hoe te communiceren met input/output (GPIO).

Daarna breidden we onze kennis uit en introduceerden functies, het aansturen van leds en schakelaars.

Nu met deze Instructable kunnen we wat we hebben geleerd gebruiken om iets leukers en nuttiger te doen: een lijn detecteren.

Dit kan ons later helpen bij het bouwen van een lijnvolgerrobot.

In het curriculum wordt het grootste deel van de programmering gedaan in C of C++, maar het is handig om vertrouwd te raken met assemblage, voordat we beginnen, afhankelijk van hogere talen en bibliotheken.

Stap 1: De hardware

Ik wil de hardware niet in detail herhalen, omdat er al bronnen zijn, maar we zullen waar nodig uitleg toevoegen.

Voor deze Instructable gebruiken we de Reflectance Sensor Arrray van Pololu, omdat deze deel uitmaakt van de TI-RSLK (de robotkit). Het is degene die wordt gebruikt in de cursus en in Lab 6 van het curriculum.

Als je dat niet hebt, kun je elke IR-detector (of een reeks daarvan) gebruiken die een digitaal signaal, HOOG of LAAG, uitvoert voor aan- en afwezigheid.

De array-sensor is het beste omdat deze kan helpen detecteren of we ons in het midden van de lijn bevinden of aan de zijkant. Bovendien, zoals we later zullen zien, kan het ons helpen de hoek van de robot ten opzichte van de lijn te detecteren.

De reflectie-array heeft detectoren die heel dicht bij elkaar staan. Dat betekent dat we meerdere detectiesignalen moeten krijgen, uiteraard afhankelijk van de dikte van de lijn.

Als dat zo is, dan moet de robot, als hij niet direct in lijn is met de lijn, een output retourneren dat de lijn breder is dan hij zou moeten zijn (omdat we onder een hoek staan).

Voor een betere uitleg van het bovenstaande, bekijk het Lab 6 document.

Voor hulp bij het bedraden / aansluiten van de sensor op het MSP432 LaunchPad-ontwikkelbord, volgen hier enkele handige instructies.

Ik heb ook dezelfde (vergelijkbare?) pdf-instructies aan deze stap toegevoegd.

Als je de Pololu-documenten aandachtig leest, leggen ze de reden uit voor de "3.3V bypass", die je wilt overbruggen als je 3.3V gebruikt in plaats van 5V.

Omdat we de robot nog niet aan het bouwen zijn, maar in plaats daarvan alleen maar leren over ARM-assemblage en ook hoe we kunnen communiceren met onderdelen (subsystemen) van de robot, hoeven we de bovenstaande instructies niet naar de letter te volgen.

Voor nu komt het aansluiten van de lijnsensorarray gewoon neer op het volgende:

• sluit 3.3V en GND van de MSP432-kaart aan op de sensorarray.
• sluit een poortpin (ik stel P5.3 voor) van de MSP432 aan op de LED-inschakelpin op de lijnsensorarray. Die pin op de sensor zit tussen 3.3V en GND.
• sluit alle acht pinnen/bits van een enkele poort (ik raad P7.0 tot en met P7.7 aan) aan op de acht pinnen van de sensorarray met het label "1" tot en met "8". Dit zijn de lijnen die HOOG of LAAG zullen worden, afhankelijk van wat ze voelen.

Zoals je kunt zien in de afbeeldingen van deze stap, en in de video, heb ik de sensor niet aan het robotchassis bevestigd, omdat ik gemak van programmeren, debuggen, testen en leren wilde.

Dus met alles aangesloten, zijn we klaar om de software in te gaan.

Stap 2: Regel volgen

De reflectie-array-sensor is best handig omdat hij op ten minste twee manieren kan helpen.

• Bepaal of de robot op de lijn is gecentreerd of naar één kant afdrijft.
• Staat de robot uitgelijnd in de richting van de lijn, of staat hij schuin.

Elk van de detectoren van de array levert in wezen één bit informatie, ofwel HOOG of LAAG.

Het idee is om al die bits te combineren in een enkel nummer of enkel bitpatroon, en dat patroon te gebruiken om beslissingen te nemen (om correct te bewegen).

Stap 3: Voordat we echt aan de slag kunnen…

.. we moeten iets nieuws leren over het programmeren van ARM-assemblages. En dan bedoel ik niet zomaar een andere instructie. Die zijn meestal klein.

Tot nu toe hebben we de "stack" niet gebruikt in onze programma's.

We hebben vertrouwd op het gebruik van de meeste core cpu-registers wereldwijd in verschillende subroutines.

Het enige wat we deden was het LR (link register) adres opslaan en herstellen voor één functie - degene die verschillende andere functies aanriep. (Ik gebruik hier door elkaar "functie" en "subroutine").

Wat we hebben gedaan is niet goed. Wat als we andere functies willen nesten? Wat als we meer dan één niveau van nesten hebben?

In eerdere voorbeelden hebben we ervoor gekozen om register R6 te gebruiken als opslag voor het LR- of retouradres. Maar als we verder/dieper willen nesten, kunnen we de waarde van R6 niet blijven veranderen. We zouden nog een ander register moeten kiezen. En een ander. En dan wordt het lastig om bij te houden welk core-cpu-register welke LR bevat om naar welke functie te herstellen.

Dus nu kijken we naar de "stapel".

Stap 4: De stapel

Hier is wat leesmateriaal waarin de stapel wordt uitgelegd.

Ik ben een grotere voorstander van een aantal ideeën:

• alleen zoveel theorie als nodig, ga snel voor de praktijk
• leer waar nodig, focus op het daadwerkelijk doen van iets en niet alleen op doelloze oefeningen of voorbeelden.

Er is veel ARM- en MSP432-documentatie online die over de stapel praat, dus ik ga dat niet allemaal herhalen. Ik ga ook het gebruik van de stapel hier tot een absoluut minimum beperken - het retouradres opslaan (het Link Register).

In wezen hebben we alleen instructies nodig:

PUSH {registerlijst}

POP{registerlijst}

Of, in ons geval, specifiek:

DRUK {LR}

POP {LR}

Een assembly-functie/subroutine zou er dus als volgt uitzien:

funcLabel:.asmfunc

PUSH{LR};dit zou waarschijnlijk een van de eerste instructies bij binnenkomst moeten zijn.; doe hier meer code..; bla… bla… bla…; ok, we zijn klaar met functie, klaar om terug te keren naar het oproepen van functie POP{LR}; dit herstelt het juiste retouradres terug naar bellen; functie. BX LR; return.endasmfunc

De video doorloopt een live voorbeeld van verschillende geneste functies.

Stap 5: De software

Het bijgevoegde bestand met het label "MSP432_Chapter…" bevat veel goede informatie over de poorten van de MSP432 en uit dat document halen we de volgende poorten, registers, adressen, enz. Het is echter een beetje gedateerd. Ik heb echter de gedetailleerde adressen voor poort 5 en hoger niet gezien. (alleen "alternatieve functies"). Maar het is nog steeds nuttig.

We gaan twee poorten gebruiken. P5, P7, P1 en P2.

P5.3 (een enkele bit) output zal zijn om de IR LED-activering op de sensor te regelen. We gebruiken P5.3 omdat het een blootliggende pin is op dezelfde header als de andere MSP432-verbindingen die naar de sensorarray gaan.

P7.0 tot en met P7.7 zijn de acht ingangen die de gegevens van de sensor verzamelen; wat het "ziet".

P1.0 is de enkele rode LED en we zouden die kunnen gebruiken om ons enkele indicaties van de gegevens te geven.

P2.0, P2.1, P2.2 is de RGB-led en die kunnen we ook gebruiken, met zijn verschillende kleurmogelijkheden, om ons een indicatie te geven van de sensorgegevens.

Als je de vorige Instructables met betrekking tot dit alles hebt doorlopen, weet je al hoe je het programma moet instellen.

Heb gewoon declaratiesectie voor de poorten en bits, enz.

Je hebt een "hoofd" sectie.

Er zou een lus moeten zijn, waar we continu de gegevens van P7 lezen, een beslissing nemen over die gegevens en de twee LED's dienovereenkomstig oplichten.

Hier zijn weer de Port Register-adressen:

• 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)

Wat vetgedrukt is, is wat we zullen gebruiken voor deze Instructable.

Programmastappen om IR-detectoren te lezen

Het volgende is psuedo-code voor het schrijven van het programma in C, maar het is nog steeds nuttig, en we zullen het vrij nauwkeurig volgen in de assembly-versie van het programma.

hoofdprogramma0) Initialiseer //ports while(1) { 1) Zet P5.3 hoog (zet IR LED aan) 2) Maak van P7.0 een uitgang, en zet deze hoog (laad de condensator) 3) Wacht 10 ons, Clock_Delay1us (10); 4) Maak van P7.0 een ingang 5) Voer deze lus 10.000 keer uit a) Lees P7.0 (zet de spanning op P7.0 om in binair) b) Voer binair uit naar P1.0 (hiermee kunt u binair in realtime zien) 6) Stel P5.3 laag in (schakel IR-LED uit, bespaar energie) 7) Wacht 10 ms, Clock_Delay1ms (10); } // herhaal (terug naar while())

Stap 6: Laten we de code verbeteren

Het doel of het gebruik van de Pololu IR LED-array is om een lijn te detecteren en te weten of de robot (toekomstige) direct in het midden van de lijn staat of aan een kant. Aangezien de lijn een bepaalde dikte heeft en de sensorarray direct loodrecht op de lijn staat, zal het N aantal sensoren een andere waarde hebben dan de rest, terwijl als de IR LED-array onder een bepaalde hoek staat (niet loodrecht), dan N+1 of N+2 IR LED/detectorparen zouden nu een andere uitlezing moeten geven.

Dus, afhankelijk van hoeveel sensoren de aanwezigheid van de lijn aangeven, moeten we weten of we gecentreerd zijn en of we onder een hoek staan of niet.

Laten we voor dit laatste experiment eens kijken of we de rode LED en de RGB LED kunnen krijgen om ons meer informatie te geven over wat de sensorarray ons vertelt.

De video gaat in op alle details. De definitieve code is ook bijgevoegd.

Dit voltooit de serie ARM-assemblage met betrekking tot GPIO. We hopen op een later tijdstip terug te komen met meer ARM-assemblage.

Bedankt.