ENSEMBLE DE BRAS GPIO - T.I. KIT D'APPRENTISSAGE DU SYSTÈME ROBOTIQUE - LAB 6 : 3 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Bonjour, Dans un précédent Instructable sur l'apprentissage de l'assemblage ARM à l'aide du Texas Instruments TI-RSLK (utilise le microcontrôleur MSP432), alias Lab 3 si vous faites le T. I. Bien sûr, nous avons passé en revue quelques instructions très basiques telles que l'écriture dans un registre et le bouclage conditionnel. Nous avons parcouru l'exécution à l'aide de l'IDE Eclipse.

Les programmes minuscules que nous avons exécutés n'ont rien fait pour interagir avec le monde extérieur.

Un peu ennuyeux.

Essayons de changer un peu cela aujourd'hui en apprenant un peu sur les ports d'entrée/sortie, en particulier les broches GPIO numériques.

Il se trouve que ce MSP432 est livré sur une carte de développement qui possède déjà deux interrupteurs à bouton-poussoir, une LED RVB et une LED rouge, le tout relié à certains ports GPIO.

Cela signifie que lorsque nous apprenons à configurer et à manipuler ces broches via l'assemblage, nous pouvons voir visuellement ces effets.

Beaucoup plus intéressant que de simplement parcourir le débogueur.

(Nous allons toujours pas à pas - ce sera notre fonction 'retard'):-D

Étape 1: Essayons d'écrire sur/de lire à partir de la RAM

Avant de passer à l'accès et au contrôle du GPIO, nous devons faire un petit pas.

Commençons par lire et écrire sur une adresse mémoire standard. Nous savons d'après le précédent Instructable (voir les images là-bas) que la RAM commence à 0x2000 0000, alors utilisons cette adresse.

Nous allons déplacer des données entre un registre central (R0) et 0x2000 0000.

Nous commençons par une structure de fichier de base ou le contenu d'un programme d'assemblage. Veuillez vous référer à ce Instructable pour créer un projet d'assemblage à l'aide de Code Composer Studio (CCS) de TI et quelques exemples de projets.

.pouce

.text.align 2.global main.thumbfunc main main:.asmfunc;------------------------------------------------ ------------------------------------------------; (notre code ira ici);------------------------------------------ ----------------------------------------.endasmfunc.end

Je veux ajouter quelque chose de nouveau à la section supérieure, s'il y a des déclarations (directives). Cela deviendra plus clair plus tard.

ACONST.set 0x20000000; nous l'utiliserons plus bas (c'est une constante)

; évidemment, '0x' dénote ce qui suit est une valeur hexadécimale.

Ainsi, le contenu de notre fichier de départ ressemble maintenant à ceci:

.pouce

.text.align 2 ACONST.set 0x20000000; nous l'utiliserons plus bas (c'est une constante); évidemment, '0x' dénote ce qui suit est une valeur hexadécimale..global main.thumbfunc main principale:.asmfunc;--------------------------------------- -------------------------------------------; (notre code ira ici);------------------------------------------ ----------------------------------------.endasmfunc.end

Maintenant que nous avons ce qui précède, ajoutons du code entre les lignes pointillées.

Nous commençons par écrire dans un emplacement RAM. Nous allons d'abord établir le modèle de données, une valeur, que nous allons écrire dans la RAM. Nous utilisons un registre central pour établir cette valeur ou ces données.

Remarque: rappelez-vous que dans le code, toute ligne comportant un point-virgule (';') signifie que tout est un commentaire après ce point-virgule.

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

; L'ÉCRITURE;------------------------------------------------ ------------------------------------------------------------- MOV R0, #0x55; le registre central R0 contiendra les données que nous voulons écrire dans l'emplacement de la RAM.; évidemment, '0x' dénote ce qui suit est une valeur hexadécimale.

Ensuite, jetons un coup d'œil aux déclarations qui NE fonctionnent PAS.

; MOV MOV n'est pas utilisable pour écrire des données dans un emplacement RAM.

; MOV est uniquement pour les données immédiates dans le registre,; ou d'un registre à un autre; c'est-à-dire MOV R1, R0.; STR doit utiliser STR.; STR R0, =ACONST; Mauvais terme dans l'expression (le '='); STR R0, 0x20000000; Mode d'adressage illégal pour l'instruction de stockage; STR R0, ACONST; Mode d'adressage illégal pour l'instruction de stockage

Sans trop expliquer, nous avons essayé d'utiliser ce « ACONST » ci-dessus. Essentiellement, il s'agit d'un substitut ou d'une constante au lieu d'utiliser une valeur littérale telle que 0x20000000.

Nous n'avons pas pu écrire pour écrire sur l'emplacement de la RAM à l'aide de ce qui précède. Essayons autre chose.

; semble que nous devons utiliser un autre registre contenant l'emplacement de la RAM dans

; afin de stocker dans cet emplacement RAM MOV R1, #0x20000000; définissez l'emplacement de la RAM (pas son contenu, mais son emplacement) dans R1.; évidemment, '0x' dénote ce qui suit est une valeur hexadécimale. STR R0, [R1]; écrivez ce qu'il y a dans R0 (0x55) dans la RAM (0x20000000) en utilisant R1.; on utilise un autre registre (R1) qui a l'adresse d'emplacement RAM; afin d'écrire dans cet emplacement RAM.

Une autre façon de procéder ci-dessus, mais en utilisant 'ACONST' au lieu de la valeur d'adresse littérale:

; faisons à nouveau ce qui précède, mais utilisons un symbole au lieu d'une valeur d'emplacement RAM littérale.

; nous voulons utiliser 'ACONST' comme remplaçant pour 0x20000000.; nous devons encore faire le '#' pour signifier une valeur immédiate,; donc (voir en haut), nous avons dû utiliser la directive '.set'.; pour le prouver, modifions le modèle de données dans R0. MOV R0, #0xAA; ok, nous sommes prêts à écrire dans la RAM en utilisant le symbole au lieu de la valeur d'adresse littérale MOV R1, #ACONST STR R0, [R1]

La vidéo va plus en détail, ainsi que la lecture à partir de l'emplacement mémoire.

Vous pouvez également afficher le fichier source.asm joint.

Étape 2: Quelques informations de base sur le port

Maintenant que nous avons une bonne idée de la façon d'écrire/lire à partir d'un emplacement RAM, cela nous aidera à mieux comprendre comment contrôler et utiliser la broche GPIO

Alors, comment interagissons-nous avec les broches GPIO ? De notre regard précédent sur ce microcontrôleur et ses instructions ARM, nous savons comment gérer ses registres internes, et nous savons comment interagir avec les adresses mémoire (RAM). Mais les broches GPIO ?

Il se trouve que ces broches sont mappées en mémoire, nous pouvons donc les traiter de la même manière que les adresses mémoire.

Cela signifie que nous devons savoir quelles sont ces adresses.

Vous trouverez ci-dessous les adresses de départ des ports. Soit dit en passant, pour le MSP432, un "port" est un ensemble de broches, et pas une seule broche. Si vous connaissez le Raspberry Pi, je pense que c'est différent de la situation ici.

Les cercles bleus dans l'image ci-dessus montrent l'écriture sur la carte pour les deux commutateurs et LED. Les lignes bleues pointent vers les LED réelles. Nous n'aurons pas à toucher aux cavaliers d'en-tête.

J'ai fait les ports qui nous intéressent en gras ci-dessous.

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

Nous n'avons pas encore fini. Nous avons besoin de plus d'informations.

Afin de contrôler un port, nous avons besoin de plusieurs adresses. C'est pourquoi dans la liste ci-dessus, on voit des "adresses paires" ou des "adresses impaires".

Blocs d'adresse de registre d'E/S

Nous aurons besoin d'autres adresses, telles que:

• Adresse du registre d'entrée du port 1 = 0x40004C00
• Adresse du registre de sortie du port 1 = 0x40004C02
• Adresse du registre de direction du port 1 = 0x40004C04
• Port 1 Sélectionnez 0 Adresse de registre = 0x40004C0A
• Port 1 Sélectionnez 1 Adresse de registre = 0x40004C0C

Et nous pouvons avoir besoin d'autres.

Ok, nous connaissons maintenant la plage d'adresses de registre GPIO pour contrôler l'unique LED rouge.

Remarque très importante: chaque port d'E/S de la carte LaunchPad MSP432 est un ensemble de plusieurs (généralement 8) broches ou lignes, et chacune peut être définie individuellement comme entrée ou sortie.

Cela signifie, par exemple, que si vous définissez des valeurs pour "l'adresse du registre de direction du port 1", vous devez vous préoccuper du bit (ou des bits) que vous définissez ou modifiez à cette adresse. Plus à ce sujet plus tard.

Séquence de programmation du port GPIO

La dernière pièce dont nous avons besoin est un processus ou un algorithme à utiliser pour contrôler la LED.

Initialisation unique:

• Configurez P1.0 (P1SEL1REG:P1SEL0REG Register) <--- 0x00, 0x00 pour une fonctionnalité GPIO normale.
• Définissez le bit 1 du registre de direction de P1DIRREG comme sortie, ou HIGH.

Boucle:

Écrire HIGH au bit 0 du registre P1OUTREG pour allumer la LED rouge

• Appeler une fonction de retard
• Écrire LOW au bit 0 du registre P1OUTREG pour éteindre la LED rouge
• Appeler une fonction de retard
• Répéter la boucle

Quelle fonction d'entrée/sortie (Configurer SEL0 et SEL1)

La plupart des broches du LaunchPad ont de multiples usages. Par exemple, la même broche peut être un GPIO numérique standard, ou elle peut également être utilisée dans les communications série UART ou I2C.

Afin d'utiliser une fonction spécifique pour cette broche, vous devez sélectionner cette fonction. Vous devez configurer la fonction de la broche.

Il y a une image ci-dessus pour cette étape qui tente d'expliquer ce concept sous forme visuelle.

Les adresses SEL0 et SEL1 forment une combinaison de paires qui agissent comme une sorte de sélection de fonction/fonctionnalité.

Pour nos besoins, nous voulons un GPIO numérique standard pour le bit 0. Cela signifie que nous avons besoin que le bit 0 pour SEL0 et SEL1 soit un LOW.

Séquence de programmation de port (à nouveau)

1. Ecrivez 0x00 dans le registre P1 SEL 0 (adresse 0x40004C0A). Ceci définit un LOW pour le bit 0

2. Ecrivez 0x00 dans le registre P1 SEL 1 (adresse 0x40004C0C). Cela définit un LOW pour le bit 0, paramètre pour GPIO.

3. Écrivez 0x01 dans le registre DIR P1 (adresse 0x40004C04). Cela définit un HAUT pour le bit 0, ce qui signifie SORTIE.

4. Allumez la LED en écrivant un registre de SORTIE 0x01 à P1 (adresse 0x40004C02)

5. Faites une sorte de retard (ou juste une seule étape pendant le débogage)

6. Éteignez la LED en écrivant un 0x00 dans le registre de SORTIE P1 (adresse 0x40004C02)

7. Faites une sorte de retard (ou juste une seule étape pendant le débogage)

8. Répétez les étapes 4 à 7.

La vidéo associée à cette étape nous guide tout au long du processus dans une démonstration en direct, alors que nous parcourons et discutons de chaque instruction d'assemblage, et montrons l'action de la LED. Veuillez excuser la longueur de la vidéo.

Étape 3: avez-vous remarqué le seul défaut de la vidéo ?

Dans la vidéo qui parcourt l'ensemble du processus de programmation et d'allumage de la LED, il y avait une étape supplémentaire dans la boucle principale, qui aurait pu être déplacée jusqu'à l'initialisation unique.

Merci d'avoir pris le temps de parcourir ce Instructable.

Le prochain développe ce que nous avons commencé ici.