Del 3: GPIO: ARM Montering: Linjeföljare: TI-RSLK: 6 steg

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

Hej. Det här är nästa del där vi fortsätter att använda ARM-montering (istället för ett språk på högre nivå). Inspirationen till denna Instructable är Lab 6 i Texas Instruments Robotics System Learning Kit, eller TI-RSLK.

Vi kommer att använda mikrokontrollern från satsen, MSP432 LaunchPad -utvecklingskortet, men kanske hittar du något användbart att extrahera från denna instruerbara även om du inte använder LaunchPad eller följer T. I. läroplan.

Vi började med en instruerbar introduktion av ARM Assembly, utvecklingsmiljön och hur man gör ett projekt.

Nästa Instructable on ARM Assembly introducerade hur man interagerar med input/output (GPIO).

Sedan utökade vi vår kunskap och introducerade funktioner, styrning av lysdioder och switchar.

Nu med denna instruerbara kan vi använda det vi har lärt oss för att göra något roligare och mer användbart: upptäcka en linje.

Detta kan hjälpa oss senare när vi bygger en robot för linjeföljare.

I läroplanen sker det mesta av programmeringen i C eller C ++, men det är bra att bekanta sig med montering innan vi börjar beroende på högre språk och bibliotek.

Steg 1: Hårdvaran

Jag vill inte göra om hårdvaran i detalj, eftersom det redan finns källor, men vi lägger till förklaringar där det behövs.

För denna instruktör kommer vi att använda reflektionssensormatrisen från Pololu, eftersom den kommer som en del av TI-RSLK (robotsatsen). Det är den som används i kursen och i Lab 6 i läroplanen.

Om du inte har det kan du använda valfri IR -detektor (eller serie av dem) som matar ut en digital signal, HIGH eller LOW, för närvaro och frånvaro.

Array -sensorn är bäst eftersom den kan hjälpa till att upptäcka om vi befinner oss mitt på linjen eller på ena sidan. Plus, som vi kommer att se senare, kan det hjälpa oss att upptäcka robotens vinkel med avseende på linjen.

Reflektansmatrisen har detektorer mycket nära bredvid varandra. Det betyder att vi borde få flera detekteringssignaler, beroende på naturligtvis tjockleken på linjen.

Om så är fallet, då om roboten inte är direkt i linje med linjen, bör den returnera en utgång som linjen är bredare än den borde vara (eftersom vi är i en vinkel).

För en bättre förklaring av ovanstående, ta en titt på Lab 6 -dokumentet.

För hjälp med kabeldragning / anslutning av sensorn till utvecklingsbordet MSP432 LaunchPad, här är några användbara instruktioner.

Jag har också lagt till samma (liknande?) Pdf -instruktioner till detta steg.

Om du noggrant läser Pololu -dokumenten förklarar de orsaken till "3.3V bypass", att du vill hoppa om du använder 3.3V istället för 5V.

Eftersom vi ännu inte bygger roboten, utan istället bara lär oss om ARM -montering och hur vi interagerar med bitar (undersystem) av roboten, behöver vi inte följa instruktionerna ovan till punkt och pricka.

För tillfället kokar/reducerar anslutningen av linjesensormatrisen till följande:

• anslut 3.3V och GND från MSP432 -kortet till sensormatrisen.
• anslut en portstift (jag föreslår P5.3) från MSP432 till LED -aktiveringsstiftet på linjesensormatrisen. Den stiftet på sensorn är mellan 3,3V och GND.
• anslut alla åtta stift/bitar i en enda port (jag föreslår P7.0 till P7.7) till de åtta stiften i sensormatrisen märkt "1" till "8". Detta är de linjer som kommer att gå HÖG eller LÅG beroende på vad de känner.

Som du kan se på bilderna från det här steget och i videon fästade jag inte sensorn på robotchassit, eftersom jag ville ha enkel programmering, felsökning, testning, inlärning.

Så med allt anslutet är vi redo att komma in i programvaran.

Steg 2: Linjeföljande

Reflektansmatrisensorn är ganska fin eftersom den kan hjälpa till på minst två sätt.

• Bestäm är roboten centrerad på linjen eller driver iväg åt ena sidan.
• Är roboten inriktad i linjens riktning, eller är den i en vinkel.

Var och en av detektorerna i matrisen tillhandahåller i huvudsak en bit information, antingen HIGH eller LOW.

Tanken är att kombinera alla dessa bitar till ett enda tal eller ett enda bitmönster och använda det mönstret för att fatta beslut (för att flytta korrekt).

Steg 3: Innan vi verkligen kan komma igång …

.. vi måste lära oss något nytt om ARM -monteringsprogrammering. Och jag menar inte bara en annan instruktion. De tenderar att vara mindre.

Hittills har vi inte använt "stacken" i våra program.

Vi har förlitat oss på att använda de flesta av kärn -cpu -registren globalt i olika delprogram.

Det enda vi gjorde var att spara och återställa LR (länkregister) -adressen för en funktion - den som kallade flera andra funktioner. (Jag använder "funktion" och "subrutin" omväxlande här).

Det vi har gjort är inte bra. Vad händer om vi vill bära andra funktioner? Vad händer om vi har mer än en häckningsnivå?

I tidigare exempel valde vi att använda register R6 som lagring för LR eller returadress. Men om vi vill göra ytterligare/djupare häckningar kan vi inte fortsätta att ändra värdet på R6. Vi skulle behöva välja ännu ett register. Och en annan. Och då blir det betungande att hålla reda på vilket kärn -cpu -register som har vilken LR som ska återställas till vilken funktion.

Så nu tar vi en titt på "stacken".

Steg 4: Stacken

Här är lite läsmaterial som förklarar stacken.

Jag är en större förespråkare för ett par idéer:

• bara så mycket teori som krävs, gå till det praktiska snabbt
• lära dig efter behov, fokusera på att faktiskt göra något och inte bara meningslösa övningar eller exempel.

Det finns gott om ARM- och MSP432 -dokumentation online som talar om stacken, så jag tänker inte repetera allt det där. Jag kommer också att hålla användningen av stapeln här till ett minimum - spara returadressen (länkregistret).

I huvudsak behöver vi bara instruktioner:

PUSH {registerlista}

POP {registerlista}

Eller, i vårt fall, specifikt:

PUSH {LR}

POP {LR}

Så en monteringsfunktion/subrutin skulle se ut så här:

funcLabel:.asmfunc

PUSH {LR}; detta borde förmodligen vara en av de första instruktionerna för inresa.; gör mer kod här..; bla bla bla…; ok, vi är klara med funktionen, redo att återgå till samtalsfunktionen POP {LR}; detta återställer rätt returadress till att ringa; fungera. BX LR; returnera.endasmfunc

Videon går igenom ett levande exempel på flera kapslade funktioner.

Steg 5: Programvaran

Den bifogade filen märkt "MSP432_Chapter …" har mycket bra information om MSP432 -portarna, och från det dokumentet får vi följande portar, register, adresser etc. Det är dock lite daterat. Jag såg dock inte de detaljerade adresserna som anges för Port 5 och senare. (endast "alternativa funktioner"). Men det är fortfarande användbart.

Vi kommer att använda två portar. P5, P7, P1 och P2.

P5.3 (en enda bit) -utgång kommer att styra IR-LED-aktiveringen på sensorn. Vi använder P5.3 eftersom det är en exponerad stift på samma rubrik som de andra MSP432 -anslutningarna som går till sensormatrisen.

P7.0 till P7.7 är de åtta ingångarna som samlar in data från sensorn; vad den "ser".

P1.0 är den enda röda lysdioden och vi kan använda den för att ge oss några indikationer på data.

P2.0, P2.1, P2.2 är RGB -lysdioden och vi kan också använda den, med dess olika färgmöjligheter, för att ge oss indikation på sensordata.

Om du har gått igenom de tidigare instruktionerna relaterade till allt detta, vet du redan hur du konfigurerar programmet.

Har bara deklarationssektion för portarna och bitarna, etc.

Du har ett "huvud" -avsnitt.

Det bör finnas en loop, där vi kontinuerligt läser data från P7, fattar beslut om dessa data och tänder de två lysdioderna i enlighet därmed.

Här är igen portregisteradresserna:

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

Vad är fetstil är vad vi kommer att använda för denna instruerbara.

Programsteg för att läsa IR -detektorer

Följande är psuedo-kod för att skriva programmet i C, men det är fortfarande användbart, och vi kommer att följa det ganska noga i monteringsversionen av programmet.

huvudprogram0) Initiera // portar medan (1) {1) Ställ in P5.3 högt (sätt på IR -LED) 2) Gör P7.0 till en utgång och ställ in det högt (laddar kondensatorn) 3) Vänta 10 oss, Clock_Delay1us (10); 4) Gör P7.0 till en ingång 5) Kör den här slingan 10 000 gånger a) Läs P7.0 (omvandlar spänning på P7.0 till binär) b) Utgång binär till P1.0 (låter dig se binär i realtid) 6) Ställ in P5.3 lågt (stäng av IR -LED, spara ström) 7) Vänta 10 ms, Clock_Delay1ms (10); } // upprepa (tillbaka till while ())

Steg 6: Låt oss förbättra koden

Syftet eller användningen av Pololu IR LED -matrisen är att upptäcka en linje och att veta om roboten (framtiden) är direkt centrerad på linjen eller bort till ena sidan. Eftersom linjen har en viss tjocklek, om sensormatrisen är direkt vinkelrät mot linjen, kommer N -antalet sensorer att ha en annan avläsning än resten, medan om IR LED -arrayen är i någon vinkel (inte vinkelrätt), då N+1 eller N+2 IR LED/detektorpar bör nu ge en annan avläsning.

Beroende på hur många sensorer som indikerar närvaron av linjen bör vi alltså veta om vi är centrerade och om vi är vinklade eller inte.

För det här sista experimentet, låt oss bara se om vi kan få den röda lysdioden och RGB -lysdioden för att ge oss mer information om vad sensormatrisen berättar för oss.

Videon går in på alla detaljer. Den slutliga koden bifogas också.

Detta kompletterar serien ARM -montering relaterad till GPIO. Vi hoppas kunna återkomma med mer ARM Assembly vid ett senare tillfälle.

Tack.