Polycope Microproc Habilitation

Université Hassiba Benbouali de Chlef ‐‐‐
Algérie
Faculté de Technologie

Département d’Electrotechnique

Les Microprocesseurs
&
Les Microcontrôleurs
__ Tome 01 __
Cours destiné aux Etudiants :

M1 & L3 Commande
M1 & L3 Génie Electrique et Informatiques Industrielle

Réalisé par : Docteur Abdallah Zegaoui
Maître de Conférences
Département ’Electrotechnique
Faculté de Technologie
Université Hassiba Benbouali de Chlef, Algérie

Avant‐propos

Ce cours est dédié aux étudiants d’Electrotechnique inscrits en troisièmes
année licence et première année Master (options Génie Electrique et
Informatique Industrielle et Commande Electrique). Il est enseigné en tant que
cours intégré en semestre 1pour les deux niveaux. Il porte sur des notions
élémentaires et avancées de l’étude et de la programmation des
microprocesseurs, et en particuliers le 16F84 de Microchip, ainsi que sur des
notions de bases sur les microcontrôleurs.
Nous commençons le cours avec une présentation générale de l’historique
des microprocesseurs et des systèmes de numération suivis d’un résumé sur les
opérations arithmétiques des nombres signés et les opérations booliennes. Nous
traitons ensuite en détail ensuite de les architectures et les fonctions de base des
microprocesseurs, tout en induisant une explication des différents types de
mémoires. Une fois les connaissances de bases assimilées, nous continuant avec
l’étude et la programmation du PIC16F84 de Microchip ainsi que la manière dont
ce dernier s’interface avec les modules externes. Tous les modules composant ce
microcontrôleur sont introduit avec détail à savoir, le compteur de programme,
les timers, les mémoires, les ports d’entrée et de sortie, la pile du système etc.
Nous terminons ce cours avec l’étude de toutes les instructions permettant la
programmation du 16F84 en langage assembleur.
Enfin, ce cours sera publié entièrement sur le site Web de l’université
Hassiba Benbouali de Chlef.
Polycopié --- cours de Microprocesseurs & Microcontrôleurs (Tome 01)
I. Table des matières

II. Historique ......................................................................................................................................... 6
III. Le système décimal .......................................................................................................................... 6
IV. Le système binaire ........................................................................................................................... 7
V. Le système hexadécimal .................................................................................................................. 8
VI. Opérations arithmétiques et nombres signés .................................................................................... 9
VII. Les nombres signés : la soustraction ................................................................................. 10
VIII. Les opérations booliennes ................................................................................................. 11

A. Le complément logique ..................................................................................................... 11
B. Le ET (AND) logique ........................................................................................................ 11
C. Le OU (OR) logique .......................................................................................................... 12
D. Le OU-EXCUSIF (Exclusif OR) ou XOR ........................................................................ 12
IX. Architecture basique d’un microprocesseur ................................................................................... 13
X. L'Unité Arithmétique et Logique ................................................................................................... 13
XI. L'accumulateur ou le registre de travail ......................................................................................... 14
XII. L’unité de commande et de contrôle ................................................................................. 15

A. l'horloge : ........................................................................................................................... 15
B. Le compteur programme PC : ............................................................................................ 15
C. Le registre d'instruction RI .............................................................................................. 16
D. Le décodeur ....................................................................................................................... 16
E. Le séquenceur .................................................................................................................... 16
XIII. Le registre d'état ................................................................................................................ 16
XIV. Le Compteur d'Instructions ............................................................................................... 16
XV. Le registre d'adresses ......................................................................................................... 16
XVI. Le Registre d'Instructions (RI) .......................................................................................... 17
XVII. Le registre d'état ................................................................................................................ 17
XVIII. Les registres généraux ....................................................................................................... 18
XIX. Structure de la mémoire principale (MP) .......................................................................... 18
XX. Exécution d’un programme ............................................................................................... 20
XXI. Les mémoires ..................................................................................................................... 21
Dr A. Zegaoui, UHBC ; Département d’’Electrotechnique, Laboratoire GEER 3

XXII. Organisation d’une mémoire ............................................................................................. 21
XXIII. Caractéristiques d’une mémoire ........................................................................................ 23
XXIV. Types de mémoires ............................................................................................................ 24

A. Mémoires mortes (ROMs) ................................................................................................. 24
B. Mémoires vives (RAMs) : ................................................................................................. 25
C. Les RAM statiques (SRAM) : ........................................................................................... 25
D. Les RAM dynamiques (DRAM) : ..................................................................................... 26
XXV. Les Microcontrôleurs : Le PIC 16F84 ............................................................................... 27
XXVI. Introduction ....................................................................................................................... 28
XXVII. Le Microcontrôleur 16F84................................................................................................. 28
XXVIII. Brochage et fonctions des différentes pattes ..................................................................... 29
XXIX. Architecture générale ......................................................................................................... 30
XXX. Organisation de la mémoire ............................................................................................... 31
XXXI. Mémoire de programme .................................................................................................... 31
XXXII. Mémoire de données .......................................................................................................... 31
XXXIII. Registres généraux ............................................................................................................. 32

A. Registres spéciaux – SFRs (Special Function RegisterS) ................................................. 32
B. Description des registres FSRs .......................................................................................... 33
C. Détail des registres STATUS et OPTION ......................................................................... 34
XXXIV. Mémoire EEPROM ........................................................................................................... 36
XXXV. Jeu d'instructions ............................................................................................................... 36
XXXVI. L'ALU et le registre W ...................................................................................................... 38
XXXVII. L'Horloge ............................................................................................................... 39
XXXVIII. Le port d' E/S PORTA ........................................................................................... 39
XXXIX. Le port d' E/S PORTB ....................................................................................................... 40
XL. Le Timer TMR0................................................................................................................. 40
XLI. Le chien de garde (Le Watchdog Timer : WDT) ............................................................... 42
XLII. Le mode SLEEP ................................................................................................................ 44
XLIII. La mémoire EEPROM de configuration ........................................................................... 44
XLIV. La mémoire EEPROM de données .................................................................................... 45

XLV. Les interruptions ................................................................................................................ 46
XLVI. Modes d'adressages ........................................................................................................... 46

A. L'adressage indirect ........................................................................................................... 47
XLVII. Le compteur programme ................................................................................................... 47
XLVIII. Détail des 35 instructions du 16F84 .................................................................................. 48
XLIX. Un mot sur TRIS : TRIState port....................................................................................... 61
L. ENCODAGE des INSTRUCTIONS ............................................................................................. 61
LI. Bibliographie .................................................................................................................................. 62


II. Historique
En 1642, Pascale inventait la Pascaline qui est une calculatrice entièrement mécanique. Le télégraphe
optique fut inventé en 1792 par les frères Chappe. La première machine qui est un métier à tisser les cartes
perforées est inventé en 1801 par Jacquard, elle prenait en charge le langage binaire et l’enregistrement
des programmes. En 1932, le monde a vu la naissance du premier calculateur électronique qui était le
compteur à tubes. Le premier ordinateur ENIAC (Electronic Numerical Integrator And Computer) est
inventé en 1946, c’est une machine qui consommait 140kW et réalisait 5000 additions par seconde contre
500 multiplications. Les mémoires à tores magnétiques ont été réalisées en 1953 et la société Texas/Kilby
fut apparaitre le premier circuit intégré en 1957. L’entreprise américaine Intel Corporation a réalisé le
premier microprocesseur en date du 15 novembre 1971 ; c’était le fameux Intel 4040 qui embarquait 2250
transistors bipolaires, tournait à la vitesse d’horloge de 108Khz avec quatre bits. La même firme a doublé
les capacités d’Intel 4040 en un autre microprocesseur appelé Intel 8080 avec des mots de huit bits, 64
kilo Octets adressables et une horloge de 2Mhz.
L’an 1981 était le début de l’informatique grand public, dont Intel équipait le premier PC et le
MOTOROLA 68000 d’Appel II. Durant la période 1985 à 1990, le monde de l’électronique avait sur les
marchés les premiers microcontrôleurs industriels l’Intel 8051 et le MOTOROLA 68HC11. Dès 1995, la
puissance des ordinateurs permettait la vulgarisation des outils de CAO (Controller Access Object) et des
compilateurs C avec comme cible les microcontrôleurs.
Par la suite et dans les années 70 apparaissent de petites entreprises de fabrication de microprocesseurs
comme MOS Technologies avec son 6502 très inspiré du 6800 mais vendu seulement 25$ et ZILOG
avec son Z80 qui constitue une amélioration technique du 8080 (augmentation du nombre de
registres, simplification de l'alimentation...). Les autres grands constructeurs (TEXAS INSTRUMENT,
FAIRCHILD, RCA, SIGNETICS etc.) se lanceront aussi dans ce marché.
Rappel sur les systèmes de numérisation
III. Le système décimal
Pour rappel un système décimal est un système de numération qui utilise 10 chiffres (de 0 à 9) pour
générer des nombres, c’est un système en base 10. Mais dans un nombre la position des chiffres a
également une grande importance. Les chiffres les moins significatifs se situent à droite du nombre, et
leur importance augmente au fur et à mesure du déplacement vers la gauche. En effet, dans le nombre
502, le 5 à une plus grande importance que le 2. En réalité, chaque chiffre, que l’on peut appeler DIGIT,
à une valeur qui dépend de son RANG. Quel est ce rapport ? Il s’agit tout simplement de l’élévation de la
BASE utilisée élevé à la puissance de son RANG. Remarquez ici une chose très importante : le comptage

du rang s’effectue toujours de droite à gauche et en commençant par 0. Pour notre nombre 502, sa valeur
est donc en réalité : 502 = 2*10° + 0*101+5*10². Notez que le symbole * est utilisé pour indiquer une
opération de multiplication. Dans les microprocesseurs un nombre décimal est écrit tel quel ou sous la
forme D’xxxxxx’ dont x peut prendre les chiffres entre 0 et 9.
IV. Le système binaire
Pour un ordinateur il ne sait que distinguer entre deux niveaux : présence ou absence de tension ! Cela
veut dire que le système décimal est inadapté. Pour représenter deux niveaux logiques (niveau haut de
tension et niveau bas) il est donc obligatoire d’utiliser un système de numération à base de deux : le
système binaire qui utilise deux chiffres, le 0 et le 1 pour représenter n’importe quel nombre sous
formes d’une série de 0 et de 1. Chaque chiffre est appelé Bit (BInary uniT en anglais) et un ensemble
de huit bit est un Octet (Byte en anglais). En binaire, un nombre est représenté sous la forme B’xxxxxx’
dont x vaut un 0 ou un 1.
Comment représenter un nombre binaire !
Puissances de 216 215 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20

2 (poids du
bit)
Equivalences 65536 32768 16384 8192 4096 2048 1024 512 128 64 32 16 8 6 4 2 1
de puissances
de 2 en
décimal
Positions des b16 b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
bits dans le
nombre
(poids du bit)
Donnée su 2 x x
bits
Donnée sur 4 x x x x
bits (quartet)
Donnée sur 8 x x x x x x x x
bits (Octet)
Donnée sur x x x x x x X x x x x x x x x x x
16 bits (mot =
2 octets)
Pour illustration, sur deux bits on ne peut représenter que B’00’, B’01’, B’10’ et B’11’ ce qui est
équivalent en binaire respectivement à 0, 1, 2 et 3 par une sommation des puissances de 2. A titre
d’exemple B’11’ = 1x20 + 1x21 = 3. Donc sur deux bits on ne peut représenter au maximum que le
nombre décimal 3. Par contre sur quatre bits (Quartet) on peut aller à B’1111’ ce qui est équivalent à
nombre 13 en décimal. A titre d’exemple le B’1001’ = 1x20 + 0x21 + 0x21 + 1x22 = 5 en décimal. Sur
quatre bits on ne peut coder en fait que les nombres naturels allant de 0 à 13 au maximum. Donc pour
coder un nombre décimal plus de 13 il nous faut plus de bits en binaire ! Une donnée, un nombre
décimal, codé sur 8 bits est appelé Octet. Donc sur un octet on peut représenter au maximum B’1111
1111’ = 1 + 2 + 4 + 8 + 16 + 32 + 64 = 127 en décimal et tout nombre supérieur à 127 nécessite plus
d’un octet pour être condé en binaire. Et sur 16 bit on peut coder un nombre décimal de moins de 65535
et plus de 65535 nécessite plus de 16 bits pour un codage en binaire.
V. Le système hexadécimal
Ecrire des nombre en binaire par une succession de 1 et de 0 sur une taille élevée (plusieurs bits) n’est
pas facile à gérer et peut même être une source d’erreur d’écriture. Pour y remédier, il a été décidé de
scinder l’octet en deux quartets et que chaque quartet était représenté par un chiffre conformément au
tableau VVV. On a déjà vu qu’un quartet ne peut coder que les nombres décimaux de 0 à 15. Pour
qu’un quartet ne puisse être représenté que par un seul chiffre, il a été décidé de remplacer les 6
nombres de 10 à 15 par les premières lettres de l’alphabet : A, B, C, D, E et F. il est à signaler qu’un
nombre hexadécimal est précédé par le suffixe 0x. À titre d’exemple, le plus grand nombre qu’on peut
représenter sur un octet est 0xFFFF FFFF = Fx160 + Fx161 + Fx162 + Fx163 + Fx164 + Fx165 +
Fx166 + Fx167 = Fx (1+16+256+4096+65536+1048576+16777216+268435456) = 16x286331153=
4 581 298 448 c’est énorme comme nombre !
Tableau d’équivalence Binaire-Hexadécimal-Décimal :
Binaire Hexadécimal Décimal
B’0000’ 0x0 0
B’0001’ 0x1 1
B’0010’ 0x2 2
B’0011’ 0x3 3
B’0100’ 0x4 4
B’0101’ 0x5 5
B’0110’ 0x6 6

B’0111’ 0x7 7
B’1000’ 0x8 8
B’1001’ 0x9 9
B’1010’ 0xA 10
B’1011’ 0xB 11
B’1100’ 0xC 12
B’1101’ 0xD 13
B’1110’ 0xE 14
B’1111’ 0xF 15
Le codage d’un nombre sur n’importe quel système de numération ou d’un système de numération à
autre est facile à faire.
VI. Opérations arithmétiques et nombres signés
Quelque soit le système de numération adopté, les opérations arithmétique se font avec les mêmes règles
qu’en décimal.
Addition :
A titre d’exemple on fait l’addition (19+25)=44 mais en binaire.
1
B’ 1 0 10 11 1’
+ B’ 1 1 0 0 1’
= B’ 1 0 1 1 0 0’

Comme indiqué sur le tableau ci-dessus :
 On additionne les chiffres de droite, et on obtient : 1+1=10 car 2 n’existe pas en binaire, on écrit
0 et on reporte 1 ;

 On additionne 1+0+le report et on obtient 10. On écrit 0 et on reporte 1 ;
 On additionne 0+0+le report et on obtient 1. On écrit 1 ;
 On additionne 0+1 on obtient 1. On écrit 1 ;
 On additionne 1+1+le report et on obtient 11. On écrit 1 et on reporte 1 ;
 Reste le report que l’on écrit, soit 1.
La réponse est alors 101100 soit 44 en décimal. On remarque bien sûr que l’addition de deux nombres
codés sur cinq bits donne lieu à un résultat codé sur six bits. C’est normal parce que cinq bit ne suffisent
pas pour coder le nombre 44 !
On procède de la même manière pour les nombres codés en hexadécimal. Effectivement, en sachant que
0xF + 0x1 = 0x10, soit 15+1 = 16.
VII. Les nombres signés : la soustraction
Dans de nombreuses applications, on utilise la soustraction mais le signe « - » n’est pas représentable
électriquement car ce n’est qu’un concept.
Pour des nombres binaires représentés par un octet, sont considérés comme « signés » si le bit 7 représente
le signe. Dans les nombre signés, si le bit 7 est mis à 1 cela signifie que le nombre est négatif et est positif
dans le cas contraire. Cette façon de faire fait perdre un nombre, car le nombre 0 aura deux représentation,
à savoir : 10000000 (-0) et 00000000 (+0). La méthode du complément à deux nous permet d’éviter cette
perte.
En binaire, Pour rendre un nombre négatif
1) On inverse la totalité du nombre (le complément à 1).
2) On ajoute 1
On obtient alors ce qu’on appelle le COMPLEMENT A DEUX du nombre.
Pour exemple, comment avoir le nombre -5 en binaire :
 On écrit 5 en binaire, soit : 00000101.
 On inverse tous les bits, soit : 11111010 (le complément à 1).
 On ajoute 1, soit 11111010+00000001= 11111011 (le complément à2).
 Et par conversion inverse, on aura :
 On écrit 5 en binaire, soit : 11111011.
 On inverse tous les bits, soit : 00000100 (le complément à 1).
 On ajoute 1, soit 00000100+00000001= 00000101 (le complément à2) ce qui donne +5 ; c’est
logique car -(-5)=5 !

Sur un octet, et dans le cas des nombres signés, on obtient les nouvelles limites suivantes :
La plus grande valeur est ‘b01111111’, soit +127.
La plus petite valeur est ‘b10000000’, soit -128.
Remarquez que les opérations continuent de fonctionner. Prenons –3 + 5
B ’11111101’ (-3)
+ B ’00000101’ (5)
-----------------------------
= B’100000010’ (2)
Et là, on dit que ça ne fait pas 2 ? Et bien si, regardez bien, il y a 9 bits, or le processeur n’en gère que 8.
Le 9ème est donc tombé dans un bit spécial que nous verrons plus tard. Dans le registre du processeur, il
reste donc les 8 bits de droite, soit 2, qui est bien égal à (–3) + 5.
Maintenant, si vous avez bien suivi, vous êtes en train de vous poser la question suivante : Quand je vois
B’11111101’, est-ce que c’est –3 ou est-ce que c’est 253 ? Et bien vous ne pouvez pas le savoir sans
connaître le contexte.
Sachez que les nombres signifient uniquement ce que le concepteur du programme a décidé qu’ils
représentent. S’il travaille avec des nombres signés ou non, ou si cet octet représente tout autre chose. La
seule chose qui importe c’est de respecter les conventions que vous vous êtes fixées lors de la création de
cet octet. C’est donc au programmeur de décider de quoi il a besoin pour tel type de données.
VIII.Les opérations booliennes
Ce type d’opérations concerne ceux qui s’effectuent bit par bit sur un octet donné. Dans ce qui suit vous
trouvez un résumé des opérations indispensables à connaître dans la programmation de tout type
microcontrôleurs et essentiellement les PICs.
A. Le complément logique
C’est la négation ou l’inversion logique, ou le NOT en anglais, mais plus précisément le complément
à 1. Elle est souvent notée « ! » devant le nombre à inverser. Son fonctionnement tout simple consiste à
inverser tous les bits de l’octet. Des 1 deviendront des 0 et vis versa. A titre d’exemple, le NOT
B’10001111’ donne ‘B01110000 ‘.
Il est à noter que pour simplifier, avant de complémenter à 1 un nombre quelconque, il faut avant
tout le coder en binaire. Le complément sert généralement à lire une valeur dont les niveaux actifs ont été
inversés dont il faut l’inverser pour avoir la vraie valeur, à réaliser des nombres négatifs …etc.
B. Le ET (AND) logique
Un ET logique, AND et souvent noté &, est la multiplication bit à bit. Elle se réalise entre deux mots et elle multiplie chaque
bit du premier mot par le bit du même rang du second mot. D’où pour réaliser un opération ET logique, il faut disposer de
deux octets. La table de vérité d’une telle opération est présentée dans le tableau ci-après :
Bit1 Bit2 AND
0 0 0
0 1 0
1 0 0
1 1 1

Par simple examen de la table de vérité, on remarque que la seule possibilité pour obtenir un « 1 » est que le Bit1
AND le Bit2 soient à « 1 ». Ce qui se fait normalement par une multiplication. 1*1 = 1, 0*1 = 0, 1*0 = 0. A titre
d’exemple, b’11001100’ AND b’11110000’ donne b’11000000’. De cet exemple, on peut utiliser cette opération
pour préparer le deuxième octet de l’opération comme un masque en vu de masquer (les rendre des 0) les bits de
l’octet qui n’intéressent pas notre application. Le masque b’11110000’ choisi dans notre exemple a permet de
garder le quartet du poids le plus fort dans l’octet b’11000000’.
En résumé, on peut donc à l’aide de cette opération logique positionner un ou plusieurs bits dans un mot à 0 sans
connaître son contenu précédent.
C. Le OU (OR) logique
Cette opération, notée généralement « | », manipule aussi deux octets et permet de positionner le résultat à 1 si
l’un des deux bits de même rang dans les deux octets est à1. Donc le bit du résultat est à 1 si le Bit1 OU le Bit2
est à 1.
La table de vérité de l’opération OR illustrant son fonctionnement est consignée dans le tableau suivant :

Bit1 Bit2 OR
0 0 0
0 1 1
1 0 1
1 1 1
Le ET logique sert, dans la programmation des microcontrôleurs, à forcer n’importe quel bit d’un octet à 1 via un
masque sans connaitre au préalable son contenu. A titre d’exemple, dans l’octet b’10001000’ on veut forcer son
sixième bit à 1 sans toucher le contenu restant. Pour cela on utilise l’opéartion avec comme masque l’octet
b’11000000’, et le résultat de l’opération sera bien sur b’11001000’.
D. Le OU‐EXCUSIF (Exclusif OR) ou XOR
Le XOR (eXclusif OR) assume la même fonction logique OR avec un détail en plus : Pour obtenir 1, il faut que
le Bit1 soit à 1 OU que le Bit2 soit à 1 à l’EXCLUSION des deux bits ensemble. Donc si les 2 bits sont à 1, alors
le résultat sera 0 conformément à la table de vérité ci-après. Elle opère sur deux octets.
Bit1 Bit2 XOR
0 0 0
0 1 1
1 0 1
1 1 0
Cette opération sert tout simplement à inverser un ou plusieurs bits dans un mot sans toucher aux autres avec la
technique de masque dans le deuxième mot. Comme exemple b’10001000’ XOR b’11000000’ donne le résultat
b’01001000’. L’exemple illustre bien l’inversion de l’état logique des deux bits du poids fort dans le premier octet.


IX. Architecture basique d’un microprocesseur
Le microprocesseur ( M.P.U. : MicroProcessor Unit ; C.P.U. : Central Processing Unit) est un circuit
intégré complexe (ensemble de millions de transistors) appartenant à la famille des Very Large Scale Intégration
(VLSI) capable d'effectuer séquentiellement et automatiquement des suites d'opérations élémentaires
(programme). Le microprocesseur remplit deux fonctions essentielles : le traitement des données et le contrôle du
système.
Le traitement de données se fait par l'unité de traitement (fonction est dédiée à l'U.A.L. : Unité Arithmétique et
Logique et ALU : Arithmetic and Logic Unit en anglais). Le traitement concerne la manipulation des données
sous formes de transfert (déplacement), opérations arithmétiques, opérations logiques.... Le contrôle du système
se traduit par des opérations de décodage et d'exécution des ordres exprimés sous forme d'instruction, c’est donc
le séquençage des opérations et c’est le rôle de l’unité de commande.
Un microprocesseur est qualifié par sa puissance qui est la capacité de traiter un grand nombre d'opérations par
seconde sur de grands nombres et en grande quantité. Cette puissance est principalement régie par les critères
suivants :
 La longueur des mots : données et instructions (on parle de largeur du bus des données).
 Le nombre d'octets que le microprocesseur peut adresser (on parle de largeur du bus des
adresses).
 La vitesse d'exécution des instructions liée à la fréquence de fonctionnement de l'horloge de
cadencement exprimée en MHZ.
Dans une unité de traitement on distingue généralement trois éléments logiques principaux :
❒ Une Unité Arithmétique et Logique (U.A.L.)
❒ Un Accumulateur. et
❒ Des registres que l'on nomme couramment : Le Compteur d'Instructions (C.I.), le Registre
d'état, le Registre d'Instructions (R.I.), le Registre d'Adresses (R.A.) et le registre
temporaire des données.
Cet ensemble est interconnecté au travers de différents bus. On trouve trois types de bus :
❒ Le bus des données (bi-directionnel)
❒ Le bus des adresses (uni-directionnel)
❒ Le bus de contrôle (bi-directionnel)
X. LʹUnité Arithmétique et Logique
C’est un circuit complexe qui assure les fonctions logiques (ET, OU, comparaison …) ou arithmétiques (addition,
division, soustraction, …). Il permet donc de traiter et tester les données. Comme l’objectif est de développer un
programme qui gère une application voulue, toute instruction qui modifie une donnée fait toujours appel à l'UAL.

Comme indiqué sur la figure 01, l'entrée de L'UAL est connectée au bus interne par un ensemble de registres
"temporaires" et aussi par un registre particulier appelé "accumulateur" ou plus particulièrement le registre de travail
(Working Register, le Registre W). Alors que la sortie de l'UAL est connectée uniquement à l'entrée de
l'accumulateur. Il est à noter que les deux entrées sont précédées par une mémoire tampon appelée registres
tampons ou verrous. Ces registres, qui ne peuvent être manipulés par le programmeur et le sont totalement
transparents, permettent de stocker des octets aux entrées de l'U.A.L. c o m m e l 'UAL est constitué d'une logique
combinatoire, elle est dépourvue de moyens propres de stockage.
Figure 01: Schéma d’une ALU.
XI. Lʹaccumulateur ou le registre de travail
Le processeur utilise toujours des registres, qui sont des petites mémoires internes très rapides d'accès
utilisées pour stocker temporairement une donnée, une instruction ou une adresse. Chaque registre stocke 8,
16 ou 32 bits. Le nombre exact de registres dépend du type de processeur et varie typiquement entre une
dizaine et une centaine. Parmi les registres, le plus important est le registre accumulateur, qui est utilisé
pour stocker les résultats des opérations arithmétiques et logiques. L'accumulateur intervient dans une proportion
importante des instructions.
C'est le registre le plus important du microprocesseur, il sert systématiquement lorsque ce dernier aura besoin de
"manipuler" des données. La plupart des opérations logiques et arithmétiques sur les données font appel au
couple "UAL - accumulateur" selon la procédure établie en figure 02 suivante:

Figure 02: Procédure de fonctionnement de l’ALU.

Ce même registre de travail aussi sert pour les déplacements et les transferts des données d'un endroit à un autre :
de mémoire à mémoire ou de mémoire à unités d'entrée-sortie (I/O). Ce type d’actions se fait en deux temps :
source vers Accumulateur et ensuite Accumulateur vers destination.
Les instructions supportées par un accumulateur sont très nombreuses. Au niveau de la programmation, il
représente une grande souplesse d'utilisation. Les autres registres du microprocesseur ne permettent que des
opérations limitées. A signaler que certains microprocesseur, possèdent des accumulateurs de longueur double
qui présentent l’avantage de : les opérations logiques et arithmétiques se font entre accumulateurs limitant ainsi
les accès (transferts) avec l'extérieur.
Par exemple, examinons ce qu'il se passe lorsque le processeur exécute une instruction comme
``Ajouter 5 au contenu de la case mémoire d'adresse 180'' :
 Le processeur lit et décode l’instruction ;

 le processeur demande à la mémoire la contenu de l'emplacement 180;
 la valeur lue est rangée dans l’accumulateur ;
 l'unité de traitement (UAL) ajoute 5 au contenu de l’accumulateur ;
 le contenu de l'accumulateur est écris en mémoire à l'adresse 180.
 C'est l'unité de commande qui déclenche chacune de ces actions dans l'ordre.
 L'addition proprement dite est effectuée par l'UAL.
XII. L’unité de commande et de contrôle
C'est l'unité de control qui supervise le déroulement de toutes les opérations au sein du processeur. Elle est
constituée principalement de :
A. lʹhorloge :
C'est l'horloge qui génère les signaux qui permettent le cadencement et la synchronisation de toutes les
opérations. Attention, l'horloge n'est pas une montre au sens commun du terme, c'est juste un signal
carré qui a une fréquence fixe (3 Ghz par exemple), a chaque coup (front) d'horloge, le microprocesseur
(qui ne l'oublions pas n'est qu'un circuit électronique) réalise une tache élémentaire. L'exécution d'une
instruction nécessite plusieurs coups d'horloges.
B. Le compteur programme PC :
Le compteur programme (PC : program counter) est un registre (pointeur) qui contient l'adresse de la
case mémoire où est stockée le prochain élément d'instruction qui devra être chargé dans le processeur
pour être analysé et exécuté. Au début de l'exécution d'un programme, le PC est initialisé par le
système d'exploitation à l'adresse mémoire où est stockée la première instruction du programme. Le
compteur programme est incrémenté automatiquement chaque fois qu'un élément d'instruction est chargée
dans le processeur

C. Le registre dʹinstruction RI

C'est là où le CPU stocke l'instruction en cours d'exécution.
D. Le décodeur
C'est lui qui va "décoder" l'instruction contenue dans RI et générer les signaux logiques correspondant et
les communiquer au séquenceur.
E. Le séquenceur
Il gère le séquencement des opérations et génère les signaux de commande qui vont activer tous les
éléments qui participeront à l'exécution de l'instruction et spécialement l'ALU.
XIII. Le registre dʹétat
Le registre d'état est formé de plusieurs bits appelés drapeaux ou indicateurs (Flags) qui sont positionnés
par l'ALU après chaque opération. Par exemple l’indicateur Z indique quand il est positionné que le
résultat de l'opération est égal à Zéro. L’indicateur C indique que l'opération a généré une retenue. Le
bit N indique que le résultat est négatif …
On dispose d'un jeu d'instructions conditionnées par l'état de différents drapeaux.
XIV. Le Compteur dʹInstructions
Le compteur d’instruction, appelé encore Compteur Programme (PC, Program Couter PC en anglais.) ou
Compteur Ordinal (C.O.) a pour mission de Pointer TOUJOURS le premier octet d'une instruction qui doit étre
exécutée après achèvement de l’exécution de l’instruction en cours. Un programme à exécuter est une succession
d'instructions ordonnées (chaque instruction peut prendre plusieurs octets) qui se trouve rangé dans une zone
mémoire, généralement à des adresses successives. Le PC repère toujours le premier octet de chaque instruction
du programme qui doit être exécutée. Le PC est connecté au bus interne des données. L’adresse de la première
instruction est à spécifiée par le programmeur via les directives du logiciel de programmation.
Cette adresse est transmise aux circuits mémoires par l'intermédiaire du bus d'adresse via le Registre d'Adresses.
Le PC pointe toujours l'adresse du début de l'instruction suivante. Il est possible de charger le PC avec une
adresse qui ne correspond pas au déroulement séquentiel du programme et ce par les détournements conditionnel
et inconditionnel (les GOTO conditionnés ou l’appel de sous-programme).
XV. Le registre dʹadresses
Le Registre d'Adresses, RA, sert d'interface entre le bus des données interne et le bus des adresses par un pilotage
du bus d'adresses du microprocesseur. Le RA se constitue d'une longueur de 16 bits, via deux registres huit bits
chacun (partie haute et partie basse). Son contenu provient de différentes sources : Le compteur d'instruction, un
registre général ou un emplacement mémoire. Son contenu d'adresse pointe la zone mémoire utile au
microprocesseur. Une fois que le premier octet de l'instruction en cours est décodé, le contenu du compteur
d'instructions est changé et va contenir l'adresse du début de l'instruction à venir. Le contenu du Registre
d'adresses change. Il est à noter que le Compteur d’Instruction diffère du Registre d’Adresse. Ce changement
correspond : soit à une incrémentation du contenu afin de lire l'information complémentaire de l'instruction
en cours, soit à un chargement d'une nouvelle valeur correspondant à une nouvelle zone mémoire utilisée
temporairement par le microprocesseur (zone différente de celle où se trouve le programme). Cette nouvelle
valeur provient : soit d'une lecture en mémoire (directement ou indirectement selon les modes d'adressage
utilisés), soit d'un calcul (addition, ...).
XVI. Le Registre dʹInstructions (RI)
Le registre d'instructions contient le premier octet de l'instruction en cours d'exécution. Ce registre
est chargé pendant le cycle de base extraction-exécution. L'information r e ç u e v i a l e le bus des
données est utilisée par le décodeur d'instructions conformément au cycle de recherche exécution ci-après :
 La donnée extraite de la mémoire est stockée dans le R.I. (c'est la phase extraction).
 Ensuite ce contenu est interprété par le décodeur d'instructions qui agit alors sur la logique de contrôle
(c'est la phase exécution).
Cet octet indique au microprocesseur deux choses :
 Une action (une lecture, une écriture ou autre ...)
 Un lieu d'action (un registre, un accumulateur, une case mémoire...)
Le résultat de cette interprétation se traduit par des niveaux logiques sur le bus de contrôle.
XVII. Le registre dʹétat
Le registre d’état, Status Register en anglais, a pour mission de stocker les résultats des tests effectués par
l'UAL après traitement sur les données. C’est un registre à bits et chaque bit nous informe d’un état bien
spécifique du microprocesseur. Un état est un indicateur, drapeau ou flag en anglais. L'existence de ces
résultats permet d'écrire des programmes avec des branchements conditionnels (nouvelle adresse dans le CI).
En fonction de l'état des bits de ce registre le microprocesseur peut, alors, exécuter des programmes
différents. Le microprocesseur prend en quelque sorte des "décisions". Le nombre de ces bits diffère d’un
constructeur à autre mais les bits les plus couramment utilisés sont :
 Le bit de retenue “Carry”: Ce bit est actif , dans le niveau logique haut, lorsque le huitième
bit du résultat de l'opération généré une retenue. Une addition de 255 et 1 sur un processeur 8 bits
génère un retenu ce qui active ce flag.
 le bit de zero: Ce bit est actif lorsque l'opération a pour effet de mettre tous les bits d'un
accumulateur ou d'un registre à la valeur logique 0 (très utilisé pour réaliser des compteurs). Aussi
pour un processeur 8 bits, l’addition de 255 et 1 donne un résultat nul dans le registre W ce qui
provoque l’activation du bit Zéro du registre Status.
 Le bit de signe: Information qui indique que le bit le plus significatif (MSB) du contenu de
l'accumulateur est un 1 logique et par suite on connait que le résultat est un nombre négatif.

XVIII. Les registres généraux
En plus des 6 registres de base que possèdent tous les microprocesseurs 8 bits, il peut en exister d'autres destinés
à faciliter la tâche du programmeur. On les nomme registres généraux. Sur notre schéma fonctionnel type, nous
avons 3 registres généraux B, C et D. Ce ne sont pas des registres puissants (tel un accumulateur) puisqu'ils
n'ont pas de liaison directe avec la sortie de l'U.A.L.
Ces registres peuvent néanmoins affecter le Registre d'Etat.
Parfois, ils peuvent constituer un registre 16 bits - appelé paire de registre (ex : BC chez Intel
ou D chez Motorola). Ainsi, il est possible de réaliser des opérations sur un mot (ex : incrémentation
de la paire).
XIX. Structure de la mémoire principale (MP)
La mémoire, figure 03, est divisée en emplacements (des cases mémoires contiguës) de taille fixe
(par exemple huit bits) utilisés pour stocker instructions et données. En principe, la taille d’un
emplacement mémoire pourrait être quelconque ; en fait, la plupart des ordinateurs en service
aujourd’hui utilisent des emplacements mémoire d’un octet (“ byte ” en anglais, soit huit bits, unité
pratique pour coder un caractère par exemple).
Figure 03 : structure de la mémoire principale
Seul le processeur peut modifier l'état de la mémoire. Chaque emplacement mémoire conserve les
informations que le processeur y écrit jusqu'à coupure de l'alimentation électrique, où tout le contenu est
perdu (contrairement au contenu des mémoires externes comme les disquettes et disques durs).
Les seules opérations possibles sur la mémoire sont :
 écriture d'un emplacement : le processeur donne une valeur et une adresse, et la mémoire range la
valeur à l'emplacement indiqué par l’adresse ;
 lecture d'un emplacement : le processeur demande à la mémoire la valeur contenue à
l'emplacement dont il indique l'adresse. Le contenu de l'emplacement lu reste inchangé.
Finalement la structure d’un microprocesseur se résume en figure 04.

Figure 04 : structure de base d’un microprocesseur.

XX. Exécution d’un programme
Le travail d'un processeur est d'exécuter des programmes. Un programme est une suite d'instructions
écrites sur chaque ligne du programme. Une instruction peut être écrite sous différents langages de
programmation. Pour un langage de bas niveau comme l'assembleur, une instruction réalise une tache
élémentaire comme une addition par exemple. Avec un langage évolué de haut niveau comme le langage
Basic ou le C, une instruction peut réaliser un ensemble de taches qui nécessiterait plusieurs instructions
en Assembleur.
Un processeur quel qu'il soit sait exécuter un ensemble bien défini de codes machines connu sous le
jeu d'instructions. Chaque code machine est un nombre binaire de quelques octets, il correspond à une
instruction élémentaire bien définie. Sur papier, on a pris l'habitude de les représenter en hexadécimal
pour faciliter.
Par exemple, l'instruction en assembleur MOVF f,d tirée du Datasheet du microprocesseur du PIC
16F84 signifie : déplacer l’octet ‘f’ et placer le résultat dans la destination ‘d’. le code machine qui réalise
cette instruction est ’00 1000 dfff ffff’. Ce codage de l’opération est appelé OPCODE.
De nos jours, les informaticiens et les programmeurs des microprocesseurs, disposent d'un choix très
important de langages de programmation différents les uns des autres : Assembleur, Basic/Qbasic, Pascal,
C/C++, Visual Basic, Visual C++, Delphi, Java, … pour l’élaboration des différentes applications. En
fait, les lignes de programme que nous écrivons constituent ce qu'on appelle un programme source qui
sera stocké dans un fichier texte dont l'extension dépend du langage choisi (test.c pour le C, test.pas pour
le pascal, test.cpp pour le c++ etc.)
Ces programmes sources sont compréhensibles par nous mais pas par le processeur. Pour que le
processeur puisse les comprendre il faut les traduire (compiler) en langage machine qui est une suite de
codes machine. Sur les PCs, se sont les fichiers avec l'extension .exe (test.exe). Chaque langage de
programmation a son compilateur qui permet de transformer le programme source en un programme
exécutable compréhensible par le processeur. Tous les exécutables se ressemblent et le processeur ne sait
pas avec quel langage ils ont été écrits.
Avec un langage de haut niveau comme le C++, une instruction que nous écrivons peut être très
sophistiquée. C'est le compilateur C++ qui la traduit en un ensemble d'instructions élémentaires
compréhensible par le processeur.
L'intérêt du langage assembleur est que chaque instruction que nous écrivons correspond à une
instruction élémentaire du processeur. C'est comme si on travaillait directement en langage machine.
Ainsi, on sait exactement tout ce que fait le processeur lors de l'exécution d'un programme.


XXI. Les mémoires
Une mémoire est un composant électronique à base de semi-conducteurs permettant de stocker
(enregistrer, conserver et restituer) des informations (instructions ou variables) sous forme binaire. Ces
informations peuvent alors être écrites ou lues. La capacité de mémorisation détermine la polyvalence des
systèmes numériques et leur adaptabilité a de nombreuse situations. De nos jours, il existe des mémoires
à lecture seule appelées ROM (Read Only Memery) et d’autres à lecture/écriture improprement appelées
RAM (Random Access Memory). Le contenu d’une ROM, fixé lors de la fabrication, reste dans la
mémoire même en absence d’alimentation. Au contraire une RAM perd son contenu une fois mise hors
secteur et du coup se sont des mémoires volatiles.
Entre les deux types précédents de mémoires, existe un autre type qui ne perd pas son contenu une
non-alimenté mais ce dernier peut être modifiable par un processus industriel. A titre d’exemple, le
contenu d’une EPROM est effacé par une exposition aux rayons ultra-violets et un nouveau contenu peut
être écrit via un appareil spécialisé, les EEPROM peuvent être électriquement reprogrammées et les
mémoires flash, les EEPROM, sont rapide à reprogrammer.
Actuellement, Il existe deux types de mémoires qui se distinguent par leur technique de fabrication :
les mémoires dynamiques et les mémoires statiques. Il s’agit dans les deux cas de mémoires volatiles qui
nécessitent une alimentation pour conserver leur contenu. La mémoire dynamique est appelée DRAM
(Dymanic RAM) par opposition à la mémoire statique appelée SRAM (Static RAM). Vue leur moindre
coût et densité supérieure d’intégration, les DRAMs sont plus utilisées comme des mémoires principales
dans les ordinateurs par contre les SRAMs sont utilisées pour les caches en raison de leurs plus grande
vitesse.
Mémoire dynamique Mémoire statique
Grande densité d’intégration Petite densité d’intégration
Bon marché Chère
Lente Rapide
Mécanisme de rafraîchissent
XXII. Organisation d’une mémoire
Le rangement d’informations dans une mémoire peut être vu sous forme d’une grille, tableau ou
matrice de dimension km. Chaque élément de la matrice est un bit. Chaque ligne de la matrice
correspond à une adresse mémoire, c'est-à-dire un emplacement mémoire et chaque colonne représente
un des bits de l’information stockée. Donc dans une mémoire km bits on aura 2k emplacement (adresses
ou parfois cases mémoires) mémoire et que chaque adresse abrite un mot de données de m bits (8, 16, 32
bits…). Le nombre de fils d’adresses d’un boîtier mémoire définit donc le nombre de cases mémoire que
comprend le boîtier. Le nombre de fils de données définit la taille des données que l’on peut sauvegarder
dans chaque case mémoire.
En plus du bus d’adresses et du bus de données, un boîtier mémoire comprend une entrée de commande
qui permet de définir le type d’action que l’on effectue avec la mémoire (lecture/écriture) et une entrée
de sélection qui permet de mettre les entrées/sorties du boîtier en haute impédance comme indiqué en
figure XXX.
Adresses

(K cases mém)
Données
R/W Mémoire (k bits)
CS
Figure 05 : circuit d’une mémoire
La figure 05 schématise un circuit mémoire ou on distingue :
 les entrées d’adresses
 les entrées de données
 les sorties de données
 les entrées de commandes :
 une entrée de sélection de lecture ou d’écriture. (R/W)
 et une entrée de sélection du circuit. (CS)
Une opération de manipulation de la mémoire (lecture/écriture) suit toujours le cycle illustré en figure
06 de haut en bas.
 sélection de l’adresse
 choix de l’opération à effectuer (R/W)
 sélection de la mémoire (CS = 0)
 lecture ou écriture la donnée

Figure 06 : Chronogramme d’un cycle de lecture/écriture.
XXIII. Caractéristiques d’une mémoire
Les caractéristiques principales et communes à toutes les mémoires sont :
 La capacité : exprimée souvent en octet, c’est le nombre total de bits que contient la
mémoire.
 Le format des données : c’est le nombre de bits que l’on peut mémoriser par case mémoire
ou tout simplement c’est la largeur du mot mémorisable.
 Le temps d’accès : c’est le temps qui s'écoule entre l'instant où a été lancée une opération de
lecture/écriture en mémoire et l'instant où la première information est disponible sur le bus de
données.
 Le temps de cycle : il représente l'intervalle minimum qui doit séparer deux demandes
successives de lecture ou d'écriture.
 Le débit : c’est le nombre maximum d'informations lues ou écrites par seconde.
 Volatilité : elle caractérise la permanence des informations dans la mémoire. L'information

stockée est volatile si elle risque d'être altérée par un défaut d'alimentation électrique et non
volatile dans le cas contraire.
Dans une mémoire magnétique, pour accéder à une adresse ciblé, il faut dérouler la bande magnétique
jusqu’à ce que l’on trouve l’enregistrement adéquat. Cela veut dire que l’accès à l’information est
séquentiel or le temps d’accès est variable selon la position de l’information recherchée. Par contre, dans
les mémoires principales utilisées dans les systèmes à microprocesseurs sont à base de transistors, et que
le temps mis pour obtenir n’importe quelle information ne dépend pas de son adresse. L’accès à une telle
mémoire est aléatoire ou direct.

XXIV. Types de mémoires
Les mémoires contiennent les programmes qui sont une série d’instruction en langage assembleur,
codées en binaires et des données qui sont des informations utilisables au cours de l’exécution du
programme.
Les caractéristiques de choix d’une mémoire sont : sa taille physique, sa vitesse (environ quelques
dizaines de ns), sa consommation et ses niveaux logiques. L’idéal est qu’elle soit à faible prix et à vitesse
élevée.
A. Mémoires mortes (ROMs)
Ce sont des mémoires à lecture seule. L’écriture dans ce genre de mémoires nécessite un
programmateur ou une procédure assez longue que les RAMs et les informations stockées sont conservées
même lors d’une coupure subite de l’alimentation.
La figure 07 présente les différents types de mémoires mortes. Tous ces types seront définis brièvement
ci-après.
ROM
Mémoires
mortes
PROM FPROM
OTP
EPROM FPROM
OTP
EPROM
Figure 07 : Différents types de mémoires mortes.

Les ROMs sont réalisées en technologie MOS et bipolaire. Ces mémoires trouvent leur application
dans la conversion de code, la génération de caractères pour l’affichage sous forme de matrice de points,
le stockage de certains programmes système. La classification de ce type de mémoires peut être résumé
comme suit :
ROM (Read Only Memory): Ce sont des mémoires à masque de fabrication de diodes disposées sur
un réseau de lignes et de colonnes ou de transistors. Programmées à l’usine, elles ne peuvent pas être
reprogrammées.
PROM à fusibles ou FPROM (Programmable Read Only Memory ou Fuse PROM) sont réalisées à
partir de transistors bipolaires dont leurs liaisons entre l'émetteur et la colonne sont effectuées par

l’intermédiaire d’un fusible. Ce genre est à programmer par l’utilisateur et ne peuvent pas être
reprogrammées.
EPROM (Erasable Programmable Read Only Memory) en plus des avantages des PROM, ces
mémoires possèdent la possibilité de l'effacement des données par l'utilisateur.
OTP MEMORY (One Time Programmable MEMORY): programmable une seule fois à l’aide d’un
programmateur.
UVPROM (EPROM effaçable par une exposition aux ultraviolet U.V.). Ce type de mémoire est placé
dans un boîtier céramique avec fenêtre de quartz effaçable aux U.V.
EEPROM ou E2PROM (Erasable Electricaly PROM) : sont des sortes de mémoires effaçables et
reprogrammables électriquement.
EPROM FLASH : effaçable électriquement, écriture plus rapide que les EEPROM mais effacement
de toute la capacité de la mémoire en un coup. En raison de sa vitesse élevée, de sa durabilité et de sa
faible consommation, la mémoire flash est idéale pour de nombreuses applications : comme les appareils
photos numériques, les téléphones cellulaires, les imprimantes, les ordinateurs portables, les récepteurs
d’ondes radio de poche et les dispositifs d’enregistrement sonore.
B. Mémoires vives (RAMs) :
Les mémoires vives sont volatiles à accès direct. Elles nécessitent une énergie pour stocker et garder
les données. Il existe deux types de mémoires vives : statiques et dynamiques.
C. Les RAM statiques (SRAM) :
La réalisation interne est essentiellement faite par une matrice de bascules, figure 08 :
 m bascules de large, où m est la taille du mot ;
 2n bascules de long, où 2n est la capacité en mots de la mémoire.

Figure 08 : RAM avec 2n emplacement mémoires (mots) et chaque mot est à m bits.
D. Les RAM dynamiques (DRAM) :
Dans cette catégorie de mémoires, les niveaux logiques sont stockés sous forme de charges électriques
dans des condensateurs. Comme le condensateur se décharge à travers des résistances de fuite, le maintien
de l’information est réalisé par une réécriture de façon régulière. Ce procédé est appelé un
rafraîchissement et qui devra se faire environ toute les deux millisecondes.

XXV. Les Microcontrôleurs : Le PIC 16F84

XXVI. Introduction
Un PIC (Programmable Interface Controller) est un microcontrôleur de chez Microchip, la société
américaine Technology à l’arizona. Ses caractéristiques principales sont :
 Séparation des mémoires de programme et de données (architecture Harvard) ;
 Communication avec l'extérieur seulement par des ports ;
 Utilisation d'un jeu d'instructions réduit, d'où le nom de son architecture : RISC (Reduced
Instructions Set Construction). Les instructions sont ainsi codées sur un nombre réduit de bits, ce
qui accélère l'exécution (1 cycle machine par instruction sauf pour les sauts qui requirent 2 cycles).
En revanche, leur nombre limité oblige à se restreindre à des instructions basiques, contrairement
aux systèmes d'architecture CISC (Complex Instructions Set Construction) qui proposent plus
d'instructions donc codées sur plus de bits mais réalisant des traitements plus complexes.
Il existe trois familles de PIC : -Base-Line : Les instructions sont codées sur 12 bits, -Mid-Line : Les
instructions sont codées sur 14 bits et, -High-End : Les instructions sont codées sur 16 bits.
Un PIC est identifié par un numéro de la forme suivant : xx (L) XX yy – zz
 xx : Famille du composant (12, 14, 16, 17, 18)
 L : Tolérance plus importante de la plage de tension
 XX : Type de mémoire de programme. XX prend la lettre C pour une

EPROM ou EEPROM, les lettres CR pour une PROM et F pour une mémoire de
type Flash.
 yy : Identification
 zz : Vitesse quartz de cadencement du microcontrôleur.
A titre d’exemple, un PIC 16F84 –10, s’identifie comme : 16 signifie que le PIC est de la famille Mid-
Line ; F le PIC a une mémoire programme de type FLASH ; son type est 84 ainsi que 10 veut dire
utilisation d’un Quartz à 10MHz au maximum.
XXVII. Le Microcontrôleur 16F84
Le 16F84 est un microcontrôleur à 08 bits avec un boîtier est un DIL (Dual In Line) de 2x9 pattes. En
dépit de sa petite taille, il est caractérisé par une architecture interne qui lui confère souplesse et vitesse
incomparables. Avec un examen de sa fiche technique, le Datasheet, ses principales caractéristiques sont :
 13 lignes d’entrées/sorties, réparties en un port de 5 lignes (PortA) et un port de 8 lignes (PortB)

 alimentation sous 5 Volts
 architecture interne révolutionnaire lui conférant une extraordinaire rapidité

 une mémoire de programme pouvant contenir 1019 instructions de 14 bits chacune (allant de
l’adresse 05h à l’adresse 3FFh)
 une mémoire RAM utilisateur de 68 emplacements à 8 bits (de l’adresse 0Ch à l’adresse 4Fh)
 une mémoire RAM de 2x12 emplacements réservée aux registres spéciaux
 une mémoire EEPROM de 64 emplacements
 une horloge interne, avec un pré-diviseur et un chien de garde
 possibilité d’être programmé in-circuit, c’est à dire sans qu’il soit nécessaire de le retirer du
support de l’application
 vecteur de Reset situé à l’adresse 00h
 un vecteur d’interruption, situé à l’adresse 04h
 bus d’adresses de 13 lignes
 présence d’un code de protection permettant d’en empêcher la duplication du programme
 facilité de programmation, simplicité et faible prix
 Soft disponible gratuitement sur le site officiel de Microship.
XXVIII. Brochage et fonctions des différentes pattes
La Figure 09 montre le brochage du circuit. Les fonctions des pattes sont les suivantes :
 VSS, VDD : Alimentation

 OSC1,2 : Horloge
 RA0-4 : Port A
 RB0-7 : Port B
 T0CKL : Entrée de comptage
 INT : Entrée d'interruption
 MCLR : Reset : 0V
Choix du mode : programmation : 12V - 14V, exécution : 4.5V - 5.5V.
Figure 09 : Brochage, repérage et définitions des pins.

XXIX. Architecture générale
La Figure 10 présente l'architecture générale du circuit. Il est constitué des éléments suivants :
 un système d'initialisation à la mise sous tension (power-up timer, …)

 un système de génération d'horloge à partir du quartz externe (timing génération)
 une unité arithmétique et logique (ALU)
 une mémoire flash de programme de 1k "mots" de 14 bits (III.1 - XII)
 un compteur de programme (program counter) et une pile (stack)
 un bus spécifique pour le programme (program bus)
 un registre contenant le code de l'instruction à exécuter
 un bus spécifique pour les données (data bus)
 une mémoire RAM contenant
 les SFR (III.2.2)
 68 octets de données(III.2.1)
 une mémoire EEPROM de 64 octets de données (VIII)
 2 ports d'entrées/sorties (VI)
 un compteur (timer) (VII)
 un chien de garde (watchdog) (X)
Figure 10 : Architecture générale du PIC 16F8X.

XXX. Organisation de la mémoire
Les PICs contiennent une mémoire de programme et une mémoire de données. La structure Harvard
des PICs fournit un accès séparé à chacune. A signaler que pendant le même cycle machine, un accès aux
deux types est possible.
XXXI. Mémoire de programme
Une fois chargée par un programmateur hard dans le corps du PIC par la liaison série, c'est elle qui
contient le programme à exécuter. L’organisation de cette mémoire est représentée dans la Figure 11. Elle
contient 1k "mots" de 14 bits dans le cas du PIC 16F84, même si le compteur de programme (PC) de 13
bits peut en adresser 8k. L'adresse 0000h contient le vecteur du RESET, l'adresse 0004h contient l'unique
vecteur d'interruption du PIC. La pile contient 8 valeurs. Comme le compteur de programme, elle n'a pas
d'adresse dans la plage de mémoire. Ce sont des zones réservées par le système.
Figure 11 : Organisation de la mémoire de programme et de la pile.
XXXII. Mémoire de données
La mémoire de donné (Data Memory) est composée de deux parties formant la RAM et une zone
EEPROM. La première contient les registres SFRs (Special Function Registers) qui permettent de
contrôler les opérations sur le circuit. La seconde contient des registres généraux, libres pour l'utilisateur
(programmeur). La dernière contient 64 octets. Il est à signaler que les instructions orientées octets ou bits
contiennent une adresse sur 7 bits pour désigner l'octet avec lequel l'instruction doit travailler. Comme à
titre d’exemple et consigné sur la Figure 12, le registre TRISA d'adresse 85h est inaccessible avec une
adresse sur 7 bits. C'est pourquoi le constructeur a défini deux banques. Le bit RP0, 5ième bit du registre
d'état (STATUS_Reg) permet de choisir entre les deux. Ainsi, une adresse sur 8 bits est composée de RP0
en poids fort et des 7 bits provenant de l'instruction à exécuter.
Figure 12 : Organisation de la mémoire de données.
XXXIII. Registres généraux
Ils sont accessibles soit directement soit indirectement à travers les registres FSR et INDF (Voir les
modes d’adressage).
A. Registres spéciaux – SFRs (Special Function RegisterS)
La Figure 13 résume la fonction de chacun des bits de registres SFRs. Le SFRs sont des registres qui
permettent la gestion du PIC dont certains ont une fonction générale et d'autres une fonction spécifique
attachée à un périphérique donné. En banque 0 (page mémoire 0) ils sont situés de l'adresse mémoire 00h
à l'adresse 0Bh par contre sont situés de l'adresse 80h à l'adresse 8Bh dans la banque 1 (deuxième page
mémoire). Les adresses mémoires 07h et 87h ne contiennent aucun registre.

Figure 13 : Description des registres SFR prise du datasheet du 16F84.
B. Description des registres FSRs
Nom du Adresse Fonction
registre Mémoire
INDF 00h-80h Utilise le contenu de FSR pour l'accès indirect à la mémoire
TMR0 01h Registre lié au compteur
PCL 02h-82h Contient les poids faibles du compteur de programmes (PC). Le

registre PCLATH (0Ah-8Ah) contient les poids forts.
STATUS 03h-83h Il contient l'état de l'unité arithmétique et logique ainsi que les bits
de sélection des banques (Figure* III.4).
FSR 04h-84h Permet l'adressage indirect.

PORTA 05h Donne accès en lecture ou écriture au port A, 5 bits. Les sorties
sont à drain ouvert. Le bit 4 peut être utilisé en entrée de comptage.
PORTB 06h Donne accès en lecture ou écriture au port B. Les sorties sont à
drain ouvert. Le bit RB0 peut être utilisé en entrée d'interruption.
EEDATA 08h Permet l'accès aux données dans la mémoire EEPROM.
EEADR 09h Permet l'accès aux adresses de la mémoire EEPROM.
PCLATCH 0Ah-8Ah Donne accès en écriture aux bits de poids forts du compteur de
programme.
INTCON 0B -8Bh Masque d'interruptions
OPTION_REG 81h Contient des bits de configuration pour divers périphériques.
TRISA 85h Indique la direction (entrée ou sortie) du port A.
TRISB 86h Indique la direction (entrée ou sortie) du port B.
EECON1 88h Permet le contrôle d'accès à la mémoire EEPROM.
EECON2 89h Permet le contrôle d'accès à la mémoire EEPROM.
C. Détail des registres STATUS et OPTION
Les figures 14 et 15 présentent les registres SFRs à utilisation très importante. Il est à noter que ce sont
des registres à bits. Ces registres seront revus plus loin dans le document.

Figure 14 : Registre d'état du PIC 16F84 - STATUS.

Figure 15 : Registre de configuration de périphériques - OPTION_REG.
XXXIV. Mémoire EEPROM
Le PIC possède une zone EEPROM de 64 octets accessibles en lecture et en écriture par le programme.
On peut y sauvegarder des valeurs, qui seront conservées même si l'alimentation est éteinte, et les
récupérer lors de la mise sous tension. Leur accès est spécifique et requiert l'utilisation de registres dédiés.
La lecture et l'écriture ne peut s'exécuter que selon des séquences particulières.
XXXV. Jeu dʹinstructions
Les PICs sont conçus pour être programmés avec un nombre d'instructions réduit ce qui leur qualifie
par une architecture RISC (Reduced Instruction Set Computer). Cette réduction permet de limiter la taille
de leur codage et donc de la place mémoire et du temps d'exécution. La format général d’une instruction
est consigné en figure 16.
Toutes les instructions sont codées sur 14 bits. Elles sont regroupées en trois grands types
 Instructions orientées octets
 Instructions orientées bits

 Instructions de contrôle
Le registre de travail W joue un rôle particulier dans un grand nombre d'instructions.
Figure 16 : Format général d'une instruction.

Il est tout à fait clair, dans le tableau ci-après, qu’une instruction peut être présentée comme suit :
Code instruction : Code opération Le bit de destination Le registre de travail

du résultat désigné par File
XX XXXX XXXX XXXX la lettre « d »
Instructions orientées octets Du bit 8 au bit 13 bit 7 L’adresse mémoire du

registre file du bit 0 au
bit 6
Instructions orientées bits Du bit 10 au bit 13 Du bit 7 au bit 9, L’adresse mémoire du

l’adresse du bit registre file du bit 0 au
bit 6
Instruction général littérales Du bit 8 au bit 13 Le littérale k est valeur --

et de contrôle (sauf le immédiate du bit 0 au
GOTO et CALL) bit 7
Les instructions CALL and Du bit 11 au bit 13 Le littérale k est valeur --

GOTO immédiate du bit 0 au
bit 12
NB : pour d=0 résultat opération stocké dans registre W et pour d=1 résultat stocké dans registre f.
La plupart des instructions opèrent en utilisant le registre de travail W (Working register) comparable
à l’accumulateur des anciens microprocesseurs, et soit un registre file soit une valeur immédiate codée

sur 8 bits appelée literal. Le résultat des opérations peut être envoyé soit dans le registre W
(accumulateur) soit dans le registre sollicité (dépendant de la valeur du bit d). Un petit nombre
d’instructions opèrent en utilisant uniquement un registre (c’est le cas des instructions BCF, BSF,
BTFSC, BTFSS, CLRW, CLRWT et SLEEP).
Liste des instructions
Figure 17 : Liste des instructions.
La Figure 17 donne la liste de toutes les instructions du PIC 16F84.
XXXVI. LʹALU et le registre W
C'est une ALU 8 Bits qui réalise les opérations arithmétique et logique entre le registre de travail W
(l’accumulateur) et n'importe quel autre registre 'File' ou constante (Literal) k. L'accumulateur W est un
registre de travail 8 bits, il n'a pas d'adresse comme les autres SFR. Pour les instructions à deux opérandes,
c'est toujours lui qui contient un des deux opérandes. Pour les instructions à un opérande, celui-ci peut
être soit W soit n'importe quel registre F. Le résultat de l'opération peut être placé soit dans le registre de
travail W soit dans le registre F.

XXXVII. LʹHorloge
L'horloge peut être soit interne soit externe. L'horloge interne est constituée d'un oscillateur à quartz
ou d'un oscillateur RC ce qui est illustré en figure 18.
Figure 18 : l’horloge, oscillateur à quartz à gauche et oscillateur RC à droite.
Avec l'oscillateur à Quartz, on peut avoir des fréquences allant jusqu'à 4, 10 ou 20 MHz selon le type
de µC. Le filtre passe bas RS-C2 limite les harmoniques dus à l’écrêtage et Réduit l’amplitude de
l’oscillation. (il n'est pas obligatoire). Avec un oscillateur R-C, la fréquence de l'oscillation est fixée par
Vdd, Rext et Cext. Elle peut varier légèrement d'un circuit à l'autre. Dans certaines applications, une
horloge externe au microcontrôleur peut être utilisée pour synchroniser le PIC sur un processus
particulier.
Quelque soit l'oscillateur utilisé, l'horloge système dite aussi horloge instruction est obtenue en
divisant la fréquence par 4. Ce qui est illustré dans les datasheets par le terme Fosc/4 pour désigner
l'horloge système.
Avec un quartz de 4 MHz, on obtient une horloge instruction de 1 MHz, soit le temps pour exécuter
une instruction de 1µs. par contre si on utilise un quartz de 20 MHz pour cadenser le PIC, l’orlige
instruction sera de 5 MHz soit un temps de 0,2 µs danc plus rapide !
XXXVIII. Le port dʹ E/S PORTA
Le port A désigné par PORTA est un port de 5 bits (RA0 à RA4). Chaque E/S est compatible TTL.
La configuration de direction pour chaque bit du port est déterminée avec le registre TRISA.
 Le bit de rang i du TRISA = 0 oblige le bit du rang i du PORTA d’être configuré en sortie
 Le bit de rang i du TRISA = 1 oblige le bit du rang i du PORTA d’être configuré en entrée
On remarque aussi que la broche RA4 est multiplexée avec l'entrée horloge du Timer0 (TMR0). Elle
peut donc être utilisée soit comme Entrée/Sortie (E/S) normale du port A, soit comme entrée horloge
pour le Timer0. Le choix se fait à l'aide du bit T0CS du registre OPTION_REG.
 T0CS = 0 configure la pin RA4 comme une simple E/S normale

 T0CS = 1 configure la pin RA4 comme une entrée d’une horloge externe pour le timerTMR0.
RA4 est une E/S à drain ouvert, si on veut l'utiliser comme sortie (pour allumer une LED par
exemple), il ne faut pas oublier de mettre une résistance externe vers Vdd. La figure 19
schématise le principe d'une sortie drain ouvert (ou collecteur ouvert). Si RA4 est positionnée à
0, l'interrupteur est fermé, la sortie est reliée à la masse, alors que si RA4 est placée à 1,
l'interrupteur est ouvert, la sortie est déconnectée d'où la nécessite de la résistance externe pour
amener le courant de l'alimentation vers la LED. La valeur de 330 Ω est donnée à titre indicatif.

Vd

330 Ω

LED

Figure 19 : Représentation de la configuration de la pin RA4 (drain ouvert).
XXXIX. Le port dʹ E/S PORTB
Le port B désigné par PORTB est un port bidirectionnel de 8 bits (RB0 à RB7). La
configuration de direction se fait à l'aide du registre TRISB pareil que le TRISA. En entrée, la
ligne RB0 appelée aussi INT peut déclencher une interruption externe dite RB0 INTERRUPT.
En entrée aussi, une quelconque des lignes RB4 à RB7 peut déclencher l'interruption RBI
INTERRUPT.
XL. Le Timer TMR0
Le timer0 est un registre à huit bits. Il peut assurer la fonction compteur et la fonction
temporisateur. Il est incrémenté en permanence soit par l’horloge interne Fosc/4 (mode timer)
soit par une horloge externe appliquée à la broche RA4 du port A (mode compteur). Le choix de
l'horloge se fait à l'aide du bit T0CS du registre OPTION_REG. En fonctionnement en mode
timer le bit TOCS du registre OPTION est mis à 0, et là le Tmr0 fonctionne par horloge interne.
Si le TOCS est mis à 1, le Tmr0 fonctionne en mode compteur par horloge externe appliquée à
RA4. Dans le cas de l'horloge externe, le choix du front du signal d’horloge sur lequel le TIMER

s'incrémente se fait via le bit TOSE du registre OPTION :TOSE = 0, incrémentation sur fronts
montants et TOSE = 1, incrémentation sur fronts descendants. Avec un cadencement de 4MHz,
pour faire clignoter une LED à une fréquence de 1Hz, il nous faut à peu près de 2000
débordement du timer0. Pour faciliter la tâche, les concepteurs ont fait recours à la notion de
prédiviseur qui n’est autre d’un diviseur d’évènements de l’horloge. Quelque soit l'horloge
choisie, on peut la passer dans un diviseur de fréquence programmable (prescaler) dont le rapport
est fixés par les bits PS0, PS1, PS2 et PSA du registre OPTION_REG (voir datasheet).
L'affectation ou non du prédiviseur se fait à l'aide du bit PSA du registre OPTION_REG : PSA
= 0, le prédiviseur est affecté au Timer0 mais si PSA = 1, pas de prédiviseur pour le timer0 car
il sera affecté au chien de garde.
Pour un PSA=0, le tableau suivant donne la valeur du prédiviseur au cas par cas (tiré du
datasheet).
PS2 PS1 PS0 /tmr0

0 0 0 2
0 0 1 4
0 1 0 8
0 1 1 16
1 0 0 32
1 0 1 64
1 1 0 128
1 1 1 256
Le prédiviseur des modules timer0/WDT (Watch Dog Timer : Chien de garde) du 16F84 est
organisé conformément à la figure 20.

Figure 20 : Diagramme bock du prédiviseur du tmr0/WDT
Le contenu du timer TMR0 est accessible par le registre tmr0 situé à la banque0 à l’adresse
01h. Il peut être lu ou écrit à n'importe quel moment. Après une écriture, l'incrémentation est
inhibée pendant deux cycles machine. Donc il faut tenir compte de ces deux cycles machines
dans le calcul exact du temps. Au débordement de TMR0 (passage de FF à 00), le drapeau T0IF
est placé à 1. Ceci peut déclencher l'interruption T0I si celle-ci est validée dans le registre
INTCON.
XLI. Le chien de garde (Le Watchdog Timer : WDT)

Le watchdog est un compteur huit bits incrémenté en permanence, que le processeur soit en
marche ou en mode sleep, par une horloge RC intégrée indépendante de l'horloge système.
Lorsqu’il déborde, WDT Time Out, deux situations sont possibles : en cas de fonctionnement
normal du microcontrôleur, le WDT time-out provoque un RESET ce qui permet d’éviter son
plantage une fois bloqué par un processus indésirable non contrôlé et en cas où il était en mode
SLEEP, le WDT time-out provoque un WAKE-UP, l'exécution du programme continue
normalement là où elle s'est arrêtée avant de rentrer en mode SLEEP. Cette dernière situation
est souvent exploitée pour réaliser des temporisations. La figure 21 montre le diagramme block
du WDT.

L'horloge du WDT est ajustée par le fabricant pour que Le Time-Out (le débordement du
WDT) sera atteint toutes les 18 ms. Par une programmation du bit PSA à 1 du registre OPTION,
on affecte au WDT un prédiviseur conformément au tableau ci-après. Le rapport du prédiviseur
est fixé par les bits PS0, PS1 et PS2 du registre OPTION_REG.
Figure 21 : Diagramme block du WDT.
PS2 PS1 PS0 /WDT

0 0 0 1
0 0 1 2
0 1 0 4
0 1 1 8
1 0 0 16
1 0 1 32
1 1 0 64
1 1 1 128
Tableau : Programmation du prédiviseur du WDT via OPTION_REG.
Pour éviter une possible Reset du microcontrôleur d’une façon répétée, il faut utiliser le WDT
avec beaucoup précaution. Pour éviter un débordement du WDT lors de l'exécution d'un
programme, deux possibilités se présentent : la première est d’inhiber le WDT d'une façon
permanente en mettant à 0 le bit WDTE dans l'EEPROM de configuration et la seconde est de
remettre le WDT à 0 périodiquement dans le programme à l'aide de l'instruction CLRWDT.

XLII. Le mode SLEEP
Dans les PIC, le mode SLEEP inhibe l’horloge système ce qui provoque l’arrêt de l’exécution
du programme. Dans ce mode le PIC fonctionne avec consommation et ce à l'aide de l'instruction
SLEEP. Pour sortir du mode SLEEP, il faut provoquer un WAKE-UP par l’intermédiaire de
l’une des possibilités suivantes :
 Provoquer un RESET externe par une mise de l’entrée MCLR au niveau logique 0 et du coup le
PIC reprend l'exécution du programme à partir du début ;
 Un débordement du WDT si celui-ci est validémais ici le PIC reprend le programme à partir de
l'instruction qui suit l'instruction SLEEP ;
 Aussi une interruption INT (sur RB0), RBI (sur RB4-RB7) ou EEI (fin d'écriture en EEPROM
de données) provoque le Wake-up. Le bit de validation de l'interruption en question doit être
validé, par contre, le WAKE-UP aura lieu quelque soit la position de bit de validation globale
GIE. Deux cas alors sont possibles:
 GIE = 0, Le PIC reprend l'exécution du programme à partir de l'instruction
qui suit l'instruction SLEEP, l'interruption n'est pas prise en compte ;
 GIE = 1, Le PIC exécute l'instruction qui se trouve juste après l'instruction
SLEEP puis se branche à l'adresse 0004 pour exécuter la procédure
d'interruption. Il est conseille, que dans le cas où l'instruction suivant SLEEP
n'est pas désirée, d’utiliser l'instruction NOP.
XLIII. La mémoire EEPROM de configuration
Durant la phase de chargement du programme dans la mémoire programme du PIC, on
programme aussi une EEPROM de configuration constituée de cinq mots de 14 bits dont :
 Quatre mots d’identification ( ID) à partir de l’adresse 0x2000 pouvant

contenir un repérage quelconque,
 Un mot de configuration (adresse 0x2007) permettant :
o de choisir le type de l'oscillateur pour l'horloge ;
o de valider ou invalider le WDT timer ;
o d’interdire la lecture des mémoires EEPROM de programme et de données via un
code de protection créé par le système.
Le mot de configuration, dans MPLAB software, est programmé par la directive __CONFIG.
Ce mot contient des fusibles conformément au registre suivant :

b1 b1 b1 b1 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
3 2 1 0
CP CP CP CP C C C C C C PWRT WDT FOSC FOSC
P P P P P P E E 1 0
Avec :
 bits 1-0 FOSC1-FOSC0, Sélection du type d'oscillateur pour
l'horloge
- 11 : Oscillateur RC
- 10 : Oscillateur HS (High speed) : quartz haute fréquence
(jusqu'à 10 MHz)
- 01 : Oscillateur XT, c'est le mode le plus utilisé, quartz jusqu'à 4
MHz
- 00 : Oscillateur LP (Low power), consommation réduite, jusqu'à
200 kHz
 bit 2 WDTE, validation du timer WDT (chien de garde)
- 1 : WDT validé
- 0 : WDT inhibé
 bit 3 PWRTE, validation d'une temporisation à la mise sous tension
- 1 : temporisation inhibée
- 0 : temporisation validée
 bit 13-4 CP, Protection en lecture du code
programme
- 1 : pas de protection
- 0 : protection activée
XLIV. La mémoire EEPROM de données
La mémoire EEPROM de données est constituée de 64 octets commençant à l'adresse 0x2100
que l'on peut lire et écrire depuis un programme. Ces octets sont conservés après une coupure
de courant et sont très utiles pour conserver des paramètres semi permanents. On y accède à
l'aide des registres EEADR et EEDATA: toute lecture écriture dans le registre EEDATA se fait
dans la position mémoire pointée par EEADR. En fait EEADR contient l'adresse relative par
rapport à la page qui commence en 0x2100, autrement dit, l'adresse va de 0 à 63. Deux registres
de contrôle (EECON1 et EECON2) sont associés à la mémoire EEMROM. La durée d’écriture

d’un octet est de l’ordre de 10 ms, la fin de chaque écriture réussie est annoncé par le drapeau
EEIF et la remise à zéro du bit RW du registre EECON1. Le drapeau EEIF peut déclencher
l'interruption EEI si elle a été validée.
XLV. Les interruptions
Une interruption provoque l’arrêt du programme principal pour aller exécuter une procédure
d'interruption (sous-programme). A la fin de cette procédure, le microcontrôleur reprend le
programme à l’endroit où il s’était arrêté et ce par enregistrement de l’adresse de retour dans la
pile du système par le CP. Le PIC16F84 possède quatre sources d'interruption (INTRB0, PortB,
Timer0, et écriture sur EEPROM). A chaque interruption sont associés deux bits : un bit de
validation et un drapeau (flag). Le premier permet d'autoriser ou d’interdire l'interruption, le
second permet au programmeur de savoir le type de cette interruption. Tous ces bits sont dans
le registre INTCON à part le drapeau EEIF de l'interruption EEI qui se trouve dans le registre
EECON1.
XLVI. Modes dʹadressages
Le mode d’adressage est la façon d’accéder à une donnée qui sera utile dans le programme.
Il existe trois grands types d'accès à une donnée (figure 22) :
- Adressage immédiat : La donnée est contenue dans l'instruction. Exemple : movlw

0xC4 ; Transfert la valeur 0xC4 dans W
- Adressage direct : La donnée est contenue dans un registre. Ce dernier peut être par un
nom (par exemple W) ou une adresse mémoire. Exemple : movf 0x2B, 0 ;
Transfert dans W la valeur contenue à l'adresse 0x2B.
- Adressage indirect : L'adresse de la donnée est contenue dans un pointeur. Dans les
PIC, un seul pointeur est disponible pour l'adressage indirect : FSR. Contenu à l'adresse
04h dans les deux banques, il est donc accessible indépendamment du numéro de
banque. En utilisant l'adressage direct, on peut écrire dans FSR l'adresse du registre à
atteindre. FSR contenant 8 bits, on peut atteindre les deux banques du PIC 16F84. Pour
les PIC contenant quatre banques, il faut positionner le bit IRP du registre d'état qui sert
alors de 9ème bit d'adresse.
L'accès au registre d'adresse contenue dans FSR se fait en utilisant le registre INDF. Il se
trouve à l'adresse 0 dans les deux banques. Il ne s'agit pas d'un registre physique. On peut le voir

comme un autre nom de FSR, utilisé pour accéder à la donnée elle-même, FSR servant à choisir
l'adresse.
Exemple : movlw 0x1A ; Charge 1Ah dans W

movwf FSR ; Charge W, contenant 1Ah, dans FSR
Movf INDF, 0 ; Charge la valeur contenue à l'adresse 1Ah dans W
Figure 22 : Adressages direct et indirect à la mémoire de données.
A. Lʹadressage indirect
L'adressage indirect se fait par l'intermédiaire des registres FSR et INDF. Le registre INDF
n'est pas un vrai registre mais représente la case mémoire pointée par le registre d'index FSR.
Pour lire ou écrire dans une case mémoire en utilisant l'adressage indirect, on commence par
placer l'adresse dans le registre FSR, ensuite on lit/écrit dans le registre INDF.
XLVII. Le compteur programme
Le Program Counter est un registre de 13 bits qui s'incrémente automatiquement lors de
l'exécution du programme. On peut toutefois le modifier par programme pour réaliser ce qu'on
appelle un goto calculé. On y accède par les registres PCL et PCLATH :
 PCL (8 bits) est la partie basse de PC, il est accessible en lecture écriture

 PCH (5 bits) est la partie haute de PC, il n'est pas accessible directement. On peut toutefois le
modifier indirectement à l'aide du registre PCLATH qui est une registre SFR accessible
en lecture écriture et où seuls 5 bits sont utilisés.
XLVIII. Détail des 35 instructions du 16F84
ADDLW : ADD Literal to W
Additionne de manière immédiate le literal au contenu du registre W, et place le résultat dans

W. Le literal est un mot de 8 bits (de 00 à FF). Cette instruction affecte 3 bits du registre d’état
: le flag C (Carry), le flag DC (Digit Carry) et le flag Z (Zéro). Elle consomme un cycle d’horloge
(1µs).
Exemple de programmation : ADDLW 04
En supposant que W contienne 06 avant l’instruction, après l’instruction il contient 0A (en

hexa : 06 + 04 = 0A)
ADDWF: ADD W and File
Additionne le contenu du registre W à l’octet situé (en mémoire RAM) à l’adresse indiquée
de suite (adresse comprise entre 0C et 4F). Le résultat peut être placé soit dans le registre W si
d=0, soit dans la mémoire RAM à la place de l’octet utilisé pour faire l’addition si d=1. Le
résultat écrase toujours l’ancienne valeur de la destination d. Cette instruction affecte 3 bits du
registre d’état : le flag C, le flag DC et le flag Z et elle consomme éventuellement un cycle
d’horloge.
Exemple de programmation : MOVF mavariable,W ;
ADDWF,0 ;
L’exemple le contenu du registre correspond à l’adresse mémoire mavariable sera mis dans
W, puis additionne mavariable au contenu de W, et range le résultat dans W. si à la place de W
on trouve 1 ou f le résultat sera rangé dans mavarible.
ANDLW : AND Literal and W
Cette instruction effectue l’opération logique ET (AND) entre la valeur immédiate du literal
et l’octet se trouvant dans le registre W. Le literal doit être un mot de 8 bits (de 00 à FF)
l’instruction affecte le bit Z du registre d’état et en matière de temps consomme un cycle
d’horloge. Il faut revoir la table de vérité d’une porte ET dans le cours de Logique et Calculateur.

Exemple de programmation : ANDLW A7
Si on suppose que W contienne 5C (01011100) avant l’instruction, après l’instruction W va

contenir 04 (A7 = 10100111, 5C = 01011100 et A7 AND 5C = 00000100 (04 en hexa)). Cette
instruction sert lorsque, dans un octet, on a besoin de récupérer un bit en particulier (ou certains
bits en particulier). Pour cela il suffit de préparer un masque, c’est à dire un octet composé de 0
(aux emplacements où se trouvent les bits à éliminer) et de 1 (aux emplacements où se trouvent
les bits à récupérer).
Exemple : on souhaite récupérer uniquement le bit 5 de l’octet 01111010. On prépare alors

le masque 00100000 et on fait un ET logique entre l’octet et le masque. Comme ceci :
01111010 (octet)
00100000 (masque)
Ce qui donne après le 00100000 (résultat)
Le résultat de l’opération permet donc bien de récupérer uniquement le bit 5 de
l’octet : ici c’est un 1 (00100000).
ANDWF : AND W and File
Cette instruction effectue l’opération logique ET (AND) entre l’octet se trouvant dans le
registre W et l’octet situé (en mémoire RAM) à l’adresse indiquée de suite (adresse comprise
entre 0C et 4F) ; avec comme résultat stocké dépendant de la valeur allouée à d. elle affecte le
bit Z du registre STATUS et consomme un cycle d’horloge.
Exemples de programmation :
ANDWF,0 Adresse
L’exemple effectue un ET logique entre l’octet se trouvant dans W et l’octet se trouvant à
Adresse, et range le résultat dans W. la table de vérité de la porte ET doit être révisée.
Cette instruction sert lorsque, dans un octet, on a besoin de récupérer un bit en particulier (ou
certains bits en particulier). Pour ce faire, il suffit de préparer un masque d’un octet composé de
0 aux emplacements où se trouvent les bits à éliminer et de 1 aux emplacements où se trouvent
les bits à récupérer. Si à titre d’exemple, on souhaite récupérer uniquement le bit 4 de l’octet
01111010, on prépare le masque 00010000 et on fait un ET logique entre l’octet et le masque.
Comme ceci :
01111010 (octet)
00010000 (masque)

Ce qui donne 00010000 (résultat)

Il est clair dans le résultat de l’opération ANDWF que seul le quatrième bit de l’octet qui est
récupérer.
BCF : Bit Clear File
C’est une instruction orientée bit, qui met à zéro le bit désigné de l’octet situé (en
mémoire RAM) à l’adresse indiquée de suite (adresse comprise entre 0C et 4F). elle n’affecte
pas le registre d’état STATUS et consomme un cycle d’horloge.
On suppose que l’adresse mémoire 24 contient l’octet 00001111, et que l’on veuille mettre à
zéro (Clear) le bit 2. Pour cela on écrit dans notre programme :
BCF 24,2 ;
Le résultat sera le changement de l’octet situé à l’adresse mémoire 24 de 00001111 à

00001011. Donc le deuxième bit à été mis à zéro.
BSF : Bit Set File
A l’inverse de l’instruction BCF, l’instruction BSF met à 1 (Set) le bit désigné de l’octet situé
à l’adresse mémoire indiquée de suite (adresse comprise entre 0C et 4F). pareil, cette instruction
n’affecte aucun bit du registre STATUS et consomme un cycle d’horloge.
Exemples de programmation : si dans l’exemple précédent, on fait :
BSF 24,2 ;
On aura la valeur initiale de l’octet qui était de 00001111 avant qu’il soit manipulé par
l’instruction BCF.
BTFSC : Bit Test File, Skip if Clear
C’est une instruction de contrôle orientée bits. Elle vérifie l’état logique du bit désigné de
l’octet situé à l’adresse mémoire, en RAM, indiquée de suite (adresse comprise entre 0C et 4F).
si le bit testé est à zéro l’instruction suivant BTFSC sera ignoré et par voie de conséquence sautée
et ne sera pas exécutée. L’instruction n’affecte aussi aucun bit du registre d’état STATUS et
selon que la réponse soit OUI ou NON, l’instruction prend 1 ou 2 cycles d’horloge.
Généralement l’instruction opère conformément à l’organigramme de traitement ci-après en
figure 23 :

Teste le bit concerné
par BTFSC/BTFSS
OUI
Est‐ce le bit
testé est à 0/1
NON
Instruction 01
Instruction 02
(Sauter instruction 01)
Figure 23 : Organigramme de traitement de l’instruction BTFSC/BTFSS.
Exemple de programmation : En supposant que l’octet dont on veut tester un bit soit situé
dans le PORTB. On veut tester l’état de la pin RB3 du registre PORTB. Si elle est à zéron on
allume une LED dans la broche RA3 du registre PORTA si on l’éteint. Pour cela il suffit d’écrire
dans notre programme :
BTFSC PORTB,3
BTFSS: Bit Test File, Skip if Set
A contrario de l’instruction BTFSC, l’instruction BTFSS vérifie l’état logique du bit désigné
de l’octet situé à l’adresse mémoire indiquée de suite (adresse comprise entre 0C et 4F). si ce bit
est à 1, ignore l’instruction suivante. Selon que le bit testé est 1 ou à 0, l’instruction prend 1 ou
2 cycles d’horloge. L’organigramme de traitement reste le même que celui indiqué sur la figure
999333.
Exemple de programmation : si on pose BTFSS PORTB,3 dans le programme, alors le bit 3

du portB sera testé et s’il est à 1 (set) l’instruction qui suit BTFSS sera ignorée.

CALL : CALL subroutine
C’est une instruction employée pour appel à sous-programme. Le microcontrôleur

sauvegarde l’adresse de retour dans la pile (stack), puis charge dans le PC (Program Counter
register) l’adresse à laquelle il y aura le début de la routine de sous-programme. Il peut s’agir
aussi bien d’une adresse que d’une étiquette et c’est là que démarre le sous-programme.
Tout sous-programme appelé par l’instruction CALL doit obligatoirement se terminer soit
par l’instruction RETURN, soit par l’instruction RETLW qui permettront le renvoi au
programme principal à la fin du sous-programme. Cette instruction prend deux cycles d’horloge.
L’instruction CALL fait toujours revenir le programme principal à l’endroit où il avait été
abandonné ; tandis que l’instruction GOTO provoque l’abandon total de la séquence et peut
conduire soit à une toute autre action, soit à l’arrêt total du programme. Donc à ne pas confondre
entre les deux instructions.
Rappel : La pile (stack) est une zone de mémoire ne pouvant contenir que 8 mots de 13 bits
dans le µC 16F84. Ceci limite les possibilités d’appel à sous-programmes à huit niveaux
d’imbrication. S’il y en avait un appel dans une neuvième imbrication, la première adresse de
retour serait perdue et bonjours les problèmes. Donc il faut faire très attention à cette remarque.
L’instruction CALL opère conformément à l’organigramme de traitement consigné en figure

24.
Programme principal
..................................
..................................
..................................
CALL sous-programme
Adresse de retour du sous‐
.................................. programme stockée dans la
.................................. pile avant d’exécuter CALL
..................................
Sous-programme
..................................
..................................
..................................
RETURN
Figure 24 : Organigramme de traitement de l’instruction CALL, Le sous-programme contient obligatoirement

l’instruction RETURN.

Exemple de programmation : si on a besoin d’un sous-programme qui fait une temporisation

de quelque secondes et qu’on appelle « Tempo » on écrit dans notre programme principal :
CALL Tempo (saute à l’adresse correspondant à Tempo).
CLRF : CLeaR File
L’instruction CLRF permet d’effacer ce qui se trouve à l’adresse mémoire indiquée de suite.
Elle affecte le bit Z du registre d’état et consomme un cycle d’horloge.
Exemples de programmation : pour mettre à zéro (initialiser) tous les bit du port B, on tappe
dans notre programme :
CLRF PORTB
CLRW: CLeaR W
Cette instruction ne concerne que le registre de travail W et qui permet de le remettre à zéro.
Elle affecte le bit Z du registre d’état et consomme un cycle d’horloge.
Exemple de programmation : on suppose que W contient la valeur 11100011 avant d’exécuter

CLRW. Après son exécution le registre W va contenir 00000000 (remise à zéro suite à
l’effacement de son contenu).
CLRWDT : CLeaR Wach Dog Timer
CLRWDT permet de mettre à zéro le compteur du chien de garde et en plus celui du pré-
diviseur, si celui-ci est activé. Cette instruction affecte deux bits du registre d’état ; le flag TO
(Time Out) passe à 1 et le flag PD (Power Down) passe à 1. Elle consomme un cycle d’horloge.
Exemple de programmation :
A l’instant d’exécution de l’instruction CLWDT, peu importe où en était le compteur du chien

de garde, cette instruction le fait revenir à zéro.
COMF : COMplement File
COMF effectue un complément bit à bit sur l’octet File situé à l’adresse indiquée de suite ; le
résultat sera stocké suivant la valeur de la destination d. il s’agit ici d’un complémnt logique tout
en changeant des 0 par des 1 et inversement. Cette instruction affecte le bit Z du registre d’état
STATUS et consomme un cycle d’horloge.
Exemple : le complément de 11001110 est 00110001.

COMF 3C,0 ; en supposant que l’octet situé à l’adresse 3C contient 00011110. Alors
l’instruction provoque le complément bit à bit de l’octet situé à l’adresse 3C et range le résultat
dans W du moment que d=0. Dans W on trouve après exécution 11100001.
DECF : DECrement File
DECF permet de décrémenter la valeur de l’octet situé à l’adresse mémoire indiquée de suite
(adresse comprise entre 0C et 4F) ; avec résultat stocké selon la valeur de d. Cette instruction
affecte le bit Z du registre d’état et consomme éventuellement un cycle d’horloge.
DECF Counter,0 (décrémente l’octet se trouvant à l’adresse Counter, et

range le résultat dans W)
La valeur contenu dans le registre relatif à l’adresse mémoire Counter sera décrémenter de 1
(Valeur – 1) et le résultat sera stocké dans W du moment que d=0.
DECFSZ: DECrement File, Skip if Zero
C’est une instruction de contrôle (test) orientée octet. Elle décrémente la valeur de l’octet
situé à l’adresse mémoire indiquée de suite (adresse comprise entre 0C et 4F), et effectue le test
: l’octet désigné a-t-il atteint zéro ? Si OUI, ignore l’instruction suivante sinon continue
l’exécution de l’instruction qui suit et qui est généralement un GOTO ou un CALL. Le résultat
du test est rangé conformément à la valeur de d. Selon qu’à la suite de la décrémentation l’octet
ait atteint ou pas la valeur zéro, l’instruction prend 1 ou 2 cycles d’horloge.
Exemple de programmation :
DECFSZ 2F,1 Décrémente l’octet situé dans l’@ mémoire 2F et range

le résultat dans l’octet concerné. Si le résultat de la
décrémentation est Zéro ignore l’instruction qui suit.
GOTO : label ; Branchement inconditionnel.

Permet d’aller de façon inconditionnelle à l’adresse indiquée de suite (label). Label peut être
une adresse mémoire comme une simple étiquette dans le programme. Cette instruction
interrompt l’exécution séquentielle des instructions et oblige à poursuivre le programme d’une
adresse complètement ailleurs. Contrairement à l’instruction CALL qui fait toujours revenir le
programme principal à l’endroit où il avait été abandonné, l’instruction GOTO provoque
l’abandon complet de la séquence et conduira à une toute autre action dans le programme. Elle
consomme deux cycles d’horloge.
INCF : INCrement File
A contrario de l’instruction DECF, l’instruction DECF incrémente la valeur de l’octet situé à

l’adresse mémoire indiquée de suite (adresse comprise entre 0C et 4F) ; le résultat est stocké
selon la règle de la valeur de la destination d. Cette instruction affecte le bit Z du registre d’état
STATUS et consomme un cycle d’horloge.
INCF 0C,0 ; incrémente l’octet situé à l’@ mémoire 0C et range le résultat dans le registre
W.
INCFSZ: INCcrement File, Skip if Zero
Incrémente la valeur de l’octet situé (en mémoire RAM) à l’adresse indiquée de suite (adresse
comprise entre 0C et 4F), et effectue un test : l’octet a-t-il atteint zéro ? Si OUI, ignore
l’instruction suivante. Le résultat est stocké conformément à la valeur de la destination d soit
dans W (d=0) soit dans l’octet File (d=1). L’instruction prend un cycle ou deux d’horloge et est
généralement suivie par GOTO ou CALL.
INCFSZ compteur,0
Incrémente l’octet se trouvant à l’adresse compteur, et range le résultat dans W car d=0. Si le
résultat est zéro, ignore l’instruction qui suit.
IORLW: Inclusive OR Literal with W
Effectue une opération logique OU inclusif entre la valeur immédiate du literal et l’octet se
trouvant dans le registre W. Le résultat de l’opération se range automatiquement dans le registre
de travail W. Le literal est un mot de 8 bits (de 00 à FF). L’instruction IORLW affecte le bit Z
du registre d’état STATUS et consomme un cycle d’horloge.

- Table de vérité d’une porte OU inclusif :
A B Q = A OR B
0 0 0
0 1 1
1 0 1
1 1 1
Exemple de programmation : IORLW B5
B5h = b’10110101’. Si par supposition W contient la valeur hexadécimale 49 (b’01001001’)

avant l’instruction IORLW. Une opération OR entre les deux octets bit à bit s’effectue comme
suit :
B5 = 10110101
49 = 01001001
OR = 11111101 (FD en hexa).
Donc après exécution de l’opération W va contenir la valeur FDh.
NB : l’instruction IORLW sert lorsque, dans un octet, on a besoin de forcer à 1 un bit en

particulier (ou certains bits en particulier). Donc on fait recours à la notion de masque, c’est à
dire on octet composé de 0 aux emplacements où se trouvent les bits à ignorer et de 1 aux
emplacements où se trouvent les bits qu’on veut forcer à 1.
Exemple : on souhaite forcer à 1 les bits 7 et 6 de l’octet 01111010.
On prépare alors le masque 11000000 et on fait un OU logique entre l’octet et le masque.

Comme ceci :
W reg (octet) 01111010
Literal (masque) 11000000
IORLW masque 11111010
Une fois forcés à 1, on peut utiliser ces bits (ou l’octet) comme on veut.
IORWF : Inclusive OR With File

Comme IORLW, l’instruction IORWF effectue une opération logique OU inclusif entre
l’octet se trouvant dans le registre W et l’octet situé (en mémoire RAM) à l’adresse située de
suite (adresse comprise entre 0C et 4F). Le résultat est à ranger selon la valeur que prend la
destination d. Cette instruction affecte le bit Z du registre d’état STATUS et consomme un cycle
d’horloge
IORWF 36,0
En supposant que le contenu de l’adresse mémoire 36 contienne la valeur C7 (11000111) et

que W contienne 69 (01101001). Il est clair qu’après l’instruction on obtient EF (11101111) qui
sera rangé dans W du moment que d=0.
NB. Cette instruction sert exactement comme IORLW à la différence que la première opère
sur un literal et la seconde sur un octet File.
MOVF : MOVe File
Cette instruction permet soit de porter dans W le contenu situé (en mémoire RAM) à l’adresse
indiquée de suite (adresse comprise entre 0C et 4F), avec l’option de programmation d=0 soit
copier l’octet sur lui-même au même emplacement de la RAM, avec l’option de programmation
d=1. Cette instruction affecte le bit Z du registre d’état STATUS et consomme un cycle
d’horloge.
Exemples de programmation : MOVF PORTA,0 ; porte le contenu du PORT A dans le

registre de travail W.
MOVLW : MOVe Literal to W
MOVLW permet de Charger de manière immédiate le literal dans le registre W. Le literal est
un mot de 8 bits (de 00 à FF). elle n’affecte aucun bit du registre STATUS et consomme un
cycle d’horloge.
Exemple de programmation : MOVLW 0A ; met 0A dans le registre de travail W, c’est à-

dire W va contenir le nombre binaire 00001010.
MOVWF: MOVe W to File
Cette instruction charge le contenu du registre W dans l’adresse mémoire indiquée de suite
(adresse de 0C à 4F). Elle affecte le flag Z du registre STATUS et consomme un cycle d’horloge.

Exemple de programmation : MOVWF 0A ; charge le contenu du W dans l’adresse RAM

0A).
NOP: No OPeration
Cette instruction demande au processeur de ne rien faire, c’est juste pour qu’il consomme un
temps d’un cycle d’horloge. On l’utilise lorsqu’on a besoin de créer des temporisations. Elle
consomme un cycle d’horloge.
Exemple de programme : NOP ; ne rien faire.
RETFIE : RETurn From IntErrupt
C’est l’instruction obligatoire pour chaque programme d’interruption. Elle permet le retour
au programme principal après exécution d’un sous-programme d’interruption. Une fois exécuté,
le compteur de programme PC sera chargé avec la valeur qui se trouve au sommet de la pile
(stack) ; ce qui provoque le retour au programme principal. Elle consomme deux cycles
d’horloge et n’affecte aucun drapeau du registre STATUS.
Exemple de programme : RETFIE.
RETLW : RETurn from subroutine with Literal in W
Cette instruction agit jusqu’à un certain point similaire à l’instruction RETURN, au sens
qu’elle ferme un sous-programme et provoque le retour au programme principal à l’endroit où
il avait été abandonné suite à un CALL ; mais avec une particularité en plus c’est de charger
dans le registre W la valeur du literal qui est un mot de 8 bits (de 00 à FF). Elle n’affecte aucun
flag du registre d’état STATUS et consomme deux cycles d’horloge.
RETURN : RETURN from subroutine
C’est l’instruction qui ferme un sous-programme et provoque le retour au programme

principal à l’endroit auquel il avait été abandonné suite à l’instruction CALL. Le PC (Program
Counter) est chargé avec l’adresse se trouvant au sommet de la pile. Elle n’affecte aucun flag du
registre d’état STATUS et consomme deux cycles d’horloge.
RLF : Rotate Left File
L’instruction RLF fait une rotation à gauche de l’octet situé de suite via le bit C (carry) du
registre STATUS. Le contenu du bit de CARRY devient le nouveau bit 0 de l’octet File ayant
effectué la rotation à gauche, tandis que son ancien bit 7 entre dans CARRY. Le résultat sera

rangé conformément à la valeur de d. Cette instruction affecte le bit C du registre d’état STATUS
et consomme un cycle d’horloge.
NB : Avant d’utiliser cette instruction il convient au préalable d’effacer le bit de CARRY.

Car, à supposer que dans CARRY il ait un 1, après une rotation à gauche de 00000001 on aurait
00000011 alors qu’on s’attendait à 00000010.
RRF : Rotate Right File
L’instruction RRF fait le chemin inverse de celui de ‘instruction RLF, donc une rotation à
droite en utilisant le bit Carry du registre STATUS. Même remarques que pour RLF.
SLEEP : Go into standby mode.
C’est l’instruction qui met en veille le processeur. Elle ne met pas le µC hors tension, mais
elle arrête le séquencement des instructions (ralentir le signal d’horloge jusqu’à l’extrême limite
: la fréquence zéro). Seul le chronomètre du Watch Dog (chien de garde) reste actif. La
consommation du boîtier (qui normalement est de 2 mA) tombe à 30 µA. Le µC se met en route
suite à une demande d’interruption, ou un signal provenant du chien de garde. Elle affecte deux
bits du registre d’état STATUS, le bit TO (Time Out) passe à 1 et le bit PD (Power Down)
passe à 0 et elle consomme un cycle d’horloge. En plus, elle met à zéro le chronomètre du chien
de garde, ainsi que le pré diviseur.
SUBLW: SUBtract Literal with W
Cette instruction fait la soustraction du literal (valeur immédiate représentée par un octet
pouvant aller de 00 à FF) du contenu du registre W, et place le résultat dans W. Elle affecte trois
bits du registre d’état : le flag C (Carry), le flag DC (Digit Carry) et le le flag Z (Zero) et
consomme un cycle d’horloge.
SUBWF : SUBtract W from File
L’instruction SUBWF soustrait la valeur contenue dans le registre W de la valeur se trouvant

(en mémoire RAM) à l’adresse indiquée de suite (adresse comprise entre 0C et 4F) ; le résultat
sera stocké selon la valeur de l’option de programmation d. Elle affecte trois bits du registre
d’état : le flag C(Carry), le flag DC (Digit Carry) et le le flag Z (Zero) et consomme un cycle
d’horloge.

SWAPF : SWAP File
Echange les quatre bits de poids fort d’un octet se trouvant (en mémoire RAM) à l’adresse
indiquée de suite (adresse comprise entre 00 et 4F), avec ses propres quatre bits de poids faible
: permuter les deux quartets de l’octet désigné et mettre le résultat selon la valeur de d.
l’instruction SWAPF n’affecte aucun bit du registre d’état et consomme un cycle d’horloge.
XORLW: eXclusive OR Literal with W
L’instruction effectue un OU exclusif (Exclusive OR) entre la valeur immédiate du literal et

l’octet se trouvant dans le registre W. Le résultat est rangé dans W et le literal est un mot de 8
bits (de 00 à FF). Cette instruction affecte le bit Z du registre d’état et consomme un cycle
d’horloge.
Pour rappel, un OR exclusif permet de comparer deux octets bit à bit. Si les bits de même
poids sont au même niveau, le résultat est zéro et si par contre ils sont à des niveaux différents,
le résultat est 1 et ce conformément à sa table de vérité ci-après :
A B Q = A XOR B
0 0 0
0 1 1
1 0 1
1 1 0
Exemple de XOR entre deux octets : (00110011) XOR (01110010) donne le résultat
(01000001).
Un XOR permet d’inverser un état logique. Exemple : Soit au départ l’octet 11111111. Si le
XOR se fait avec 00000000, rien ne change ; le résultat reste 11111111. Si par contre le XOR
se fait avec 00000001,le résultat devient 11111110. Alors que les zéros ne font rien changer,
les 1 provoquent un basculement d’état logique.
NB. Cette instruction sert lorsque, dans un octet, on a besoin d’inverser un bit en particulier
(ou certains bits en particulier). Donc on est astreint d’utiliser la technique des masques. Dans le
masque on fait des 1 logiques pour les bits dont on veut les inverser et des 0 logiques pour ceux
qu’on veut garder leurs états logiques.

XORWF: Exclusive OR W and File
Cette instruction opère exactement comme XORLW à la différence que XORWF compare
les bits du registre W avec le registre situé en l’adresse mémoire en RAM et indiquée de suite.
L’utilisation reste la même. Pareil, cette instruction affecte le bit Z du registre d’état STATUS
et consomme un cycle d’horloge.
XLIX. Un mot sur TRIS : TRIState port
cette instruction est spécifique au 16F84. Microchip recommande de ne pas l’utiliser, dans le
but de laisser les programmes (écrits pour ce type de microcontrôleur) compatibles avec ceux
écrits pour d’autres modèles de PIC. Donc cette instruction permet de valiser la direction des
posrts (PORTA et PORTB) soit en sortie soit en entrées : Ce registre configure, c’est à dire
définit le sens de fonctionnement de chacune des lignes des ports A et B ; assigne à chaque ligne
soit le rôle d’entrée, soit le rôle de sortie, sans pour autant provoquer aucune entrée ni aucune
sortie. Alors charger le registre TRIS (A ou B) avec un SET met les lignes de port à haute
impédance. Il s’agit d’un registre de 8 bits, pouvant tous se programmer individuellement par 0
ou par 1 :
 0 = la ligne de port (qui lui correspond) est configurée comme sortie

 1 = la ligne de port (qui lui correspond) est configurée comme entrée
S’agissant d’un registre à lecture/écriture simultanée, on ne peut pas y écrire directement,
mais il faut obligatoirement transiter par le registre W. aussi il est important de toujours se
rappeler que le registre TRIS (A ou B) se trouve en page mémoire 1 (Banque 1) du 16F84. En
programmation, on procède comme suit :
 MOVLW 00000100 ; On charge dans le registre W l’octet de configuration

de port (ligne 2 en entrée, toutes les autres lignes en sortie)
 MOVWF TRISB ; l’instruction TRIS est validée.
L. ENCODAGE des INSTRUCTIONS
Dans le datasheet, et avec chaque instruction on trouve des lettres qui font partie de
l’encodage. La signification des lettres utilisées dans l’encodage des instructions sont :
 b = position du bit dans l’octet sur lequel on opère ( il peut aller de 0 à 7)
 d = registre de destination, avec deux variantes :

o d = 0 : le résultat est placé dans W
o d = 1 : le résultat est placé dans le registre
 f , généralement adresse de la mémoire RAM où se trouve l’octet concerné ( dans

l’espace mémoire compris entre 00 et 4F).
 k = valeur du literal (ou adresse, dans les instructions CALL et GOTO)
 w = registre W (accumulateur)
 x = valeur indifférente : peut être soit 0 soit 1. L’assembleur lui donne

automatiquement la valeur 0 (forme recommandée par Microchip)
LI. Bibliographie
[1] Micrichip, PIC16F84A Data Sheet 18-pin Enhanced FLASH/EEPROM 8-bit
Microcontroller.
[2] Bignoff ; La programmation des PIC, première partie-révision R35 Démarrer les
PIC avecle PIC 16F84.
[3] Nebojsa Matic, PIC Microcontrollers.
[4] Marc Spencer WA8S. MEPIC pgramming for bigginers. The American Radio
Relay League, Inc, 2010.
[5] Microchip. PICMicro MID-Rang MCU Family Reference Manual.
[6] Nebojsa Matic. Basic for Microntroller. 2003.
[7] Michael A. Covington. PIC Assembly Language for the Complete Beginner.
Copyright c 1999, 2004 Michael A. Covington.

Polycope Microproc Habilitation

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Polycope Microproc Habilitation

Transféré par

Droits d'auteur :

Formats disponibles

Cours destiné aux Etudiants :

I. Table des matières

III. Le système décimal .......................................................................................................................... 6

IV. Le système binaire ........................................................................................................................... 7

V. Le système hexadécimal .................................................................................................................. 8

VI. Opérations arithmétiques et nombres signés .................................................................................... 9

VII. Les nombres signés : la soustraction ................................................................................. 10

VIII. Les opérations booliennes ................................................................................................. 11

IX. Architecture basique d’un microprocesseur ................................................................................... 13

X. L'Unité Arithmétique et Logique ................................................................................................... 13

XI. L'accumulateur ou le registre de travail ......................................................................................... 14

XII. L’unité de commande et de contrôle ................................................................................. 15

XIII. Le registre d'état ................................................................................................................ 16

XIV. Le Compteur d'Instructions ............................................................................................... 16

XV. Le registre d'adresses ......................................................................................................... 16

XVI. Le Registre d'Instructions (RI) .......................................................................................... 17

XVII. Le registre d'état ................................................................................................................ 17

XVIII. Les registres généraux ....................................................................................................... 18

XIX. Structure de la mémoire principale (MP) .......................................................................... 18

XX. Exécution d’un programme ............................................................................................... 20

XXI. Les mémoires ..................................................................................................................... 21

Dr A. Zegaoui, UHBC ; Département d’’Electrotechnique, Laboratoire GEER 3

XXII. Organisation d’une mémoire ............................................................................................. 21

XXIII. Caractéristiques d’une mémoire ........................................................................................ 23

XXIV. Types de mémoires ............................................................................................................ 24

XXV. Les Microcontrôleurs : Le PIC 16F84 ............................................................................... 27

XXVI. Introduction ....................................................................................................................... 28

XXVII. Le Microcontrôleur 16F84................................................................................................. 28

XXVIII. Brochage et fonctions des différentes pattes ..................................................................... 29

XXIX. Architecture générale ......................................................................................................... 30

XXX. Organisation de la mémoire ............................................................................................... 31

XXXI. Mémoire de programme .................................................................................................... 31

XXXII. Mémoire de données .......................................................................................................... 31

XXXIII. Registres généraux ............................................................................................................. 32

XXXIV. Mémoire EEPROM ........................................................................................................... 36

XXXV. Jeu d'instructions ............................................................................................................... 36

XXXVI. L'ALU et le registre W ...................................................................................................... 38

XXXVII. L'Horloge ............................................................................................................... 39

XXXVIII. Le port d' E/S PORTA ........................................................................................... 39

XXXIX. Le port d' E/S PORTB ....................................................................................................... 40

XL. Le Timer TMR0................................................................................................................. 40

XLI. Le chien de garde (Le Watchdog Timer : WDT) ............................................................... 42

XLII. Le mode SLEEP ................................................................................................................ 44

XLIII. La mémoire EEPROM de configuration ........................................................................... 44

XLIV. La mémoire EEPROM de données .................................................................................... 45

Dr A. Zegaoui, UHBC ; Département d’’Electrotechnique, Laboratoire GEER 4

XLV. Les interruptions ................................................................................................................ 46

XLVI. Modes d'adressages ........................................................................................................... 46

XLVII. Le compteur programme ................................................................................................... 47

XLVIII. Détail des 35 instructions du 16F84 .................................................................................. 48

XLIX. Un mot sur TRIS : TRIState port....................................................................................... 61

L. ENCODAGE des INSTRUCTIONS ............................................................................................. 61

LI. Bibliographie .................................................................................................................................. 62

Dr A. Zegaoui, UHBC ; Département d’’Electrotechnique, Laboratoire GEER 5

Rappel sur les systèmes de numérisation

Dr A. Zegaoui, UHBC ; Département d’’Electrotechnique, Laboratoire GEER 6

Comment représenter un nombre binaire !

Puissances de 216 215 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20

Tableau d’équivalence Binaire-Hexadécimal-Décimal :

Binaire Hexadécimal Décimal

Dr A. Zegaoui, UHBC ; Département d’’Electrotechnique, Laboratoire GEER 8

A titre d’exemple on fait l’addition (19+25)=44 mais en binaire.

Comme indiqué sur le tableau ci-dessus :

Dr A. Zegaoui, UHBC ; Département d’’Electrotechnique, Laboratoire GEER 9