INSA GE IF2 TP Microcontrôleur INSA GE

Objectifs

But global :
Acquérir l’expérience d’un développement d’applications à base de micro contrôleur.
Séance 1 :
Prise en main du matériel et des logiciels de développement.
Séance 2 :
Notions avancées
TP MICROCONTROLEUR, FAMILLE PIC Réalisation d’une petite application.

Séances 1 et 2

Thomas Grenier,
Dominique Tournier,
Olivier Bernard,
David Lévèque.

2/47
 TP Microcontrôleur INSA GE TP Microcontrôleur INSA GE

Présentation du matériel

1- Logiciel MPLAB de Microchip

Il s’agit de l’environnement informatique de développement pour PIC fourni par le

constructeur Microchip. Il est gratuitement téléchargeable et utilisable.
MPLAB permet d’éditer le code assembleur (reconnaissance des instructions et des
variables internes), compiler le code (le lier à des librairies si besoin), simuler le
comportement d’un PIC (ceci permet de tester le bon fonctionnement d’un programme
(débogage) par simulation) et de piloter des outils de développement supplémentaires comme
MPLAB ICD 2.
Ce programme est présent sur chaque PC de la salle de TP

2- Kit MPLAB ICD 2

Ce kit permet de programmer et de déboguer un microcontrôleur PIC via le logiciel

MPLAB IDE. Ce kit est composé :
D’un module ICD 2 (circulaire) contenant l’électronique de communication,
D’un câble USB permettant la communication entre le bloc circulaire et le PC,
Un petit câble RJ11 permettant la communication entre le bloc et le PIC.

Figure 2: Les 3 éléments du kit ICD 2 ; le câble RJ11 est en bas de l’image

11
US
B RJ Ne pas connecter d’alimentation au module ICD 2 !!! Le module est alimenté par USB.

3- Carte à PIC

Deux cartes sont nécessaires à ce TP : la carte « process » et la carte « mini ».

Module ICD La carte « process » est la carte sur laquelle le PIC 16F877A est présent. On trouve sur
Figure 1: Câblage du kit ICD 2 cette carte (Figure 23) :
- l’alimentation (il est nécessaire d’alimenter cette carte),
- un connecteur RJ11 pour le débogage/programmation du PIC via le kit ICD,
- un interrupteur permettant de basculer entre fonctionnement autonome du PIC
(position basse) ou fonctionnement par ICD et programmation (position haute, la LED
rouge est allumée),
- l’oscillateur à quartz (20MHz)
- un connecteur vers d’autres cartes.

Sur la carte « Mini » sont présents : 8 LEDs, 4 boutons poussoir et un buzzer (voir schéma
Figure 21).

3/47 4/47
 TP Microcontrôleur 1 INSA GE TP Microcontrôleur 1 INSA GE

Q- Pendant combien de temps faudra t’il maintenir le BP appuyé pour garantir

I. – Prise en main (1° séance) l’extinction de l’éclairage ?

Avant de commencer le TP, vérifier que vous disposez :
- d’un PC avec MPLAB IDE, Q- Quel est le rôle de la temporisation effectuée après « éteindre éclairage » ?
- d’un module MPLAB ICD 2,
- des deux cartes, l’une avec un PIC 16F877A (à 20MHz), l’autre avec les 8 LEDs,
les 4 boutons poussoirs et le buzzer, 2- Manipulations 1: MPLAB IDE
- d’une alimentation pour la carte PIC,
- d’un câble USB, • Lancement MPLAB IDE
- d’un petit câble RJ11, Lancer le logiciel de développement MPLAB.
Démarrer Programmes Microchip  MPLAB IDE  MPLAB IDE
Dans un premier temps ne pas connecter le kit ICD2 ni les cartes : tout se fait sur PC
(questions 1- et 2- ). • Création d’un nouveau projet
Au lancement de MPLAB, un projet par défaut est utilisé. Pour chaque nouvelle
application il est conseillé de créer un nouveau projet. Un projet permet de gérer les fichiers
de code assembleur, la référence et les paramètres du microcontrôleur ainsi que les options et
1- Présentation de l’application : Bouton-poussoir intelligent outils de débogage.
Le but est de réaliser la commande d’un éclairage à partir d’un simple bouton poussoir. En
Pour créer un nouveau projet :
appuyant une première fois sur le bouton poussoir, on allume l’éclairage. Une seconde
Project  Project Wizard…
pression l’éteindra. Cependant, si on ne pense pas à éteindre les lampes, une minuterie les
La fenêtre wizard apparaît. Cliquer sur « Suivant », la fenêtre ci après apparaît.
éteindra automatiquement.
Sélectionner le microcontrôleur présent sur votre platine (16F877A) et passer à la fenêtre
Voici l’organigramme de l’application (le code assembleur est présent sur les PC et est
suivante.
fourni en annexe) :

Début

Initialisation E/S

Initialisation des variables tempo = 0

Attendre un premier
Attendre 1s Attente BP
appuie sur le BP

Allumer éclairage
Eteindre éclairage
Attendre 1s

Appuie sur BP ?

Incrémenter tempo tempo = tempo + 1

Sélection du microcontrôleur
Fin
tempo == temps d’attente ?
temporisation ? La fenêtre qui suit permet de choisir les programmes de développement. On gardera
l’ensemble logiciel proposé par MicroChip (vérifier que le contenu de la fenêtre ressemble à
celui présenté ci-après).
Figure 3 : Organigramme de l’application Bouton-poussoir intelligent.

5/47 6/47
 TP Microcontrôleur 1 INSA GE TP Microcontrôleur 1 INSA GE

Sélection compilateur et lieur

La dernière fenêtre du wizard apparaît ensuite, elle résume les principaux paramètres du
projet.
Ensuite, il faut choisir le nom et l’emplacement du projet (choisir C:\Temp).

La fenêtre suivante permet d’ajouter des fichiers existants à votre projet. Pour l’instant, ne
pas ajouter de fichier. Après avoir cliqué sur « Terminer » de la fenêtre précédente, votre projet est créé,
mais il est vide ! Il va falloir ajouter des fichiers sources (en assembleur) et des outils de
simulation, débogage et programmation.

7/47 8/47
 TP Microcontrôleur 1 INSA GE TP Microcontrôleur 1 INSA GE

• Ajout de fichier source assembleur (.asm)  Messages d’erreur, « warning » et « message1 »

Commencer par copier le fichier TPuC_1.asm (présent sur le bureau) dans le répertoire de Si le compilateur détecte une erreur (respectivement, une ambiguïté) de syntaxe il le
votre projet (dans C :\Temp) . Il s’agit du programme assembleur de l’application. signalera par une erreur (respectivement, par un warning ou message) dans la fenêtre
Ensuite, ajouter ce fichier à votre projet. A partir du menu, procéder ainsi : « Output ». En assembleur, les erreurs sont :
Project  Add Files to Project… - utilisation d’une instruction ou d’un registre qui n’existe pas,
Choisir le fichier TPuC_1.asm de votre répertoire. - utilisation d’une variable non définie précédemment,
- utilisation d’une étiquette non définie précédemment.
Q- Analyser rapidement le code (faire le lien avec l’organigramme, fonction, solution Les warning et message sont des mises en gardes qu’il est fortement conseillé de vérifier.
pour la temporisation, variables,…) puis justifier (se reporter au schéma des cartes), le Notamment, dans le cas de la programmation des PIC :
test de la première détection d’appuie sur le bouton poussoir : - l’accès à un registre n’appartenant pas à la banque en cours d’utilisation,
; touche ? - pour les instructions, l’opérande de destination (f ou W) est facultatif. Si elle n’est pas
btfsc PORTB, 0 présente, le compilateur génère un warning signalant que par défaut il a utilisé le « file
goto main_prg register » (noté file ou f) comme destination !

• Compilation d’un seul fichier

 But de la compilation
Le fichier assembleur n’est pas exécutable par un microcontrôleur (ni par un processeur).
Il est nécessaire de le transformer en langage machine : chaque mnémonique est transformée
en un code hexadécimal, les sauts aux étiquettes sont remplacés par des sauts relatifs, … Tout
ceci est fait par le compilateur.
Pour que le compilateur génère le code machine, il est évident que le fichier assembleur ne
doit comporter plus aucune erreur de syntaxe…

 Comment compiler
Pour compiler un seul fichier .asm, sélectionner le fichier dans la fenêtre de gestion de
projet (si elle a été fermée faire « View Projet ») puis cliquer sur le bouton droit. Ensuite
faire « Assemble » : Figure 5 : Fenêtre « Output » des messages de construction et compilation.

Un double clic sur une erreur (ou un warning, message) renvoie dans le fichier et à la
ligne où l’erreur (ou le warning, message) a été détectée.

Q- Corriger les erreurs du fichier TP_uC1.asm. (4 erreurs)

Q- Prendre en compte les warnings et modifier le code si nécessaire. (1 message est
crucial !)

• Construction (Build)
 But de la construction
La construction d’un projet va créer le programme complet de l’application en langage
machine.
Quand un projet contient plusieurs fichiers et qu’il existe des liens entre ces fichiers, il est
nécessaire de construire (« Build ») le projet. La construction consiste à compiler tous les
fichiers puis à faire les liens (« link ») entre les différents fichiers et librairies utilisés.
S’il n’y a aucune erreur (pour la compilation et l’éditeur de liens) le langage machine
de l’application est généré.

Figure 4 : Compilation d’un seul fichier .asm

1
Les « message » et les warning sont équivalents : il s’agit de mises en gardes signalées par le compilateur.

9/47 10/47
 TP Microcontrôleur 1 INSA GE TP Microcontrôleur 1 INSA GE

 Comment construire un projet

Plusieurs solutions : • Etude du .lst
- clic droit sur le nom du projet dans la fenêtre de gestion projet puis « Build All » Le fichier listing (.lst) est un fichier au format texte dont le contenu permet de passer
(ou Make), facilement du langage assembleur (mnémonique) au langage machine et inversement. Lors
- par le menu : Project  Build All (ou Make), d’une compilation, ce fichier est toujours créé, même en cas d’erreur de syntaxe. Il s’agit du
- par les raccourcis : ctrl+F10 pour Build All (F10 pour Make). fichier listing (ou log) du compilateur. Dans ce ficher on trouve tous les commentaires du
compilateur (erreurs, parfois warning, …) ainsi que le codage ligne à ligne des instructions.
 Messages d’erreur et de mise en garde Pour ouvrir le fichier .lst du projet : à partir du menu faire View  Disassembly Listing ;
Mêmes démarches que pour la compilation d’un seul fichier avec en plus le problème des ou trouver le fichier .lst portant le nom de votre projet et l’ouvrir dans un éditeur de texte.
liens entre fichiers et librairies si le projet en contient.
Q- Ouvrir le fichier .lst et vérifier le code de l’instruction bsf STATUS, RP0 ainsi
Q- Construire le projet. Si les erreurs de syntaxe assembleur ont été corrigées dans la que vos conclusions.
question précédente, la construction du projet ne doit pas poser de problème.

• Etude du .hex
Le langage machine généré par la construction d’un projet est généralement stocké dans
un fichier « .hex » au format texte (« .o » ou « .exe » pour le format binaire). Sous MPLAB ce 3- Manipulations 2: débogage et simulation
fichier est situé dans le répertoire de votre projet, et il porte le même nom de votre projet avec
l’extension « .HEX ». L’environnement de développement MPLAB avec le kit ICD 2 permet 3 types
d’exécution :
Q- Ouvrir le fichier .HEX de votre projet dans un éditeur de texte. - simulation du PIC sur PC avec débogage (pratique pour mettre au point un
Q- A l’aide de la Figure 6, déterminer le code machine correspondant à la première programme).
instruction du programme principal : - exécution avec débogage sur PIC (grâce au débogueur du kit ICD),
bsf STATUS, RP0. - exécution sur PIC autonome, finalité du développement…
(Compléter en binaire la valeur « Encoding » en trouvant l’adresse mémoire du registre
STATUS et le numéro du bit représenté par RP0 ; cf. Figure 13 page 29) Nous allons étudier et exploiter ces trois modes d’exécution dans l’ordre précédent (qui est
l’ordre logique de déploiement…).
Q- Où se situe ce code dans le .HEX ?
• Simulation sur PC et débogage
Il faut commencer par activer l’outil MPLAB SIM : dans le menu
Debugger  Select Tool  MPLAB SIM
Une barre d’outils propre au débogage apparait et de nombreuses options sont maintenant
disponibles dans le menu Debugger.

Il est maintenant possible d’exécuter le programme :

Debugger  Run (ou F9 ou de la barre d’outils)
Le programme tourne… mais il n’est pas possible de modifier l’état du bouton poussoir ni
d’interagir avec les registres pendant l’exécution…
Pour interagir avec l’exécution du programme, une solution consiste à l’arrêter avant
l’exécution de certaines instructions. Pour cela on place des « breakpoint » (point d’arrêt)
dans le programme assembleur. Lorsque l’exécution s’arrête sur un breakpoint, on peut lire et
modifier les registres du microcontrôleur.
Pour placer un breakpoint sur une ligne, double cliquer sur cette ligne.

Dans la fonction main, placer un breakpoint à chaque écriture du bit 0 du PORTD

ainsi que sur les call Tempo_Ws.
Figure 6 : Détail de codage de l’instruction BSF
Afficher le contenu de registres :
View  Watch
Ajouter les registres de la SFR (en utilisant le bouton Add SFR) :
- WREG (nom complet du registre W)

11/47 12/47
 TP Microcontrôleur 1 INSA GE TP Microcontrôleur 1 INSA GE

- PORTB
- PORTD
La fenêtre Watch doit ressembler à ceci :

Figure 7 : Fenêtre Watch avec 3 registres visualisés

Faire un RESET du processeur :

Debugger  Reset  MCLR Reset
ou: Debugger  Reset  Processor Reset (ou : F6, )

Relancer l’exécution du programme (Run). On peut voir la valeur des registres à Figure 8 : Initialisation de RB0 à 1
chaque breakpoint.
Apres un breakpoint on peut continuer d’exécuter le programme jusqu’au prochain
Création de la mise à l’état bas : aller sur l’onglet Asynch de cette même fenêtre pour
breakpoint (refaire Run) ou exécuter une seule instruction à la fois : ajouter une interaction non synchronisée qui correspondra à une pression sur le bouton
Debugger  Step Into (F7) poussoir (la pression sur le bouton poussoir peut se produire n’importe quand, d’où le
Debugger  Step Over (F8) pour ne pas aller dans le code d’une fonction appelée « Asynch »).
via un CALL.
Sur la première ligne choisir RB0, et l’action adaptée… Puis valider (Apply).
On obtient ceci :
Q- Donner l’évolution des valeurs des registres PORTB et PORTD à chaque
breapoint. Justifier ces valeurs.
Q- Pourquoi le programme s’exécute entièrement ? (comme si on appuyait tout le
temps sur le bouton poussoir)

On va maintenant interagir avec le bit PORTB<0> (RB0) sans modifier le code grâce à
l’utilisation de stimuli. On va initialiser RB0 à la valeur 1 et permettre une mise à 0
momentanée.

Pour faire ceci, lancer la fenêtre Stimulu à partir du menu :
Debugger  Stimulus  New Workbook

Initialisation de RB0 : Sur l’onglet Pin /Register Action ajouter un signal sur RB0. Figure 9 : Evénement non synchrone sur RB0
Choisir l’instant de modification (t=0) puis la valeur que l’on souhaite appliquer à RB0 (1),
enfin valider (Apply). On obtient ceci : Sur l’exemple de la Figure 9, toute pression avec la souris sur le bouton
provoquera une mise à l’état bas de RB0. Cet état est maintenu indéfiniment…

Initialiser le processeur (Reset) et exécuter à nouveau le programme.

Q- Vérifier que le programme fonctionne correctement. Modifier le programme

assembleur si besoin

13/47 14/47
 TP Microcontrôleur 1 INSA GE TP Microcontrôleur 1 INSA GE

Programmer le PIC : (interrupteur en position haute, LED rouge allumée) il est

4- Manipulations 3 : Exécution avec débogage sur le PIC (ICD) nécessaire d’envoyer le code machine dans le PIC. Procéder ainsi, dans le menu
Le kit ICD permet de déboguer un programme sur le circuit réel. Il est recommandé Degugger  Program
d’avoir validé globalement son programme avant de le tester sur les cartes (notamment Si la programmation s’est correctement déroulée, on obtient l’affichage suivant dans la
vérifier que les configurations des ports d’E/S correspondent aux câblages électronique). fenêtre Output :
Pour permettre le débogage sur le circuit, une partie des ressources du PIC est utilisée par
le kit ICD et le code transmis possède une surcouche permettant de faire le débogage.

• Alimentation des cartes « process » et « Mini »

 Quitter MPLAB.
 Connecter l’alimentation à la carte « process » PIC.
 Mettre l’interrupteur en position haute (la LED rouge est allumée).

• Connexion PC, kit ICD 2, carte à PIC

 Connecter le module ICD 2 à la carte process avec le cordon RJ11.
 Connecter le PC au module ICD 2 avec le cordon USB

Rem : Si windows détecte un nouveau périphérique :

- Fermer MPLAB (sauvegarder votre travail).
- Suivre les instructions de windows pour l’installation des pilotes. Les pilotes se
trouvent dans le répertoire :
C:\ Program Files\Microchip\MPLAB IDE\ICD 2\Drivers
- Relancer MPLAB IDE et ouvrir votre projet.

• Choisir ICD 2 comme outil de débogage

Dans le menu faire :
Debugger  Select Tool  MPLAB ICD 2
(Si besoin, préciser que le kit est connecté en USB.)
De nouvelles options sont alors disponibles dans le menu Debugger.

Commencer par initialiser la communication avec le module ICD 2 : Le programme est maintenant chargé dans le PIC mais le PC reste le superviseur de
Debugger  Connect l’exécution.
Si le kit est correctement configuré et connecté, on obtient l’affichage suivant dans la
fenêtre Output (sinon vérifier que l’interrupteur est en position haute et qua la LED rouge est • Exécution
allumée) :
Lancer le programme en faisant Degugger  Run (F9)
Pour arrêter l’exécution du programme faire Debugger  Halt (F5)

Q- Vérifier le fonctionnement de l’application.

• Débogage
De même qu’en simulation, il est possible de suivre l’évolution des registres et du
programme pas à pas. Il faut placer des breakpoint sur des lignes puis exécuter le programme
(F9). Il est ensuite possible de contrôler l’exécution du programme (Pas à pas : Step Into et
Step Over) et le contenu des registres (View  Watch).

Q- Mettre un breakpoint sur la ligne clrf tempo et suivre l’évolution des registres
PORTB et PORTD jusqu’à l’appel de la fonction Tempo_Wms (call Tempo_Ws).
• Construction et programmation du PIC

Enlever les breakpoint de votre code (double clic sur les lignes avec un breakpoint).

Faire une construction de votre projet (Build All).

15/47 16/47
 TP Microcontrôleur 1 INSA GE TP Microcontrôleur 2 INSA GE

5- Manipulations 4 : Programmation du PIC et fonctionnement II - Projet Chenille Lumineuse et notions avancées (2° séance)
autonome
Il s’agit de la programmation finale. Celle-ci permettra l’exécution du programme par le Le but de cette séance de TP est de réaliser une petite animation à LED où l’utilisateur
PIC sans aucune connexion au module ICD. pourra faire varier la vitesse de défilement ainsi que choisir le programme d’animation.
Pour programmer le PIC il faut choisir le kit ICD 2 comme programmateur. Il faut noter Cette application permettra de s’intéresser aux notions avancées de la programmation des
que le kit ICD peut soit être utilisé comme débogueur soit comme programmateur, mais pas PIC :
les deux en même temps. - adressage indirect,
- bits de configuration,
• Choisir ICD 2 comme outils de programmation - réservation statique d’espace mémoire,

Enlever ICD 2 comme débogueur (si besoin) : - utilisation du linker,
Debugger  Select Tool  None (ou MPLAB SIM)

Choisir ICD 2 comme programmeur : 1- Présentation
Programmer  Select Programmer  MPLAB ICD 2
• Description de l’application (cahier des charges)

Initialiser la communication avec le module :
Programmer  Connect
Il s’agit de réaliser une chenille lumineuse (chenillard) à 8 voies (commande indépendante
Si tout se passe bien, on obtient l’affichage suivant :
de 8 sorties). Plusieurs séquences d’animation seront programmées. L’utilisateur pourra
changer de séquence d’animation ainsi que la vitesse de défilement grâce aux 4 boutons
poussoirs.

• Organigramme global de l’application

Début

Initialisations - Initialisation des valeurs en RAM

- configuration des E/S
- Variables: vitesse, prg, nbpas, pas, touche, tempo
Attendre 1 ms

Lecture des touches et

• Programmation du PIC modification de vitesse et prg

Construire votre projet
nbpas = nombre de pas du prg en cours

Programmer le PIC : (interrupteur en position haute, LED rouge allumée) Mise à jour de nbpas et de pas pas = numéro du pas en cours
Programmer  Program

• Exécution du programme sur le PIC Lecture de la valeur du pas du prg en cours

Pour déconnecter électriquement le kit ICD sans déconnecter le câble RJ11, basculer
l’interrupteur en position basse (la LED rouge s’éteint). Le programme s’exécute sur le PIC Pilotage des sorties
(faire un reset : appuyer sur le bouton au dessous du connecteur RJ11).

Q- Vérifier le fonctionnement de l’application en autonomie.

tempo ++ Fin de tempo? Comparaison: tempo > vitesse ?

Q - Proposer et tester une solution plus convenable pour la gestion du bouton poussoir.

Fin du premier TP : vous devez être familiarisé avec MPLAB IDE/ICD et maitriser les Passer au pas suivant
principes de mise au point d’un programme.
Remettre tempo à 0

17/47 18/47
 TP Microcontrôleur 2 INSA GE TP Microcontrôleur 2 INSA GE

• Choix technologiques
3- Analyse du code assembleur
L’application sera basée sur les cartes « process » et « mini » (PIC 16F877A à 20MHz).
Q- Repérer les 3 parties du programme : configuration, déclaration (variables,
Les séquences d’animation seront stockées en mémoire RAM.
fonctions), implémentation.
On ne mettra pas en œuvre d’interruptions (rendez vous en 4GE).
• Fonctions :
Q- Combien de fonctions sont utilisées par le programme principal ?
Q- Donner leur nom et leur rôle et où elles sont implémentées (où est le code de la
2- Manipulations 1 : création du projet fonction).
 Créer un nouveau répertoire dans c: /temp. Q- Justifier la déclaration extern copy_init_data dans TPuC2.asm.
 Copier dans ce répertoire les fichiers suivant (présent dans « Mes Documents ») :
- TPuC_2.asm
- IDASM16.ASM • Variables et mémoires
- 16f877a.lkr Grâce à mplink, il est possible de réserver des espaces en mémoire RAM pour les
 Ouvrir MPLAB et créer un projet dans le répertoire C:\Temp. variables. Ceci est fait dans des sections comme udata et idata (il en existe d’autre).
 Ajouter à votre projet en tant que « source code » les copies des deux fichiers .asm. La section udata permet de réserver des espaces en mémoire RAM dont les valeurs ne
 Ajouter à votre projet comme « linker script » la copie de 16f877a.lkr. sont pas initialisées. On doit préciser la taille de l’espace mémoire (en octet) à réserver.
La section idata permet de réserver et d’initialiser des espaces mémoires RAM. La taille
Contrairement au TP précédent, mplink (le linkeur) sera utilisé pour construire ce de l’espace mémoire à allouer est directement déduite par le nombre des valeurs initiales.
projet (le fait d’inclure un fichier .lkr au projet provoque automatiquement l’utilisation de Quelque soit le type de section utilisé, chaque espace mémoire est nommé, c'est-à-dire
mplink). L’utilisation de mplink ajoute de nombreuses commandes et macro, notamment pour qu’il est identifié par une variable. Cette variable est équivalente à l’adresse de l’espace
la gestion et la réservation des variables. mémoire (ou du premier élément dans le cas d’un tableau).

Pour ce TP, seul le fichier TPuC_2.asm est à modifier. Q- Compléter la figure suivante représentant la mémoire RAM : ajouter le contenu
des variables table_nbpas et table_prg.
adresses contenu adresses contenu

prg0_pas 10000000 table_nbpas

prg0_pas + 1 11000000

prg0_pas + 2 01100000

00110000

…
prg1_pas 10000001
adresses contenu
prg1_pas + 1 01000010
table_prg
00100100

…
19/47 20/47
 TP Microcontrôleur 2 INSA GE TP Microcontrôleur 2 INSA GE

Q- Ajuster les valeurs du TIMER1 pour obtenir un temps d’attente d’environ W ms.
Q- Quel est le rôle de chacun de ces tableaux ? Donner l’erreur de votre fonction pour une attente des 1 ms et de 250 ms. Conclusions.

Remarque : pour la famille PIC16 les valeurs initiales sont stockées dans la ROM et
doivent ensuite être copiées dans la RAM au début du programme. D’où l’utilisation de la • Analyse des touches
fonction copy_init_data. La gestion des touches est faite dans la fonction Analyse_BP. Cette fonction n’est pas à
modifier.
Q- Analyser le code de la fonction copy_init_data. Quelles techniques de
programmation sont utilisées par cette fonction ? Q- Quel est le but de la première instruction : movf touche, f ?
Q- Donner l’organigramme de la fonction Analyse_BP.
Q- Expliquer le rôle de la variable « touche ».
Q- Justifier la présence des trois return de cette fonction en termes d’algorithme, de
4- Modifications et validation du code vitesse d’exécution et de lisibilité du programme. Juger la pertinence de chacun de ces
trois critères.
• Fonction Tempo_Ws
Q- Compléter le code suivant provoquant le warning (Message):
• Accès au nombre de pas de la séquence en cours :
Tempo_Wms_B1: Q- Compléter le programme principal en insérant le code permettant de mettre dans
movf Tempo_Wms_value ; la variable nbpas le nombre de pas de la séquence en cours. Le nombre de pas de la
btfsc STATUS, Z séquence encours prg est la valeur table_nbpas[prg] (se reporter à la question 3 : Analyse
Q- Compléter le code de la fonction Tempo_Wms : il manque la valeur de du code assembleur).
configuration du TIMER1 (T1CON) ainsi que les valeurs de TMR1H et TMR1L. Cette Rappels : - movlw table_nbpas
fonction doit permettre de faire une pause de W millisecondes. charge la valeur littérale de table_nbpas dans W, c'est-à-dire la valeur équivalente au nom
« table_nbpas ». Il s’agit d’une adresse. Cette instruction correspond en langage C à
Q- Vérifier par simulation le temps d’attente de votre fonction : &(table_nbpas[0]) -> W (ou plus simplement table_nbpas -> W).
 Passer en débogage par simulation (MPLAB SIM).
 Ouvrir l’outil StopWatch qui permet de compter le nombre de cycles (et le temps) - movf table_nbpas, W
exécutés : charge dans W le contenu du registre table_nbpas, c'est-à-dire la valeur contenue à
Debugger  StopWatch. l’adresse mémoire représentée par table_nbpas. Ceci correspond à table_nbpas[0] -> W en
 Mettre un breakpoint sur la ligne call Tempo_Wms. langage C.
 Exécuter le programme (Run). - pour accéder aux éléments d’un tableau, il faut utiliser l’adressage indirect…
 Quand le programme bloque sur le breakpoint, cliquer sur « Zero » de la fenêtre (cf. annexe page 30).
StopWatch (remise à 0 des compteurs de cycles et de temps).
 Exécuter la fonction (conseil : sans faire du pas à pas dans le code de la fonction). Q- Valider par simulation sur PC le code ajouté.
 Le temps écoulé est donné dans la fenêtre Stopwatch.

• Accès au pas de la séquence en cours :

Q- Même travail pour l’accès à la valeur du pas de la séquence en cours : charger
dans W la valeur de table_pas[prg][pas].

Q- Valider par simulation sur PC le code ajouté.

Figure 10 : Fenêtre Stopwatch.

21/47 22/47
 TP Microcontrôleur 2 INSA GE Annexes : TP Microcontrôleur INSA GE

5- Programmation du PIC
Annexes :
• Etude des bits de configuration
 Compiler le programme. Ouvrir hors de MPLAB le fichier .lst du nom de votre projet.
Q- Qu’est ce que l’adresse 2007 ?
Q- Qu’elle est la valeur mise à cette adresse ? A quoi correspond cette valeur ?

• Etude de la gestion des espaces mémoires Extraits de la documentation du 16F877

 Ouvrir hors de MPLAB le fichier .map .
Q- Que contient ce fichier ? - Organisation mémoire 25
Q- Qu’elles sont les adresses attribuées à prg0_pas et table_nbpas en RAM ? - Détails des registres 26
Q- A qu’elle adresse ROM commence le stockage des valeurs initiales des tableaux ? - Registre STATUS 29
Q- Combien d’octets en RAM sont encore libres dans la bank0 ? - Adressage indirect 30
- Description du PORTA 31
- Description du PORTB 32
• Validation du fonctionnement - Description du PORTC 33
- Description du PORTD 34
Q- Valider votre programme sur les cartes PIC. Faire des tests ! - Description TIMER1 35
- Jeu d’instructions 37

Schéma des cartes « Mini » et « process » et Implémentation

6- Améliorations des cartes

Q- Ajouter une séquence lumineuse de votre composition.

Code assembleur TPuC_1.asm (séance 1)
Q- Modifier le code pour permettre une incrémentation et une décrémentation
rapides si on maintient les boutons poussoirs enfoncés.

Code assembleur TPuC_2.asm (séance 2)

Fin du deuxième TP : les microcontrôleurs ? ça fait pas peur !

23/47 24/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

Figure 12 : Description des registres

Figure 11 : Organisation mémoire

25/47 26/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

27/47 28/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

Figure 14 : Adressage indirect

Figure 13 : Description du register STATUS

29/47 30/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

Figure 15 : Description du PORTA

Figure 16 : Description PORTB

31/47 32/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

Figure 18 : Description PORTD

Figure 17 : Description PORTC

33/47 34/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

Figure 19 : Description TIMER1

35/47 36/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

Annexes :
Schéma des cartes « Mini » et « process »
Implémentation des cartes

Figure 21 : Schéma de la carte « Mini »

Figure 20: Jeu d’instructions des PIC 16

37/47 38/47
Annexes : TP Microcontrôleur INSA GE Annexes : TP Microcontrôleur INSA GE

Figure 22 : Implantation de la carte « Mini »

Figure 23 : Implantation de la carte « process »

39/47 40/47
 Annexe : code TP1 INSA GE Annexe : code TP1 INSA GE

goto Tempo_Ws_B1; Tempo_Wms_Value != 0

Annexes : Code assembleur TPuC_1.asm (séance 1) bcf T1CON, TMR1ON ; Timer1 stops to increment
AVEC LES ERREURS nécessaires au TP…;) RETURN

; ******************************************************************
#include <p16F877A.inc> ; processor specific variable definitions main:
__CONFIG _HS_OSC & _WDT_OFF & _BODEN_OFF & _LVP_OFF & _PWRTE_OFF &
_CPD_OFF & _WRT_OFF & _CP_OFF bsf STATUS, RP0; Selection bank 1
bcf TRISD ; mise à 0 du bit 0 de TRISD
;***** VARIABLE DEFINITIONS bsf TRISB, 0 ; mise à 1 du bit 0 de TRISB
Tempo_Ws_value equ 0x0020 bcf STATUS, RP0 ; Selection bank 0
Tempo_Ws_mem equ 0x0021
tempo equ 0x0022 bcf PRTD,0
;********************************************************************** main_prg:
ORG 0x0000 ; processor reset vector ; init tempo
goto main ; go to beginning of program clrf tempo;
ORG 0x0010
; touche ?
Tempo_Ws: btfsc PORTB, 0
movwf Tempo_Ws_value ;dans W temps en ms à attendre goto main_prg
; INIT compteur
bsf STATUS, RP0 ; Bank1 ; allumage
clrf PIE1 ; Disable peripheral interrupts bsf PORTD,0
bcf STATUS, RP0 ; Bank0
clrf PIR1 ; Clear peripheral interrupts Flags main_attente:
movlw 0x30 ; Internal Clock source with 1:8 prescaler ; attendre 1s
movwf T1CON ; Timer1 is stopped and T1 osc is disabled movl .1
call Tempo_Ws
movlw 0x76
movwf TMR1H ; ; touche ?
movlw 0x97 btfss PORTB, 0
movwf TMR1L ; goto main_eteindre
bsf T1CON, TMR1ON ; Timer1 starts to increment
; incrementer tempo : tempo = tempo + 1
; 20 MHz / 4 = 5MHz incf tempo
; prescale de 8 : 5MHZ /8 = 625kHz soit 625 000 incrémentations = 1 s
; nombre de remplissage du compteur 16 bits : 625000/65536 = 9,53 .... (>9) ; fin tempo ?
; pour 9 : 9 * 65536 = 589824 incrémentations réalisées movf tempo
; il manque 625000 - 589824 = 35176 incrémentations sublw .10
; donc charger le compteur avec 65536 - 35176 = 30359 => 0x7697 btfss STATUS, Z
; il faut donc partir de cette valeur puis boucler 9 fois (1+9 = 10 it) goto main_attente ; Z=0
Tempo_Ws_B1:
movlw 0x0A main_Eteindre:
movwf Tempo_Ws_mem ; eteindre LED
Tempo_Ws_B2: bcf PORTD, 0 ; LED eteinte
Tempo_Ws_OVFL_WAIT:
btfss PIR1, TMR1IF ; attendre 1s
goto Tempo_Ws_OVFL_WAIT movlw .1
; Timer has overflowed call Tempo_Ws
bcf PIR1, TMR1IF
; 9 * ; retour au debut
decfsz Tempo_Ws_mem, f; s goto main_prg
goto Tempo_Ws_B2; Tempo_Wms_Value != 0 END ; directive 'end of program'

decfsz Tempo_Ws_value, f; s

41/47 42/47
 Annexe : code TP2 INSA GE Annexe : code TP2 INSA GE

btfsc STATUS, Z
Annexes : Code assembleur TPuC_2.asm (séance 2) return
AVEC LES ERREURS nécessaires au TP…;) decf Tempo_Wms_value, f

;-->
; CODE INCOMPLET !!!! special TP2...
movlw 0x??
movwf TMR1H ;
#include <p16F877A.inc> ; processor specific variable definitions
;-->
__CONFIG _HS_OSC & _WDT_OFF & _BODEN_OFF & _LVP_OFF & _PWRTE_OFF &
movlw 0x??
_CPD_OFF & _WRT_OFF & _CP_OFF
movwf TMR1L ;
bsf T1CON, TMR1ON ; Timer1 starts to increment
#define NB_PRG 4
Tempo_Wms_OVFL_WAIT:
;***** VARIABLE DEFINITIONS
btfss PIR1, TMR1IF
extern copy_init_data
goto Tempo_Wms_OVFL_WAIT
udata
; Timer has overflowed
Tempo_Wms_value res 1
bcf PIR1, TMR1IF
tempo res 1
bcf T1CON, TMR1ON ; Timer1 stops to increment
pas res 1
goto Tempo_Wms_B1
prg res 1
vitesse res 1
nbpas res 1
; ******************************************************************
touche res 1
; Lecture de PORTB
; lecture et modification de "touche", "prg", "vitesse"
idata
Analyse_BP:
prg0_pas db b'10000000', b'11000000', b'01100000', b'00110000',
;lecture des touches si: touche = 0?
b'00011000', b'00001100', b'00000110',b'00000011'
movf touche, f
db b'00000001', b'00000011', b'00000110', b'00001100',
btfsc STATUS, Z
b'00011000', b'00110000', b'01100000', b'11000000'
goto Analyse_BP0
prg1_pas db b'10000001', b'01000010', b'00100100', b'00011000',
; sinon plus de touches appuyées sur le portB ?
b'00011000', b'00100100', b'01000010', b'10000001'
movf PORTB, W
prg2_pas db b'10101010',b'01010101'
sublw 0x0F
prg3_pas db b'10001000',b'01000100', b'00100010', b'00010001'
btfss STATUS, Z
return ; non : pas de lecture
table_prg db prg0_pas, prg1_pas, prg2_pas, prg3_pas
table_nbpas db .16, .8, .2, .4
; gestion du relachement des touches
clrf touche;
;**************************************************************
RST CODE 0x0
; Lecture des touches
goto main ; go to beginning of program
Analyse_BP0:
btfsc PORTB, 0 ; BP moins vite!
PGM CODE
goto Analyse_BP1 ; pas appuyé : on va voir un autre bouton
Tempo_Wms:
movwf Tempo_Wms_value ; dans W : le temps en ms à attendre
incf touche, f; gestion touche
; INIT compteur
; on incremente (ralentir) si vitesse < 255
bsf STATUS, RP0 ; Bank1
movlw .255
clrf PIE1 ; Disable peripheral interrupts
subwf vitesse, W
bcf STATUS, RP0 ; Bank0
btfss STATUS, C
clrf PIR1 ; Clear peripheral interrupts Flags
incf vitesse, f ;
;-->
movlw 0x?? ;
Analyse_BP1:
movwf T1CON ;
btfsc PORTB, 1 ; BP plus vite
goto Analyse_BP2; pas appuyé : on va voir le bouton suivant
Tempo_Wms_B1:
movf Tempo_Wms_value
incf touche, f; gestion touche

43/47 44/47
 Annexe : code TP2 INSA GE Annexe : code TP2 INSA GE

; on decremente (accelerer) si vitesse > 0

movf vitesse, f; pour positionner le flag Z movf table_nbpas, W
btfss STATUS, Z movwf nbpas; le nombre de pas du programme
decf vitesse, f
clrf tempo; ; on part de 0
Analyse_BP2:
btfsc PORTB, 2 ; BP : prg -- main_prg:
goto Analyse_BP3 ; attente de 1 ms
movlw .1
incf touche, f; gestion touche call Tempo_Wms
; prg > 0 nop ; pour debug
movf prg, f; pour positionner le flag Z
btfss STATUS, Z ; fonction analyse des touches
decf prg, f call Analyse_BP

Analyse_BP3: ; mise à jour nbpas : table_nbpas[prg] -> nbpas

btfsc PORTB, 3 ; BP : prg ++ ; movlw table_nbpas
return ; fin de la fonction ;
;
incf touche, f; gestion touche ;
; on increment jusqu'à 2 ; movwf nbpas
movlw NB_PRG-1
subwf prg, W ; pas = nbpas ?
btfss STATUS, C movf pas, W
incf prg, f subwf nbpas, W
return btfsc STATUS, Z
clrf pas
; pas > nbpas (nbpas - pas < 0) ?
btfss STATUS, C
; ****************************************************************** clrf pas
main:
; Initialisation des valeurs en RAM ; lire table[prg][pas] -> W
call copy_init_data ; movlw table_prg
;
; Init E/S ;
clrf PORTB ;
clrf PORTD ;
;
bsf STATUS, RP0; bank 1 ;

movlw 0x0F ; W -> PORTD

movwf TRISB ; 4 premiers bits de PORTB en entrée movwf PORTD

clrf TRISD ; PORTD en sortie ; tempo > vitesse ? si oui changer de pas
movf vitesse, W
bcf STATUS, RP0; bank 0 subwf tempo, W
btfsc STATUS, C
; Init des variables goto pas_suivant
clrf touche
; tempo ++
movlw .150 incf tempo, f
movwf vitesse; 150 : vitesse par initiale ; retour au debut du prg
goto main_prg
clrf pas; premier pas
pas_suivant:
clrf prg ; prg0 = prg par defaut ; pas suivant

45/47 46/47
 Annexe : code TP2 INSA GE

incf pas, f

; remise à 0 de tempo
clrf tempo

;retour au debut du prg

goto main_prg

END

47/47