Igsit - Automatisme - Microcontrôleurs

EPO
AUTOMATISME :
MICROCONTRÔLEURS
1A IGSIT
NIKIEMA Daniel
MICROCONTRÔLEURS : MISE EN ŒUVRE ET PROGRAMMATION
Table des matières

I. INTRODUCTION ......................................................................................................................................... 3
II. MICROCONTRÔLEURS PIC ....................................................................................................................... 4
1. Le microcontrôleur PIC16F84 .................................................................................................................... 5
1.1. Présentation ................................................................................................................................... 5
1.2. La mémoire programme (flash) ............................................................................................... 7
1.3. La mémoire RAM .......................................................................................................................... 7
1.4. L'ALU et le registre W .................................................................................................................. 9
1.5. Les ports d'entrées/sorties ....................................................................................................... 9
1.6. L'Horloge ...................................................................................................................................... 11
1.7. Le Timer TMR0............................................................................................................................ 11
1.8. Le Watchdog Timer WDT (Chien de garde) ........................................................................ 13
1.9. La mémoire EEPROM de données .......................................................................................... 14
1.10. Le compteur programme (Program Counter) ................................................................ 15
1.11. Les interruptions.................................................................................................................... 16
1.12. Le mode SLEEP ........................................................................................................................ 17
1.13. Les indicateurs d'état ........................................................................................................... 18
1.14. La mémoire EEPROM de configuration ............................................................................ 18
1.15. Les instructions du PIC16F84 ............................................................................................ 19
2. Les outils de développement ................................................................................................................... 25
3. Programmation ............................................................................................................................................ 26
3.1. Algorithme/Organigramme ou ordinogramme ................................................................ 26
3.2. Langages de programmation ................................................................................................. 29
3.3. Création de projet et simulation sur MPLAB ...................................................................... 37
4. Présentation de la sous famille PIC16F87x ......................................................................................... 39
4.1. Brochage ...................................................................................................................................... 39
4.2. Architecture interne .................................................................................................................. 40
4.3. La mémoire RAM et les registres spéciaux ........................................................................ 42
4.4. Exemple de mise en œuvre du PIC16F877 ........................................................................ 45
III. MICROCONTRÔLEURS MSP430 ............................................................................................................ 46
1. Le microcontrôleur MSP430G2553 ........................................................................................................ 48
1.1. Présentation ................................................................................................................................. 48
1.2. L’horloge système ..................................................................................................................... 51
1.3. Les Ports d’Entrées/Sorties ..................................................................................................... 53
1.4. Le CPU (Central Processing Unit)........................................................................................... 56
1.5. Le Jeu d’instructions et les modes d’adressage ............................................................... 59
1.6. Les timers ..................................................................................................................................... 64
2. Programmation ............................................................................................................................................ 65
2.1. Langage Assembleur................................................................................................................. 66
2.2. Langage C .................................................................................................................................... 71
Annexes .............................................................................................................................................................. 74
Nombre de cycles et longueur des instructions ...................................................................................... 74
Opérateurs du langage C ................................................................................................................................ 76
Bibliographie et Webographie ...................................................................................................................... 77
NIKIEMA Daniel Page 2/77

I. INTRODUCTION
Un microcontrôleur est une unité de traitement de l’information de type
microprocesseur à laquelle on a ajouté des périphériques internes permettant de
faciliter l'interfaçage avec le monde extérieur sans nécessiter l’ajout de composants
externes complexes.
Un microcontrôleur de configuration minimale contient :

 Un CPU (Central Processing Unit) pour l'exécution du programme ;
 Une ROM (Read only Memory) ou Flash pour stocker le programme ;
 Une RAM (Random Access Memory) pour les données temporaires de
traitement ;
 Une EEPROM (Electrically Programmable Read Only Memory) pour les données
à conserver hors tension ;
 Des compteurs programmables (timers) pour les opérations de comptage ;
 Des interfaces d'entrées/sorties (ports) pour la communication avec
l'extérieur.
Les microcontrôleurs plus évolués peuvent contenir en plus de ces éléments

principaux :
 Des CAN (Convertisseur Analogique Numérique) ;
 Des comparateurs analogiques ;
 Des ports parallèles ;
 Des ports séries ;
 Des ports USB ;
 Des ports I2C, …
Ils sont en général utilisés pour contrôler de simples machines et constituent des
systèmes embarqués (véhicules, appareils électroménagers, cartes à puce, lecteurs
de carte à puce, cartes d'automatisme industriel, ...).
Exemples de microcontrôleurs :
 8051, 80C186XX, … d’Intel ;
 68HC11, 68HC12, 68HC16, … de Motorola ;
 MSP430F1611, MSP430G2553, … de Texas Instruments (TI) ;
 PIC16F84, PIC16F877, PIC18xxxx, PIC24xxxx, ... de Microchip ;
 ATmega328P, ATmega2560, … de Atmel (racheté par Microchip) utilisés par
Arduino ;
 Etc.
Par rapport à un projet, le choix d’un microcontrôleur est fait en fonction des
ressources (Entrées/Sorties, ports et protocoles de communication, modules
internes, …) nécessaires au développement de l’application. Il est aussi fonction de
la marque qu’on maitrise. En général, chaque constructeur propose un ensemble de
familles de microcontrôleurs en fonction des différentes applications.
Ce document se limitera à une initiation à la programmation des microcontrôleurs

PIC et MSP430, respectivement des constructeurs Microchip et Texas Instruments.

II. MICROCONTRÔLEURS PIC

Les PIC (Peripheral Interface Controllers) sont de technologie RISC (Reduced
Instruction Set Computer) avec une architecture de type Harvard (c’est-à-dire que la
mémoire programme et les mémoires de données sont sur des bus différents). La
figure ci-dessous résume l’évolution des familles PIC.
Evolution des familles PIC
L’étude se portera particulièrement sur le PIC16F84 de la sous-famille PIC16. On

pourra facilement passer à une autre famille dès lors que les bases ont été
assimilées.
Pour identifier un microcontrôleur PIC, on utilise simplement son numéro :

 Les 2 premiers chiffres indiquent la catégorie du PIC, par exemple 16 indique
un PIC de famille Mid-Range ;
 Vient ensuite parfois une lettre L qui indique que le PIC peut fonctionner avec
une plage de tension beaucoup plus tolérante ;
 On trouve ensuite une ou deux lettre(s) pour indiquer le type de mémoire
programme :
 C indique que la mémoire programme est une EPROM ou plus rarement une
EEPROM,
 CR pour indiquer une mémoire de type ROM,
 F pour indiquer une mémoire de type FLASH.
 On trouve ensuite un nombre qui constitue la référence du PIC ;
 On trouve enfin un tiret suivi de deux chiffres indiquant la fréquence d’horloge
(quartz) maximale que peut recevoir le PIC.
Donc, un PIC16F84-10 est un PIC Mid-Range donc la mémoire programme est de

type FLASH de référence 84 et capable d’accepter une fréquence maximale
d’horloge de 10MHz.

1. Le microcontrôleur PIC16F84
1.1. Présentation
a. Brochage et mise en œuvre
Le PIC16F84 est commercialisé dans un boîtier classique 18 broches.
Brochage du PIC16F84
Pour fonctionner, il faut :
 Une alimentation de 2 à 6V (niveau haut sur VDD et la masse sur Vss).

 Un niveau haut sur ̅̅̅̅̅̅̅̅
MCLR (Master CLeaR). Un niveau bas sur cette broche
provoque un reset du processeur.
 Un quartz (ou un réseau RC) sur OSC1 et OSC2 ou un signal d’horloge sur
OSC1/CLKIN.
Le reste des broches (RA0 à RA4 pour le PORTA et RB0 à RB7 pour le PORTB) sont 13
entrées/sorties à la disposition de l’utilisateur. Elles sont configurables et
exploitables individuellement ou ensemble par port.
Le schéma suivant illustre une mise en œuvre du PIC16F84.
Le bouton poussoir BP raccordé sur RB0 (en entrée) pourra être utilisé pour
commander la LED connectée sur RA0 (en sortie). La résistance R2 de 10kΩ est

appelée « résistance de rappel » qui sert à rappeler au 5V l’entrée RB0 pour lui
imposer un état logique 1, on dit que RB0 est en « pull up ». Un appui sur le BP
mettra alors RB0 à l’état logique 0. Ce changement sera donc détecté par le
programme (code) pour agir sur l’état de RA0 afin d’allumer ou éteindre la LED.
Remarque :
 Si une entrée est rappelée à la masse, est dit qu’elle est en « pull down » ;
 Les résistances de rappel peuvent être internes pour certaines broches ;
 R1 est calculée de sorte à limiter le courant qui sort de RA0 à 20mA
maximum.
b. Architecture interne
Le PIC16F84 est un microcontrôleur 8 bits dont l'architecture interne, de type

Harvard (mémoire programme et mémoire de données séparées), est représentée ci-
dessous.
Architecture interne du PIC16F84
c. Principales Caractéristiques
Les principales caractéristiques du PIC16F84 sont :

 Une mémoire programme de type flash de 1K (1024) mots de 14 bits ;
 Une mémoire RAM constituée de :

 15 registres de control appelés SFR (Special Function Registers) ;

 68 octets de RAM utilisateur appelés GPR (General Propose Resisters);
 Une mémoire EEPROM de donnée de 64 octets ;
 Deux ports d'entrées/sorties bidirectionnelles, un de 5 bits (PORTA) et un de 8
bits (PORTB) dont les valeurs limites de courant par broche sont de :
 25 mA pour un courant entrant ;
 20 mA pour un courant sortant ;
 Un timer (Compteur) cadencé par une horloge interne ou externe ;
 Un chien de garde appelé WDT (Watchdog Timer) : compteur qui est un timer
particulier ;
 Un prédiviseur de fréquence programmable permettant d'étendre les possibilités
du Timer TMR0 ou du chien de garde WDT ;
 4 sources d'interruption ;
 L'horloge peut être générée par 4 types d'oscillateurs sélectionnables ;
 Protection de la mémoire programme contre la lecture ;
 Fonctionnement en mode sleep pour une réduction de la consommation ;
 Programmation par mode ICSP (In Circuit Serial Programming).
1.2. La mémoire programme (flash)

Cette mémoire, figure ci-contre, de 1024
mots stocke le programme. Elle est non
volatile et supporte jusqu'à 1000 cycles
d'écriture/effacement. Chaque position de
14 bits contient une instruction.
L'emplacement du programme peut se
faire à n'importe quel endroit de la
mémoire. Cependant il faut savoir que
suite à un RESET ou lors de la mise sous
tension, le PIC commence l'exécution du
programme à l'adresse 0000h (h signifie
hexadécimal). De plus, lorsqu'il y a une
interruption, le PIC va à l'adresse 0004h. Il
est donc conseillé de placer le début du
programme après l'adresse 0004h et de
mettre un branchement au début du
programme à l'adresse 0000h et un
branchement au début de la routine
d'interruption s'il y en a une à l'adresse
0004h. Le programme est implanté dans la
mémoire flash à l'aide d'un programmateur
Organisation de la mémoire flash
(hard+soft).
1.3. La mémoire RAM

La mémoire RAM, la figure suivante, est constituée de deux parties :

 Les registres SFR (Special Function Registers) sont les registres de

fonctionnement du PIC. L'ensemble de ces registres est souvent appelé fichier
des registres. Nous reviendrons sur ces registres tout le long de ce document.
 Les registres GPR (General Propose

Registers) sont des positions mémoire
que l'utilisateur peut utiliser pour
stocker ses variables et ces données.
On remarquera donc que,
indépendamment de leur nature, les
positions de la RAM sont toujours
appelées registres. Les registres GPR
débutent à l'adresse 0Ch.
La mémoire RAM est organisée en deux

Banks. Pour accéder à un registre, il faut
d'abord se placer dans la Bank où il se
trouve. Ceci est réalisé en positionnant le
bit RP0 du registre STATUS :
(RP0 = 0 → Bank 0, RP0 = 1 → Bank 1). Le
bit RP1 est maintenu à 0.
Pour la mémoire utilisateur, l'utilisation

des pages (Bank) n'est pas nécessaire
puisque la Bank 1 est "mapped" avec la
Bank 0. Cela signifie qu'écrire une donnée
à l'adresse 0Ch ou à l'adresse 8Ch revient
au même.
Organisation de la mémoire RAM
Ci-dessous, une représentation des bits RP0 et RP1 dans le registre STATUS.
STATUS : IRP RP1 RP0 TO PD Z DC C
Bits du registre STATUS
Principe de sélection des Banks :
RP1 RP0 Bank sélectionnée

0 0 Bank 0 (00h - 7Fh)
0 1 Bank 1 (80h - FFh)
1 0 Bank 2 (100h - 17Fh)
1 1 Bank 3 (180h - 1FFh)
Sélection des Banks
Le tableau suivant donne une représentation détaillée de tous les SFR.

Registres SFR (Special Function Registers)
1.4. L'ALU et le registre W

C'est une ALU (Arithmetic Logic Unit) 8 Bits qui réalise les opérations arithmétiques
et logiques entre l'accumulateur W (Work-register pour registre de travail) et
n'importe quel autre registre 'F' (File) ou constante 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.
1.5. Les ports d'entrées/sorties

a. Le port d'entrées/sorties PORTA
Le port A désigné par PORTA est un port de 5 bits (RA0 à RA4). Chaque broche
(E/S pour Entée/Sortie ou I/O pour Input/Output) est bidirectionnelle et
compatible TTL. La configuration de la direction (entrée ou sortie) de chaque
broche du port est réalisée avec le registre TRISA :
 Bit i de TRISA = 0  bit i de PORTA configuré en sortie ; 

 Bit i de TRISA = 1  bit i de PORTA configuré en entrée.

La broche RA4 est multiplexée avec l'entrée horloge du timer TMR0. Elle peut donc
être utilisée soit comme E/S normale du port A, soit comme entrée horloge pour le
Timer TMR0. Le choix se fait à l'aide du bit T0CS (TMR0 Clock Source Select bit) du
registre OPTION_REG :
 T0CS = 0  RA4 est une E/S normale ;

 T0CS = 1  RA4 égale l'entrée d'horloge externe pour le timer TMR0.
Registre OPTION_REG : RBPU INTEDG TOCS TOSE PSA PS2 PS1 PS0
Bits du registre OPTION_REG
RA4 est une E/S à drain ouvert, si on veut l'utiliser comme

sortie (pour allumer une LED par exemple), il faut utiliser
une résistance de rappel externe vers Vdd comme illustre
le schéma ci-contre. Si RA4 est positionnée à 0,
l'interrupteur est fermé, la sortie est reliée à la masse. 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 pour amener
le courant de l'alimentation vers la LED. La valeur de 330Ω
est donnée à titre indicatif et est à ajuster selon Principe d'utilisation
de RA4 en sortie
l'application.
b. Le port d'entrées/sorties PORTB
Le port B désigné par PORTB est un port bidirectionnel de 8 bits (RB0 à RB7).
Toutes les broches sont compatibles TTL. La configuration de la direction se fait à
l'aide du registre TRISB :
 Bit i de TRISB = 0  bit i de PORTB configuré en sortie ; 

 Bit i de TRISB = 1  bit i de PORTB configuré en entrée.
En entrée, la broche RB0 appelée aussi INT peut déclencher l’interruption externe
INT. En entrée, une quelconque des broches RB4 à RB7 peut déclencher
l'interruption RBI. Nous reviendrons là-dessus dans le paragraphe réservé aux
interruptions.
Chaque broche du PORTB peut être connectée ou déconnectée à Vdd (5 V) via une
résistance de rappel interne de 10 kΩ à l'aide du bit 𝐑𝐁𝐏𝐔 (PORTB Pull-Up enable bit)
du registre OPTION_REG :
 RBPU = 1 : résistances de rappel du PORTB déconnectées ;

 RBPU = 0 : résistances de rappel du PORTB connectées.

1.6. 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.
Avec l'oscillateur à Quartz représenté

ci-contre, on peut avoir des fréquences
allant jusqu'à 4, 10 ou 20 MHz selon le
type de microcontrôleur. Le filtre passe
bas RS limite les harmoniques dus à
l’écrêtage et réduit l’amplitude de Oscillateur à quartz
l’oscillation (il n'est pas obligatoire).
Les valeurs de C1 et C2 dépendent de

la fréquence du quartz. Nous y
reviendrons.
Avec l'oscillateur RC, figure ci-contre, la

fréquence d'oscillation est fixée par
Vdd, Rext et Cext. Elle peut varier
légèrement d'un circuit à l'autre.
Oscillateur RC
Dans certains cas, une horloge externe
au microcontrôleur peut être utilisée
pour synchroniser le PIC sur un
processus particulier, figure ci-contre.
Quel que soit l'oscillateur utilisé,

l'horloge système dite aussi horloge Horloge externe
instruction est obtenue en divisant la
fréquence externe par 4.
On utilise le terme Fosc/4 pour désigner l'horloge système (où Fosc égale à la
fréquence à l'entrée de l'oscillateur).
Avec un quartz de 4 MHz, on obtient une horloge instruction de 1 MHz. Ce qui

donne 1 microseconde par cycle instruction.
1.7. Le Timer TMR0

Les Timers permettent d’effectuer des temporisations avec une extrême précision
comparativement aux temporisations par logiciel (combinaison des instructions en
boucle pour perdre du temps).
Ils sont configurables (choix de l’horloge, diviseur programmable, …), disposent des
possibilités d’interruption (activation d’un flag au débordement) et servent à
certains modules comme le Capture/Compare pour des fonctions PWM (Pulse Wide
Modulation) par exemple pour certains PIC comme le PIC16F877.

Le PIC16F84 ne possède qu’un seul timer nommé TMR0.
C’est un compteur 8 bits ayant les caractéristiques suivantes :
 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 :
 T0CS = 0  RA4 est une E/S normale ;

 T0CS = 1  RA4 égale l'entrée d'horloge externe pour le timer TMR0.
Dans le cas de l'horloge externe, on peut choisir le front sur lequel le TIMER
s'incrémente à l'aide du bit T0SE (TMR0 Source Edge select bit) du registre
OPTION_REG :
 T0SE = 0  incrémentation sur fronts montants ;

 T0SE = 1  incrémentation sur fronts descendants.
 Quel que soit l'horloge choisie, on peut la passer dans un diviseur de fréquence
programmable appelé prédiviseur (prescaler) dont le rapport est fixé par les bits
PS0, PS1 et PS2 (Prescaler rate Select bits) du registre OPTION_REG.
L'affectation ou non du prédiviseur se fait à l'aide du bit PSA (Prescaler
Assignment bit) du registre OPTION_REG :
 PSA = 0  on utilise le prédiviseur ;

 PSA = 1  on n'utilise pas de prédiviseur (il est affecté au chien de garde).
Registre OPTION_REG : RBPU INTEDG TOCS TOSE PSA PS2 PS1 PS0
Bits du registre OPTION_REG
PS2 PS1 PS0 Valeur de Division

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
Valeurs de configuration du prédiviseur pour TMR0
 Le contenu du timer TMR0 est accessible par le registre qui porte le même nom.
Il peut être lu ou écrit à n'importe quel moment. Après une écriture,
l'incrémentation est inhibée pendant deux cycles instruction.
 Au débordement de TMR0 (FFh  00h), le drapeau T0IF (TMR0 Overflow

Interrupt Flag bit) est placé à 1. Ceci déclenche l'interruption de débordement
TMR0 si celle-ci est validée.

Schéma fonctionnel du TMR0
1.8. Le Watchdog Timer WDT (Chien de garde)

C’est un compteur 8 bits incrémenté en permanence (même si le microcontrôleur
est 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 :
 Si le microcontrôleur est en fonctionnement normal, le WDT time-out
provoque un RESET. Ceci permet d’éviter de rester planté en cas de blocage du
microcontrôleur par un processus indésirable non contrôlé ;
 Si le microcontrôleur est 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 situation est souvent exploitée pour
réaliser des temporisations.
L'horloge du WDT est ajustée pour que Le Time-out arrive toutes les 18 ms. Il est
cependant possible d'augmenter cette durée en faisant passé le signal time-out dans
un prédiviseur programmable (partagé avec le timer TMR0). L'affectation se fait à
l'aide du bit PSA (Prescaler Assignment bit) du registre OPTION_REG :
 PSA = 1  on utilise le prédiviseur ;
 PSA = 0  on n'utilise pas de prédiviseur (il affecté à TMR0).
Le rapport du prédiviseur est fixé par les bits PS0, PS1 et PS2 du registre
OPTION_REG.
PS2 PS1 PS0 Valeur de Division

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
Valeurs de configuration du prédiviseur pour WDT
L'utilisation du WDT doit se faire avec précaution pour éviter les réinitialisations
inattendues répétées du programme. Pour éviter un WDT time-out lors de
l'exécution d'un programme, on a deux possibilités :

 Inhiber le WDT d'une façon permanente en mettant à 0 le bit WDTE (Watch Dog
Timer Enable bit) dans l'EEPROM de configuration ;
 Remettre le WDT à 0 périodiquement dans le programme à l'aide de l'instruction
CLRWDT pour éviter qu'il ne déborde.
Schéma fonctionnel du WDT
1.9. La mémoire EEPROM de données

La mémoire EEPROM de données est constituée de 64 octets commençant à
l'adresse 2100h 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 2100h, autrement dit, l'adresse va de 0 à 63.
Deux registres de contrôle (EECON1 et EECON2) sont associés à la mémoire

EEPROM.
La durée d’écriture d’un octet est de l’ordre de 10 ms. La fin de chaque écriture
réussie est annoncée par le drapeau EEIF (EEPROM write operation Interrupt Flag bit)
et la remise à zéro du bit WR (Write Control bit) du registre EECON1. Le drapeau
EEIF peut déclencher l'interruption « fin d’écriture dans l’EEPROM de données » (EEI)
si elle a été validée.
EECON1 : - - - EEIF WRERR WREN WR RD

Bits du registre EECON1
a. Procédure de lecture dans l'EEPROM de données
 Placer l’adresse relative dans EEADR ;

 Mettre le bit RD (Read Control bit) de EECON1 à 1 ;
 Lire le contenu du registre EEDATA.

b. Procédure d'écriture dans l'EEPROM de données
 L'écriture dans L'EEPROM doit être autorisée : bit WREN (EEPROM Write Enable
bit) égal 1 ;
 Placer l’adresse relative dans EEADR ;
 Placer la donnée à écrire dans EEDATA ;
 Placer 55h dans EECON2 ;
 Placer AAh dans EECON2 ;
 Démarrer l'écriture en positionnant le bit WR ;
 Attendre la fin de l'écriture (EEIF = 1 ou WR = 0) ;
 Recommencer au deuxième point si on a d'autres données à écrire.
Le drapeau WRERR (EEPROM Error Flag bit) est positionné si une erreur d'écriture
intervient.
EECON2 est un registre de commande. L’écriture de valeurs spécifiques dans

EECON2 provoque l’exécution d’une commande spécifique dans l’électronique
interne du PIC.
1.10. Le compteur programme (Program Counter)

Le Program Counter (PC) 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é. Il est formé de deux
registres :
 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 un
registre SFR accessible en lecture/écriture et où seuls 5 bits sont utilisés.
Si on veut modifier le Program Counter pour réaliser un saut (goto calculé), il faut
d'abord placer la partie haute dans le registre PCLATH, ensuite on écrit la partie
basse dans PCL. Au moment de l'écriture dans PCL, le contenu de PCLATH est
recopié automatiquement dans PCH.
Principe du goto calculé
Dans les instructions de branchement, l'adresse de destination est codée sur 11

bits. Lors de l'exécution de telles instructions, les 11 bits sont copiés dans PC et les
deux bits manquants sont pris dans PCLATH. Pour le 16F84, On n'aura pas besoin
de ces deux bits car pour adresser 1024 lignes de programme, seuls 10 bits du PC
sont utilisés.

Principe des instructions de branchement
1.11. Les interruptions

Une interruption provoque l’arrêt du programme principal pour aller exécuter une
procédure (fonction ou sous-programme) d'interruption. A la fin de cette procédure,
le microcontrôleur reprend le programme à l’endroit où il s’était arrêté. Le PIC16F84
possède 4 sources d'interruption. A chaque interruption sont associés deux bits: un
bit de validation et un drapeau. Le premier permet d'autoriser ou non
l'interruption, le second permet au programmeur de savoir de quelle interruption il
s'agit. Tous ces bits sont dans le registre INTCON à part le drapeau EEIF de
l'interruption EEI qui se trouve dans le registre EECON1.
a. Déroulement d'une interruption
Lorsque l'événement déclencheur d'une interruption intervient, alors son drapeau

(flag) est positionné à 1 (levé). Si l'interruption correspondante a été validée, elle est
alors déclenchée : le programme arrête ce qu'il est en train de faire et va exécuter la
procédure d'interruption qui se trouve à l'adresse 0004h en exécutant les étapes
suivantes :
 l'adresse contenue dans le PC (Program Counter) est sauvegardée dans la pile,

puis remplacée par la valeur 0004h (adresse de la routine d'interruption).
 Le bit GIE (Global Interrupt Enable bit) du registre INTCON est mis à 0 pour
inhiber toutes les interruptions (afin d'éviter une autre interruption pendant
l'exécution de la procédure d'interruption).
 A la fin de la procédure d'interruption (instruction RETFIE) :

 le bit GIE est remis à 1 (autorisant ainsi un autre événement);
 le contenu du PC est rechargé à partir de la pile, ce qui permet au programme
de reprendre là où il s'est arrêté.
Remarques :
 Le drapeau reste à 1 même après le traitement de l’interruption. Par

conséquent, il faut toujours le remettre à 0 à la fin de la routine d'interruption,
sinon l'interruption sera déclenchée de nouveau juste après l'instruction RETFIE.
 Seul le PC est empilé automatiquement. Si cela est nécessaire, les registres W et

STATUS doivent être sauvegardés en RAM puis restaurés à la fin de la routine
d'interruption pour que le microcontrôleur puisse reprendre le programme
principal dans les mêmes conditions où il l'a laissé.

b. L'interruption INT (Entrée RB0 du port B)
Cette interruption est provoquée par un changement d'état sur la broche RB0 du
PORTB quand elle est configurée en entrée. Elle est gérée par les bits :
 INTE (RB0/INT Interrupt Enable bit) : bit de validation (1 = valide, 0 = inhibée) ;

 INTF (RB0/INT Interrupt Flag bit) : drapeau.
 INTEDG (Interrupt Edge Select bit) du registre OPTION_REG : front de
déclenchement (1 = front montant, 0 = front descendant).
c. L'interruption RBI (RB4 A RB7 du port B)
Cette interruption est provoquée par un changement d'état sur l'une des entrées
RB4 à RB7 du PORTB quand elle est configurée en entrée. Le front n'a pas
d'importance. Les bits associés sont RBIE (RB Port Change Interrupt Enable bit) pour
la validation et RBIF (RB Port Change Interrupt Flag bit) pour le drapeau.
d. L'interruption T0I : Débordement du Timer TMR0
Cette interruption est provoquée par le débordement du TMR0 (passage de FFh à

00h). Les bits associés sont T0IE (validation) et T0IF (drapeau).
e. L'interruption EEI : fin d'écriture dans l'EEPROM
Cette interruption est déclenchée à la fin d'une écriture réussie dans l'EEPROM. Les
bits associés sont EEIE (validation) et EEIF (drapeau).
INTCON GIE EEIE T0IE INTE RBIE T0IF INTF RBIF

EECON1 - - - EEIF WRERR WREN WR RD
OPTION_REG RBPU INTEDG TOCS TOSE PSA PS2 PS1 PS0
Bits associés aux interruptions
Le bit GIE permet de valider ou d'interdire (globalement) toutes les interruptions.
1.12. Le mode SLEEP

Le PIC peut être placé en mode faible consommation à l'aide de l'instruction SLEEP.
Dans ce mode, l'horloge système est arrêtée et cela entraine l'arrête de l'exécution
du programme.
Pour sortir du mode SLEEP, il faut provoquer un WAKE-UP, pour cela il y a trois
possibilités :
 RESET externe dû à l'initialisation du PIC en mettant l'entrée MCLR à 0. Le PIC

reprend l'exécution du programme à partir du début ;
 Time-out du chien de garde WDT si celui-ci est validé. Le PIC reprend le

programme à partir de l'instruction qui suit l'instruction SLEEP ;
 Interruption INT (sur RB0) ou RBI (sur RB4-RB7) ou EEI (fin d'écriture dans
l’EEPROM de données). Le bit de validation de l'interruption en question doit être

validé, par contre, le WAKE-UP a lieu quel que soit l'état du bit de validation
globale GIE. On a alors deux situations :
 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 0004h pour exécuter la procédure
d'interruption. Dans le cas où l'instruction suivant SLEEP n'est pas nécessaire,
il faut utiliser l'instruction NOP.
1.13. Les indicateurs d'état

Les indicateurs d'état C, DC et Z sont des bits qui nous informent sur l'état du
résultat de la dernière instruction exécutée. Les indicateurs 𝐓𝐎 et 𝐏𝐃 indiquent les
causes du dernier reset. Ils sont situés dans le registre STATUS.
STATUS : IRP RP1 RP0 TO PD Z DC C
Bits du registre STATUS
 C (Carry) : ce bit vaut :

 0 si le résultat de l'opération est positif et sans retenue ;
 1 lorsque le résultat de l'opération dépasse la valeur FFh ou si le résultat est
négatif.
 DC (Digital Carry) : ce bit vaut :

 0 s'il n'y a pas de retenue entre les bits 3 et 4 des opérandes ;
 1 lorsqu'une retenue s'est produite entre les bits 3 et 4 des opérandes.
 Z (Zero) : ce bit vaut :

 0 pour indiquer que le résultat de l'opération est différent de zéro ;
 1 pour indiquer que le résultat de l'opération est nul.
 𝐓𝐎 (Time-out) : ce bit vaut :

 1 pour indiquer un reset par mise sous tension du microcontrôleur ou
l'exécution de l'instruction CLRWDT ou SLEEP ;
 0 après un débordement du Watch Dog Timer (WDT).
 𝐏𝐃 (Power-Down) : ce bit vaut :

 1 pour indiquer un reset par mise sous tension du microcontrôleur ou
l'exécution de l'instruction CLRWDT ;
 0 pour indiquer l'exécution de l'instruction SLEEP.
1.14. La mémoire EEPROM de configuration

Pendant la phase d'implantation d'un programme dans la mémoire programme du
PIC, on programme aussi une EEPROM de configuration constituée de 5 mots de 14
bits :
 4 mots d’identification (ID) à partir de l’adresse 0x2000 pouvant contenir un
repérage quelconque que nous n'utiliserons pas ;
 1 mot de configuration (adresse 0x2007), représenté au tableau ci-dessous,
qui permet :
 de choisir le type de l'oscillateur pour l'horloge,

 de valider ou non le WDT timer,

 d’interdire la lecture des mémoires EEPROM de programme et de données.
13 12 11 10 9 8 7 6 5 4 3 2 1 0
CP CP CP CP CP CP CP CP CP CP PWRTE WDTE FOSC1 FOSC0
Bits de configuration du microcontrôleur
 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 : quartz jusqu'à 4 MHz ;
- 00 : Oscillateur LP (Low Power), consommation réduite, jusqu'à 200 kHz.
Remarque : les valeurs de C1 et C2, représentées au tableau suivant,

dépendent de la configuration de l'oscillateur à quartz.
Valeurs de C1 et C2 pour l'oscillateur à quartz
 Bit 2 = WDTE : validation du WDT (chien de garde) :

- 1 : WDT activé ;
- 0 : WDT inhibé.
 Bit 3 = PWRTE : validation d'une temporisation à la mise sous tension :

- 1 : temporisation inhibée ;
- 0 : temporisation activée.
 Bit 13:4 = CP : protection en lecture du code programme

- 1 : pas de protection ;
- 0 : protection activée.
1.15. Les instructions du PIC16F84

Tous les PIC Mid-Range ont un jeu de 35 instructions. Chaque instruction est codée
sur un mot (code opératoire) de 14 bits qui contient le code opération (OC) ainsi
que l'opérande. A part les instructions de saut, toutes les instructions sont
exécutées en un cycle d'horloge interne. Sachant que l’horloge fournie au PIC est
divisée par 4, si on utilise par exemple un quartz de 4 MHz, on obtient donc
1000000 cycles/seconde. Cela donne une puissance d'exécution de l’ordre de
1MIPS (1 Million d’ Instructions Par Seconde).

Les 35 instructions peuvent être regroupées en quatre catégories, représentées à la

figure suivante :
 Les instructions « orientées octet » pour traitement de registres

Ce sont des instructions qui manipulent les données sous forme d’octets contenus
dans des registres. Elles sont codées de la manière suivante :
 6 bits pour le code opération ;

 1 bit (d) pour indiquer si le résultat obtenu doit être conservé dans le registre
de travail (accumulateur) W de l’unité de calcul ou sauvé dans un registre F (F
pour File) ;
 Reste 7 bits pour encoder l'adresse de l’opérande (128 positions au total).
Remarque : 7 bits ne donnent pas accès à la mémoire RAM totale, donc voici
l’explication de la division de la RAM en deux Banks. Pour remplacer le bit
manquant, on utilise le bit RP0 du registre STATUS. Bien qu'on ne l'utilise pas sur le
16F84, le bit RP1 est aussi réservé pour le changement de Bank, le 16F876 par
exemple possède 4 banks.
 Les instructions « orientées bits »

Ce sont des instructions destinées à manipuler directement les bits d’un registre
d'une case mémoire. Elles sont codées de la manière suivante :
 4 bits pour le code opération ;

 3 bits pour indiquer le numéro du bit à manipuler (de 0 à 7) ;
 7 bits pour indiquer l’opérande.
 Les instructions opérant sur une donnée littérale

Ce sont les instructions qui manipulent des données qui sont codées dans
l’instruction directement. Elles sont codées de la manière suivante :
 Le code opération est codé sur 6 bits ;

 Il est suivie d’une valeur IMMEDIATE codée sur 8 bits (donc de 0 à 255).
 Les instructions de saut et appel de procédures (sous-programmes)

Ce sont les instructions qui provoquent une rupture dans la séquence de
déroulement du programme. Elles sont codées de la manière suivante :
 Le code opération est codé sur 3 bits ;

 La destination est codée sur 11 bits.
Nous pouvons déjà en déduire que les sauts ne donnent accès qu’à 2K (211) de
mémoire programme. Pas de problème pour le 16F84 qui ne possède que 1k de
mémoire programme.
Dans cette catégorie se trouvent aussi des instructions spéciales appelées

instructions de contrôle.

Formats des instructions
a. Le jeu d'instructions
Le tableau suivant représente le jeu d'instructions du 16F84.

Jeu d'instructions du PIC16F84
addlw k : Additionne une constante k à W. Résultat dans W. Les bits de STATUS

affectés sont C, DC et Z.
addwf f,d : Additionne une variable à l’adresse f avec W. Résultat dans f si d=1 ou
dans W si d=0. Les bits de STATUS affectés sont C, DC et Z.
sublw k : Soustraction : k-W, résultat dans W. Les bits de STATUS affectés sont C,
DC et Z.
subwf f,d : Soustraction : une variable à l’adresse f - W, résultat dans f si d=1 ou

dans W si d=0. Les bits de STATUS affectés sont C, DC et Z.
andlw k : ET logique entre une constante k et W. Résultat dans W. Le bit de

STATUS affecté est Z.

andwf f,d : ET logique entre une variable à l’adresse f et W. Résultat dans f si d=1
ou dans W si d=0. Le bit de STATUS affecté est Z.
iorlw k : OU logique entre une constante k et W. Résultat dans W. Le bit de

iorwf f,d : OU logique entre une variable à l’adresse f et W. Résultat dans f si d=1
ou dans W si d=0.
xorlw k : OU Exclusif entre une constante k et W. Résultat dans W. Le bit de

xorwf f,d : OU Exclusif entre une variable à l’adresse f et W. Résultat dans f si d=1
ou dans W si d=0. Le bit de STATUS affecté est Z.
comf f,d : Complément à 1 de f. Résultat dans f si d=1 ou dans W si d=0. Le bit de

rlf f,d : Rotation logique à gauche de la variable stockée à l’adresse f. Résultat

dans f si d=1 ou dans W si d=0. Le bit de STATUS affecté est C.
rrf f,d : Rotation logique à droite de la variable stockée à l’adresse f. Résultat

dans f si d=1 ou dans W si d=0. Le bit de STATUS affecté est C.
swapf f,d : Permute les deux quartets de f. Résultat dans f si d=1 ou dans W si d=0.
incf f,d : Incrémente de 1 la variable à l’adresse f. Résultat dans f si d=1 ou dans

W si d=0. Le bit de STATUS affecté est Z.
incfsz f,d : Incrémente de 1 la variable à l’adresse f. Résultat dans f si d=1 ou dans

W si d=0. Si le résultat de l’opération vaut 0, alors l’instruction suivante
est ignorée (instruction NOP exécuté à la place).
decf f,d : Décrémente de 1 la variable à l’adresse f. Résultat dans f si d=1 ou dans

W si d=0. Le bit de STATUS affecté est Z.
decfsz f,d : Décrémente de 1 la variable à l’adresse f. Résultat dans f si d=1 ou dans

W si d=0. Si le résultat de l’opération vaut 0, alors l’instruction suivante
est ignorée (instruction NOP exécuté à la place).
movf f,d : Met la variable contenu à l’adresse f dans W si d=0 ou dans f si d=1. Le
bit de STATUS affecté est Z.
movlw k : Met la variable k dans W
movwf f : Met la variable contenu dans W à l’adresse f.
clrf f : Met 0 dans f. Le bit de STATUS affecté est Z.
clrw : Met 0 dans W. Le bit de STATUS affecté est Z.
clrwdt : Fait un reset du chien de garde (registre WDT mis à 0). Les bits de
STATUS affectés sont TO et PD.
bcf f,b : Met le bit b de f à 0.

bsf f,b : Met le bit b de f à 1.
btfsc f,b : Teste le bit b de f. Si ce bit vaut 0 alors l’instruction suivante est ignorée
(instruction NOP exécuté à la place).
btfss f,b : Teste le bit b de f. Si ce bit vaut 1 alors l’instruction suivante est ignorée
(instruction NOP exécuté à la place).
call k : Appel à un sous-programme (PC mémorisé dans la pile système).
goto k : Branchement inconditionnel à l’adresse k.
nop : Aucune opération effectué (1 cycle instruction perdu).
retfie : Fin du programme interruption (dépile la pile système).
retlw k : Fin d’un sous-programme (associée à call). Met la variable k dans W.
return : Fin d’un sous-programme (associée à call).
sleep : Met le microprocesseur en mode sommeil. Les bits de STATUS affectés

sont TO et PD.
Remarque : pour d = 0, on peut écrire ,W et pour d = 1 on peut écrire ,F. Exemple :

addwf Variable,W  addwf Variable,0 : W prend W + Variable
addwf Variable,F  addwf Variable,1 : Variable prend W + Variable
b. Les modes d'adressage
Dans une instruction, l'adressage spécifie l'emplacement de l'opérande avec lequel

l'instruction doit être exécutée. Pour le PIC16f84 on distingue trois modes
d'adressage.
 Adressage immédiat ou littéral

Dans ce mode d’adressage, le code opération est suivi par la donnée, ou opérande,
à manipuler. Exemples :
movlw .47 ; stocke la valeur 47 en décimale dans le registre W.

sublw 0xB7 ; soustraction B7h - W et résultat dans W.
 Adressage direct
Dans ce mode d’adressage, le code opération est suivi d’un nombre de 7 bits non
signé qui est l’adresse effective pour une page précise (Bank0 ou Bank1) de la
donnée, ou opérande, à manipuler. Dans ce mode d’adressage, les instructions se
terminent par une valeur précédée d’une virgule qui indique la destination du
résultat ou le numéro d’un bit à manipuler. Exemples :
Andwf 0x0E,W ; ET logique entre W et le contenu de l’adresse 0x0E, résultat

dans W.
andwf 0x0E,F ; ET logique entre W et le contenu à l’adresse 0x0E, résultat à

l’adresse 0x0E.

bsf 0x1F,7 ; mettre à 1 le bit n°7 du contenu de l'adresse 1Fh.
 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
(attention, les adresses sont sur 8 bits et non sur 7 bits comme pour le mode
d’adressage direct), ensuite on lit ou écrit dans le registre INDF. Exemple :
movlw 0x0E ; W prend 0Eh

movwf FSR ; pointer l'adresse 0Eh
movf INDF,W ; W prend le contenu de l'adresse pointée par FSR
Dans ce mode d’adressage, le bit IRP du registre STATUS représente le neuvième

bit de l'adresse pointée pour les PIC qui contiennent plus de deux Banks. Il n'est
donc pas utilisé pour le 16F84.
2. Les outils de développement

Pour développer une application à base de microcontrôleur il faut disposer d’un
minimum de matériel. En effet, il faut tout d’abord être à même d’écrire le
programme que va exécuter le microcontrôleur, puis de le transformer en langage
machine (fichier hexadécimal avec l’extension .hex) que le microcontrôleur peut
comprendre, et enfin de le transférer dans la mémoire programme contenue dans
son boîtier. Cet équipement minimum doit cependant, si possible, être complété par
un moyen de test du programme car, hélas, il est assez rare qu’un programme
fonctionne au premier essai, surtout s’il est long et complexe. Ce sont les fameux «
bugs » qu’il faut essayer au maximum d’éliminer. L’ensemble de ces outils constitue
ce que l’on appelle outils de développement ou système de développement. La
figure suivante résume l’enchaînement des étapes de développement.
Microchip propose gratuitement l'outil de développement MPLAB qui regroupe

l'éditeur de texte, l'assembleur MPASM, un outil de simulation et le logiciel de
transfert du programme. MPLAB peut être téléchargé du site Web
http://www.microchip.com.
Nous utiliserons MPLAB pour écrire, compiler et éventuellement simuler nos

programmes et ensuite nous utiliserons un programmateur adapté pour transférer
les programmes dans la mémoire flash du PIC.

OUTIL
ECRITURE DU PROGAMME
EDITEUR DE TEXTE SOURCE
LISTING SOURCE
(SUITE DE MNEMONIQUES,
INSTRUCTION)
COMPILATEUR/ COMPILATION ET ASSEMBLAGE
ASSEMBLEUR DU PROGRAMME
LISTING OBJET
(SUITE DE CODES BINAIRES QUI
CONSTITUE LE FICHIER .hex)
TRANSFERT DU
PROGRAMMATEUR PROGRAMME DANS LA
MEMOIRE PROGRAMME DU
MICROCONTROLEUR
uC (CIRCUIT PROGRAMME)
MAQUETTE OU
SIMULATEUR OU ESSAI SUR L'APPLICATION
EMULATEUR
Les étapes de développement
3. Programmation
3.1. Algorithme/Organigramme ou ordinogramme
Un l'algorithme est un ensemble de règles opératoires rigoureuses permettant de
décrire un processus particulier. Exemples : algorithme de régulation de
température, de conditionnement de bouteilles, ... Un algorithme peut donc être
représenté de diverses manières.
 Un algorithme peut être représenté par un organigramme (ou ordinogramme)

qui est une représentation graphique normalisée utilisée pour analyser ou
décoder un problème. L'organigramme qui met en œuvre des symboles
représentant des traitements, des données, des liaisons, …, présente l'intérêt
d'une visualisation globale mais reste limité aux études peu complexes. Les
figures suivantes représentent les symboles usuels d'un organigramme.
Début ou Fin
Opération ou Traitement Sous-programme
de programme
Autres symboles pour

les Entrées/Sorties
Prise de décision Non Entrée

(condition vraie ?)
Oui Sortie
Symboles usuels d'un organigramme

 Un algorithme peut être écrit sous forme littérale, avec un langage

algorithmique qui utilise un ensemble de mots clés et de structures
permettant d'organiser l'exécution des traitements de manière systématique.
 Structure linéaire
Elle se caractérise par une suite d'actions à exécuter successivement dans
l'ordre de leur énoncé.
Algorithme Organigramme
Début action Début

Faire action 1
Faire action 2
Action 1
.
.
. Action 2
Faire action n
Fin action
Action n
Fin
 Structures alternatives
Une structure alternative n'offre que deux issues possibles s'excluant
mutuellement.
 Structure alternative réduite : si … alors … fin si
Si condition
Alors action Non Oui
Fin si Condition
Action

 Structure alternative complète : si … alors … sinon … fin si
Si condition
Alors action 1 Non Oui
Sinon action 2 Condition
Fin si
Action 2 Action 1
 Structures répétitives
Une structure répétitive ou itérative répète l'exécution d'un traitement.
 Nombre de répétitions inconnu
 Répéter … jusqu'à …
Répéter
action Action
jusqu'à condition vraie
Non Oui
Condition
 Tant que … faire … fin tant que
Tant que condition vraie

Faire action
Action
Fin tant que
Non Oui
Condition

 Nombre de répétions connu : pour … de … à … faire … fin pour
Pour indice de début à fin par pas de n

Faire action V = VInitiale
Fin pour
Non Oui
V=VFinale
action
V = V +/- pas
Remarque :
V signifie Valeur
V = V +/- pas se lit : nouvelle valeur de V égale

à la précédente plus (incrémentation) ou moins
(décrémentation) le pas.
3.2. Langages de programmation

Le langage compris par les microprocesseurs est le langage machine, où chaque
instruction se présente sous forme d'un nombre exprimé en binaire (base 2) ou en
hexadécimal (base 16).
Le langage machine étant très lourd à utiliser par le programmeur, une

représentation sous forme mnémonique appelée langage assembleur est utilisée.
Des langages dits évolués permettent le développement de programmes complexes

à l'aide d'interpréteurs (BASIC) ou de compilateurs (PASCAL, langage C, FORTRAN,
…). La mise au point du logiciel est alors facilitée, mais l'exécution est plus lente car
les programmes générés sont souvent plus longs.
a. Langage assembleur
 Format des nombres
L'assembleur reconnaît les nombres codés en décimal, hexadécimal, binaire ou

octal. Pour préciser la base, les préfixes ci-dessous sont utilisés :
Base Syntaxe Exemple (36)10

Décimale : D'valeur' D'36'
.valeur .36
Hexadécimale : H'valeur' H'24'

0xvaleur 0x24
valeurh 24h

Binaire : B'valeur' (8 bits) B'00100100'
Octale : O'valeur' O'44'

0valeur 044
On peut à l'aide de la directive LIST ou RADIX définir un format par défaut. Si par
exemple on place une des directives suivantes au début du programme, tous les
nombres sans indication de base seront interprétés en décimal :
LIST r = dec
RADIX dec
Les RADIX valables sont dec (pour décimal), hex (pour hexadécimal) et oct (pour
octal). Au lieu de déclarer le format par défaut dans le code source, une de ces
options peut être cochée dans MPLAB.
 Les directives de MPASM
Les directives de l'assembleur sont des directives qu'on ajoute au programme et qui
seront interprétées par l'assembleur MPASM. Ce ne sont pas des instructions
destinées au PIC. Les directives les plus utilisées sont :
 LIST : permet de définir un certain nombre de paramètres comme le processeur

utilisé (p), la base par défaut pour les nombres (r), le format du fichier hex à
produire (f) ainsi que d'autres paramètres. Exemple :
LIST p=16F84, r=dec, f=inhx8m
 #INCLUDE : permet d'insérer un fichier source. Par exemple le fichier p16f84.inc

contient les définitions d'un certain nombre de constantes comme les noms des
registres ainsi que les noms de certains bits. Exemple :
#INCLUDE "p16f84A.inc"
 __CONFIG : permet de définir les 14 fusibles de configuration qui seront copié

dans l'EEPROM de configuration lors de l'implantation du programme dans le PIC
(protection de code, type d'oscillateur, chien de garde et temporisation au
reset). Exemple :
__CONFIG B'11111111110010'
ou
__CONFIG H'3FF2'
Si le fichier p16f84.inc a été inséré, on peut utiliser les constantes prédéfinies :
__CONFIG _CP_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC
Remarque : _ON pour activer et _OFF pour désactiver.
 EQU : permet de définir une constante ou une variable. Exemple :

xxx EQU 0x0C
Chaque fois que le compilateur rencontrera xxx, il la remplacera soit par la

constante 0x0C. Cela peut être une constante s'il s'agit d'une instruction avec
adressage immédiat, ou d'une adresse s'il s'agit d'une instruction avec
adressage direct.
 #DEFINE : définit un texte de substitution. Exemple :
#DEFINE Led PORTA,1
Chaque fois que le compilateur rencontrera le texte Led, il le remplacera par

PORTA,1.
 Les MACROS : Une macro remplace un morceau de code souvent utilisé.

Exemple :
TRANSFERT macro
bcf STATUS,RP0
movwf PORTB
endm
La macro se compose d’un nom écrit en première colonne, suivi par la directive
«macro». Commence alors à la ligne suivant la portion de code qui constitue la
macro. La fin de la macro est définie par la directive «endm» (end of macro).
Pour notre exemple, chaque fois que la macro TRANSFERT sera rencontrée, elle
sera remplacée au moment de l’assemblage par les 2 lignes :
bcf STATUS,RP0
movwf PORTB
La macro simplifie donc l’écriture du programme, mais ne raccourcit pas la taille

du fichier hexadécimal obtenu, puisque les 2 lignes seront écrites dans le PIC
chaque fois que la macro est appelée.
Notez que l’on peut utiliser des macros plus complexes, avec passage de
paramètres.
 CBLOCK/ENDC : définit un bloc de constantes (variables). Exemple :
CBLOCK 0X0C
var : 1
cpt : 2
k :1
ENDC
Le chiffre après les ":" indique le nombre d'octets sur lesquels sera codée la
variable. Cela signifie que var est une variable sur un octet (adresse 0x0C), cpt

est une variable sur 2 octets (adresses 0x0D et 0x0E) et k est une variable sur
un octet (adresse 0x0F).
 ORG : définit la position dans la mémoire programme à partir de laquelle seront

inscrites les instructions suivantes. Exemple :
ORG 0x00
GOTO prog_principal
 DE : pour déclarer des donnés qui seront stockée dans l'EEPROM de donnée au
moment de l'implantation du programme sur le PIC. Exemple :
ORG 0x2100
DE "Programmer un PIC, rien de plus simple", 'A', 'B', 4
 DT : pour déclarer un tableau RETLW. Exemple :
DT "Programmer un PIC",23,0x47
L'assembleur remplacera cette ligne par la suite d'instructions :

RTLW 'P'
RTLW 'r'
RTLW 'o'
.
.
.
RTLW 'C'
RTLW 23
RTLW 0x47
 END : indique la fin du programme.
 Structure d'un programme écrit en assembleur
Un programme écrit en assembleur doit respecter une certaine syntaxe et un certain

nombre de règles afin qu'il soit facile à lire et à débuguer.
 Tout ce qui commence à la première colonne est considéré comme une

étiquette (label) permettant de faire des renvois (sauts) ou des appels (sous-
programmes) et aussi des assignations de constantes et de variables.
 Tout ce qui suit un point-virgule (quel que soit la colonne) est considéré comme
un commentaire non interprété par le compilateur.
 Les directives et les instructions doivent commencer après la deuxième colonne.
Nous organiserons nos programmes de la manière suivante :
 Etape 1 : Quelques lignes de commentaire précisant la fonction du programme.
 Etape 2 : Configuration du microcontrôleur. Exemple :

LIST p=16f84, f=inhx8m, r = dec

#INCLUDE "p16f84.inc"
__CONFIG _CP_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC
 Etape 3 : Définition des constantes et des variables. Exemple :
cblock 0x0C
cpt : 1
var : 2
endc
#define led PORTA,1

#define Max 10
 Etape 4 : Si le programme utilise des interruptions, mettre à l'adresse 0x0000

(adresse du RESET) une instruction de branchement au début du programme
principal. Exemple :
org 0x0000
goto prog_principal
 Etape 5 : Ecrire la routine d'interruption à l'adresse 4. Exemple :
ORG 0x0004
Ecrire la routine d'interruption ici
RETFIE
Si le programme est configuré pour interdire les interruptions, on peut se passer

des étapes 4 et 5.
 Etape 6 : Ecrire les sous-programmes (s'il y en a). Chaque procédure commence

par une étiquette qui représente son nom, et se termine par l'instruction
RETURN ou RETLW.
 Etape 7 : Ecrire le programme principal (commençant par l'étiquette

prog_principal si les étapes 4 et 5 sont présentes).
 Etape 8 : terminer avec la directive end.
 Exemple de programme assembleur
; on connecte un interrupteur sur RB0 (entrée) et une LED sur RB1 (sortie)
; l’anode est reliée à RB0 à travers une résistance de 220 Ω et la cathode à VSS
; une résistance de pull up est placée entre RB0 et VDD et l’interrupteur relié VSS.
; Si on ouvre l’interrupteur, la LED doit s'allumer, si on ferme l’intérupteur, elle doit
; s'éteindre

LIST P=16f84A ; declaration du uC

#include "P16f84.inc"
__config _CP_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC ; configuration du uC
bsf STATUS,RP0 ; bank 1

movlw B'11111101'
movwf TRISB ; pour configurer RB0 en entrée et RB1 en sortie
bcf STATUS,RP0 ; bank 0
test ; etiquette test
btfss PORTB,0 ; sauter si interrupteur ouert, si RB0 = 1
goto off ; sinon aller à off
bsf PORTB,1 ; allumer Led, RB1 = 1
goto test ; aller à test
off ; etiquette off, on vient ici si interrupteur fermé
bcf PORTB,1 ; éteindre Led, RB1= 0
goto test ; aller à test
end ; fin programme
c. Langage C embarqué
Le langage C embarqué respecte les règles du C standard. Mais quelques directives

de configurations et de déclarations viennent s’ajouter en fonction du
microcontrôleur.
Il existe plusieurs compilateurs C pour les PIC. Nous nous servirons de « CCS C
Compileur » qui offre un grand nombre d’avantages à travers les multiples
fonctions et bibliothèques intégrées.
Nous utiliserons un fichier de bibliothèque système externe, le fichier

P16F84_628.C ou P16F876_877.C, fourni avec le cours pour pouvoir accéder
directement aux registres et aux bits spéciaux par leurs noms.
 Opérateurs et types de données
Les opérateurs logiques binaires sont souvent utilisés pour optimiser les codes. Le
tableau suivant résume ces opérateurs.
Opérateurs logiques du C
Rappels : exploitation des opérateurs logiques
 NOT (NON) permet de complémenter un bit ou tous les bits d’un mot binaire ;
 OR (OU) permet de positionner un ou plusieurs bits à 1 ;
 AND (ET) permet de positionner un ou plusieurs bits à 0 ;

 XOR (OU exclusif) permet d’inverser (complémenter) l’état un ou plusieurs

bits.
Tous les autres opérateurs du C standard sont également utilisables : !, &&, ||, %, +, -
, /, ...
Le compilateur exploite les types de donnés listés ci-dessous :
Les types de données de CCS C Compiler
 Exploitation des interruptions avec CCS C
Les déclarations des fonctions d’interruption se font par les directives :
 #int_EXT pour l’interruption RB0 ;

 #int_RB pour l’interruption RB4 à RB7 change ;
 #int_TIMER0 pour l’interruption Timer0 overflow ;
 #int_EEPROM pour l’interruption de fin écriture mémoire EEPROM.
Une fonction d’interruption n’est jamais appelée et ne retourne rien. Les flags
d’interruption sont automatiquement remis à 0 par CCS C.
Exemple : déclaration et implémentation d’une fonction d’interruption Timer0.
#int_timer0 //directive de déclaration

interruption_TMR0() //nom de la fonction (au choix)
{
RA0 = RA0^1; //exemple d’instruction, inverser Led sur RA0
}
 Exemple de programme C
/*Le programme principal fait clignoter une Led sur RA2 lorsqu’on appuie un BP
(Bouton poussoir) connecté sur RB0 et l’interruption TMR0 fait clignoter à 1 Hz une
led sur RA0. Led : anode sur RA2 à travers une résistance de 220 Ω et la cathode à
la masse. BP relié sur RB0 par une borne et l’autre à la masse, l’appui met la masse
sur RB0. Une résistance pull up est connectée entre RB0 et VDD*/

#device PIC16F84 //déclaration du uC

#fuses NOPROTECT, NOWDT, PUT, HS //configuration du uC
//NOPROTECT : pas de protection du code source
//NOWDT : watch dog désactivé
//PUT : power up timer activé
//HS : oscillateur haute fréquence (sup ou égal 4Mhz)
#use delay (clock=4000000) //déclaration fréquence quartz pour les delay : 4 Mhz
//assignations des registres et bits spéciaux si le fichier « P16F84_628.C » n’est pas inclus
#byte PORTA = 0x05
#byte PORTB = 0x06
#byte TRISA = 0x85
#byte TRISB = 0x86
#byte TMR0 = 0x01
#byte INTCON = 0x0B
#byte OPTION_REG = 0x81
#bit GIE = INTCON.7

#bit T0CS = OPTION_REG.5
#bit PSA = OPTION_REG.3
#bit PS2 = OPTION_REG.2
#bit RA2 = PORTA.2
#bit RB0 = PORTB.0
//Déclaration des variables

int16 cpt_ms; //entier 16 bits qui servira de compteur pour les interruptions TMR0
//fonction d'interruption TMR0

//pré-diviseur à 8 et valeur de recharge TMR0 à 131 implique 125 comptages par
//interruption : ce qui donne 8*125 = 1000us = 1ms par interruption
#int_timer0
interruption_TMR0()
{
TMR0 = 131; //pour compter de 131 à 255 càd 125 comptages par interruption
++cpt_ms; //incrémenter cpt_ms
if(cpt_ms==500) //si 500 ms càd 0,5sec
{
cpt_ms = 0; //remettre cpt_ms à 0
RA0 = RA0^1; //inverser Led sur RA0
}
}
//programme principal
void main (void)
{
//initialisation du uC
PORTA = 0; //effacer PORTA
PORTB = 0; //effacer PORTB
TRISA = 0b11111010; //configuration PORTA : RA2 et RA0 en sortie et le reste en entrée
TRISB = 0b11111111; //configuration PORTB : RB0 en entrée et le reste aussi en entrée

//configuration TMR0
T0CS = 0; //TMR0 synchronisé sur F_instructions
PSA = 0; //prédiviseur sur TMR0
PS0 = 0; //valeur du pré-diviseur égale 8
PS1 = 1;
PS2 = 0;
//activation Interruption TMR0
GIE = 1; //activation des interruptions
T0IE = 1; //activer Interruption TMR0
//boucle infinie
while(1)
{
if(RB0 == 0) //si BP appuyé c-à-d RB0 égal 0
{
RA2 = RA2^1; //inverser état led sur RA2
delay_ms(250); //temporisation de 250 ms (fonction fournie par CCS C)
}
}
}
3.3. Création de projet et simulation sur MPLAB

Nous allons réaliser un petit programme pour voir les procédures de
fonctionnement de MPLAB (version 8.60).
 Créez un nouveau dossier, puis le nommez Essai_PIC.
 Lancez le logiciel MPLAB.
 Ouvrez une nouvelle fenêtre (de l'éditeur) en exécutant file  new ou en

cliquant sur l'icône feuille blanche sur la barre d'outils.
 Tapez le petit programme ci-dessous dans la fenêtre qui vient de s'ouvrir. Ce
programme incrémente sans fin la position mémoire (RAM) 0Ch.
cpt equ 0x0C

loop
incf cpt,F
goto looop
end
 Sauvegardez (file  save) ce programme dans le dossier Essai_PIC sous le

nom essai.asm.
 Sur la barre d'outils, exécuter Project  New…
 Sur la petite fenêtre (fenêtre projet) qui apparait, écrivez Essai dans le champs
de texte Project Name, sélectionnez le dossier Essai_PIC dans le champs de
texte Project Directory à l'aide de du bouton Browse et cliquez sur le bouton
OK. Cliquez sur le bouton OK sur la nouvelle fenêtre qui apparaitra.

 Sur la nouvelle petite fenêtre qui apparait, cliquez droit sur Source Files et
prenez l'option Add Files. Sur la fenêtre qui apparaitra, sélectionnez le fichier
essai.asm dans le dossier Essai_PIC et cliquez sur le bouton Ouvrir.
 Sur la fenêtre projet, double cliquez sur essai.asm dans Source Files pour
l'ouvrir.
 Sur la barre d'outils, exécutez Configure  Select Device  PIC16F84 puis

Debugger  Select tool  MPLAB SIM.
 Lancez la compilation du programme à l'aide de la commande Project  Build

All. Apparemment il y a un problème, le compilateur nous signale qu'il y a une
erreur à la ligne 4 : Error[113] ?:\Essai_PIC\essai.asm 4 : Symbol not previously
defined (looop). Evidemment, le label loop défini précédemment prend
seulement deux o. Corrigez et recommencez. Cette fois ça semble aller. On
peut vérifier que le compilateur à crée le fichier essai.hex dans le dossier
Essai_PIC.
Nous pouvons maintenant exécuter notre programme en simulation pour voir s'il
réalise bien la tache demandée :
 Ouvrez la fenêtre qui visualise la mémoire RAM en exécutant View  File

Registers. La case mémoire 0x0C se trouve sur la première ligne (ligne : 0000,
colonne : 0C).
 Exécutez maintenant le programme PAS à PAS en cliquant à chaque fois sur le

bouton Step Into (figure 14) et en observant la case mémoire 0Ch.
 On peut aussi exécuter en continu en cliquant sur le bouton Animate. Pour

arrêter, il faut cliquer sur le bouton Halt.
La figure ci-après illustre les icônes de simulation.
Icônes de simulation
Pour programmer en C :
 Créer un nouveau fichier et le nommer avec l’extension .C
 Aller faire un clic-droit sur « le nom du projet » dans la petite fenêtre du

projet, puis sélectionner « Select Language Toolsuite » :

 Sur la nouvelle fenêtre qui s’ouvre, sélectionner le CCS C Compiler dans

« Active Toolsuite » et indiquer le bon chemin dans « Location » :
 Retourner sur la fenêtre du projet pour ajouter le code source C dans

« Source Files » en faisant clic-droit, puis « Add Files » et sélectionner le
fichier source dans le dossier du projet.
 Double cliquer sur le fichier pour l’ouvrir et commencer à programmer.
4. Présentation de la sous famille PIC16F87x

La sous famille PIC16F87x regroupe les références 873, 876, 874 et 877. Ils
disposent plus de ressources que le PIC16F84. Tout programme destiné au
PIC16F84 peut être adapté pour ces derniers, mais pas le contraire.
Le jeu d’instructions est le même que pour le PIC16F84.
4.1. Brochage
Ci-dessous, les boîtiers PDIP (28 broches pour les 873/876 et 40 broches pour les
874/877) donnent les représentations externes de ces microcontrôleurs.

Brochage PIC16F87x
4.2. Architecture interne

Cette sous-famille dispose :
 Jusqu’à 8 Kmots de flash ;

 Jusqu’à 368 octets de RAM ;
 Jusqu’à 256 octets de EEPROM ;
 Jusqu’à 33 E/S ;
 Trois timers : Timer0 (8bits avec pré-diviseur), Timer1 (16 bits avec pré-
diviseur) et Timer2 (8bits avec pré-diviseur et post-diviseur) ;
 Deux modules CCP (Capture/Compare/PWM) ;
 Un port série synchrone ;
 Un USART (port série synchrone et asynchrone) ;
 Un port parallèle pour les PIC16F877 et 874 ;
 Un CAN (Convertisseur Analogique Numérique) 10 bits avec 8 canaux pour
les PIC16F877 et 874 ;
 Un Watch Dog Timer (WDT) ;
 Une fonction ICD (In-Circuit Debugger).
La figure ci-dessous illustre l’architecture interne des PIC16F877/874.

Architecteur interne PIC16F877/874

4.3. La mémoire RAM et les registres spéciaux

La RAM est subdivisée en quatre Banks (0, 1, 2 et 3). Les combinaisons des bits RP0
et RP1 (du registre STATUS) permettent d’accéder aux banks.
L’espace « utilisateur » réservé aux variables commence aux adresses 20h, A0h,
120h et 1A0h, respectivement dans les bank0, bank1, Bank2, Bank3.
Ci-dessous, la représentation de la RAM du PIC16F877/876.
Organisation de la RAM des PIC16F877/876

Les tableaux suivants résument les registres spéciaux.

Résumé des registres spéciaux

4.4. Exemple de mise en œuvre du PIC16F877

Souvent, avant la phase de production d’un produit, des kits expérimentaux
permettent le développement et le test des programmes. Le schéma suivant
présente le kit expérimental HJ-5G PIC (photo à la page de garde) développé autour
du PIC16F877.
Schéma du kit de développement expérimental HJ-5G PIC pour le PIC16F877

III. MICROCONTRÔLEURS MSP430

Texas Instruments (TI) produits plusieurs types de microcontrôleurs, 8, 16, 32 bits.
Ils ont leur propres architecture pour certains d'entre eux alors que pour d'autres ils
utilisent le core ARM (Advanced Risc Machine). Ci-dessous, un résumé des familles
de processeurs TI.
Résumé des processeurs TI
La famille msp430 est constituée de microcontrôleurs 16 bits avec une architecture

de type Von Neumann, ce qui signifie que les mémoires programme et données sont
unifiées (contrairement à l'architecture Harvard où mémoire programme et mémoire
de données sont sur des bus séparés). La figure suivante illustre l’architecture
commune de la famille MSP430.

Architecture interne MSP430
MAB constitue le bus d’adresses et MDB le bus de données.

L’interface JTAG (Joint Test Action Group) sert au transfert du programme et au
debug.
Un des avantages de l'architecture Von Neumann est que le code peut aussi bien
être exécuté à partir de la mémoire RAM que de la mémoire FLASH. Du code
machine peut donc être créé à la volé et copié en RAM pour être exécuté.
La famille MSP430 présente une consommation d’énergie ultra faible et constitue de

plusieurs dispositifs présentant différents ensembles de périphériques destinés à
diverses applications.
Les figures suivantes illustrent respectivement l’évolution des microcontrôleurs

MSP430 et la signification des références.

Evolution de la famille MSP430
Signification des références
Cette partie sera consacrée à l’initiation à la programmation du MSP430G2553.
1. Le microcontrôleur MSP430G2553
1.1. Présentation
a. Brochage
Le MSP43G2553 appartient au sous-groupe MSP430G2x53 et se présente sous

plusieurs boîtiers. Ci-dessous, la représentation du boîtier PDIP 20 broches.

Brochage du MSP430G2553
Chaque Broche est associée à un ou plusieurs noms qui correspondent à des

fonctions. On identifie trois groupes de broches : les alimentations (DVCC pour 1.8
à 3.6V et DVSS pour la masse), les broches de programmation (RST ̅̅̅̅̅ et TEST) et les
pattes d'entrée-sortie (P1.x et P2.x) qui vont permettre de réaliser l'application
proprement dite.
L’exécution du programme interne est interrompue lorsque la broche RST̅̅̅̅̅ est active
(état 0) et reprend à nouveau depuis le vecteur de reset (début) lorsque RST ̅̅̅̅̅
redevient inactive (état 1). Il est donc nécessaire de rappeler cette broche à VCC
(pull-up) avec une résistance d'environ 47 kΩ. Un condensateur d’environ 100 nF
doit être monté entre les broches d’alimentation (DVCC et DVSS) pour éviter les
reset dus aux parasites à travers l’alimentation. Souvent, il est aussi nécessaire
̅̅̅̅̅ et la masse.
d’utiliser un deuxième condensateur entre RST
Les broches d'entrée-sortie sont librement utilisables pour l'application. Chaque

broche peut être soit une entrée, soit une sortie. Elles sont regroupées en 2 ports :
le port P1 et le port P2. Ces deux ports sont complets car ils comportent chacun 8
E/S : P1.0 à P1.7 et P2.0 à P2.7.
b. Architecture interne
La figure suivante illustre l’architecture interne de sous-famille MSP430G2x53.

Architecture interne
Le Port P3 n’est pas disponible pour le MSP430G2553.

MAB constitue le bus d’adresses et MDB le bus de données.
L’interface JTAG (Joint Test Action Group) sert au transfert du programme.
L’utilisation d’un quartz à travers l’oscillateur est optionnelle car ce microcontrôleur
dispose d’un système d’horloge interne configurable.
c. Principales caractéristiques
Les principales caractéristiques sont :
 Plage de tensions d'alimentation : 1,8 V à 3,6 V

 Consommation ultra faible
 Mode actif : 230 µA à 1 MHz, 2,2 V
 Mode veille : 0,5 µA
 Mode arrêt (rétention RAM) : 0,1 µA
 Cinq modes d'économie d'énergie
 Activation ultrarapide depuis le mode veille en moins de 1 µs
 Technologie RISC 16 bits, durée du cycle d'instruction de 62,5 ns
 Fréquences internes jusqu'à 16 MHz
 Oscillateur interne basse fréquence à très basse consommation
 Quartz 32 kHz
 Source d'horloge numérique externe
 Deux timers 16 bits avec trois registres de capture/comparaison
 Deux Ports E/S 8 bits chacun
 27 instructions de base avec 7 modes d’adressage
 Des registres spéciaux, Spécial Function Registers (SFR)
 16Ko de Flash et 512 octets de RAM
 Un CAN sur 10 bits
 Modules UART, SPI, …

 Watch Dog Timer
d. Plan mémoire et organisation de la mémoire
Les figures suivantes illustrent respectivement le plan mémoire et l’organisation de

la mémoire du MSP430G2553.
Plan mémoire
Organisation de la mémoire
1.2. L’horloge système

La figure suivante illustre l’horloge système du MSP430G2553.

Représentation de l’horloge système
Trois sources sont disponibles avec des diviseurs de fréquence :
 VLOCLK (Very Low‐power CLK) : Interne de ~12kHz ;

 LFXT1CLK (Cristal) : basse fréquence (32KHz) ;
 DCOCLK (Digitally Controlled Oscillator CLK) : Interne calibrée à haute
fréquence (jusqu’à 16 Mhz).
Trois signaux sont utilisables :
 MCLK (Main CLocK) : utilisé comme horloge du CPU et commutable sur toutes
les sources ;
 SMCLK (Sub‐Main CLocK) : utilisé pour les périphériques (disponible même en
mode sleep) ;
 ACLK (Auxiliary CLocK) : utilisé pour certains périphériques en mode basse
consommation.
Après reset par mise sous tension, MCLK et SMCLK sont alimentés par le DCOCLK à
environ 1.1 MHz, et ACLK est alimenté par LFXT1CLK en mode LF (Low Frequency).

Les bits SCG0, SCG1, OSCOFF et CPUOFF du registre STATUS (RS) configurent les
modes d’opération the MSP430 et permettent d’activer ou de désactiver les
horloges.
Les registres DCOCTL, BCSCTL1, BCSCTL2 et BCSCTL3 permettent la configuration

par logiciel des signaux de l’horloge système.
Exemple : configuration du DCO à 1 MHz
CLR.B &DCOCTL ; Select lowest DCOx and MODx settings

MOV.B &CALBC1_1MHZ,&BCSCTL1 ; Set range
MOV.B &CALDCO_1MHZ,&DCOCTL ; Set DCO step + modulation
1.3. Les Ports d’Entrées/Sorties

a. Description
Le MSP430G2553 possède deux ports E/S de 8 bits chacun notés P1 et P2. P1 et P2

sont constitués respectivement des E/S P1.0 à P1.7 et P2.0 à P2.7. Ces E/S peuvent
fonctionner en mode digital ou être associées à des périphériques. Par exemple,
P2.6 et P2.7 peuvent être utilisées pour un quartz externe.
Les E/S sont :
 Individuellement programmables ;
 Individuellement et indépendamment configurables en entrée ou en sortie ;
 Individuellement configurables en interruption ;
 Indépendamment utilisables en registres (P1 et P2) de d’entrée ou de sortie ;
 Individuellement configurables en pull up or pull down sur des résistances
internes ;
 Entrées d’oscillateur sélectionnables.
b. Configuration et exploitation des E/S
Un ensemble de registres SFR (Special Fonction Registers) est associé à chaque port
E/S pour sa configuration et son exploitation.
 PxDIR configure le mode entrée (0) ou sortie (1) de chaque bit du port.
 PxOUT détermine les niveaux de sortie sur les broches en sortie (1 pour Vdd
et 0 pour Vss). Mais lorsque le bit est en mode entrée et que le bit
correspondant dans PxREN est actif, ce registre détermine si la résistance
d'entrée est en pull up (1) ou pull down (0).
 PxIN permet de lire les niveaux des broches en entrée.
 PxREN permet d'activer (1) / désactiver (0) les résistances de rappel sur les
broches.
 PxIE permet d'activer (1) / désactiver (0) les interruptions sur changement
d'état des broches individuellement.
 PxIES détermine si l'interruption doit se produire lors d'une transition
montante (0) ou descendante (1).

 PxIFG indique s'il y a eu une condition d'interruption (1) sur la broche

associée. Le bit doit-être remis à zéro dans la fonction (sous-routine ou sous-
programme) de l’interruption.
 PxSEL et PxSEL2 sélectionnent le périphérique à associer à chaque broche.
Ces bits à 00 configurent la broche associée en E/S digitale.
x désigne le numéro du port. Tous ces registres sont de la largeur du port, car
chaque bit de ces registres est en correspondance avec le bit du port à la même
position. Pour un port 8 bits, ils ont 8 bits.
Le tableau suivant résume les registres associés à chaque port.
Registres associés aux ports
Comme exemple, la figure suivante illustre la configuration matérielle des broches

P1.0 et P1.2 du port 1 en fonction des registres associés.

Configuration matérielle de P1.0 et P1.2

1.4. Le CPU (Central Processing Unit)

Le CPU est constitué de l’UAL et de 16 registres spécifiques. La figure ci-dessous
illustre l’organisation du CPU.
Organisation du CPU
Il permet :
 des opérations sur les registres SFR en un cycle d’horloge ;

 un bus d'adresses de 16 bits pour un accès direct sur toute la plage de
mémoire ;
 un bus de données de 16 bits permettant la manipulation directe des
données ;
 le transfert direct de mémoire-à-mémoire sans utilisation de registres
intermédiaires ;
 un format d’instruction sur un byte (8 bits) ou un mot (word) de 16 bits.

Les registres spécifiques ont une largeur de 16 bits :
 le registre R0 est dédié au compteur de programme (PC) ;

 le registre R1 contient le pointeur de pile (SP pour Stack Pointer) ;
 le registre R2 contient entre autre le registre d’état (SR pour Status Register),
 les registres R2 et R3 sont des générateurs de constantes, fournissant six
valeurs immédiates (les plus utilisées) pour l’exécution des instructions ;
 les registres R4 à R15 sont à usage général à la disposition du programmeur.
L’UAL a une largeur de 16 bits. Elle permet d’effectuer des calculs arithmétiques
(additions, soustraction, comparaison) et des opérations logiques (AND, OR, XOR).
Des indicateurs permettent de caractériser les résultats :

 résultat nul ;
 résultat négatif ;
 dépassement de capacité ;
 retenue pour les calculs.
a. Compteur de programme (PC)
Le compteur de programme de 16 bits (PC/R0) indique la prochaine instruction à

exécuter. Chaque instruction emploie un nombre pair de bytes (deux, quatre, six ou
huit), le PC est incrémenté en conséquence. Le PC est donc aligné sur des adresses
paires. Les instructions d’accès à l'espace mémoire (jusqu’à 32 KB) sont effectuées
sur des mots (16 bits).
Le PC peut être adressé par toutes les instructions et de tous les modes d'adressage.
Exemples :
 MOV.W #LABEL,PC ; Branchement à l’adresse LABEL
 MOV.W LABEL,PC ; Branchement à l’adresse contenue dans LABEL
 MOV @R4,PC ; Branchement indirect à l’adresse continue R4
 ADD #4,PC ; Saut de deux mots (4 positions mémoire)
b. Pointeur de pile (SP)
Le pointeur de pile de 16 bits (SP/R1) est employé par le CPU pour stocker les
adresses de retour des appels de sous-routines (sous-programmes) et des routines
(programmes) interruptions. Il emploie une pré-décrémentation et une post-
incrémentation. Le pointeur de pile peut être employé pour toutes les instructions et
modes d'adressage. Le pointeur de pile est initialisé dans la RAM par l'utilisateur, et
il est aligné sur des adresses paires.
Exemple :
 MOV 2(SP),R6 ; [SP]+2 −> R6 (R6 prend le contenu de SP + 2)
 MOV R7,0(SP) ; R7 −> [SP]+0 (SP prend le contenu de R7)
 PUSH #0123h ; 0123h −> [SP] (SP prend 0123h)
 POP R8 ; [SP] −> R8 (= 0123h) (R8 prend le contenu de SP)

c. Registre d’état (SR)
 V : Indicateur de dépassement. Ce bit est mis à 1 lors d’un dépassement sur

d’une opération arithmétique entre nombres considérés comme signés.
 N : Indicateur de nombre négatif. Ce bit est mis à 1 lorsque le résultat d’une
opération arithmétique est négatif (bit de signe égal à 1).
 Z : Indicateur de nombre nul. Ce bit est mis à 1 lorsque le résultat d’une
opération arithmétique est nul.
 C : Indicateur de report. Ce bit est mis à 1 lorsque le résultat d’une opération
arithmétique provoque un report.
 SCG1 (System Clock Generator 1) : Ce bit, lorsqu’il est mis à 1 provoque

l’arrêt de SMCLK.
 SCG0 (System Clock Generator 0) : Ce bit, lorsqu’il est mis à 1 provoque
l’arrêt du DC0 si DCOCLK n’est pas utilisé comme Master Clock (MCLK).
 OSCOFF (Oscillator Off) : Ce bit, lorsqu’il est mis à 1 provoque l’arrêt de
l’oscillateur à quartz LFXT1 si ce dernier n’est pas utilisé comme MCLK ou
SMCLK.
 CPUOFF (CPU Off) : Ce bit est mis à 1 pour arrêter du CPU.
 GIE (General Interrupt Enable) : Activation (1) / désactivation (0) générale des
interruptions.
d. Registres CG1 et CG2
Six constantes spécifiques sont produites avec les registres générateurs de

constantes R2 (CG1) et R3 (CG2), sans exiger un mot de 16 bits supplémentaire
pour coder l’instruction.
Génération de constantes
As représente deux bits indiquant le mode d’adressage de l’opérande « source ».
Les avantages des registres générateurs de constantes sont : aucune instruction

spéciale requise, aucun mot de code additionnel pour les six constantes et aucun
accès mémoire requis pour rechercher la constante. L'assembleur utilise

automatiquement les registres générateurs de constantes si une des six constantes

prédéfinies est employée comme opérande immédiat de source. Les registres R2 et
R3, utilisés comme générateurs de constantes, ne peuvent pas être adressés
explicitement ; ils agissent en tant que registres « source ».
L'ensemble du MSP430 comprend seulement 27 instructions. Cependant, les

registres générateurs de constantes permettent au MSP430 d’avoir 24 instructions
additionnelles émulées (dérivées).
Par exemple :
L'instruction à un seul opérande CLR dst est émulée par l'instruction à deux
opérandes MOV R3,dst ;
L’instruction CLR R5 est donne MOV #0,R5 où #0 est remplacé par l’assembleur en
utilisant R3 avec As=00 ;
L’instruction INC dst donne ADD R3,dst d’où INC R5 est remplacé par ADD #1,R5.
e. Registres à usage général R4 à R15
Les douze registres R4 à R15 du CPU peuvent être utilisés sur des largeurs de 8 bits
(suffixe .B) ou 16 bits (suffixe .W). L’écriture d’un byte force la mise à 0 des bits
[15…8].
1.5. Le Jeu d’instructions et les modes d’adressage

Le jeu d’instructions est constitué de 27 instructions de base et de 24 instructions
émulées.
Certaines instructions peuvent s’effectuer, au choix, sur des données d’un octet
avec l’indication .B (pour Byte) ou sur des données de deux octets avec l’indication
.W (pour Word).
a. Les instructions de base
Trois formats sont disponibles.
 Instructions à deux opérandes (dual-operand) :

 Instructions à un opérande (Single-operand) :
 Instructions de saut (Jump) :

Exemples d’exploitation de quelques instructions :
 bic.b #BIT3,P1DIR
Force à 0 le bit 3 de P1DIR pour configurer P1.3 en entrée.
BIT3 égal « 00001000b » qui vise le bit 3 de la «destination » c’est-à-dire
P1DIR et le force à 0 par l’opération NOT(00001000b) AND P1DIR, et le
résultat dans P1DIR.
bis.b #BIT3,P1REN ; force bit 3 de P1REN à 1 pour activer la résistance.

de rappel
bis.b #BIT3,P1OUT ; force bit 3 de P1OUT à 1, pour un pull up sur P1.3.
 bis.b #(BIT6+BIT0),P1DIR
Force à 1 les bits 6 et 0 de P1DIR pour configurer P1.6 et P1.0 en sortie.
(BIT6+BIT0) donne (01000000b+00000001b) = « 01000001b » qui vise les
bits 6 et 0 de P1DIR pour les forcer à 1 par l’opération (01000001b) OR
P1DIR, et le résultat dans P1DIR.
L’opérateur « + » peut être remplacé par l’opérateur « | », OU logique.
 bis.b #BIT6,P1OUT ; force P1.6 à 1 si elle est configurée en sortie.
 bic.b #BIT6,P1OUT ; force P1.6 à 0 si elle est configurée en sortie.
 xor.b #BIT0,P1OUT ; inverse l’état de P1.0 si elle configurée en sortie.
 bit.b #BIT3,P1IN ; test de P1.3 en entrée.

Effectue l’opération (00001000b) AND P1IN.
Le résultat sera égal à 0 si P1.3 est au niveau bas, et différent de 0 si P1.3 est
au niveau haut.
 jnz label ; sauter à l’adresse « label » si le flag Z = 0.
 jz label ; sauter à l’adresse « label » si le flag Z = 1.
 jmp label ; sauter à l’adresse « label » sans condition.
 test_BP
bit.b #BIT3,P1IN ; tester de P1.3 en entrée et en pull up.
jnz test_BP ; sauter à « test_BP » si le P1.3 est au niveau haut.
xor.b #BIT0,P1OUT ; sinon, continuer ici (si P1.3 est au niveau bas).

b. Les instructions émulées
Ce sont des instructions dérivées des instructions de base.
c. Les modes d’adressage
La famille MSP430 possède sept modes d'adressage pour les opérandes de source et
quatre modes d'adressage pour les opérandes de destination qui permettent
d’adresser la totalité l'espace mémoire.
Ces modes d’adressage sont valables aussi bien sur les instructions de chargement
(MOV) que sur des opérations logiques et arithmétiques (ADD, SUB, AND, BIS, …).
Au niveau du code opératoire (code de l’instruction) :
 As : deux bits indiquent le mode d’adressage pour l’opérande de source ;

 Ad : un bit indique le mode d’adressage pour l’opérande de destination.

Le tableau suivant résume les modes d’adressage.
Résumé des modes d’adressage
Exemples :
MOV.W #45,R5 ; (immédiat pour Source et registre pour Destination)

; mettre la valeur 45 dans R5
ADD.B R12,&0204h ; (registre pour Source et absolu pour Destination)
;’l’adresse 0204h prend son contenu + celui de R12
Le tableau ci-dessous résume les formats des instructions et les syntaxes des modes
d’adressage.

Les formats des instructions et les modes d’adressage
La figure suivante illustre le codage d’une instruction à deux opérandes.
Exemple de codage d’une instruction à deux opérandes
1.6. Les timers

Les Timers permettent d’effectuer des temporisations avec une extrême précision
comparativement aux temporisations par logiciel (combinaison des instructions en
boucle). (Voir annexes pour le nombre de cycles des instructions)
Ils sont configurables (choix de l’horloge, diviseur programmable, …), disposent des
possibilités d’interruption (activation d’un flag au débordement) et servent à
certains modules comme le Capture/Compare pour des fonctions PWM (Pulse Wide
Modulation) par exemple.
Le MSP430G2553 possède deux timers de 16 bits chacun, Timer_A (registre TAR) et

Timer_B (registre TBR). La figure suivante illustre le diagramme fonctionnel du
Timer_A.

Diagramme fonctionnel du Timer_A
2. Programmation
Il existe plusieurs environnements de développement intégrés (IDE) qui supportent
les MSP430 : IAR Embedded Workbench, CCS (Code Composer Studio), MSPGCC, ...
Texas instruments fourni CCS, gratuitement avec une limitation de 16Ko de

programme flash, qui sera retenu pour le développement de nos programmes en
assembleur et C.
Le kit de développement expérimental msp430 launchpad, représenté ci-dessous,

sera utilisé pour le test des programmes.

LaunchPad MSP-EXP430G2553
Rappels : exploitation des opérateurs logiques
 NOT (NON) permet de complémenter un bit ou tous les bits d’un mot binaire.
 OR (OU) permet de positionner un ou plusieurs bits à 1.
 AND (ET) permet de positionner un ou plusieurs bits à 0.
 XOR (OU exclusif) permet d’inverser (complémenter) l’état un ou plusieurs
bits.
2.1. Langage Assembleur

a. Les directives
 Directives de déclaration de section
 Directives du linker

 Directives d’initialisation de données (RAM et Programme)
 Directives du listing

 Directives de référence d’autres fichiers
 Directives d’affectation de symboles de linkage et de visibilité
 Directives de codes inter langage et de fin de code
 Directives de macro
b. Exemple de programme assembleur
Le programme suivant fait clignoter à 1 Hz une Led connectée sur P1.6 lorsqu’un
bouton poussoir (BP) relié à P1.3 est appuyé (tiré à la masse).
P1.3 doit donc être configurée en entrée et sa résistance pull up activée. P1.6 sera
configurée en sortie.
 Créer un dossier où le projet sera enregistré.

 Lancer l’application CCS.
 Sur le menu, aller à « file », « New » et cliquer sur « Projet ».
 Dans la nouvelle fenêtre qui s’ouvre, dérouler « Code Composer Studio »,
sélectionner « CCS Project » et cliquer sur « Next ».

 La fenêtre suivante s’ouvre alors :
 donner un nom au projet dans le champ « project name »

 choisir le composant : « MSP430G2553 »
 Sélectionner le Dossier du projet dans « Location »
 Choisir le modèle de fichier dans « project templates and examples » :
« empty assembly-only project »
 cliquer sur le bouton « Finish ».
On obtient alors un code de base à compléter en fonction de l’application.
Sur la barre d’outils, utiliser les icônes suivantes pour compiler et tester le
programme :

;-------------------------------------------------------------------------------
; MSP430 Assembler Code Template for use with TI Code Composer Studio
; MCK à environ 1 Mhz
; un cycle d’instruction égal environ 1 microseconde
;-------------------------------------------------------------------------------
.cdecls C,LIST,"msp430.h" ; Include device header file
;-------------------------------------------------------------------------------
.text ; Assemble into program memory
.retain ; Override ELF conditional linking
; and retain current section
.retainrefs ; Additionally retain any sections
; that have references to current section
;-------------------------------------------------------------------------------
RESET mov.w #__STACK_END, SP ; Initialize stack pointer
StopWDT mov.w #WDTPW | WDTHOLD,&WDTCTL ; Stop watchdog timer
clr.b &DCOCTL ; DCOCTL = 0

mov.b &CALBC1_1MHZ,&BCSCTL1 ; MCLK à 1 MHz
mov.b &CALDCO_1MHZ,&DCOCTL ; MCLK à 1 MHz
;-------------------------------------------------------------------------------
; Main loop here
;-------------------------------------------------------------------------------
main mov.b #01000000b,P1DIR ; bits P1.3 en entrée et P1.6 en sortie

bis.b #BIT3,P1REN ; active résistance sur P1.3
bis.b #BIT3,P1OUT ; résistance pull up sur P1.3
bic.b #BIT6,P1OUT ; P1.6 prend 0, Led éteinte
test_BP bit #BIT3,P1IN ; tester si BP appuyé, si résultat égal 0

jnz test_BP ; sinon aller à test_BP
xor.b #BIT6,P1OUT ; inverse P1.6 (Led)
mov.w #2,R5 ; pour faire 2 fois la boucle de 250msec
; soit 2*250msec = 500msec
call #tempo ; appelle le sous-programme tempo pour attendre
; environ 500 msec
jmp test_BP
tempo mov.w #62500,R4 ; R4 prend 62500 et sera utilisé comme compteur

; pour exécuter « boucle » 62500 fois
boucle nop ; pas d’opération, perdre 1us x 62500
sub.w #1,R4 ; --R4, perdre 1us x 62500
jnz boucle ; aller à boucle tant que R4 est différent de 0
; perdre 2us x 62500
mov.w #62500,R4 ; R4 prend 62500 et sera utilisé comme compteur
; pour exécuter « boucle » 62500 fois si R5 > à 1
; à ce niveau, on a perdu 4us x 62500 = 250 ms
sub,w #1,R5
jnz boucle ; aller à boucle tant que R4 est différent de 0
; boucle est exécutée autant de fois que la
; valeur passée dans R5 : R5 x 250 ms
ret ; retourner du sous-programme, fin tempo

;-------------------------------------------------------------------------------
; Stack Pointer definition
;-------------------------------------------------------------------------------
.global __STACK_END
.sect .stack
;-------------------------------------------------------------------------------
; Interrupt Vectors
;-------------------------------------------------------------------------------
.sect ".reset" ; MSP430 RESET Vector
.short RESET
.end ; fin du programme
2.2. Langage C
Le langage C embarqué respecte les règles du C standard. Mais quelques directives
de configurations et de déclarations viennent s’ajouter en fonction du
microcontrôleur.
Les opérateurs logiques binaires sont souvent utilisés pour optimiser les codes. Le
tableau suivant résume ces opérateurs.
Tous les autres opérateurs du C standard sont également utilisables : !, &&, ||, %, +, -
, =, /, etc. (voir annexes pour tous les opérateurs)
a. Exemple de programme C
Reprenons le programme précédent, qui fait clignoter à 1 Hz une Led connectée sur
P1.6 lorsqu’un bouton poussoir (BP) relié à P1.3 est appuyé (tiré à la masse), en C.
Pour la création du projet C, répéter les étapes du paragraphe b de 2.1 jusqu’à la

dernière fenêtre où il faut choisir le modèle de fichier « Empty Project (with
main.C) » dans « project templates and examples » avant de cliquer sur « Finish ».

On obtient alors un code de base à compléter en fonction de l’application.
_delay_cycles(x) est une fonction qui compte le nombre de cycles CPU passé en
argument (x). Elle est fournie directement par CCS. Comme après un RESET le MCLK
(Master CLK) fonctionne à environ 1Mhz, 500000 cycles donnent 500 millisecondes.
Si on configure le DCO (Digitally Controlled Oscillator) qui alimente MCLK pour une
autre fréquence, il faut ajuster l'argument en conséquence.
// MCLK également environ 1 Mhz, donc un cycle d’instruction égal environ 1 microseconde
#include <msp430g2553.h>
#include <stdio.h>
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // désactivation du watchdog timer
P1DIR |= BIT6; // mise à 1 pour P1.6 en sortie pour la Led

P1OUT &= ~BIT6; // mise à 0 de P1.6 pour éteindre Led
P1DIR &= ~BIT3; // mise à 0 pour P1.3 en entrée
P1OUT |= BIT3; // 1 sur P1OUT.3 active la résistance pull up
P1REN |= BIT3; // mise à 1 pour activer la résistance pull up sur P1.3
while (1) // boucle infinie

{
if(!(P1IN & BIT3)) // si BP appuyé, P1.3 = 0, alors
{
P1OUT ^= BIT6; // inverser P1.6 c-à-d l’état de la Led
_delay_cycles(500000); // temporisation de 500 ms environ
}
}
}

b. Exploitation des interruptions
Les déclarations des fonctions d’interruption se font par les directives :
 #pragma vector=PORT1_VECTOR
__interrupt void nom (void) //pour les interruptions du Port1
 #pragma vector=PORT2_VECTOR
__interrupt void nom (void) //pour les interruptions du Port2
 #pragma vector=TIMER0_A1_VECTOR
__interrupt void nom (void) //pour l’interruption TimerA overflow
 etc.
Le nom est au choix. Chaque source d’interruption doit être correctement

configurée et activée pour permettre son exploitation.
L’instruction « _BIS_SR(GIE) ; » permet l’activation générale de toutes les

interruptions. La désactivation se fait par « _BIC_SR(GIE) ; ».
Une fonction d’interruption n’est jamais appelée et ne retourne rien. Les flags
d’interruption des ports doivent être remis à 0 dans la fonction d’interruption.
Exemple : programme avec une fonction d’interruption sur P1.3 configurée en

entrée et en pull up. Chaque appui du bouton poussoir sur P1.3 inverse l’état une
Led connectée sur P1.0 configurée en sortie.
#include <msp430.h
#pragma vector=PORT1_VECTOR // déclaration du vecteur d’interruption Port1

__interrupt void P1_3_int (void) // interruption sur P1.3
{
_delay_cycles(50000); // temporisation de 50 msec, anti rebonds
while(!(P1IN & BIT3)); // attendre le relâchement du BP
_delay_cycles(50000); // temporisation de 50 msec, anti rebonds
P1OUT ^= BIT0; // inverser P1.0 c-à-d l’état de la Led
P1IFG &= ~BIT3; // effacer le flag d’interruption P1.3
}
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // désactivation du watchdog timer
P1DIR |= BIT0; // mise à 1 pour P1.0 en sortie, pour la Led
P1OUT |= BIT0; // mise à 1 de P1.0 pour allumer la Led
P1DIR &= ~BIT3; // mise à 0 pour P1.3 en entrée
P1OUT |= BIT3; // 1 sur P1OUT.3 active la résistance pull up
P1REN |= BIT3; // mise à 1 pour activer la résistance pull up sur P1.3
P1IE |= BIT3; // mise à 1 pour activer l’interruption P1.3
P1IES |= BIT3; // mise à 1 pour interruption sur front descendant
P1IFG &= ~BIT3; // effacer le flag d’interruption P1.3
_BIS_SR(GIE); // activer les interruptions
while (1) ; // boucle infinie, la fonction principale ne fait plus rien
}

ANNEXES
Nombre de cycles et longueur des instructions


Opérateurs du langage C
 Affectation et arithmétique
 Comparaison :
 Logique de comparaison :

 Logique binaire
BIBLIOGRAPHIE ET WEBOGRAPHIE
 PIC16F8X, document DS30430C,
http://ww1.microchip.com/downloads/en/devicedoc/30430c.pdf
 Programmation des PIC, Première partie-PIC16F84, par BIGONOFF,

http://www.abcelectronique.com/bigonoff/loadpart1.php?par=781a5
 ELECTRONIQUE PRATIQUE N° 289 - Décembre 2004, TRANSOCEANIC
 MSP430x2xx Family User's Guide
 MSP430 Assembly Language Tools v19.6.0.STS User's Guide

Igsit - Automatisme - Microcontrôleurs

Transféré par

Droits d'auteur :

Formats disponibles

Igsit - Automatisme - Microcontrôleurs

Transféré par

Informations du document

Titre original

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

Igsit - Automatisme - Microcontrôleurs

Transféré par

Droits d'auteur :

Formats disponibles

EPO

Table des matières

NIKIEMA Daniel Page 2/77

Un microcontrôleur de configuration minimale contient :

Les microcontrôleurs plus évolués peuvent contenir en plus de ces éléments

Ce document se limitera à une initiation à la programmation des microcontrôleurs

NIKIEMA Daniel Page 3/77

II. MICROCONTRÔLEURS PIC

Evolution des familles PIC

L’étude se portera particulièrement sur le PIC16F84 de la sous-famille PIC16. On

Pour identifier un microcontrôleur PIC, on utilise simplement son numéro :

Donc, un PIC16F84-10 est un PIC Mid-Range donc la mémoire programme est de

NIKIEMA Daniel Page 4/77

Le PIC16F84 est commercialisé dans un boîtier classique 18 broches.

Pour fonctionner, il faut :

 Une alimentation de 2 à 6V (niveau haut sur VDD et la masse sur Vss).

Le schéma suivant illustre une mise en œuvre du PIC16F84.

NIKIEMA Daniel Page 5/77

Le PIC16F84 est un microcontrôleur 8 bits dont l'architecture interne, de type

Architecture interne du PIC16F84

Les principales caractéristiques du PIC16F84 sont :

NIKIEMA Daniel Page 6/77

 15 registres de control appelés SFR (Special Function Registers) ;

1.2. La mémoire programme (flash)

1.3. La mémoire RAM

NIKIEMA Daniel Page 7/77

 Les registres SFR (Special Function Registers) sont les registres de

 Les registres GPR (General Propose

La mémoire RAM est organisée en deux

Pour la mémoire utilisateur, l'utilisation

STATUS : IRP RP1 RP0 TO PD Z DC C

Bits du registre STATUS

Principe de sélection des Banks :

RP1 RP0 Bank sélectionnée

Le tableau suivant donne une représentation détaillée de tous les SFR.

NIKIEMA Daniel Page 8/77

Registres SFR (Special Function Registers)

1.4. L'ALU et le registre W

1.5. Les ports d'entrées/sorties

 Bit i de TRISA = 0  bit i de PORTA configuré en sortie ; 

NIKIEMA Daniel Page 9/77

 T0CS = 0  RA4 est une E/S normale ;

Bits du registre OPTION_REG

RA4 est une E/S à drain ouvert, si on veut l'utiliser comme

b. Le port d'entrées/sorties PORTB

 Bit i de TRISB = 0  bit i de PORTB configuré en sortie ; 

 RBPU = 1 : résistances de rappel du PORTB déconnectées ;

NIKIEMA Daniel Page 10/77

Avec l'oscillateur à Quartz représenté

Les valeurs de C1 et C2 dépendent de

Avec l'oscillateur RC, figure ci-contre, la

Quel que soit l'oscillateur utilisé,

Avec un quartz de 4 MHz, on obtient une horloge instruction de 1 MHz. Ce qui

1.7. Le Timer TMR0

NIKIEMA Daniel Page 11/77

Le PIC16F84 ne possède qu’un seul timer nommé TMR0.

C’est un compteur 8 bits ayant les caractéristiques suivantes :

 T0CS = 0  RA4 est une E/S normale ;

 T0SE = 0  incrémentation sur fronts montants ;