GPIO-ARM-MONTAGE - T.I. LERN-KIT FÜR ROBOTIKSYSTEME - LAB 6: 3 Schritte

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Hallo, In einer früheren Anleitung zum Erlernen der ARM-Baugruppe mit dem Texas Instruments TI-RSLK (verwendet den MSP432-Mikrocontroller), auch bekannt als Lab 3, wenn Sie die T. I. Natürlich gingen wir einige sehr grundlegende Anweisungen wie das Schreiben in ein Register und das bedingte Schleifen durch. Wir haben die Ausführung mit der Eclipse-IDE durchlaufen.

Die von uns ausgeführten Teeny-Programme haben nichts zur Interaktion mit der Außenwelt beigetragen.

Ziemlich langweilig.

Lassen Sie uns heute versuchen, dies ein wenig zu ändern, indem wir etwas über die Ein-/Ausgangs-Ports lernen, insbesondere die digitalen GPIO-Pins.

Zufälligerweise kommt dieses MSP432 auf einem Entwicklungsboard mit bereits zwei Drucktastenschaltern, einer RGB-LED und einer roten LED, die alle mit einigen GPIO-Ports verbunden sind.

Das bedeutet, dass wir, wenn wir lernen, diese Pins durch die Montage einzurichten und zu manipulieren, diese Effekte visuell sehen können.

Viel interessanter, als nur durch den Debugger zu gehen.

(Wir werden immer noch einen Schritt machen - dies wird unsere 'Verzögerungsfunktion' sein):-D

Schritt 1: Versuchen wir, in den RAM zu schreiben/aus dem RAM zu lesen

Bevor wir auf den GPIO zugreifen und ihn steuern, sollten wir einen kleinen Schritt machen.

Beginnen wir mit dem Lesen und Schreiben in eine Standardspeicheradresse. Wir wissen aus dem vorherigen Instructable (siehe Bilder dort), dass RAM bei 0x2000 0000 beginnt, also verwenden wir diese Adresse.

Wir werden Daten zwischen einem Kernregister (R0) und 0x2000 0000 verschieben.

Wir beginnen mit einer grundlegenden Dateistruktur oder dem Inhalt eines Assemblerprogramms. Bitte beziehen Sie sich auf dieses Instructable, um ein Assembly-Projekt mit dem Code Composer Studio (CCS) von TI und einigen Beispielprojekten zu erstellen.

. Daumen

.text.align 2.global main.thumbfunc main main:.asmfunc;--------------------------------- ----------------------------------------------------------; (unser Code wird hier eingefügt);----------------------------------------------------- ---------------------------------------.endasmfunc.end

Ich möchte dem oberen Abschnitt etwas Neues hinzufügen, wenn es einige Deklarationen (Anweisungen) gibt. Es wird später klarer.

ACONST.set 0x20000000; wir werden dies weiter unten verwenden (es ist eine Konstante)

; Offensichtlich bedeutet '0x', was folgt, ist ein Hex-Wert.

Der Inhalt unserer Startdatei sieht jetzt also so aus:

. Daumen

.text.align 2 ACONST.set 0x20000000; wir werden dies weiter unten verwenden (es ist eine Konstante); Offensichtlich bedeutet '0x', was folgt, ist ein Hex-Wert..global main.thumbfunc main main:.asmfunc;----------------------------------------- ------------------------------------------; (unser Code wird hier eingefügt);----------------------------------------------------- ---------------------------------------.endasmfunc.end

Nun, da wir das Obige haben, fügen wir Code zwischen den gestrichelten Linien hinzu.

Wir beginnen mit dem Schreiben in einen RAM-Speicherort. Zuerst erstellen wir das Datenmuster, einen Wert, den wir in den RAM schreiben. Wir verwenden ein Kernregister, um diesen Wert oder diese Daten zu ermitteln.

Hinweis: Denken Sie daran, dass im Code jede Zeile mit einem Semikolon (';') bedeutet, dass alles ein Kommentar nach diesem Semikolon ist.

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

; SCHREIBEN;------------------------------------------------ ---------------------------------------------------------- MOV R0, #0x55; Das Kernregister R0 enthält die Daten, die wir in den RAM-Speicherort schreiben möchten.; Offensichtlich bedeutet '0x', was folgt, ist ein Hex-Wert.

Als nächstes werfen wir einen Blick auf Aussagen, die NICHT funktionieren.

; MOV MOV kann nicht verwendet werden, um Daten in einen RAM-Speicherort zu schreiben.

; MOV ist nur für sofortige Daten in Register,; oder von einem Register zum anderen; d.h. MOV R1, R0.; STR muss STR verwenden.; STR R0, =AKONST; Ungültiger Ausdruck im Ausdruck (das '='); STR R0, 0x20000000; Unzulässiger Adressierungsmodus für Store-Befehl; STR R0, AKONST; Unzulässiger Adressierungsmodus für Speicherbefehle

Ohne zu viel zu erklären, haben wir versucht, das oben genannte 'ACONST' zu verwenden. Im Wesentlichen ist es ein Stellvertreter oder eine Konstante, anstatt einen Literalwert wie 0x20000000 zu verwenden.

Wir waren nicht in der Lage, mit den oben genannten Methoden in den RAM-Speicherort zu schreiben. Versuchen wir etwas anderes.

; Es scheint, dass wir ein anderes Register verwenden müssen, das den RAM-Speicherort enthält

; um an diesem RAM-Speicherort zu speichern MOV R1, #0x20000000; setze den RAM-Speicherort (nicht den Inhalt, sondern den Speicherort) in R1.; Offensichtlich bedeutet '0x', was folgt, ist ein Hex-Wert. STR R0, [R1]; schreibe, was in R0 (0x55) ist, in RAM (0x20000000) mit R1.; wir verwenden ein anderes Register (R1), das eine RAM-Positionsadresse hat; um in diesen RAM-Speicherort zu schreiben.

Eine andere Möglichkeit, das oben Genannte zu tun, jedoch 'ACONST' anstelle des literalen Adresswerts zu verwenden:

; Machen wir das obige noch einmal, aber verwenden wir ein Symbol anstelle eines wörtlichen RAM-Speicherortwerts.

; wir wollen 'ACONST' als Ersatz für 0x20000000 verwenden.; wir müssen immer noch das '#' ausführen, um einen unmittelbaren Wert anzuzeigen,; Also (siehe oben) mussten wir die '.set'-Direktive verwenden.; Um dies zu beweisen, ändern wir das Datenmuster in R0. MOV R0, #0xAA; ok, wir sind bereit, mit dem Symbol anstelle des literalen Adresswerts MOV R1, #ACONST STR R0, [R1] in den RAM zu schreiben

Das Video geht etwas mehr ins Detail und geht schrittweise durch das Lesen aus dem Speicherort.

Sie können auch die angehängte.asm-Quelldatei anzeigen.

Schritt 2: Einige grundlegende Portinformationen

Da wir nun eine gute Idee haben, wie man in einen RAM-Speicherort schreibt / liest, wird uns dies helfen, besser zu verstehen, wie man den GPIO-Pin steuert und verwendet

Wie interagieren wir also mit den GPIO-Pins? Aus unserem vorherigen Blick auf diesen Mikrocontroller und seine ARM-Anweisungen wissen wir, wie man mit seinen internen Registern umgeht, und wir wissen, wie man mit Speicheradressen (RAM) interagiert. Aber GPIO-Pins?

Es kommt vor, dass diese Pins speicherabgebildet sind, sodass wir sie ähnlich wie Speicheradressen behandeln können.

Das bedeutet, dass wir wissen müssen, was diese Adressen sind.

Unten sind die Port-Startadressen. Beim MSP432 ist ein "Port" übrigens eine Sammlung von Pins und nicht nur ein Pin. Wenn Sie mit dem Raspberry Pi vertraut sind, ist das meiner Meinung nach anders als die Situation hier.

Die blauen Kreise im obigen Bild zeigen die Beschriftung der Platine für die beiden Schalter und LEDs. Die blauen Linien zeigen auf die eigentlichen LEDs. Wir müssen die Header-Jumper nicht berühren.

Ich habe die Ports, mit denen wir uns beschäftigen, unten fett gedruckt.

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

Wir sind noch nicht fertig. Wir brauchen mehr Informationen.

Um einen Port zu steuern, benötigen wir mehrere Adressen. Deshalb sehen wir in der obigen Liste "gerade Adressen" oder "ungerade Adressen".

E/A-Register-Adressblöcke

Wir benötigen weitere Adressen, wie zum Beispiel:

• Port 1 Eingangsregisteradresse = 0x40004C00
• Port 1 Ausgangsregisteradresse = 0x40004C02
• Port 1 Richtung Registeradresse = 0x40004C04
• Port 1 Wählen Sie 0 Registeradresse = 0x40004C0A
• Port 1 Wählen Sie 1 Registeradresse = 0x40004C0C

Und wir brauchen vielleicht andere.

Ok, wir kennen jetzt den Bereich der GPIO-Registeradressen, um die einzelne rote LED zu steuern.

Ein ganz wichtiger Hinweis: Jeder I/O-Port auf dem MSP432 LaunchPad-Board ist eine Sammlung von mehreren (normalerweise 8) Pins oder Leitungen, und jeder kann einzeln als Eingang oder Ausgang eingestellt werden.

Das bedeutet zum Beispiel, dass Sie beim Einstellen von Werten für die "Port 1 Direction Register Address" darauf achten müssen, welches Bit (oder welche Bits) Sie an dieser Adresse einstellen oder ändern. Dazu später mehr.

GPIO-Port-Programmiersequenz

Das letzte Stück, das wir brauchen, ist ein Prozess oder Algorithmus, der verwendet wird, um die LED zu steuern.

Einmalige Initialisierung:

• Konfigurieren Sie P1.0 (P1SEL1REG:P1SEL0REG-Register) <--- 0x00, 0x00 für normale GPIO-Funktionalität.
• Setzen Sie das Richtungsregister Bit 1 von P1DIRREG als Ausgang oder HIGH.

Schleife:

Schreiben Sie HIGH in Bit 0 des P1OUTREG-Registers, um die rote LED einzuschalten

• Rufen Sie eine Verzögerungsfunktion auf
• Schreiben Sie LOW in Bit 0 des P1OUTREG-Registers, um die rote LED auszuschalten
• Rufen Sie eine Verzögerungsfunktion auf
• Schleife wiederholen

Welche Eingangs-/Ausgangsfunktion (Konfiguration von SEL0 und SEL1)

Viele der Pins auf dem LaunchPad haben mehrere Verwendungszwecke. Derselbe Pin könnte beispielsweise ein digitaler Standard-GPIO sein, oder er kann auch in der UART- oder I2C-Seriellkommunikation verwendet werden.

Um eine bestimmte Funktion für diesen Pin zu verwenden, müssen Sie diese Funktion auswählen. Sie müssen die Funktion des Pins konfigurieren.

Oben befindet sich ein Bild für diesen Schritt, das versucht, dieses Konzept in visueller Form zu erklären.

Die Adressen SEL0 und SEL1 bilden eine Paarkombination, die als eine Art Funktions-/Merkmalsauswahl dient.

Für unsere Zwecke wollen wir einen digitalen Standard-GPIO für Bit 0. Das bedeutet, dass wir Bit 0 benötigen, damit SEL0 und SEL1 ein LOW sind.

Port-Programmiersequenz (wieder)

1. Schreiben Sie 0x00 in das Register P1 SEL 0 (Adresse 0x40004C0A). Dies setzt ein LOW für Bit 0

2. Schreiben Sie 0x00 in das Register P1 SEL 1 (Adresse 0x40004C0C). Dies setzt ein LOW für Bit 0, eine Einstellung für GPIO.

3. Schreiben Sie 0x01 in das P1-DIR-Register (Adresse 0x40004C04). Dadurch wird ein HIGH für Bit 0 gesetzt, was OUTPUT bedeutet.

4. Schalten Sie die LED ein, indem Sie ein 0x01 in das P1 OUTPUT Register schreiben (Adresse 0x40004C02)

5. Führen Sie eine Art Verzögerung durch (oder führen Sie beim Debuggen nur einen einzelnen Schritt durch)

6. Schalten Sie die LED aus, indem Sie 0x00 in das P1 OUTPUT Register schreiben (Adresse 0x40004C02)

7. Führen Sie eine Art Verzögerung durch (oder führen Sie beim Debuggen nur einen einzelnen Schritt durch)

8. Wiederholen Sie die Schritte 4 bis 7.

Das dazugehörige Video zu diesem Schritt führt uns in einer Live-Demo durch den gesamten Prozess, indem wir jede Montageanleitung einzeln durchgehen und besprechen und die LED-Aktion zeigen. Bitte entschuldigen Sie die Länge des Videos.

Schritt 3: Haben Sie den einen Fehler im Video entdeckt?

In dem Video, das den gesamten Prozess der Programmierung und Beleuchtung der LED durchläuft, gab es einen zusätzlichen Schritt in der Hauptschleife, der bis zur einmaligen Initialisierung hätte verschoben werden können.

Vielen Dank, dass Sie sich die Zeit genommen haben, dieses Instructable durchzugehen.

Das nächste erweitert das, was wir hier begonnen haben.