V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE
UNIVERSITE M’HAMED BOUGARA DE BOUMERDES
FACULTE DES SCIENCES
Département de Physique
Spécialité : InfoTronique
V.TOURTCHINE
MICROCONTROLEUR DE LA FAMILLE PIC
Support de cours & Prise en main du logiciel MPLAB
Manuscrit élaboré selon le programme officiellement agrée et confirmé par le Conseil
Scientifique de la Faculté des Sciences
BOUMERDES - 2009
-0-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
I. LES MICROCONTROLEURS
1.1 Qu’est ce qu’un microcontrôleur (μC):
C’est un ordinateur monté dans un circuit intégré. Les avancées
technologiques en matière d’intégration, ont permis d’implanter sur une puce de
silicium de quelques millimètres carrés la totalité des composants qui forment la
structure de base d’un ordinateur.
Comme tout ordinateur, on peut décomposer la structure interne d’un
microprocesseur en trois parties :
-Les mémoires
-Le processeur
-Les périphériques
Les mémoires sont chargées de stocker le programme qui sera exécuté
ainsi que les données nécessaires et les résultats obtenus.
Le processeur est le cœur du système puisqu’il est chargé d’interpréter les
instructions du programme en cours d’exécution et de réaliser les opérations
qu’elles contiennent .Au sein du processeur, l’unité arithmétique et logique
ALU interprète, traduit et exécute les instructions de calcul.
Les périphériques ont pour tâche de connecter le processeur avec le
monde extérieur dans les deux sens. Soit le processeur fournit des
informations vers l’extérieur (périphérique de sortie), soit il en reçoit
(périphérique d’entrée).
Les PICs sont des composants RISC (Reduce Instructions Construction Set),
ou encore composant à jeu d’instructions réduit. L'avantage est que plus on réduit le
nombre d’instructions, plus facile et plus rapide en est le décodage, et plus vite le
composant fonctionne.
La famille des PICs est subdivisée en 3 grandes familles : La famille BaseLine, qui utilise des mots d’instructions de 12 bits, la famille Mid-Range, qui utilise
des mots de 14 bits (et dont font partie la 16F84 et 16F876), et la famille High-End,
qui utilise des mots de 16 bits (18FXXX).
Pour identifier un PIC, on utilise simplement son numéro :
 Les 2 premiers chiffres indiquent la catégorie du PIC, 16 indique un PIC MidRange.
 Vient ensuite parfois une lettre L, celle-ci indique que le PIC peut fonctionner
avec une plage de tension beaucoup plus tolérante.
 Vient en suite une ou deux lettres pour indiquer le type de mémoire programme :
- C indique que la mémoire programme est une EPROM ou plus rarement une
EEPROM
- CR pour indiquer une mémoire de type ROM
- F pour indiquer une mémoire de type FLASH.

On trouve ensuite un nombre qui constitue la référence du PIC.
-1-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------

On trouve ensuite un tiret suivi de deux chiffres indiquant la fréquence d’horloge
maximale que le PIC peut recevoir.
1.2 Intérêt des microcontrôleurs :
Les microcontrôleurs sont de taille tellement réduite qu’ils peuvent être sans
difficulté implantés sur l’application même qu’ils sont censés piloter. Leur prix et leurs
performances simplifient énormément la conception de système électronique et
informatique.
On peut encore préciser :
 Les performances sont identiques voir supérieurs à ses concurrents.
 Très utilisé donc très disponible.
 Les outils de développement sont gratuits et téléchargeables sur le WEB.
 Le jeu d'instruction réduit est souple, puissant et facile à maîtriser.
 Les versions avec mémoire flash présentent une souplesse d'utilisation et des
avantages pratiques indéniables.
 La communauté des utilisateurs des PICs est très présente sur le WEB. On
trouve sur le Internet quasiment tout ce dont on a besoin, tutoriaux pour
démarrer, documents plus approfondis, schémas de programmeurs avec les
logiciels qui vont avec, librairies de routines, forums de discussion . . .
L’utilisation des microcontrôleurs ne connaît de limite que l’ingéniosité des
concepteurs, on les trouve dans nos cafetières, les magnétoscopes, les radios
II. PRESENTATION GENERALE DU PIC 16F84
Nous nous limiterons dans ce support de cours à la famille Mid-Range et
particulièrement au PIC 16F84, sachant que si on a tout assimilé, on pourra
facilement passer à une autre famille, et même à un autre microcontrôleur.
Donc, un 16F84-04 est un PIC Mid-Range dont la mémoire programme est de
type FLASH de référence 84 et capable d’accepter une fréquence d’horloge de
4MHz.
Notez que les PICs sont des composants STATIQUES, c’est à dire que la
fréquence d’horloge peut être abaissée jusque l’arrêt complet sans perte de données
et sans dysfonctionnement. Une version –10 peut donc toujours être employée sans
problème en lieu et place d’une – 04. Pas l’inverse, naturellement.
Le PIC 16F84 est un microcontrôleur 8 bits. Il dispose donc d'un bus de
données de huit bits. Puisqu’il traite des données de huit bits, il dispose d’une
mémoire de donnée dans laquelle chaque emplacement (défini par une adresse)
possède huit cases pouvant contenir chacune un bit.
L’organisation générale du PIC 16F84 est composée par 4 blocs principaux
comme le montre la figure 1 :
-Mémoire de programme
-Mémoire de données
-Processeur
-Ressources auxiliaires (périphériques)
La mémoire de programme contient les instructions pilotant l’application à
laquelle le microcontrôleur est dédié. Il s’agit d’une mémoire non volatile ( elle garde
son contenu, même en l’absence de tension ), elle est de type FLASH c’est à dire
-2-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
qu’elle peut être programmée et effacée par l’utilisateur via un programmateur et un
PC. La technologie utilisée permet plus de 1000 cycles d’effacement et de
programmation. Pour le PIC 16F84 cette mémoire est d’une taille de 1024*14 bits,
c’est à dire qu’elle dispose de 1024 emplacements (de 000h à 3FFh) contenant
chacun 14 cases car dans le cas du PIC, les instructions sont codées sur 14 bits. On
peut donc stocker 1024 instructions.
Fig.1
La mémoire de donnée est séparée en deux parties :
-une mémoire RAM de 68 octets puisque le bus de donnée est de huit bits.
Cette RAM est volatile (les données sont perdues à chaque coupure de courant). On
peut y lire et écrire des données.
-une mémoire EEPROM de 64 octets dans laquelle on peut lire et écrire des
données (de huit bits soit un octet) et qui possède l’avantage d’être non volatile (les
données sont conservées même en l’absence de tension). La lecture et l’écriture
dans cette mémoire de données sont beaucoup plus lentes que dans la mémoire de
données RAM.
Le processeur est formé de deux parties :
-une unité arithmétique et logique (ALU) chargée de faire des calculs.
-un registre de travail noté W sur lequel travail l’ALU.
Les ressources auxiliaires qui sont dans le cas du PIC16F84
- ports d’entrées et de sorties.
- temporisateur.
- interruptions
- chien de garde
- mode sommeil
Ces ressources seront analysées dans la suite du cours.
-3-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
III. ARCHITECTURE DU PIC 16F84
3.1 Brochage et caractéristiques principales
Le PIC16F84 est un circuit intégré de 18 broches (Fig. 2) :
Fig.2
L’alimentation du circuit est assurée par les pattes VDD et VSS. Elles
permettent à l’ensemble des composants électroniques du PIC de fonctionner.
Pour cela on relie VSS (patte 5) à la masse (0 Volt ) et VDD (patte 14) à la
borne positive de l’alimentation qui doit délivrer une tension continue comprise
entre 3 et 6 Volts.
Le microcontrôleur est un système qui exécute des instructions les
unes après les autres à une vitesse (fréquence) qui est fixée par une horloge
interne au circuit. Cette horloge doit être stabilisée de manière externe au
moyen d’un cristal de quartz connecté aux pattes OSC1/CLKIN (patte 16) et
OSC2/CLKOUT (patte 15).
La patte 4 est appelée MCLR. Elle permet lorsque la tension
appliquée est égale à 0V de réinitialiser le microcontrôleur. C’est à dire que si
un niveau bas (0 Volt) est appliqué sur MCLR le microcontrôleur s’arrête,
place tout ses registres dans un état connu et se redirige vers le début de la
mémoire de programme pour recommencer le programme au début (adresse
dans la mémoire de programme : 0000).
A la mise sous tension, la patte MCLR étant à zéro, le programme démarre
donc à l’adresse 0000,( MCLR=Master CLear Reset ).
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
Les broches RB0 à RB7 et RA0 à RA4 sont les lignes
d’entrées/sorties numériques. Elles sont au nombre de 13 et peuvent être
-4-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
configurées en entrée ou en sortie. Ce sont elles qui permettent au
microcontrôleur de dialoguer avec le monde extérieur (périphériques).
L’ensemble des lignes RB0 à RB7 forme le port B et les lignes RA0 à RA4
forment le port A. Certaines de ces broches ont aussi d’autres fonctions
(interruption, timer).
3.2 Structure interne
La structure interne du PIC16F84 est donnée figure 3 : (structure HARVARD :
la mémoire de programme et la mémoire de données sont séparées contrairement à
l'architecture Von Neuman qui caractérise d'autres fabricants de microcontrôleurs).
Fig.3
On retrouve sur ce schéma la mémoire de programme, la mémoire RAM de
données, la mémoire EEPROM, les ports A et B, ainsi que la partie processeur avec
-5-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
l’UAL et le registre de travail W (World). Nous allons étudier à présent plus en détail
le fonctionnement du PIC.
3.2 Principe de fonctionnement du PIC
Un microcontrôleur exécute des instructions. On définit «le cycle instruction »
comme le temps nécessaire à l’exécution d’une instruction. Attention de ne pas
confondre cette notion avec le cycle d’horloge qui correspond au temps nécessaire à
l’exécution d’une opération élémentaire (soit un coup d'horloge).
Une instruction est exécutée en deux phases :
la phase de recherche du code binaire de l’instruction stocké dans la
mémoire de programme
la phase d’exécution ou le code de l’instruction est interprété par le
processeur et exécuté.
Chaque cycle instruction dure 4 coup d’horloge comme le montre la figure 4 :
Fig.4
On pourrait donc croire qu’un cycle instruction dure 8 cycles d’horloge mais
l’architecture particulière du PIC lui permet de réduire ce temps par deux.
En effet, comme les instructions issues de la mémoire de programme circulent
sur un bus différent de celui sur lequel circulent les données, ainsi le processeur peut
effectuer la phase de recherche d’une instruction pendant qu’il exécute l’instruction
précédente (voir les figure 5 et 6).
Fig.5
-6-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Fig.6
3.4 Déroulement d’un programme
Le déroulement d’un programme s’effectue de façon très simple.
A la mise sous tension, le processeur va chercher la première instruction qui
se trouve à l’adresse 0000 de la mémoire de programme, l’exécute puis va chercher
la deuxième instruction à l’adresse 0001 et ainsi de suite (sauf cas de saut ou
d’appel de sous programme que nous allons voir plus loin). On parle de
fonctionnement séquentiel.
La figure 7 va nous permettre de mieux comprendre le fonctionnement :
Fig. 7
-7-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
On constate sur cette figure que la mémoire de programme contient
1024 emplacements (3FF en hexadécimale) contenant 14 bits (de 0 à 13).
Une instruction occupe un emplacement qui est défini par une adresse. Le
processeur peut alors sélectionner l'emplacement souhaité grâce au bus
d’adresse et il peut lire son contenu (ici l’instruction) grâce à son bus
d’instruction (voir figure 6). Cet adressage s’effectue à l’aide d’un compteur
ordinal appelé PC qui lors de la mise sous tension démarre à zéro puis
s’incrémente de 1 tous les quatre coups d’horloge, on exécute bien ainsi les
instructions les unes à la suite des autres.
Mais il arrive que dans un programme on fasse appel à un sous
programme dont l’adresse de l’instruction ne se trouve pas juste après celle
qui est en train d’être exécutée. C’est le rôle de la pile qui sert à emmagasiner
de manière temporaire l’adresse d’une instruction. Elle est automatiquement
utilisée chaque fois que l’on appelle un sous programme et elle permet une
fois que l’exécution du sous programme est terminée de retourner dans le
programme principal juste après l’endroit où l’on a appelé le sous programme.
On constate que cette pile possède huit niveaux, cela signifie qu’il n’est pas
possible d’imbriquer plus de huit sous programmes, car au-delà de huit, le
processeur ne sera plus capable de retourner à l’adresse de base du
programme principal.
L’adresse 0000 est réservée au vecteur RESET, cela signifie que
c’est à cette position que l’on accède chaque fois qu’il se produit une
réinitialisation (0 volts sur la patte MCLR). C’est pour cette raison que le
programme de fonctionnement du microcontrôleur doit toujours démarrer à
cette adresse.
L’adresse 0004 est assignée au vecteur d’interruption et fonctionne
de manière similaire à celle du vecteur de Reset. Quand une interruption est
produite et validée, le compteur ordinal PC se charge avec 0004 et
l’instruction stockée à cet emplacement est exécutée.
3.5 La mémoire de données RAM
Si l’on regarde la mémoire de donnée RAM, on s’aperçoit que celle-ci est un
peu particulière comme le montre la figure 8 :
-8-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Fig. 8
On constate en effet que cette mémoire est séparée en deux pages (page 0 et
page 1). De plus, on remarque que tant pour la page 0 que pour la page 1, les
premiers octets sont réservés pour SFR (Special File Registre). Ces emplacements
sont en effet utilisés par le microcontrôleur pour configurer l’ensemble de son
fonctionnement. On les appelle registres spécifiques et nous verrons au chapitre
suivant leurs rôles.
Le bus d’adresse qui permet d’adresser la RAM est composé de 7 fils ce qui
veut dire qu’il est capable d’adresser 128 emplacements différents. Or, chaque page
de la RAM est composée de 128 octets, le bus d’adresse ne peut donc pas accéder
aux deux pages, c’est pourquoi on utilise une astuce de programmation qui permet
de diriger le bus d’adresse soit sur la page 0, soit sur la page 1. Cela est réalisé
grâce à un bit d’un registre spécifique (le bit RP0 du registre STATUS) dont nous
verrons le fonctionnement plus loin.
La RAM de données proprement dite se réduit donc à la zone notée GPR
(Registre à usage générale ) qui s’étend de l’adresse 0Ch (12 en décimale jusqu’à
-9-
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
4Fh (79 en décimale soit au total 68 registres en page 0 et autant en page 1, mais
on constate que les données écrites en page 1 sont redirigées en page 0 cela
signifie qu’au final l’utilisateur dispose uniquement de 68 registres (donc 68 octets de
mémoire vive) dans lesquels il peut écrire et lire à volonté en sachant qu’à la mise
hors tension, ces données seront perdues.
3.6 Les registres
Nous avons vu au chapitre précédent que la mémoire de données RAM
contenait des registres spécifiques qui permettent de configurer le PIC, nous allons
les détailler un à un et voir comment on peut accéder à la page 0 ou la page 1. Afin
de faciliter la compréhension, les registres les plus utilisés sont encadrés et
enfoncés.
adresse 00 et 80 ,INDF . Cette adresse ne contient pas de registre
physique, elle sert pour l’adressage indirect.
adresse 01 , TMR0 . Contenu du Timer (8 bits). Il peut être incrémenté par
l’horloge (tous les 4 coups d'horloge) ou par la broche RA4.
adresse 02 et 82 , PCL .8 bits de poids faibles du compteur ordinal PC. Les
5 (13-8) bits de poids forts sont dans PCLATH.
adresse 03 et 83 , STATUS Registre d’état .
Les cinq bits de poids faible de ce registre sont en lecture seule, ce sont des
témoins (drapeaux ou flag en anglais) caractérisant le résultat de l’opération
réalisée par l’UAL. Le bit RP0 est lui en lecture /écriture et c’est lui qui permet
de sélectionner la page dans la mémoire RAM.
Si RP0=0 on accède à la page 0 et si RP0=1 on accède à la page 1 .
RP0
TO/
PD/
Z
DC
C
Au reset, seul le bit RP0 de sélection de page est fixé (RP0=0 : page 0)
TO/ (Time Out) : débordement du timer WDT
PD/ : (Power Down) caractérise l’activité du chien de garde WDT
Z
(Zéro) résultat nul pour une opération arithmétique et logique.
DC
C
(Digit Carry) retenue sur un quartet (4 bits)
(Carry) retenue sur un octet (8 bits).
adresse 04 et 84 , FSR . Registre de sélection de registre : contient
l’adresse d’un autre registre (adressage indirect)
adresse 05 , PORTA . Ce registre contient l’état des lignes du port A (voir
chapitre sur les ports).
adresse 06 , PORTB . Ce registre contient l’état des lignes du port B (voir
chapitre sur les ports).
- 10 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
adresse 08 , EEDATA .Contient un octet lu ou à écrire dans l’EEPROM de
données.
adresse 09 , EEADR . Contient l’adresse de la donnée lue ou écrite dans
l’EEPROM de données.
adresse 0A et 8A, PCLATH . Voir l’adresse 02 PCL.
adresse 0B et 8B , INTCON .
Contrôle des 4 interruptions
GIE
EEIE T0IE INTE RBIE
T0IF INTF
RBIF
Masques :
GIE : (Global Interrupt Enable) : masque global d’inter.
EEIE : (EEProm Interrupt Enable) autorise l'interruption venant de l'EEPROM.
T0IE : (Timer 0 Interrupt Enable) autorise l'interruption provoquée par le
débordement du TIMER0
INTE: (Interrupt Enable) autorise l’interruption provoquée par un changement
d'état sur broche RB0/INT
RBIE: (RB Interrupt Enable) autorise les interruptions provoquées par un
changement d'états sur l'une des broches RB4 à RB7. Si ces bits sont mis à 1,
ils autorisent les interruptions pour lesquels ils sont dédiés.
Drapeaux :
T0IF : (Timer 0 Interrupt Flag) débordement du TIMER
INTF ( Interrupt Flag) interruption provoquée par la broche RB0/INT
RBIF ( RB Interrupt Flag) interruption provoquée par les broches RB4-RB7.
adresse 81 , OPTION
8 bits (tous à 1 au RESET) affectant le comportement des E/S et de TIMER.
RBPU INTEDG RTS RTE PSA PS PS1
2
1
PS
0
RBPU/ (RB Pull-Up) Résistances de tirage à Vdd des entrées du port B (voir
le détail du fonctionnement au chapitre port). Si RBPU=0 les résistances de
Pull-Up sont connectées en interne sur l'ensemble du port B.
- 11 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
INTEDG (Interrupt Edge) sélection du front actif de l’interruption sur RB0/INT
(1 pour front montant et 0 pour front descendant).
RTS (Real Timer Source) sélection du signal alimentant le timer 0 : 0 pour
horloge interne, 1 pour RA4/T0CLK
RTE (Real Timer Edge) sélection du front actif du signal timer (0 pour front
montant).
PSA (Prescaler Assignment) 0 pour Timer 0 et 1 pour chien de garde WDT.
PS2…0 (PreScaler 210) sélection de la valeur du diviseur de fréquence pour
les timers.
adresse 85 , TRISA . Direction des données pour le port A : 0 pour sortir et
1 pour entrer (voir chapitre sur les ports).
adresse 86 , TRISB . Direction des données pour le port B : 0 pour sortir et
1 pour entrer (voir chapitre sur les ports).
adresse 88 , EECON1 Contrôle le comportement de l’EEPROM de
données.
EEIF
WRERR WREN WR
RD
EEIF (EEProm Interrupt Flag) passe à 1 quand l’écriture est terminée.
WRERR (WRite Error) 1 si erreur d’écriture.
WREN (WRite Enable) : 0 pour interdire l’écriture en EEPROM de données.
WR (WRite) 1 pour écrire une donnée. Bit remis automatiquement à 0
RD (ReaD) : 1 pour lire une donnée. Bit remis automatiquement à 0
adresse 89 , EECON2 . Registre de sécurité d’écriture en EEPROM de
données.
Une donnée ne peut être écrite qu’après avoir écrit successivement 0x55 et
0xAA dans ce registre.
3.7 Les ports d’entrées/sorties
Le PIC16F84 est équipé de 13 lignes d’entrées/sorties réparties en deux ports :
-le port A : RA0 à RA4
-le port B : RB0 à RB7
Chaque ligne peut être configurée soit en entrée, soit en sortie, et ceci
indépendamment l’une de l’autre. Pour cela on utilise les registres TRISA et TRISB.
Le bit de poids faible (b0) du registre TRISA correspond à la ligne RA0, le bit
b1 de TRISA correspond à RA1 et ainsi de suite. Il en est de même pour le port B et
le registre TRISB (b0 de TRISB correspond à RB0  b7 correspond à RB7).
- 12 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Si l’on veut placer une ligne en sortie il suffit de mettre le bit correspond dans
TRISA ou TRISB à 0 (à retenir : 0 comme Output = sortie).
Si l’on veut placer une ligne en entrée, il suffit de placer le bit correspondant
dans TRISA ou TRISB à 1 (à retenir : 1 comme Input = entrée).
Les bits des deux registres PORTA et PORTB permettent soit de lire l’état
d’une ligne si celle-ci est en entrée, soit de définir le niveau logique d’une ligne si
celle-ci est en sortie.
Lors d’un RESET, toutes les lignes sont configurées en entrées.
Important :
Particularité du PORTA :
 les bits b7 à b5 des registres TRISA et PORTA ne correspondent à rien car il n’y
a que 5 lignes (b0 à b4). RA4 est une ligne à collecteur ouvert, cela veut dire
que configurée en sortie cette broche assure 0 Volt à l’état bas, mais qu’à l’état
haut, il est nécessaire de fixer la valeur de la tension grâce à une résistance de
tirage (pull up en anglais)
Particularité du PORTB :
 il est possible de connecter de façon interne sur chaque ligne une résistance de
tirage (pull up) dont le rôle consiste à fixer la tension de la patte (configuré en
entrée) à un niveau haut lorsque qu’aucun signal n’est appliqué sur la patte en
question. Pour connecter ces résistances, il suffit de placer le bit RBPU/ du
registre OPTION à 0.
3.8 Le Timer
Dans la majeure partie des applications, il est nécessaire de contrôler le
temps; afin de ne pas occuper le microcontrôleur qu'à cette tâche (boucle de
comptage qui monopolise le micro), on le décharge en utilisant un timer. Le pic
16F84 dispose de deux timers, un à usage général (le TMR0) et un autre utilisé pour
le chien de garde (watch dog WDG).
Le TMR0 est un compteur ascendant (qui compte) de 8 bits qui peur être
chargé avec une valeur initiale quelconque. Il est ensuite incrémenté à chaque coup
d'horloge jusqu'à ce que le débordement ait lieu (passage de FF à 00).
Le principe est représenté figure 9 :
Fig.9
Le TMR0 peut remplir deux fonctions:
-Temporisateur ou contrôle du temps. Son entrée d'incrémentation est
alors l'horloge qui correspond au cycle instruction (Fosc/4). Il est
possible d'utiliser un prédiviseur de fréquence que nous verrons plus
loin.
- 13 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
-Compteur d'événements. Dans ce cas les d'impulsions d'entrées du
timer sont fournies par la patte RA4/TOCK1 le choix s'effectue grâce au
bit RTS du registre OPTION.
Le pic 16F84 dispose d'un diviseur de fréquence qui peut être assigné soit au
chien de garde WDG, soit au TMR0 (uniquement un à la fois). L'assignation du
prédiviseur se fait grâce au bit PSA du registre OPTION.
La structure interne du TMR0 est donc la suivante (figure 10)
Fig.10
Suivant que le prédiviseur est assigné au chien de garde ou au TMR0, la
valeur de la prédivision n'est pas la même, il faut donc être vigilant lors de la
programmation comme le montre la figure 11.
Fig.11
- 14 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
3.9 Mise en oeuvre
L’utilisation et la mise en œuvre très simple des PICs les a rendus
extrêmement populaire au point que la société qui les fabrique (MICROCHIP) est en
passe de devenir le leader mondial dans le domaine des microcontrôleurs devant
MOTOROLA et INTEL.
Il suffit d’alimenter le circuit par ses deux broches VDD et VSS, de fixer sa
vitesse de fonctionnement à l’aide d’un quartz (figure12) et d’élaborer un petit
système pour permettre de réinitialiser le microcontrôleur sans avoir à couper
l’alimentation (figure 13).
Fig.12
Fig.13
Il suffit ensuite d’écrire le programme en langage assembleur sur un
ordinateur grâce au logiciel MPLAB de MICROCHIP (logiciel gratuit) puis de le
compiler pour le transformer en langage machine et le transférer dans le PIC grâce à
un programmateur.
Lors de la mise sous tension, tous les registres spécifiques sont placés dans
un état déterminé comme le montre la figure 14
u = unchanged ; x = unknown ; - =unimplemented (read as 0);
q = value depends on condition
Fig.14
- 15 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Il ne nous reste plus qu’à voir le jeu d’instruction de programmation en
assembleur du PIC et c’est là que réside tout l’intérêt puisqu’il ne dispose que de 35
instructions qui lui permettent de réaliser toutes les tâches.
IV. JEU D’INSTRUCTIONS DU PIC 16F84
Afin de comprendre la fonction de chaque instruction, la notation adoptée pour
les données et adresses manipulées par les instructions est fort simple et est la
suivante :
-f
représente un registre
-b
représente un numéro de bit en sachant que 0 correspond toujours au
bit de poids faible (le plus à droite dans le registre)
-k
représente une donnée aussi appelée littérale
Un certain nombre d’instructions (ADDWF, ANDWF, etc..) utilise une notation
spéciale présentée sous la forme :
ADDWF
f, d
Où f indique le registre et où d peut prendre deux valeurs (0 ou
1), ce qui change le comportement de l’instruction. Si d est à 0, le
résultat est placé dans le registre de travail W, la valeur dans le
registre f est alors inchangée, alors que si d est à 1, le résultat
est placé dans le registre f.
Un autre type d’instruction mérite quelques éclaircissements, ce sont les
instructions de branchement conditionnel. Prenons comme exemple :
BTFSC
f, b
Qui va vouloir dire (Bit Test File Skip if Clare) qui signifie que l’on
va tester le bit b du registre f (b peut prendre une valeur de 0 à 7
pour un registre 8 bits) .Il peut alors y avoir deux solutions :
-Soit le bit testé est à 1, donc la condition testée n’est pas
réalisée, le programme continue alors son déroulement
normalement en séquence avec l’instruction juste en dessous.
-Soit le bit testé vaut 0, donc la condition testée est réalisée et le
programme saute l’instruction qui suit le BTFSC dans le
programme.
Les 35 instructions sont donc les suivantes :
BITS
INSTRUCTION
SYNTAXE
OPERATION
d’état
du registre
STATUS
affectées
durée
CYCLE
W+kW
ADDLW
(Add Literal to W)
ADDLW
k
On ajoute au registre de
travail la valeur k et on
place le résultat dans le
registre de travail W
- 16 -
C, DC, Z
1
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
BITS
INSTRUCTION
SYNTAXE
OPERATION
W+ff si d=1
W+fW si d=0
ADDWF
(Add W to F)
ADDWF
f, d
d’état
du registre
STATUS
affectées
durée
CYCLE
ou
On ajoute le contenu de
W et le contenu de f et on
place le résultat dans f si
d=1 ou dans W si d=0
C, DC, Z
1
C, DC, Z
1
Z
1
aucuns
1
aucuns
1
W ET k fW
ANDLW
(And Literal and W)
ANDLW
k
On effectue un ET logique
entre k et et le contenu de
W, et on place le résultat
dans le registre de travail
W
W ET ff si d=1 ou W
ET fW si d=0
ANDWF
( And W with F )
ANDWF
f, d
BCF
(Bit Clear F)
BCF
f, b
BSF
(Bit Set F)
BSF
On effectue un ET logique
entre le contenu de W et
le contenu de f , on place
le résultat dans W si d=0
ou dans f si d=1
0b (f)
On met à 0 le bit b du
registre f
1b (f)
f, b
On met à 1 le bit b du
registre f
saut de l’instruction qui
suit si b (f)=0
BTFSC
(Bit Test,
Clear)
BTFSC
Skip
f, b
if
Si le bit b de f est nul,
l’instruction qui suit celleci est ignorée et traitée
comme un NOP. Dans ce
cas et dans ce cas
seulement,
l’instruction
BTFSC demande deux
cycles pour s’exécuter.
aucuns
1 ou 2
aucuns
1 ou 2
saut de l’instruction qui
suit si b (f)=1
BTFSS
(Bit Test, Skip if Set)
BTFSS
f, b
Si le bit b de f est à 1,
l’instruction qui suit celleci est ignorée et traitée
comme un NOP. Dans ce
cas et dans ce cas
- 17 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------seulement,
l’instruction
BTFSS demande deux
cycles pour s’exécuter.
BITS
INSTRUCTION
SYNTAXE
OPERATION
d’état
du registre
STATUS
affectées
durée
CYCLE
appeler
un
sou
programme (label)
CALL
(subroutine Call)
CLRF
(Clear F)
CALL
label
CLRF
f
On sauvegarde l’adresse
de retour dans la pile puis
on appelle le sous
programme définit avec
l’étiquette label
aucuns
2
Z
1
Z
1
Z
1
Z
1
Z
1
aucun
1 ou 2
0F
On met le contenu du
registre f à 0 et on
positionne Z
0W
CLRW
(Clear W)
On met le contenu du
registre W à 0 et on
positionne Z
CLRW
0WDT et 0pré
diviseur du Timer
CLRWDT
(Clear Watch Dog
Timer)
On met le contenu du
registre du timer chien de
garde à 0 ainsi que le pré
diviseur
CLRWDT
/ff si d=1 ou /fW si
d=0
COMF
(Complement F)
COMF
f, d
On
complémente
le
contenu du registre f bit à
bit , le résultat est placé
dans f si d=1 , dans W si
d=0.
f-1f si d=1 ou f-1W
si d=0
DECF
(Decrement F)
DECF
f, d
On diminue le contenu du
registre f d’une unité, le
résultat est placé dans f si
d=1, dans W si d=0 (dans
ce cas f reste inchangé).
f-1f si d=1 ou f-1W
si d=0 et saut si f-1=0
DECFSZ
DECFSZ
f, d
On diminue le contenu du
registre f d’une unité, le
résultat est placé dans f si
- 18 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------d=1, dans W si d=0 (dans
ce
cas
f
reste
inchangé).Si le résultat
est
nul,
l’instruction
suivante est ignorée et
dans ce cas, cette
instruction dure deux
cycles.
(Decrement F, Skip if
Zero)
BITS
INSTRUCTION
GOTO
(branchement
inconditionnel)
SYNTAXE
GOTO
label
On effectue un saut dans
le programme pour aller à
l’adresse pointé par le
label précisé dans GOTO
f+1f si d=1
f+1W si d=0
INCF
(Increment F)
INCF
f, d
d’état
du registre
STATUS
affectées
OPERATION
durée
CYCLE
aucun
2
Z
1
aucun
1 ou 2
Z
1
Z
1
ou
On augment le contenu
du registre f d’une unité,
le résultat est placé dans f
si d=1, dans W si d=0
(dans ce cas f reste
inchangé).
f+1f si d=1 ou
f+1W si d=0 et saut
si f-1=0
INCFSZ
(Increment F, Skip if
Zero )
INCFSZ
f, d
On augmente le contenu
du registre f d’une unité,
le résultat est placé dans f
si d=1, dans W si d=0
(dans ce cas f reste
inchangé).Si le résultat
est
nul,
l’instruction
suivante est ignorée et
dans ce cas, cette
instruction dure deux
cycles.
W OU k  W
IORLW
IORLW
(Inclusive
with W )
Or
k
literal
On effectue un OU
logique entre le contenu
de W et le littéral k, le
résultat est placé dans W.
W OU ff si d=1 ou W
OU fW si d=0
IORWF
(Inclusive Or W with F)
IORWF
f, d
On effectue un OU entre
le contenu de W et le
contenu de f , on place le
résultat dans f si d=1,
dans W si d=0
- 19 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------ff si d=1 ou fW si
d=0
MOVF ( Move F )
MOVF
f,d
On déplace le contenu de
f dans f si d=1 ou de f
dans W si d=0, ça permet
en fait de tester le
contenu de f par rapport à
0 et de positionner le bit Z
Z
BITS
INSTRUCTION
SYNTAXE
OPERATION
d’état
du registre
STATUS
affectées
1
durée
CYCLE
kW
MOVLW
(Move Literal to W )
MOVLW
k
MOVWF
(Move W to F )
MOVWF
f
On charge le contenu de
W avec le littéral k
aucun
1
aucun
1
aucun
1
aucun
2
aucun
2
aucun
2
Wf
On charge le contenu de f
avec le contenu de W
néant
NOP
(No Operation)
NOP
On
ne
fait
que
consommer du temps
machine (un cycle dans
ce cas)
Pile PC
RETFIE
(Return From
Interrupt )
On charge le compteur
ordinal avec la valeur qui
se trouve au sommet de
la pile pour revenir au
programme
principal
lorsque l’exécution du
sous
programme
est
terminée.
RETFIE
kW, PilePC
RETLW
(Return Literal to W)
RETLW
k
On charge le contenu de
W avec le littéral k puis on
charge
le
compteur
ordinal PC avec la valeur
qui se trouve au sommet
de la pile effectuent ainsi
un
retour
de
sous
programme.
PilePC
RETURN
(Return
RETURN
On charge le compteur
ordinal PC avec la valeur
qui se trouve au sommet
de la pile effectuent ainsi
- 20 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------un
retour
de
sous
programme. C’est un
RETLW simplifié.
from subroutine)
SLEEP ( Sleep )
0PD,
0WDT,
prédiviseur
SLEEP
1T0,
0
On place le circuit en
mode sommeil avec arrêt
de l’oscillateur. Cette
commande est à utiliser
avec
précaution,
elle
nécessite la connaissance
du mode sommeil.
BITS
INSTRUCTION
SYNTAXE
OPERATION
d’état
du registre
STATUS
affectées
durée
CYCLE
k-WW
SUBLW
(Substract
Literal)
SUBLW
W
On soustrait le contenu du
registre W du littéral k et
on place le résultat dans
W (soustraction par la
méthode du complément
à 2).
k
from
C, DC, Z
1
C, DC, Z
1
aucun
1
Z
1
f-WW si d=0 ou fWf si d=1
SUBWF
(Substract W from F )
SUBWF
f, d
On soustrait le contenu du
registre W du contenu du
registre f et on place le
résultat dans W si d=0, ou
dans f si d=1 (soustraction
par la méthode du
complément à 2).
f(0-3)f(4-7) et f(47)f(0-3) résultat dans
W ou f selon d
SWAPF
(Swap F)
SWAPF
f, d
On échange les quatre
bits de poids forts avec
les quatre bits de poids
faibles et on place le
résultat dans W si d=0, ou
dans f si d=1
W
OU
kW
XORLW
(Exclusive Or Literal
with W )
XORLW
EXCLUSIF
k
On effectue un OU
Exclusif entre W et le
littéral k, le résultat est
placé dans W
W OU EXCLUSIF fW
si d=0 ou W OU
EXCLUSIF ff si d=1
- 21 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------XORWF
(Exclusive Or W with
F)
XORWF
f, d
Z
1
On effectue un OU
Exclusif entre W et le
contenu de f, le résultat
est placé dans W si d=0,
sinon il est placé dans f.
RLF (Rotate Left F through carry)
Syntaxe :
RLF
f,d
7
6
5
4
3
2
1
0
C
Opération :
Registre f
On effectue une rotation à gauche de un bit du contenu du registre f en passant par
le bit de retenu C. Si d=1 le résultat est placé dans f, si d=0, le résultat est placé dans
W
Bit d’état du registre STATUS affecté : C
Durée :
1 cycle
RRF (Rotate Right F through carry)
Syntaxe :
RRF
f, d
Opération :
7
6
5
4
3
2
1
0
C
Registre f
On effectue une rotation à droite de un bit du contenu du registre f en passant par le
bit de retenu C. Si d=1 le résultat est placé dans f, si d=0, le résultat est placé dans
W
Bit d’état du registre STATUS affecté : C
Durée :
1 cycle
- 22 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
V. LES OUTILS DE DEVELOPPEMENT
5.1 Deux mot sur MPLAB
MPLAB peut être télécharger directement du site Web http://www.microchip.com
Les étapes nécessaires permettant de voir un programme s'exécuter sur un PIC
sont :
• Ecrire un programme en langage assembleur dans un fichier texte et le
sauvegarder avec l'extension .asm
• Compiler ce programme avec l'assembleur MPASM fourni par Microchip. Le
résultat est un fichier avec l'extension .hex contenant une suite d'instruction
compréhensible par le pic.
• Transplanter le fichier .hex dans la mémoire programme du PIC (mémoire flash) à
l'aide d'un programmateur adéquat. On peut utiliser les programmateurs de
Microchip ou tout autre programmateur acheté ou réalisé par soit même.
• Mettre le PIC dans son montage final, mettre sous tension et admirer le travail.
Microchip propose gratuitement l'outil de développement MPLAB qui regroupe
l'éditeur de texte, le compilateur MPASM, un outil de simulation et le logiciel de
programmation. Le programmateur lui-même, n'est pas gratuit.
Pour ce qui nous concerne, nous utiliseront MPLAB pour écrire, compiler et
éventuellement simuler nos programmes, ensuite nous utiliserons un programmateur
PICSTART Plus@ pour implanter les programmes dans la mémoire flash du PIC.
5.2 Les directives de MPASM
Les directives de l'assembleur sont des instructions qu'on ajoute dans le
programme et qui seront interprétées par l'assembleur MPASM. Ce ne sont pas des
instructions destinées au PIC.
5.2.1 Les directives les plus utilisées
• LIST : permet de définir un certain nombre de paramètres comme le processeur
utilisé (p), la base par défaut pour les nombres (r), le format du fichier hex à
produire (f) ainsi que d'autres paramètres. Exemple :
LIST p=16F84A, r=dec, f=inhx8m
• INCLUDE : permet d'insérer un fichier source. Par exemple le fichier p16f84A.inc
contient la définition d'un certain nombre de constante comme les noms des
registres ainsi que les noms de certain bits;
INCLUDE "p16f84A.inc"
• _ _CONFIG : permet de définir les 14 fusibles de configuration qui seront copié
dans l'EEPROM de configuration lors de l'implantation du programme dans le PIC
(protection de code, type d'oscillateur, chien de garde et temporisation du départ)
_ _CONFIG B'11111111111001'
_ _CONFIG H'3FF9'
si le fichier p16f84.inc a été inséré, on peut utiliser les constantes prédéfinies :
_ _CONFIG _CP_OFF & _XT_OSC & _PWRTE_OFF & _WDT_OFF
- 23 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
• EQU : permet de définir une constante ou une variable :
XX EQU 0x20
Chaque fois que le compilateur rencontrera XX, il la remplacera soit par la
constante 0x20. ça peut être une constante s'il s'agit d'une instruction avec
adressage immédiat, ou d'une adresse s'il s'agit d'une instruction avec adressage
direct.
• #DEFINE : définit un texte de substitution
#DEFINE pos(x,y,z) (y-2z+x)
Chaque fois que le compilateur rencontrera le texte pos(x,y,z), il le remplacera
par (y-2z+x)
• ORG : définit la position dans la mémoire programme à partir de laquelle seront
inscrites les instructions suivantes.
• DE : pour déclarer des donnés qui seront stockée dans l'EEPROM de donnée au
moment de
l'implantation du programme sur le PIC
ORG
0x2100
DE "Programmer un PIC, rien de plus simple", 70, 'Z'
• END : indique la fin du programme
Pour plus de détail sur les directives de MPASM, voir "MPASM USER'S GUIDE"
5.3 Format des nombres
L'assembleur reconnaît les nombres en décimal, hexadécimal, binaire ou octal. Pour
préciser la base il faut utiliser les préfixes précisés dans le tableau ci-dessous :
On peut à l'aide de la directive LIST ou RADIX
définir un format par défaut. Si par exemple on
place une des instructions suivantes au début du
programme, tous les nombres sans préfix seront
interprétés en décimal :
LIST r = dec
RADIX dec
(les radix valables sont dec, hex ou oct)
Base
Décimal
Binaire
Préfixe
D'nnn'
.nnn
H'nn'
0xnn
nnh
B'….'
Octal
O'nnn'
Hexadéci
mal
Exemple
D'36'
.36
H'24'
0x24
24h
B'0010010
0'
O'44'
5.4 Structure d'un programme écrit en assembleur
Un programme écrit en assembleur doit respecter une certaine syntaxe et un
certain nombre de règles afin qu'il soit facile à lire et à débuguer :
• Tout ce qui commence à la première colonne est considéré comme une
étiquette (label) permettant de faire des renvois et aussi des assignations de
constantes et de variables.
• tout ce qui suit un point virgule est considéré comme un commentaire non
interprété par le compilateur
- 24 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
• Un programme apparaît donc comme un texte écrit sur 3 colonnes :
- la colonne de gauche contient les étiquettes
- la colonne du milieu contient les l’instructions
- la colonne de droite contient des commentaires
Il existe différentes écoles indiquant comment doit être organisé un programme.
Voici un exemple d'organisation :
1) Quelques lignes de commentaire précisant la fonction du programme.
2) Configuration, exemple :
LIST
INCLUDE
_ _CONFIG
p=16f84
"p16f84.inc"
H'3FF9'
3) Définition des constantes et des variables, exemple :
Microchip propose gratuitement l'outil de développement MPLAB qui regroupe l'éditeur
de texte, le compilateur MPASM, un outil de simulation et le logiciel de programmation. Le
programmateur lui-même, n'est pas gratuit.
Pour ce qui nous concerne, nous utiliseront MPLAB pour écrire, compiler et
éventuellement simuler nos programmes, ensuite nous utiliserons un programmateur
PICSTART Plus@ pour implanter les programmes dans la mémoire flash du PIC.
Led
X
cblock
y,z
u,v,w
endc
equ
equ
0x0D
0
0x0C
4) Si le programme utilise des interruptions, mettre à l'adresse 0000 (adresse
du RESET) une instruction de branchement au début du programme principal :
ORG
0x0
GOTO
debut
5) Ecrire la routine d'interruption à l'adresse 4
ORG
0X4
écrire la routine d'interruption ici
RETFIE
Si le programme est configuré pour interdire les interruptions, on peut se
passer des étapes 4) et 5),
6) Ecrire les sous programmes (s'il y en a). Chaque procédure commence par
une étiquette qui représente son nom, et se termine par l'instruction RETURN
7) Ecrire le programme principal (commençant par l'étiquette début: si les
étapes 4 et 5
END
- 25 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
5.5 Références
[1] PIC16F8X, document DS30430C, www.microchip.com
[2] PIC16F84a, document DS35007A, www.microchip.com
[3] Programmation des PIC, Première partie-PIC16F84-Révision 5, par BIGONOFF,
http://www.abcelectronique.com/bigonoff/organisation.php?2654c
- 26 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Présentation de MPLAB:
MPLAB est un outil de développement pour les PIC 16F84 et autres.
Il contient



un éditeur
un assembleur
un simulateur
Il permet



La rédaction du fichier source en langage assembleur (fichier.ASM)
Sa transformation en fichier objet (fichier.HEX) prêt à être chargé dans la mémoire
programme du microcontrôleur
L’ensemble des fichiers nécessaires à ces opérations est regroupé dans un espace " projet "
(fichier.PJT)
1. Création d’un nouveau projet
1.1 Préparation
 Créez dans votre espace disque dur (par exemple le disque C) un répertoire où vous rangez tous
vos projets et y tappelez, à titre d’exemple : « Projets MPLAB ». Il est recommandé de créez aussi un
sous répertoire, par exemple : « manip_1 », « LED_clinot », « manip_2 » etc...
1.2 Utilisation d’un tutorial « Wizard » pour la création des projets
 Lancez MPLAB IDE v.6.60 à partir de l’icône représenté ci-contre, qui se trouve
dans votre bureau.
 Après quelques instants, vous vous retrouvez avec un écran vide avec menu et
barres d’outil. Si certaine fichiers ou projets s’ouvrent lors du démarrage, fermez-les.
 Après avoir lancé
MPLAB, choisissez dans
le
menu
« Project »
l’option
« Project
Wizard… »
(voir la figure 1).
Fig.1
- 27 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
 L’assistant de création
de projet s’affiche.
(Fig.2)
 Cliquez sur « Suivant »
Fig.2

La première étape
(Fig.3) consiste à indiquer
la
référence
du
microcontrôleur qui sera
utilisé (dans notre cas
c’est le PIC 16F84A).
 Cliquez ensuite sur
« Suivant »
Fig.3
- 28 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
 La seconde étape (voir la
figure 4) consiste à indiquer
le langage qui sera utilisé
pour la programmation.
Pour une programmation en
assembleur,
choisissez
pour la rubrique « Active
Toolsuite »
le
langage
« Microchip
MPASM
Toolsuite »
 Cliquez ensuite sur
« Suivant »
Fig.4
Indiquer le nom
souhaité pour le projet
Cliquer pour parcourir
l’arborescence des
répertoires
Spécifier le répertoire
(Projets MPLAB) et
sous répertoire
(manip_1)
Cliquer pour
sélectionner
Fig.5
- 29 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------La troisième étape (voir la figure 5) consiste à indiquer le nom du projet ainsi que son emplacement.
 Indiquez dans la case « Project Name » le nom souhaité pour le projet (par exemple : manip_1)
 Spécifiez le répertoire dans la case « Project Directory » en utilisant le bouton « Browse » pour
parcourir l’arborescence des répertoires. Dans notre cas c’est le répertoire « Projet MPLAB » et sous répertoire « manip_1 » (voir la figure 5). Cliquer « Select »
 Cliquez ensuite sur « Suivant »

La dernière étape 4
permet d’ajouter au projet un
fichier source existant (fig.6).
Dans le cas où aucun fichier
source n’est à incorporer au
projet, cliquez directement
sur « Suivant ».

Pour ajouter un fichier
source existant, parcourir
l’arborescence
dans
la
fenêtre
de
gauche,
sélectionner le fichier désiré
puis cliquer sur bouton
« Add ». Cocher ensuite la
case située à gauche du
nom du fichier pour qu’il
soit copié à partir de son
emplacement
d’origine
dans le répertoire du
projet.

Cliquez ensuite sur
« Suivant ».
Fig.6
 L’assistant de création de
projet (fig.7) affiche un résumé
de celui-ci : contrôler les
différentes
informations
présentées :
a) Référence du
microcontrôleur ;
b) Outil utilisé en fonction du
langage ;
c) Répertoire du projet.
 Cliquez sur « Terminer »
pour valider la création du
projet.
Fig.7
- 30 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------

MPLAB affiche dans une
fenêtre le nom du projet
(d’extension
.mcp :
MicroChipe Project). Celui-ci
mentionne éventuellement le
nom
du
fichier
source
spécifiée
à
l’étape
4
précédente. Un double clic
sur celui-ci permet de l’ouvrir
en vue de l’éditer.
 Si aucun fichier existant n’a
été incorporé au projet à
l’étape 4, choisir dans le
menu
« File »
l’option
« New » ou cliquer sur l’icône.
Une
fenêtre
d’édition
apparaît. Taper le texte du
programme
source
(en
assembleur) puis enregistrer
le fichier dans le même
répertoire que celui du
projet.

Incorporer ce nouveau
fichier
au
projet
en
choisissant l’option « Add
Files… » dans le menu
contextuel (obtenu par un clic
du bouton droit de la souris)
de la rubrique « Source
Files ».
Rechercher
puis
sélectionner
le
fichier
sauvegardé précédemment.
MPLAB affiche, en plus de la fenêtre du projet, une fenêtre d’édition dans laquelle on peut aisément
modifier le programme source grâce à la coloration syntaxique.
- 31 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
2. Ouverture d’un projet existant

L’ouverture d’un projet
existant (d’extension .mcp)
peut
se
faire
en
choisissant dans le menu
« Project »
l’option
« Open… » ou en cliquant
sur l’icône verte « Open
Project »
3. La mise en œuvre du logiciel MPLAB
3.1 La barre d’outils de MPLAB
Fig.8
- 32 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------Les différentes icônes disponibles dans la barre d’outils de MPLAB sont définiées sur la figure 8.
Remarque : en fonction du mode de fonctionnement choisi (mode simple, mode « Débuggage »,
mode programmation), les icônes de la partie droite ne sont pas les mêmes. La barre d’outils
représentée sur la figure 8 correspond au mode « Débuggage ».
3.2 Les fenêtres de MPLAB
En plus de ces différentes icônes de la figure 8, plusieurs fenêtres peuvent être affichées (voir la
figure 9) :
 Les fenêtres qu’il est indispensable d’avoir en permanences ouvertes :
- projet en cours (il est impossible de la fermer)
- fichier(s) source(s) du projet : un double clic sur le nom du fichier source dans le gestionnaire de
projet permet de rouvrir celui-ci.
- Fenêtre de « Sortie » (« Output ») : les différents onglets permettent d’afficher :
 Les résultats de la compilation (onglet « Build »)
 Le résultat de la recherche dans tous les fichiers source du projet (onglet « Find in files »)
Dans le cas où cette fenêtre a été fermée, cocher dans le menu « View » l’option « Output »
Fig.9
 Certaines fenêtres qu’il est utile d’afficher dans certains cas (voir la figure 10) :
- « Watch » : permet d’afficher le contenu de registres du microcontrôleur ou de variables (choisir dans
le menu « View » l’option « Watch »).
- « Special Fonction Registers » : permet d’afficher le contenu des registres particuliers du
microcontrôleur (choisir dans le menu « View » l’option « Special Fonction Registers »).
- « File Registers » : permet d’afficher le contenu des registres particuliers du microcontrôleur (choisir
dans le menu « View » l’option « File Registers »).
- « Disassembly listing » : permet d’afficher le listing du programme en assembleur à la suite de la
compilation, associé au code objet généré (choisir dans le menu « View » l’option « Disassembly
listing »).
- 33 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Fig.10
3.3 Les différentes étapes du développement
Pour développer une application destinée à être exécutée par un microcontrôleur PIC avec le logiciel
MPLAB seul, les différentes étapes sont les suivantes :
- saisie du programme source (en assembleur) grâce à l’éditeur de texte de MPLAB ;
- assemblage ou compilation du programme source ;
- « débuggage » du programme, c’est-à-dire recherche et correction des erreurs de programmation;
- programmation du microcontrôleur cible pour obtenir un fonctionnement autonome de la carte
électronique en cours de développement.
3.3.1 Saisie du programme source – Assemblage / Compilation
L’éditeur de texte de MPLAB permet, grâce à la coloration syntaxique, d’écrire le programme source
en assembleur.
La traduction du programme source en code objet s’effectue grâce à l’icône « Build» (voir fig. 11).
Il est impératif d’observer le résultat de la compilation dans l’onglet « Build » de la fenêtre « Output »
(fig.9) :
 Un message d’erreur (« Error ») nécessite obligatoirement une modification du programme source,
la compilation n’étant pas complète. Pour corriger l’erreur, un double clic sur le message d’erreur de la
fenêtre « Output » permet d’arriver directement sur la ligne du programme source comportant l’erreur.
 Un message d’avertissement (« Warning », « Message ») doit être examiné avec soin : dans
certains cas, il s’agit d’un oubli ou d’une erreur dans le programme source. Cependant, un programme
- 34 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------destiné à être exécuté par un microcontrôleur comporte systématiquement une boucle infinie qui sera
signalée par un message d’avertissement.
 Le Message « BUILD SUCCEEDED » indique une compilation réussie (comportant éventuellement
des avertissements).
3.3.2 Mode « Débuggage »
Pour détecter d’éventuelles erreurs de programmation, il est nécessaire de faire exécuter le
programme par le microcontrôleur en mode « débuggage ». Ce mode permet les différentes actions
suivantes :
 Exécution en pas à pas ;
 Exécution fonction par fonction ;
 Exécution en continu ;
 Exécution continue jusqu’à une certaine ligne du programme source (« point d’arrêt »);
 Affichage du contenu de registres du microcontrôleur et/ou variables (valeurs actualisées à chaque
arrêt du programme).
3.3.2.1 Passage en mode « Débuggage »
Pour bénéficier du mode de
fonctionnement «Débuggage »,
choisir dans le menu
« Debugger » l’option « Select
Tool » puis « MPLAB SIM ».
Les principales icônes utilisées pour le « débuggage » apparaissent dans la partie droite de la barre
d’outils de MPLAB :
Fig.11
- 35 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------3.3.2.2 Etapes du mode « Débuggage »
La procédure habituelle est la suivante :
 Lancer la compilation (ou l’assemblage) du programme source après chaque modification de celuici : icône « Build (Compile le programme)» (voir la figure 11) ;
 Exécuter le programme soit en continu (icône « Run (Lance le programme) » soit en modes pas à
pas (icônes «Step Into», « Step Over » ou « Step Out »);
 Après un lancement en continu du programme, l’arrêt de celui-ci s’effectue grâce à l’icône « Halt »,
suivi éventuellement d’un « Reset ».
La flèche verte indique la prochaine instruction qui sera exécutée.
3.3.2.3 Utilisation de points d’arrêt.
L’exécution du programme en continu ne permet pas toujours de détecter l’origine d’un
fonctionnement incorrect.
Les modes pas à pas ou fonction par fonction sont parfois d’une mise en oeuvre laborieuse.
Il peut alors être judicieux d’utiliser les points d’arrêts : une ligne du programme source est
affectée d’un marqueur qui déclenchera l’arrêt du programme lorsque le microcontrôleur exécutera
l’instruction correspondante.
La définition et la suppression des points d’arrêts est réalisée par un double clic sur la ligne
souhaitée, ou en choisissant lors d’un clic droit sur celle-ci l’option « Set Breakpoint » ou « Remove
Breakpoint ».
La suppression de tous les points d’arrêts s‘effectue en choisissant lors d’un clic droit dans la
fenêtre d’édition l’option « Breakpoints » puis « Remove All Breakpoints ».
Remarque : à un instant donné, un seul point d’arrêt est actif (« Enable »), les éventuels autres points
d’arrêts sont provisoirement désactivés (« Disable »).
- 36 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Point d’arrêt actif
Point d’arrêt désactivé
Suppression/Activation des points d’arrêt
4. Exercice
4.1 Créez votre source
Une fois le projet entièrement défini, vous pouvez commencer à développer le code de votre
application.
Sélectionnez File ->New. Vous obtenez une fenêtre de l’éditeur. Saisir le fichier ci-dessous
(fig.12) en exemple (joint sous le nom de votre projet).
4.2 Ajoutez le fichier au projet
1. Dans la fenêtre nom du projet.mcw sélectionnez Source Files puis avec le bouton
droit faire Add. File
2. Sélectionnez le fichier que vous venez de créer et de sauvegarder.
3. Cliquez sur Ouvrir.
Le nom du fichier doit apparaître dans la fenêtre projet au dessous de « Source Files ».
- 37 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Fig.12 Le fichier source
4.3 Construisez le projet
Après avoir configuré le projet et saisi le code il est temps de construire le projet. Cela
provoquera la compilation du fichier source en utilisant la suite logicielle choisie.
Sélectionnez Project -> Build All pour construire le projet. Votre fichier doit être assemblé
correctement et vous obtenez la fenêtre ci-dessous.
- 38 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------S’il y a eu un problème de compilation celui-ci est indiqué dans la fenêtre pour permettre de
retrouver les erreurs. Un double cloc sur l’erreur pointe directement la ligne du programme sur laquelle
se situe l’erreur.
Une fois la compilation terminée le fichier debug (*.cod ou *.cof) généré par MPLAB sera
chargé. Ce fichier permet de débouguer le code source et de visualiser les variables symboliques
dans les fenêtres d’observation.
4.4 Simulez le comportement du programme
4.4.1 Sélectionnez Debbugger -> Select Tools -> MPLAB SIM.
4.4.2 Faites un Reset du programme; sélectionnez Debugger -> Reset ou touche de
fonction F6. Une flèche verte apparaît à gauche de la première ligne du programme.
4.4.3
Lancez l’exécution de votre programme ; faites Debugger -> Run ou F9.
L’information « Running » apparaît à la gauche de la barre d’état.
4.4.4
Pour arrêter l’exécution faites Debugger -> Halt ou F5.
4.4.5
Vous pouvez aussi exécuter le programme pas à pas : faites Debugger -> Step
Info ou touche F7. A ce moment la flèche verte pointe l’instruction qui va être
exécutée. A tout instant vous pouvez voir le contenu d’une variable en plaçant le
pointeur de la souris sur le nom de la variable.
4.5 Visualisez la fenêtre d’observation
Lorsque l’on exécute le programme il est intéressant de voir évoluer le contenu des registre
utilisés dans le programme. Toutes les fenêtres de debogage sont accessibles par le menu View.
File Rejister
Programme Memory
EEPROM
Sp. Fct. Registers
Watch
Hardware Stack
Disassembly Listing
Simulator Trace
- 39 -
Contenu de la RAM et des FER
Contenu de la mémoire programme
Contenu de la mémoire de sauvegarde en
EEPROM
Tous les registres SFR
Voir ci dessous
Contenu de la pile
Code Hex desassemblé
Voir plus loin
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------Faite View -> Watch pour ouvrir une fenetre d’observation (Watch Windows).
Deux menu déroulants vous permettent de
sélectionner soit le contenu des registres (Add
SFR) soit le contenu des variables utilisés (Add
Symbol).
Sélectionnez par exemple PORTB puis cliquez sur
Add SFR.
Faites la même chose pour sélectionner TRISB,
retard_1 et retard_2.
Vous obtenez ainsi une fenêtre qui vous indique le
nom, l’adresse et la valeur des quatre symboles
sélectionnés. L’affichage de la valeur se fait par
défaut en hexadécimal, ce mode peut être modifié
en faisant un clic droit dans la fenêtre. Vous
pouvez afficher les informations sur 8, 16, 24 ou 32
bits dans les formats hexadécimaux, binaires,
décimaux ASCII ou en nombre flottant.
Sélectionnez Properties en cliquant par bouton
droit de souris sur le registre intéressé (retard_1).
4.6. Exécution et visualisation
4.6.1
Effectuez un Reset du programme.
4.6.2
Faites exécuter le programme pas à pas jusqu’à la ligne
bsf
PORTB,0
; on allume la LED
4.6.3
Faite avancer le programme d’un pas de plus et observez le changement d’état du bit 0 du
PORTB.
4.6.4
Avancez de deux pas pour voir le contenu retard_1 à FF.
4.6.5
La temporisation est réalisée par décrémentation de deux variables ; pour raccourcir la durée
vous pouvez modifier directement les valeurs de retard_1 et retard_2 en cliquent deux fois sur
la valeur et en saisissant la nouvelle valeur (par exemple : 0x02).
4.6.6
Exécutez le programme de manière à revenir à la ligne (fig.13)
bcf
4.6.7
PORTB,0
; on éteint la LED
Pour continuer utilisez le bouton 5 Step Over (fig.11) ceci permet d’exécuter tout le sousprogramme en mode Run et de pointer l’instruction suivante.
4.7 Utiliser les points d’arrêt et le mode Trace
Ces deux modes permettent soit d’arrêter l’exécution du programme à des endroits précis
(point d’arrêt) soit d’enregistrer les actions du programme (mode Trace).
- 40 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Fig.13
4.7.1 Utilisation d’un point d’arrêt
Il est souvent intéressant d’exécuter un programme et de l’arrêter à un endroit bien
détermine ; ceci est possible en utilisant les points d’arrêt.
4.7.1.1 Effectuez un Reset de l’application.
4.7.1.2 Effectuez un clic droit sur la ligne suivante
bcf
PORTB,0
; on éteint la LED
4.7.1.3 Dans le menu contextuel qui apparaît choisissez Set Breakpoint. Un signal stop doit
apparaître en face de la ligne indiquée (fig.14).
Fig.14
- 41 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------4.7.1.4 Lancez la simulation en mode Run ; l’exécution s’arrête à l’emplacement du point
d’arrêt pré défini (fig.14).
Fig.15
4.7.1.5 Effectuez un Reset du programme. Selectionnez Debugger -> Stopwatch. La
fenêtre « Stopwatch » doit être apparaître (fig.15).
4.7.1.6 Lancez la simulation en mode Run ; l’exécution s’arrête à l’emplacement du point
d’arrêt pré défini et dans la fenêtre Stopwatch vous pouvez consulter le nombre de
cycles machines et le temps d’exécution en μs (fig.15).
4.7.2 Utilisation du mode Trace
Ce mode permet d’enregistrer les actions du programme en cours d’exécution et de suivre
ensuite son comportement.
4.7.2.1 Validez le mode Trace en faisant Debugger -> Setting ; choisissez ensuite l’onglet
Trace / Pins pour obtenir la fenêtre ci-dessous.
Deux cases à cocher contrôlent la manière dont s’effectue la collecte des données. Si seule le
première case est cochée (Trace Enable) le simulateur enregistre les données en mode Run jusqu’à
ce qu’il rencontre un point d’arrêt ou qu’il soit arrêté manuellement. Il permettra ensuit de visualiser les
8192 dernières cycles. Si la deuxième case est aussi cochée (Break Trace Buffer Full) le simulateur
enregistre les 8192 cycles d’exécution et arrête la mémorisation et l’exécution du code.
- 42 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------4.7.2.2 Faites View -> Simulator Trace. La trace du simulateur montre pour chaque cycle
machine l’instruction exécute plus les données qui ont été lues ou écrites dans les
registres. Pour chaque instruction la trace donne l’adresse du Compteur de
Programme, le code opération (Op) en hexadécimal, l’étiquette s’il y a lieu et
l’instruction désassemblée. Les quatre colonnes suivantes montrent les données lues
ou écrites (fig.16):
 SA
Adresse Source
adresse du registre où a été lue la donnée
 SD
Source Data
donnée lue
 DA
Destination Adresse adresse du registre où a été écrite la donnée
 DD
Data Destination
donnée écrite
Fig.16
La dernière colonne donne le nombre de cycles. Cela peut permettre de mesurer la
durée d’exécution d’une parte du programme. Si vous cliquez avec le bouton droit de
la souris dans la ligne grise du haut vous obtenez un menu qui vous permet de choisir
les colonnes à afficher.
4.8 Utiliser les fonctions avancées du simulateur
4.8.1 Configurez le simulateur
Après avoir sélectionné MPLAB SIM comme outil de debogage, sélectionnez Debugger ->
Settrings ; vous obtenez la fenêtre ci-dessous.
- 43 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------L’onglet « Clock » permet de fixer la fréquence de l’horloge pour permettre à la trace du
simulateur de définir les durées d’exécution des cycles machines et donc de mesurer des durées
d’exécution de partie de programme.
L’onglet « Break Options » donne des informations sur les points d’arrêt. Si la case « Global
Break Enable » n’est pas cochée alors les points d’arrêt seront inopérants. Ceci est util quand on a de
nombreux points d’arrêts et que l’on veut les invalider sans les supprimer. Remarquez la possibilité
d’observer les dépassements de la pile.
L’onglet « Trace/Pins » a été déjà vu au paragraphe 4.7.2.
L’onglet « Limitations » indique les limitations générales du simulateur par rapport au
composant qui doit être simulé ; le bouton « Détails » ouvre le menu d’aide et permet de détaiiller les
limitations liées à ,chaque composant.
4.8.2 Création de stimulus
Les stimuli sont des pseudo signaux appliqué aux entrées du processeur. Ils permettent de
simuler l’influence de l’environnement sur le déroulement du programme.
Choisissez Debugger -> Stimulus Controller pour ouvrir la fenêtre de la figure 17.
Fig.17
L’onglet « Pin Stimulus » permet de définir les pseudo signaux que l’on veut créer ; ils peuvent
être de type :
 Soit synchrones et ils sont définis comme des horloges dont on donne la durée à l’état haut et
bas
 Soit comme des signaux asynchrone actionnés par clic sur le bouton « Fire », ce clic
produisant l’effet indiqué dans la colonne « Action »
L’onglet « File Stimulus » permet de créer des fichiers de simulus qui peuvent être
mémorisées et rejoués.
- 44 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
Règle d’or de la programmation des PICs : programmer en boucle.
Fonction de temporisation.
Le but de cette partie de manuscrit est de maîtriser la programmation en assembleur d’un
PIC, en utilisant des exemples d’applications très simples.
I. Exemple d’application du PIC 16F84: TELERUPTEUR
Cet exemple de programmation est destiné pour
apprendre les différentes étapes de
programmation en assembleur. Le fichier assembleur proposé pour cet exemple permet de faire
allumer les LEDs connectés sur le microcontrôleur de la famille PIC.
La figure 1 représente le schéma de principe du telerupteur.
Le circuit doit réaliser la fonction suivante. Un appui sur un des boutons-poussoirs (B_P)
branchés sur le portA allume les 8 LEDs branchés sur le port B, une seconde l’appui fait les éteindre.
Remarque : pour simplifier le schéma, on a représenté un sel B_P (branché en parallèle avec les
autres B_P qui peuvent être installés éventuellement dans les différents endroits) et une LED.
VDD
5V
VDD
5V
R2
B_P
1kΩ
0.1%
10uF
C4
U1
17
18
1
2
3
R3
RA0
RA1
RA2
RA3
RA4T0CKI
4
MCLR
16 OSC1CLKIN
1kΩ
0.1%
5
VSS
VDD
RB0INT
RB1
RB2
RB3
RB4
RB5
RB6
RB7
OSC2CLKOUT
14
6
7
8
9
10
11
12
13
15
PIC16F84A
C1
5V
R1
220Ω
0.1%
LED
1uF
VDD
U2
C3
C2
15pF
15pF
Fig.1
Remarque important :
Pour programmer en langage ASSEMBLEUR il faut non seulement connaître le fonctionnement de chaque
instruction, mais aussi l’architecture interne du microcontrôleur, la structure de sa mémoire, les adresses des
registre spéciaux, le fonctionnement de chacune de ses ressources internes, etc..
La programmation en langage ASSEMBLEUR s’appuie sur des organigrammes plus travaillés, et requiert plus de
rigueur et de minutie.
- 45 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------II. Approche structurelle et analyse du schéma électrique
Particularité du Bouton-Poussoir (B_P)
Les microcontrôleurs sont des composants très rapides. Ils ne fonctionnent pas à la même échelle de
temps que nous. Imaginons de nous transformer en PIC. Nous voyons alors un énorme B_P.
Lorsque ce B_P est appuyé, c’est alors une énorme barre qui vient court-circuiter deux contacts. Cette
barre est élastique. Que « voit » le PIC ? Il « voit » une énorme barre flexible qui tombe d’une énorme hauteur sur
deux contacts métalliques. Une fois la barre est en contact, elle rebondit plusieurs fois (c’est le régime
transitoire). A chaque appui sur le B_P, le PIC « voit » donc une série de fermeture et d’ouverture du B_P, au lieu
d’une seule à notre échelle de temps. Le PIC est donc plus rapide que notre B_P.
Toujours Il faut tenir en compte les régimes transitoires des périphériques (bouton_poussoir, clavier etc..)
branchés sur le microcontrôleur
III. Une des variantes de la programmation de l’application
3.1 Organigramme
Avant la construction d’un programme il est préférable de réaliser un organigramme qui
représente le cheminement d’un programme à écrire. Cela va faciliter la programmation en
assembleur.
L’organigramme de réalisation de notre programme en question est proposé sur la figure 2.
Ici chaque action est symbolisée par un rectangle, un choix est symbolisé par un losange.
3.2 Organisation d’un fichier « .asm ». Quelques étapes pour la construction d’un programme.
Le fichier assembleur de l’application est donné par la figure 3.
Considérons les étapes principales généralement utilisés et conseillés dans la programmation en
assembleur (voir : Programmation des PIC, Première partie-PIC16F84 par
BIGONOFF, http://www.abcelectronique.com/bigonoff/organisation.php?2654c)
3.2.1 Les commentaires
De la ligne 1 à la ligne 13 vous voyez un cadre. Le premier caractère de chaque ligne, vous
verrez le symbole « ; ». Tout ce qui suit étant considéré comme zone de commentaire, vous pouvez y
mettre ce que vous voudrez. Ce commentaire vous aiderais de vous rappellerez ce que vous voulu
faire. Les commentaires vous seront alors d’une grande utilité si vous décidez de modifier votre
programme.
A la ligne 19, nous trouverons une DIRECTIVE destinée à MPASM pour indiquer quel type de
processeur est utilisé dans ce programme.
3.2.2 Les directives
Les DIRECTIVES ne font pas partie du programme, elles ne sont pas traduites en OPCODE,
elles serrent à indiquer à l’assembleur de quelle manière il doit travailler. Ce sont donc des
COMMANDES destinées à l’assembleur en lui-même.
- 46 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------EXPLICATION
Directives pour MPASM
On utilisera les registres :
« retard_ms », « mémo » et les
constantes « B_P » et « LEDs »
Le portA et le portB seront
programmés d’après le schéma
de principe
On
vérifie
que
le
Bouton_Poussoir est appuyé
pour lancer le programme
On appelle du sous-programme
de temporisation
On appelle du sous-programme
de gestion des LEDs
On
vérifie
que
le
Bouton_Poussoir est relâché
pour revenir au début du
programme.
Fig.2 : L’organigramme de l’application
Fig.3 : Le programme assembleur de l’application
1)
2)
3)
4)
5)
6)
7)
8)
9)
10)
11)
12)
13)
14)
15)
16)
17)
18)
19)
20)
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Ce programme assure la gestion des LEDs en mode
; de télécommande :un appui sur un des
; Boutons-Poussoirs allume les LEDs tendis que
; l’appui suivante fait éteindre ces LEDs
;
; Nom du projet : TELERUPTEUR
; Auteur : V.Tourtchine
; Date : 09/2009
; Microcontrôleur : Microchip PIC 16F84A
; Langage : Assembleur
; IDE : Microchip MPLAB
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;xxxxxxxxxxxxxxxx
; Processeur
;xxxxxxxxxxxxxxxx
List p=16F84A
#include <p16F84A.inc>
- 47 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------21)
22)
23)
24)
25)
26)
27)
28)
29)
30)
31)
32)
33)
34)
35)
36)
37)
38)
39)
40)
41)
42)
43)
44)
45)
46)
47)
48)
49)
50)
51)
52)
53)
54)
55)
56)
57)
58)
59)
60)
61)
62)
63)
64)
65)
66)
67)
68)
69)
70)
71)
72)
73)
74)
75)
76)
77)
78)
79)
80)
81)
82)
83)
84)
85)
86)
87)
88)
;xxxxxxxxxxxxxxxxxxxxxx
; Bits de configuration
;xxxxxxxxxxxxxxxxxxxxxx
__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC
;code protect OFF
;watchdog timer OFF
;power up timer ON
;xxxxxxxxxx
; Macro
;xxxxxxxxxx
bank1 macro
bsf
endm
STATUS,RP0
; passage en banque 1
bank0 macro
bcf
endm
STATUS,RP0
; passage en banque 0
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;
Définition des constantes
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
#DEFINE
B_P
PORTA,0
#DEFINE
LEDs
PORTB
; B_P est branché sur le PORTA,0
; LEDs sont branchées sur le PORTB
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;
Déclaration des registres temporaires
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
CBLOC
0x00c
retard_ms : 1
; « retard_ms » à l'adresse 0x0c
mémo : 1
; « mémo » à l'adresse 0x0d
compte_1 : 1
compte_2 : 1
;xxxxxxxxxxxxxxxxxxxxxxx
; Démarrage sur reset
;xxxxxxxxxxxxxxxxxxxxxxx
org
goto
0x0000
start
;adresse de départ après reset
;adresse 0: start
;xxxxxxxxxxxxxxxxxxxx
; Initialisation
;xxxxxxxxxxxxxxxxxxxx
start
bank1
movlw
B'00000001'
movwf
TRISA
movlw
B'00000000'
movwf
TRISB
bank0
clrf
PORTA
clrf
PORTB
clrf
mémo
movlw
D’10’
movwf
retard_ms,f
goto
début
; bit 0 du PORTA configuré en entrée
; PORTB configuré en sortie
; initialisation du portA
; initialisation du portB
; initialisation du registre "mémo"
; 10 -> w
; initialisatio du"retard_ms" avec 10
; -> début du programme principal
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;
Programme principal
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
début
btfss
B_P
; tester si B_P est appuyé?
goto
début
; non -> début
- 48 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------89)
90)
91)
92)
93)
94)
95)
96)
97)
98)
99)
100)
101)
102)
103)
104)
105)
106)
107)
108)
109)
110)
111)
112)
113)
114)
115)
116)
117)
118)
119)
120)
121)
122)
123)
124)
125)
call
call
call
goto
tempo
gestion
appui
début
;
;
;
;
oui -> appeller du s/programme "tempo"
appeller du s/programme "gestion"
appeller s/programme "appui"
retour au début du programme
;======== Sous-programme "tempo" de temporisation ===============
tempo
movlw
D’250’
; le contenu pour le registr « compte_1 »
movwf
compte_1
; 250 -> « compte_1 »
movf
retard_ms,w
; le contenu du « retard_ms » -> W
movwf
compte_2,f
; W -> « compte_2 »
boucle_1
nop
decfsz compte_1,f
; décrémenter le « compte_1 » et sauter:
goto
boucle_1
; -> boucle_1 si « compte_1 » n’est pas 0
movlw
D’250’
; si « compte_1 » est 0
movwf
compte_1,f
; on charge le « compte_1 » avec D’250’
boucle_2
decfsz compte_2,f
; décrémenter le « compte_2 »
goto
boucle_1
; si le « compte_2 » n’est pas 0
return
; si le « compte_2 » est 0
;====== Sous-programme "gestion" des LEDs ==============
gestion
comf
mémo,f
; inverser les bits du registre "mémo"
movf
mémo,w
; sauvegarder « mémo » dans le registre w
movwf
LEDs
; charger le registre LEDs par w
return
; -> programme principal
;======== Sous-programme"appui" du test de B_P =================
appui
btfsc
B_P
; détecter si B_P est appuyé?
goto
appui
; oui -> appui
return
; non -> programme principal
END
; fin du programme
3.2.4 La directive CONFIG
La ligne 25, commence par « __ CONFIG ». Cette ligne contient les « fameux fusibles » qui
fixent le fonctionnement du PIC.
Les valeurs écrites ici seront intégrées dans le fichier « .hex » pour signaler au
programmateur les valeurs à encoder aux adresses spécifiques du PIC.
3.2.5 Les macros
Plus bas, lignes 34 à 36, nous trouverons une MACRO :
bank1
macro
bsf
endm
; passage en banque 1
STATUS,RP0
La macro se compose d’un nom écrit en première colonne, suivi par la directive « macro ».
Commence alors à la ligne suivante la portion de code qui constitue la macro. La fin de la macro est
définie par la directive « endm ».
Une macro remplace donc un morceau de code que nous utilisons souvent. La macro
fonctionne également uniquement comme un simple traitement de texte. Chaque fois que la macro
sera rencontrée, elle sera remplacée au moment de l’assemblage par la ligne (dans notre cas) :
bsf
STATUS,RP0
La macro simplifie donc l’écriture, mais ne raccourci pas la taille du fichier .hex obtenu,
puisque la ligne sera écrites dans le PIC.
- 49 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------3.2.6 La définitions des constantes
Descendons encore un peu. Dans les lignes 51 et 53 nous trouverons un exemple de
DEFINE. Les « define » est destiné pour remplacer un texte plus complexe.
Par exemple nous pourrons utiliser un PORT suivi d’un numéro de bit, ou bien carrément une
instruction avec ses paramètres.
Une définition est construite de la manière suivante : La directive #DEFINE, suivie par le nom
que l’on désir utiliser, puis la chaîne à substituer. Dans notre exemple :
Les définitions servent à simplifier une modification éventuelle dans le programme.
Supposons que vous décidez de connecter le B_P sur le PORTA bit 4 (RA4), à titre d’exemple. Nul
besoin de rechercher partout dans le programme, il suffira de changer dans la zone DEFINE.
#DEFINE B_P
PORTA,0
soit autrement :
bouton
#DEFINE
equ
B_P
0
PORTA,bouton
puis
#DEFINE B_P
PORTA,4
soit autrement :
bouton
#DEFINE
equ
B_P
4
PORTA,bouton
puis
3.2.7 La déclaration des registres temporaires ou des variables
La zone de mémoire RAM librement utilisable commence à l’adresse 0x0c.
Donc vous pouvez utiliser 68 emplacements RAM, qui répondront à la syntaxe suivante :
retard_ms
mémo
equ
equ
0x0c
0x0d
; le registre « retard_ms » à l’adresse 0x0c
; le registre « mémo » à l’adresse 0x0d
3.2.8 La zone des variables
Toute zone définie par l’utilisateur commence avec la directive CBLOCK, suivie par l’adresse
du début de la zone. Ensuit, nous pouvons utiliser 68 emplacements mémoire, qui répondront à la
syntaxe suivant : nom de la variable suivi du signe « : » suivi de la telle utilisée. Dans notre exemple
on peut défini des registres temporaire comme suit :
CBLOCK 0x0c
retard_ms : 1
mémo
: 1
; début de la zone variable
; le registre « retard_ms » à l’adresse 0x0c
; le registre « mémo» à l’adresse 0x0d
3.2.9 Les étiquettes
Vous trouverez dans les programmes en 1ère colonne ce qu’on a l’appelé des ETIQUETTES.
Ce sont des noms que vous choisissez et qui sont des REPERES pour le programme.
L’assembleur les remplacera par l’adresse du programme à, l’endroit où elles sont
positionnées. Ceci vous évite de devoir calculer les emplacements programme.
3.2.10 La directive « ORG »
La directive ORG, suivie de l’adresse, précise à quelle adresse les instructions qui suivent
seront placées dans le PIC.
Après un reset ou mise sous tension, le PIC démarre toujours à l’adresse 0x00. Le début du
programme doit donc se situer là.
L’adresse 0x04 est l’adresse utilisée par les interruptions (nous verrons dans le prochain
séance de TD). Il ne vous reste donc pas grande place pour placer votre programme. Nous
commencerons donc par un saut vers l’emplacement du programme principal où nous aurons plus de
place. Allons donc voir ligne 68 comment tout ceci fonctionne :
org
goto
0x00
start
; adresse de départ après reset
; adresse 0 : start
- 50 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------La première ligne est une DIRECTIVE qui indique que la ligne suivante sera placée à
l’adresse 0x00.
La seconde ligne est une INSTRUCTION qui indique au PIC que le programme doit sauter à
l’adresse « start » . « start » est une ETIQUETTE.
Après le reset, le PIC exécute donc l’instruction goto start qui se trouve à l’adresse 0x00,
suivie par l’instruction qui se trouve à l’adresse start plus bas dans le programme (donc juste en
dessous de l’étiquette start).
3.2.11 La routine d’initialisation
Les instructions contenues à partir de l’étiquette « start » (de la ligne 70 à la ligne 81) vous
devriez avoir comprise.
3.2.12 Le programme principal
A partir de la ligne 86 à la ligne 123 c’est le programme principal. Dans notre cas ce
programme peut être représenté sans utiliser l’appelle des sous-programmes et de macro. Le choix
dépend de la fréquence d’utilisation dans le programme des sous-programmes et des macro. Vous
pouvez choisir la méthode que vous préférez. Très important, c’est d’avoir compris les deux
méthodes.
3.2.13 La directive « END »
Cette directive précise l’endroit où doit cesser l’assemblage de votre programme. Elle est
obligatoire dans tout programme.
Toutes les instructions situées après la directive END seront tout simplement ignorées.
3.3 Calcul du temps d’exécution d’une temporisation
Grâce aux caractéristiques sur le jeu (set) d’instructions des PIC, on peut connaître le
nombre de cycles nécessaires pour l’exécution d’une instruction. Sachant que l’horloge interne divise
par 4 le fréquence issue du quartz, cella donne, pour un quartz de 4 MHz, un temps de 1 µs par cycle
machine (f = 4 MHz /4 = 1 MHz, d’où T = 1/f = 1 µs).
A chaque fois qu’on a besoin d’introduire dans le programme une temporisation, il faut
calculer le temps machine nécessaire pour exécuter cette temporisation afin de déterminer la valeur
exacte de la temporisation.
Prenons l’exemple d’une temporisation (de la ligne 96 à 110 dans notre programme) avec un
quartz de 4 MHz.
L’instruction goto et return dure 2 cycles machines, l’instruction decfsz dure 1 cycle ainsi
que l’instruction nop. Le registre « compte_1 » est initialisé à 250.
Le PIC fera 250 fois la boucle_1 de temporisation : la temporisation est donc de :
(ligne 102 + ligne 103 + ligne 104) x compte_1 – ligne104
= (nop + decfsz + goto) x compe_1 – goto = (1+1+2) x 250 – 2 = 1 000 – 2 (cycles)
Maintenant avec la boucle_2 = retard_ms on a:
(1 000 – 2) x compte_2 + (ligne105 + ligne106)compte_2 – ligne109
soit :
(1 000 – 2) x retard_ms + (movlw + movwf) x retard_ms – goto
soit:
(1 000 – 2) x retard_ms +(1+1)x retard_ms – 2 (cycles) plus :
(ligne89 + ligne97 + ligne98 + ligne99 + ligne 100 + ligne 110)
soit :
(call + movlw + movwf + movf + movwf + return) = (2 + 1 + 1 +1 + 1 + 2) = 8 (cycles)
Finalement le nombre de cycles NbCycles est égale à :
NbCycles = 1 000 x retard_ms – 2 x retard_ms + 2 x retard_ms – 2 + 8 = 1 000 x retard_ms + 4
Alors on peut déterminer le temps totale de temporisation :
3
NbSycles x 1 µs = 1 000 x retard_ms x 1 µs + 4 x 1 µs = 10 x retard_ms x 1 µs + 4 x 1 µs
3
Si on néglige les 4 µs par rapport à 10 x retard_ms x 1 µs, on a pour le temps de
temporisation: tempo = 103 x retard_ms x 1 µs = 103 x retard_ms (µs).
Supposons que le régime transitoire du B_P n’est dépasse pas 10 ms = 10 x 103 µs.
Alors on peur calculer le contenu maximal du registre « retard_ms » :
3
3
retard_ms = 10 x 10 / 10 = 10 (cycles)
Dans notre programme le registre « retard_ms » a été initialisé avec le contenu à 10.
- 51 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
--------------------------------------------------------------------------------------------------------------------------------------
IV. Exercices
Exercice 1. Une minuterie
Le schéma d’application est représenté sur la figure 1.
Le fonctionnement du circuit est suivant.
De que le montage sera alimenté et le bouton-poussoir B_P appuyé, la LED devra s’allumer et
y restera durant un période préalablement établi (180 ms ).
L’organigramme est représenté sur la figure 4.
Pour la temporisation on utilisera une fonction « tempo » de l’exemple précédent.
Écrire en assembleur le programme pour le PIC 16F84A.
Fig. 4 L’organigramme d’une minuterie
Exercice 2. Le clignotant
Le schéma d’application est représenté sur la figure 1.
Le fonctionnement du circuit est suivant.
De que le montage sera alimenté, et le bouton_poussoir B_P sera constamment appuyé la
LED devra clignoter indéfiniment (période de 400 millisecondes)
Écrire en assembleur le programme pour cette application en utilisant PIC 16F84A.
Exercice 3. Les feux tricolores
Le but de cet exercice est de simuler le fonctionnement de deux feux tricolores.
Le schéma de principe est représenté sur la figure 5.
- 52 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------La partie commentaire de l’organigramme représenté sur la figure 6 décrit successivement
ce que doit faire le programme. On défini une constante, que l’on nomme « Inter0 », et qui correspond
au bouton marche / arrêt de notre montage, et une constante « Inter1 » qui correspond à l’interrupteur
qui déclare les faux en mode clignotant. On effectue une temporisation longue « tempo_lg » environ 4
s et une temporisation courte « tempo_ct » environ égal à 1,5 s.
Ecrire en assembleur le programme correspondant à l’organigramme de la figure 6.
2
2
+5 v
1k
Inter 0
1
Inter 1
R1
1
Alimentation
stabilisée 5 V
R6
+
C1
R2
1k
R3
1k
1uF
0
0
0
R5
R4
3 X 470
U1
17
18
1
2
3
0
16
15
4
Q1
14
RA0
RB0/INT
RA1
RB1
RA2
RB2
RA3
RB3
RA4/T0CLK
RB4
RB5
OSC1/CLK
RB6
OSC2/CLKOUT RB7
6
7
8
9
10
11
12
13
LV
LJ
LR
MCLR
0
VDD
PIC16F84
R7
4 MHz
+
C3
15pF
0
C4
15pF
C2
10uF
0
R8
LR
R9
LJ
0
0
3 X 470
Fig.5
- 53 -
LV
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------COMMENTAIRES
Etat initial
On utilise les registres :
retard_1, retard_2, retard_3.
Déclaration des variables utilisées
Le porte A est programmé en entrée et le
porte B en sortie (vers la LED)
Initialisation des ports A et B
On impose un signal rouge aux deux feux
tricolores.
Initialisation des feux au signal rouge
Le bouton
marche-arrêt
est appuiyé ?
NON
On vérifie que l’interrupteur «Marche» est
appuyé pour lancer le programme.
OUI
Si le bouton clignotant est appuyé, le
programme se déroute vers l’étiquette
« clignote », les feux clignotent à l’orange.
OUI
Le bouton
clignotant est
appuiyé ?
NON
Fonctionnement normal
Appel de la temporisation longue
Appel de la temporisation longue avant de
passer le feu 1 au vert.
Feu 1 au vert, fue 2 au rouge
Appel de la temporisation longue
Appel de la temporisation longue avant de
passer le feu 1 à l’orange.
Feu 1 à l'orange, fue 2 au rouge
Appel de la temporisation courte
Appel de la temporisation courte avant de
repasser le feu 1 au rouge.
Feu 1 àu rouge, fue 2 au rouge
Appel de la temporisation courte
Appel de la temporisation courte.
Feu 1 àu rouge, fue 2 au vert
Le feu 2 passe au vert.
Appel de la temporisation longue
Appel de la temporisation longue.
Feu 1au rouge, fue 2 à l'orange
Le feu 2 passe à l’orange.
Appel de la temporisation courte
Appel de la temporisation courte avant de
retourner en début de programme.
Feu 1 à l'orange, fue 2 à l'orange
Fonctionnement en clignotant
Passage des feux 1 et 2 à l’orange.
Appel de la temporisation courte
Appel de la temporisation courte.
Feu 1 éteint, fue 2 éteint
On éteint les 2 feux.
Appel de la temporisation courte
Appel de la temporisation courte et retour.
Fig. 6
- 54 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Nom du projet : tricolor
;
; Auteur : V.TOURTCHINE
; Date : 09/2009
; Microcontrôleur : Microchip PIC 16F84A
; Langage : Assembleur
; IDE : Microchip MPLAB
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;xxxxxxxxxxx
; Processeur
;xxxxxxxxxxx
List p=16F84A
#include <p16F84A.inc>
;xxxxxxxxxxxxxxxxxxxxxx
; Bits de configuration
;xxxxxxxxxxxxxxxxxxxxxx
__config _CP_OFF & _WDT_OFF & _PWRTE_OFF & _XT_OSC
;xxxxxx
; Macro
;xxxxxx
bank1 macro ; passage en banque 1
bsf STATUS,RP0
endm
bank0 macro ; passage en banque 0
bcf STATUS,RP0
endm
LRon_1 macro
bsf
LR_1
endm
LJon_1 macro
bsf
LJ_1
endm
LVon_1 macro
bsf
LV_1
endm
LRon_2 macro
bsf
LR_2
endm
LJon_2 macro
bsf
LJ_2
endm
LVon_2 macro
bsf
LV_2
endm
;xxxxxxxxxxxxxxxxxxxxxxxxxxx
; Déclaration des variables
;xxxxxxxxxxxxxxxxxxxxxxxxxxx
CBLOCK 0x0C
retard_ct : 1
retard_lg : 1
compte_1 : 1
compte_2 : 1
ENDC
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Définition des consrantes
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
#DEFINE
LR_1
PORTB,0
- 55 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------#DEFINE
#DEFINE
#DEFINE
#DEFINE
#DEFINE
#DEFINE
#DEFINE
LJ_1
LV_1
LR_2
LJ_2
LV_2
Inter0
Inter1
PORTB,1
PORTB,2
PORTB,3
PORTB,4
PORTB,5
PORTA,0
PORTA,1
;xxxxxxxxxxxxxxxxxxxx
; Démarrage sur reset
;xxxxxxxxxxxxxxxxxxxx
org 0x0000
goto start
;xxxxxxxxxxxxxxx
; Initialisation
;xxxxxxxxxxxxxxx
start
bank0
clrf
clrf
bank1
movlw
movwf
movlw
movwf
bank0
clrf
clrf
movlw
movwf
movlw
movwf
clrf
clrf
goto
PORTA
PORTB
B'00000011'
TRISA
B'00000000'
TRISB
PORTA
PORTB
d'6'
retard_lg
d'2'
retard_ct
compte_1
compte_2
début
;xxxxxxxxxxxxxxxxxxxx
; Programme principal
;xxxxxxxxxxxxxxxxxxxx
début
btfss Inter0
goto
début
btfsc Inter1
goto
clignote
call
STOP
call
route_1avert
call
route_1
call
J_1
call
STOP
call
route_2avert
call
route_2
call
J_2
goto
début
;=========== s/p tempo_lg ================
tempo_lg
movlw
d'250'
movwf
compte_1
movf
retard_lg,w
movwf
compte_2
boucle_1lg
nop
decfsz
compte_1
goto
boucle_1lg
movlw
d'250'
movwf
compte_1
- 56 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------boucle_2lg
decfsz
goto
return
compte_2,f
boucle_1lg
;========== s/p tempo_ct
=============
tempo_ct
movlw
movwf
movf
movwf
d'100'
compte_1
retard_ct,w
compte_2
nop
decfsz
goto
movlw
movwf
compte_1,f
boucle_1ct
d'100'
compte_1
boucle_1ct
boucle_2ct
decfsz
goto
return
compte_2,f
boucle_1ct
;========== s/p STOP =========
STOP
clrf
PORTB
LRon_1
LRon_2
call
tempo_ct
return
;======== s/p J_1 ============
J_1
clrf
PORTB
LJon_1
LRon_2
call
tempo_ct
return
;========= S/P J_2 ===========
J_2
clrf
PORTB
LJon_2
LRon_1
call
tempo_ct
return
;======== S/P route_1 =========
route_1
clrf
PORTB
LVon_1
LRon_2
call
tempo_lg
return
;======= S/P route_2 =========
route_2
clrf
PORTB
LRon_1
LVon_2
call
tempo_lg
return
- 57 -
V.Tourtchine. Microcontrôleur de la famille PIC. Support de cours & Prise en main du logiciel MPLAB
-------------------------------------------------------------------------------------------------------------------------------------;====== S/P route_1 avert ========
route_1avert
clrf
PORTB
LRon_1
LJon_1
LRon_2
call
tempo_ct
return
;======= s/p route_2 avert =========
route_2avert
clrf
PORTB
LRon_1
LRon_2
LJon_2
call
tempo_ct
return
;======= s/p clignote =========
clignote
clrf
PORTB
call
tempo_ct
LJon_1
LJon_2
call
tempo_ct
goto
début
END
- 58 -