Ce cours donne les bases théoriques et pratiques nécessaires à une bonne compréhension et utilisation des microcontrôleurs. De nombreux exemples seront abordés. Des exercices seront proposés, compatibles avec les cartes à microcontrôleurs Arduino ou LaunchPad MSP430G.
5.4 Debug avec CCS
Loading...
From the course by École Polytechnique Fédérale de Lausanne
Comprendre les Microcontroleurs
50 ratings
From the lesson
Périphériques internes
Nous commencerons cette semaine par les timers et les interruptions, dont vous apprécierez petit à petit l'utilité et la puissance. Mais le plus important, c'est de progresser dans la programmation, par la pratique.
Meet the Instructors
Jean-Daniel NicoudHon. Prof.
Informatique
Pierre-Yves RochatChargé de cours
EPFL, Génie mécanique
Bonjour.
Lorsque l'on travaille avec des microcontrôleurs, une
des grandes difficultés, c'est de faire fonctionner
les programmes qu'on a écrit, de trouver
les pannes qui sont à l'intérieur, de dépanner.
On parle parfois aussi de déverminage ou encore de débogage,
mais c'est certainement le terme anglais "debug" qui est le plus utilisé.
Je rappelle qu'il y
a plusieurs manières de programmer un microcontrôleur.
La technique qui est utilisée dans
l'Arduino utilise ce qu'on appelle une bootloader.
Il s'agit d'un programme qui doit être présent sur le microcontrôleur
et qui permet de charger un autre programme dans ce même microcontrôleur.
C'est d'ailleurs une de, une des contraintes,
on ne peut pas acheter un microcontrôleur
tout nu, tout neuf, comme le fabriquant le livre.
Il ne va pas fonctionner sur un
Arduino puisqu'il faut préalablement lui installer un bootloader.
Il existe aussi des programmateurs, celui qui
est utilisé pour les MSP430, par exemple.
Le mode ISP qui est utilisé pour les
AVR et qui permet une première programmation d'un Arduino.
Vous vous souvenez, on a notre schéma, notre montage, on a ici,
quelque chose qui nous permet de nous relier au PC pour faire la programmation.
La plupart des programmateurs permettent
simplement de programmer le microcontrôleur.
Mais certains programmateurs ont des
fonctions supplémentaires qui offrent cette
possibilité de, en quelque sorte, voir à l'intérieur du microcontrôleur,
voir ce qui se passe dans notre microcontrôleur.
Historiquement, c'est souvent les systèmes JTAG qui ont été utilisés.
C'est un terme que vous devez connaître, on
en parle souvent en rapport avec les microcontrôleurs.
On peut programmer des AVR avec des interfaces JTAG.
Les ARM sont presque toujours programmés également, avec cette technologie.
Il existe aussi des systèmes
spécifiques inventés par certains fabriquants, par
exemple, le système debugWire des AVR.
Il est assez génial parce qu'il utilise une seule patte, la patte
Reset, mais dans un mode spécial et qui permet, donc, non seulement
de programmer le microcontrôleur, mais aussi de suivre ce qui se passe
à l'intérieur, et ça va être une aide énorme pour faire le dépannage,
le debug.
Il faut, dans ce cas-là, utiliser le programmateur Dragon proposé par Atmel.
Il se trouve que le launchPad MSP430 contient aussi un de ces programmateurs
évolués qui permet de regarder ce qui se passe à l'intérieur du microcontrôleur.
Ces dispositifs étaient jusqu'à il y a
pas très longtemps réservés à des professionnels.
C'était des dispositifs
extrêmement coûteux, et le fait qu'ils soient disponibles sur le launchPad
à un prix très intéressant est, euh, un avantage, euh, de taille.
Évidemment, un programmateur donné pourra être utilisé
dans sa fonction de debug, pour autant qu'on utilise le logiciel correspondant.
Dans le cas des MSP430 de Texas Instruments, c'est le logiciel
Code Composer Studio dont vous voyez, ici, une vue générale qui permet de faire cette
programmation avec debug. Vous reconnaissez ce type d'environnement.
Ici, on voit les fichiers qui sont associés
au projet qu'on est en train de réaliser.
Ici, il y a le source du programme qu'on écrit, et puis là, il y aura
la console qui par exemple, nous donnera les, le résultat de la compilation, avec
éventuellement des erreurs, et il y a
aussi, ici, une fenêtre avec des aides diverses.
Essayons de créer pas à pas, un
projet avec cet environnement Code Composer Studio.
La première chose qu'il faut faire, c'est
aller dans File, sélectionner New, puis CCS Project.
Donc, on va créer un projet qui
contiendra plus tard un ou plusieurs fichiers sources.
Donc, CCS Project.
Le menu suivant, euh, nous demande de donner
le nom au projet, l'extension est donnée automatiquement.
Il faut, comme d'habitude, cliquer sur Next.
Il y a encore deux fenêtres sur lesquelles il suffit de cliquer Next, et je m'arrête,
ici, sur la troisième fenêtre, dans laquelle
il est nécessaire de donner une réponse.
On doit choisir le microcontrôleur qu'on va utiliser.
Si on clique simplement dans la liste, la liste est très longue.
C'est un peu difficile de trouver le processeur qui nous intéresse.
Alors, ce qui est plus facile, c'est de choisir dans
cette famille, dans cette liste de familles, la famille MSP430G
qui est celle qui correspond au launchPad.
Et ensuite, on fait dérouler une liste qui est moins longue et
le processeur qui est originalement sur le launchPad, c'est celui-ci, le 25 53.
Ensuite, il suffit de choisir Next.
On a donc créé un projet, et on n'a
pas encore créer de fichier source associé à ce projet.
Et il est nécessaire de cliquer, avec le bouton
de droite, sur le nom du projet, de choisir à
nouveau, New, et cette fois, de choisir Source File, fichier source.
Ensuite, on a le menu où on doit donner le nom du fichier.
N'oubliez-pas de donner l'extension point C, puisqu'il s'agira
bien d'un fichier point C, et ensuite, on
se trouve avec une page vide dans lequel
il suffit d'écrire le programme que nous souhaitons écrire.
J'ai pris comme exemple, pour cette démonstration,
un source qu'il est important de pouvoir calibrer.
C'est le, l'utilisation d'un capteur de distance infrarouge, et à
un moment donné, on doit faire une petite attente pour
que globalement, le temps de mesure corresponde à, le temps
de décharge de la capacité dans les conditions de travail
réel, et il va falloir ajuster cette valeur-là.
Donc, ça sera très intéressant de pouvoir
visualiser ce que va nous rendre notre procédure
et on verra que c'est, ça sera très facile de le faire, grâce au debugger.
Lorsque le source est prêt, Il faut cliquer dans Project,
puis Build Active Project. Donc, on fait la construction du projet.
C'est le thème qui est utilisé pour la compilation, suivi des
étapes qui suivent la compilation parti, en particulier, euh, l'édition des liens.
Dans ce cas-là, il n'y a pas eu d'erreurs, on voit bien, ici, Build Complete.
Par contre, il y a eu un Warning, un avertissement qui est d'ailleurs tout
à fait pertinent, puisque mon programme principal
dit ceci : Mesure égale Mesure Distance,
mais on ne fait rien pour le moment, de cette valeur.
Donc, elle n'est pas utilisée.
Et là, c'est très intéressant de pouvoir, malgré tout, lancer
ce programme qu'on va ensuite arrêter et on ira regarder la
valeur mesurée sans avoir besoin de s'occuper de mettre du
matériel supplémentaire autour de notre
microcontrôleur pour afficher cette valeur mesurée.
On va lancer l'environnement de Debug grâce
à la sélection Target, puis Debug Active Project.
Target, c'est donc la cible, on parle souvent
de système cible pour, euh, ces systèmes microcontrôleurs.
Donc, on va dépanner le project actif sur le système cible.
Et on se trouve, après quelques dizaines de secondes,
je devrais dire, ça prend un petit peu de temps; le, l'environnement doit se
commuter, doit changer Le programmateur doit envoyer le code à l'intérieur
du microcontrôleur et lorsque tous ces, toutes ces opérations sont terminées, on
se trouve avec un environnement un petit peu différent de tout à l'heure.
On trouve quelque part, dans une fenêtre un peu minuscule, le source
du programme que nous venons d'écrire.
On trouve, ici, euh, les messages qui viennent d'une console.
On trouve, ici, les instruction ta, traduites
en assembleur, ça peut être extrêmement utile,
et on retrouvera, ici, des noms de
variables, ce qui va être extrêmement intéressant.
Pour le moment, le programme ne s'exécute pas encore,
il va falloir, ici, cliquer sur la touche Run
qui est une petite flèche verte qui va
permettre de lancer le programme à l'intérieur du microcontrôleur.
Une fois que le programme est lancé, on ne va rien voir du tout.
Pourquoi?
Notre programme s'exécute à l'intérieur du microcontrôleur, il fait
ses mesures de distance, mais il ne les affiche pas.
Il va être, donc, nécessaire d'arrêter l'exécution du programme.
Ici, il y a une touche Alt que
vous allez trouver, qui vous permet d'arrêter le programme.
Donc, la touche Alt, c'est cette touche qui est juste
entre le Run et l'arrêt complet du système de Debug.
Une fois que le programme est arrêté, on
voit, ici, l'endroit où le programme s'est arrêté.
Il se trouve qu'il était dans cette boucle d'attente lorsqu'il s'est arrêté.
On voit que des variables locales, ici, i et j ont une certaine
valeur. La distance vaut la même valeur que le j.
On est au milieu de la procédure de mesure de
distance, c'est donc pas du tout des informations qui sont intéressantes.
Ce qu'on va faire maintenant, c'est qu'on va
créer un point d'arrêt à l'intérieur du programme.
En anglais, on appelle ça un break point.
Je vais donc cliquer sur cette ligne, ici, qui est la fin de
la procédure et qui donne l'instruction Return Distance, avec le bouton de droite.
Je vais chosir New Breakpoint.
Je vais choisir Breakpoint, et à ce moment-là,
mon programme va devoir s'arrêter s'il passe à cet endroit-là.
Je vais donc, renoncer l'exécution et lorsqu'elle
va s'arrêter, je vais voir le résultat à l'intérieur de mon microcontrôleur.
C'est bien ici, que je me suis arrêté, donc, juste au niveau du return distance.
J'ai de nouveau les
valeurs de i et de j.
Le j est arrivé à 254, on est donc bien à la fin de la boucle de mesure.
Par contre, on a, ici, la valeur qui
a effectivement été lue, qui est la valeur 41.
Donc, en fonction de l'objet que j'avais placé en face de mon capteur,
je vois que la valeur 41 a été donnée. Je vais pouvoir faire d'autres
tests de cette manière-là pour éventuellement calibrer mon programme.
Je pense que vous vous rendez compte
que c'est extrêmement puissant, comme manière de travailler
puisqu'on peut, en quelque sorte, aller voir
à l'intérieur du microcontrôleur, ce qui se passe.
Lorsqu'on écrit des programmes complexes, on peut tout à coup
perdre contrôle, ne plus très bien savoir ce qui se passe.
Il est toujours possible, avec ce dispositif,
d'arrêter l'exécution, d'aller voir des variables.
Il est possible également, de faire du pas
à pas, ce qui est aussi extrêmement intéressant.
Ce que nous venons de voir
maintenant, c'était considéré comme des outils professionnels
tout à fait coûteux et inabordables pour les étudiants et pour les amateurs.
Aujourd'hui, c'est des technologies qui sont peu coûteuses et je
vous encourage vivement à apprendre à les utiliser, à les maîtriser, vous serez
beaucoup plus efficaces pour le développement-microcontrôleur.
Explore our Catalog
Join for free and get personalized recommendations, updates and offers.
Coursera provides universal access to the world’s best education,
partnering with top universities and organizations to offer courses online.
© 2018 Coursera Inc. All rights reserved.
