Allumer pour y voir plus clair en Assembleur !

Objectifs pédagogiques associés :

 Utiliser l'IDE et ses fonctions de déboguage en simulé et en réel
 Créer une petite section Data
 Créer et appeler un sous-programme simple
 Réaliser les structures algorithmes de base en assembleur
 Externaliser une procédure dans un module (fichier) extérieur.

L'applicatif à développer :
Le but de cette première étape est de faire un programme principal s'exécutant dans le main qui
permet d’allumer et d’éteindre une LED simple en fonction de l’état d’un interrupteur d’entrée.

Le travail en pas à pas :

A partir du colis étudiant que vous aurez téléchargé et dézippé dans votre répertoire de travail
courant :

 Compilez, analysez, exécutez le projet Projet/Roue/Etape0/Etape0.uvproj. Ce projet

ne fait pas grand-chose, en tout cas rien de bien observable. Il vous donne cependant une
structure de projet pour la suite du travail. Dans cette structure, on observe (figure 1) que
dans la version de base le projet contient 5 fichiers : 2 fichiers (dont un écrit en langage C)
rangés dans le groupe Système qui permettent d’initialiser le processeur, une « grosse »
librairie qui contient toute sorte de fonctions qui seront utiles par la suite et enfin deux
fichiers utilisateurs dont le fichier Principal.asm qui inclut la fonction d’entrée main. Le
fichier FonctionEtape0.asm contient des fichiers d’initialisation des périphériques, et
impose dès le départ une bonne structuration logicielle dans vos projets.

Figure 1 : structure du projet initial

-1-
  Fermez cette Etape0 qui servira de base pour régénérer de nouveau projet par la suite.
Recopiez (en dupliquant l’ensemble du catalogue puis en le renommant) l'ensemble du
projet Etape0 en Etape1. Ouvrir le projet de cette Etape1.
La roue dispose d’un capteur de passage et d’un certain nombre de LEDs qui sont toutes, plus ou
moins directement, accessibles via des broches du STM32. L’accès à ces broches se fait en lisant
et/ou écrivant dans des registres d’entités qui sont appelées GPIO (General Purpose Input Output)
dans la documentation du µcontrôleur. Deux de ces entités sont utilisées dans notre configuration
matérielle : le port A (GPIOA) et le port B (GPIOB). A notre niveau, et pour les besoins de ces TP, on
peut se contenter de considérer que nous aurons à lire et/ou écrire des données (la plupart du temps
des bits) dans des zones précises dont on connait l’adresse. Les zones de bits à atteindre sont
schématisées sur la figure 2.

Figure 2 : Répartition des bits d’entrée sortie pour la roue magique (ceci n’est pas une tablature pour luth…)

Le capteur est une cellule magnétique tout ou rien, de type « index », qui permet de repérer une
position angulaire unique et précise de la roue. Si vous regardez l’arrière de la partie tournante vous
en comprendrez vite le fonctionnement. Pour connaître l’état du capteur () il suffit d’aller lire
l’information à l’adresse indiquée. Le capteur est câblé en logique négative. Ainsi si le bit est à 0 la
roue est dans la position de référence ; le bit est à 1 si le capteur ne détecte pas la présence de
l’aimant. Nous verrons par la suite (énoncé n°2) comment piloter la barrette de LEDs avec les broches
 à . Pour l’instant il s’agit de piloter uniquement la LED simple avec la broche de sortie .Si la
broche est à l’état 1, la LED est allumée, sinon elle est éteinte.

Pour les broches de sortie, il y a possibilité soit de lire/écrire son état via les registre dénommés
output sur la figure 2, soit en écrivant un 1 dans les bits des registres Set (resp. Reset) de mettre à
l’état haut (resp. bas) les broches de sortie correspondantes. Contrairement aux registres output,

-2-
l’écriture d’un 0 sur un registre Set/Reset est sans aucun effet, d’où l’intérêt et l’existence d’une
telle fonctionnalité.

 Les premières lignes code que vous allez écrire vont permettre d’allumer puis d’éteindre la
LED. Afin de prendre conscience de l’intérêt des registres Set/Reset, on réalisera cette
manœuvre deux fois comme dans l’algorithme ci- dessous :
Procedure main
Init_cible(0)
; pour allumer la LED avec le registre SET
(PortB.Set)16=  (0x01 << 10)
; pour éteindre la LED avec le registre RESET
(PortB.Reset)16=  (0x01 << 10)

; pour allumer la LED avec le registre output

Etat_PortB =  (PortB.Output)16
Etat_PortB = (Etat_PortB) ou (0x01 << 10)
PortB.Output)16 =  Etat_PortB
; pour éteindre la LED avec le registre output
Etat_PortB =  (PortB.Output)16
Etat_PortB = (Etat_PortB) et not((0x01 << 10))
(PortB.Output)16 =  Etat_PortB

Tantque(vrai)
rien Faire ; boucle infinie terminale
FinTantque
Fin main

 Ecrivez, au sein de la procédure main, le code et testez-le tout d’abord sur la cible Simulé.
Vérifiez (et formez-vous aux outils de Debug) que la broche PortB.10 s’allume bien. Pour
cela fonctionnez en mode pas à pas après avoir positionné un point d’arrêt sur la première
instruction de votre code. Vous pouvez également ouvrir l’Analysis Windows ( ). Cet
analyseur est normalement déjà configuré et vous pourrez y vérifier l’évolution temporelle
de la broche PortB.10.
 Procédez de même sur la cible Réel en prenant garde qu’effectivement votre poste est bien
connecté à la cible via une sonde Jtag. L’observation du passage allumé ne peut se faire
qu’en mode pas à pas.
 Créez, dans le même fichier Principal pour l’instant, deux fonctions qui ne prendront
aucun argument ni d’entrée ni de sortie et qui réalisent l’allumage (Allume_LED) et
l’extinction (Eteint_LED) de la LED. On utilisera la forme Set/Reset pour écrire ces
fonctions. Modifiez éventuellement ces fonctions pour qu’elles utilisent obigatoirement
l’adressage indirect indexé (la base et les index seront initialisés à l’aide des constantes
définies en début de ficher). Modifiez la procédure main pour qu’elle fasse appel à ces deux
fonctions. Vérifiez en simulé et en réel le bon fonctionnement de vos fonctions. La procédure
main se résumera donc à l’algorithme suivant :
Procedure main
Init_cible(0)
Tantque(vrai)
Allume_LED()
Eteint_LED()
FinTantque
Fin main

 Externalisez ces deux fonctions dans le fichier FonctionEtape.asm – Vérifiez en mode

réel.

-3-
Maintenant qu’il est possible de « voir réagir » la cible, cherchons à conditionner l’état de la LED sur
la lecture du capteur d’entrée. Pour en connaître son état il suffit d’aller lire le bit () indiqué sur la
figure 2.

Pour tester cette partie en simulation, l’Analysis Windows ( ) conserve son intérêt de
visualisation puisque l’état du capteur est également tracé dans la configuration par défaut. Par
contre il ne permet pas d’affecter l’état de celui-ci. Pour ce faire vous pouvez utiliser l’outil Toolbox
( ) qui propose 2 boutons réalisant l’affectation de la broche d’entrée correspondante au capteur.
Cet outil permet donc de simuler le fonctionnement binaire du capteur. Pour les plus curieux d’entre
vous, ces boutons sont créés par l’appel au fichier Simulator.ini qui est chargé par défaut lors du passage en
mode Debug.

 Commençons simplement par mettre en place l’algorithme simpliste suivant :

Procedure main
Init_cible(0)
Tantque(vrai)
Si (Capteur = 1)
Allume_LED
Sinon
Eteint_LED() ;
FinTantque
Fin main

Dans ce code on prendra garde à ce que la structure Si..Sinon soit codée sur le modèle de ce
qui a été donné en cours, à savoir qu’il ne doit y avoir qu’un seul saut conditionné et un saut
absolu. Testez ce programme en mode simulé puis testez en mode réel en faisant tourner le
disque à la main.
Si vous avez fait tourner le moteur à vitesse réelle, vous avez dû observer que la LED ne paraissait
toujours allumée, ce qui est parfaitement normal puisque le capteur passe à zéro (logique négative)
que de façon furtive! Dans la dernière version de cette étape, nous vous proposons de mettre en
place un algorithme qui, sur la base de ce qui a été écrit précédemment, permet de basculer l’état de
la LED à chaque fois qu’un front montant du capteur est détecté. Dans un second temps, on ajoutera
un nombre maximum N (défini comme une constante du programme) de détections de fronts
montants. Passé ce nombre de détection la LED sera constamment allumée. Le fonctionnement
attendu correspond à l’Analysis Windows de la figure 3.

Figure 3 : chronogramme du fonctionnement attendu

-4-
 Ecrivez l’algorithme (et mettez-le en commentaire dans l’entête de la fonction main) qui permet de
mettre en place la détection du front montant et le basculement de l’état de la LED. Codez-le
puis testez-le directement en réel (si vous rencontrer des difficultés pour la mise au point vous
pourrez revenir en mode simulé puisque les manipulations peuvent parfois y être plus). Même s’il
serait plus efficace d’utiliser un registre pour mémoriser l’état passé du capteur, nous
utiliserons ici pour le codage un variable interne qui sera nommée OldEtat.
 Modifiez l’algorithme et le codage pour que la détection des fronts montants ne soit faite
que N fois. Lorsque ce nombre est atteint, la LED reste allumée.
 Compactez le catalogue Etape1 et déposez-le sur le dépôt Moodle prévue à cet effet. Une
review de votre code et une évaluation vous sera produite en retour.

-5-