Partie 3 : GPIO : Assemblage ARM : Suiveur de ligne : TI-RSLK : 6 étapes

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

Bonjour. Il s'agit du prochain volet où nous continuons à utiliser l'assembly ARM (au lieu d'un langage de niveau supérieur). L'inspiration pour ce Instructable est Lab 6 du Texas Instruments Robotics System Learning Kit, ou TI-RSLK.

Nous utiliserons le microcontrôleur du kit, la carte de développement MSP432 LaunchPad, mais vous trouverez peut-être quelque chose d'utile à extraire de cet Instructable même si vous n'utilisez pas le LaunchPad ou si vous ne suivez pas le T. I. programme d'études.

Nous avons commencé avec un Instructable présentant l'assemblage ARM, l'environnement de développement et comment créer un projet.

Le prochain Instructable sur ARM Assembly a présenté comment interagir avec les entrées/sorties (GPIO).

Ensuite, nous avons élargi nos connaissances et introduit des fonctions, contrôlant les LED et les interrupteurs.

Maintenant, avec ce Instructable, nous pouvons utiliser ce que nous avons appris pour faire quelque chose de plus amusant, de plus utile: détecter une ligne.

Cela peut nous aider plus tard lorsque nous construirons un robot suiveur de ligne.

Dans le programme, la plupart de la programmation se fait en C ou C++, mais il est utile de se familiariser avec l'assembleur, avant de commencer en fonction des langages de niveau supérieur et des bibliothèques.

Étape 1: le matériel

Je ne veux pas ressasser le matériel en détail, car il existe déjà des sources, mais nous ajouterons des explications si nécessaire.

Pour ce Instructable, nous utiliserons le réseau de capteurs de réflectance de Pololu, car il fait partie du TI-RSLK (le kit de robot). C'est celui utilisé dans le cours, et dans le Lab 6 du curriculum.

Si vous ne l'avez pas, vous pouvez utiliser n'importe quel détecteur IR (ou une série d'entre eux) qui émet un signal numérique, HAUT ou BAS, pour la présence et l'absence.

Le capteur matriciel est le meilleur car il peut aider à détecter si nous sommes juste au centre de la ligne ou sur un côté. De plus, comme nous le verrons plus tard, cela peut nous aider à détecter l'angle du robot par rapport à la ligne.

Le réseau de réflectance a des détecteurs très proches les uns des autres. Cela signifie que nous devrions obtenir plusieurs signaux de détection, en fonction bien sûr de l'épaisseur de la ligne.

Si c'est le cas, alors si le robot n'est pas directement aligné avec la ligne, il devrait alors renvoyer une sortie indiquant que la ligne est plus large qu'elle ne devrait l'être (parce que nous sommes à un angle).

Pour une meilleure explication de ce qui précède, jetez un œil au document Lab 6.

Pour obtenir de l'aide sur le câblage/la connexion du capteur à la carte de développement LaunchPad MSP432, voici quelques instructions utiles.

J'ai également ajouté les mêmes (similaires ?) instructions pdf à cette étape.

Si vous lisez attentivement les documents Pololu, ils expliquent la raison du "dérivation 3,3 V", que vous voudrez sauter si vous utilisez 3,3 V au lieu de 5 V.

Étant donné que nous ne construisons pas encore le robot, mais que nous apprenons simplement l'assemblage ARM et comment interagir avec les pièces (sous-systèmes) du robot, nous n'avons pas à suivre les instructions ci-dessus à la lettre.

Pour l'instant, la connexion du réseau de capteurs de ligne se résume à ce qui suit:

• connectez 3,3 V et GND de la carte MSP432 au réseau de capteurs.
• connectez une broche de port (je suggère P5.3) du MSP432 à la broche d'activation de la LED sur le réseau de capteurs de ligne. Cette broche sur le capteur est entre 3,3 V et GND.
• connectez les huit broches/bits d'un seul port (je suggère P7.0 à P7.7) aux huit broches du réseau de capteurs étiquetées "1" à "8". Ce sont les lignes qui deviendront HAUT ou BAS en fonction de ce qu'elles détectent.

Comme vous pouvez le voir dans les images de cette étape, et dans la vidéo, je n'ai pas attaché le capteur au châssis du robot, car je voulais une facilité de programmation, de débogage, de test, d'apprentissage.

Donc, avec tout ce qui est connecté, nous sommes prêts à entrer dans le logiciel.

Étape 2: suivi de ligne

Le capteur à matrice de réflectance est assez astucieux car il peut aider d'au moins deux manières.

• Déterminez si le robot est centré sur la ligne ou dérive d'un côté.
• Le robot est-il aligné dans la direction de la ligne ou est-il incliné.

Chacun des détecteurs du réseau fournit essentiellement un bit d'information, soit HAUT, soit BAS.

L'idée est de combiner tous ces bits en un seul nombre ou motif binaire unique, et d'utiliser ce motif pour prendre des décisions (afin de se déplacer correctement).

Étape 3: Avant de pouvoir vraiment commencer…

.. nous devons apprendre quelque chose de nouveau sur la programmation en assembleur ARM. Et je ne parle pas seulement d'une autre instruction. Ceux-ci ont tendance à être mineurs.

Jusqu'à présent, nous n'avons pas utilisé la "pile" dans nos programmes.

Nous nous sommes appuyés sur l'utilisation de la plupart des registres du processeur central dans le monde entier dans différents sous-programmes.

La seule chose que nous avons faite a été de sauvegarder et de restaurer l'adresse LR (registre de liaison) pour une fonction - celle qui appelait plusieurs autres fonctions. (J'utilise ici "fonction" et "sous-programme" de manière interchangeable).

Ce que nous avons fait n'est pas bon. Et si on voulait imbriquer d'autres fonctions ? Et si nous avons plus d'un niveau d'imbrication ?

Dans les exemples précédents, nous avons choisi d'utiliser le registre R6 comme stockage pour le LR ou l'adresse de retour. Mais si nous voulons faire une imbrication plus poussée/plus profonde, nous ne pouvons pas continuer à modifier la valeur de R6. Il faudrait encore choisir un autre registre. Et un autre. Et puis, il devient fastidieux de garder une trace de quel registre du processeur central contient quel LR pour restaurer quelle fonction.

Alors maintenant, nous jetons un coup d'œil à la "pile".

Étape 4: La pile

Voici quelques lectures expliquant la pile.

Je suis un plus grand partisan de quelques idées:

• autant de théorie que nécessaire, passez à la pratique rapidement
• apprenez au besoin, concentrez-vous sur la réalisation de quelque chose et pas seulement sur des exercices ou des exemples inutiles.

Il y a beaucoup de documentation ARM et MSP432 en ligne qui parle de la pile, donc je ne vais pas ressasser tout ça. Je vais également garder l'utilisation de la pile ici au strict minimum - en sauvegardant l'adresse de retour (le registre des liens).

Essentiellement, nous n'avons besoin que d'instructions:

PUSH {enregistrer la liste}

POP{enregistrer la liste}

Ou, dans notre cas, plus précisément:

POUSSER {LR}

POP {LR}

Ainsi, une fonction/sous-routine d'assemblage ressemblerait à ceci:

funcLabel:.asmfunc

PUSH{LR}; cela devrait probablement être l'une des premières instructions à l'entrée.; faire plus de code ici..; bla.. bla… bla…; ok, nous en avons fini avec la fonction, prêt à revenir à la fonction appelante POP{LR}; cela restaure la bonne adresse de retour à l'appel; fonction. BXLR; retour.endasmfunc

La vidéo passe par un exemple en direct de plusieurs fonctions imbriquées.

Étape 5: Le logiciel

Le fichier joint intitulé "MSP432_Chapter…" contient de nombreuses informations utiles sur les ports du MSP432, et à partir de ce document, nous obtenons les ports, registres, adresses, etc. suivants. C'est un peu daté, cependant. Cependant, je n'ai pas vu les adresses détaillées répertoriées pour le port 5 et plus. (uniquement "fonctions alternatives"). Mais ça reste utile.

Nous allons utiliser deux ports. P5, P7, P1 et P2.

La sortie P5.3 (un seul bit) servira à contrôler l'activation de la LED IR sur le capteur. Nous utilisons P5.3 car il s'agit d'une broche exposée sur le même en-tête que les autres connexions MSP432 allant au réseau de capteurs.

P7.0 à P7.7 seront les huit entrées qui collectent les données du capteur; ce qu'il "voit".

P1.0 est la seule LED rouge et nous pourrions l'utiliser pour nous donner quelques indications sur les données.

P2.0, P2.1, P2.2 est la LED RVB et nous pouvons également l'utiliser, avec ses différentes possibilités de couleurs, pour nous donner une indication des données du capteur.

Si vous avez parcouru les précédents Instructables liés à tout cela, vous savez déjà comment configurer le programme.

Il suffit d'avoir une section de déclaration pour les ports et les bits, etc.

Vous aurez une section "principale".

Il devrait y avoir une boucle, où nous lisons en continu les données de P7, prenons une décision de ces données et allumons les deux LED en conséquence.

Voici à nouveau les adresses du registre des ports:

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

Ce qui est en gras est ce que nous utiliserons pour ce Instructable.

Étapes du programme pour lire les détecteurs IR

Ce qui suit est un pseudo-code pour écrire le programme en C, mais il est toujours utile, et nous le suivrons de très près dans la version assembleur du programme.

programme principal0) Initialisez //ports while(1) { 1) Réglez P5.3 à l'état haut (allumez la LED IR) 2) Faites de P7.0 une sortie et mettez-la à l'état haut (charge du condensateur) 3) Attendez 10 us, Clock_Delay1us (dix); 4) Faire de P7.0 une entrée 5) Exécuter cette boucle 10 000 fois a) Lire P7.0 (convertit la tension sur P7.0 en binaire) b) Sortir binaire vers P1.0 (permet de voir binaire en temps réel) 6) Réglez P5.3 bas (éteignez la LED IR, économisez de l'énergie) 7) Attendez 10 ms, Clock_Delay1ms (10); } // répéter (retour à while())

Étape 6: Améliorons le code

Le but ou l'utilisation de la matrice de LED IR Pololu est de détecter une ligne et de savoir si le robot (futur) est directement centré sur la ligne ou sur un côté. De plus, puisque la ligne a une certaine épaisseur, si le réseau de capteurs est directement perpendiculaire à la ligne, le nombre N de capteurs aura une lecture différente du reste, alors que si le réseau de LED IR est à un certain angle (non perpendiculaire), alors Les paires LED/détecteur IR N+1 ou N+2 devraient maintenant donner une lecture différente.

Ainsi, selon le nombre de capteurs indiquant la présence de la ligne, nous devrions savoir si nous sommes centrés, et si nous sommes inclinés ou non.

Pour cette dernière expérience, voyons simplement si nous pouvons obtenir que la LED rouge et la LED RVB nous donnent plus d'informations sur ce que le réseau de capteurs nous dit.

La vidéo rentre dans tous les détails. Le code final est également joint.

Ceci termine la série d'assemblages ARM liés à GPIO. Nous espérons revenir avec plus d'assemblage ARM plus tard.

Merci.