Professional Documents
Culture Documents
PARTIE 1
Noxyben
2007
-1-
Introduction ................................................................................................................................ 3
Intérêt de la programmation en langage C ................................................................................. 4
Choix du compilateur ................................................................................................................. 5
Choix d’un PIC : le 16F877 ....................................................................................................... 6
Choix du programmateur ........................................................................................................... 7
Structure du PIC 16F877............................................................................................................ 8
Le cœur du PIC : le microprocesseur ..................................................................................... 9
La mémoire .......................................................................................................................... 11
La Pile et le Compteur Programme ...................................................................................... 13
Les Ports d’Entrées/Sorties généraux : PORTA, PORTB, PORTC, PORTD, PORTE....... 15
Le Port Parallèle Esclave (PSP : Parallel Slave Port) .......................................................... 17
Le circuit de génération d’horloge ....................................................................................... 18
Le TIMER0 .......................................................................................................................... 19
Le TIMER1 .......................................................................................................................... 20
Le TIMER2 .......................................................................................................................... 22
Les modules CCP1 et CCP2................................................................................................. 23
Le convertisseur Analogique – Digital 10bits :.................................................................... 25
L’USART ............................................................................................................................. 27
Le SSP, Synchronous Serial Port ......................................................................................... 29
La logique de RESET........................................................................................................... 31
L’In-Circuit Debugger.......................................................................................................... 33
Low-Voltage Programming et ICSP (In-Circuit Serial Programming) ............................... 34
Les Bits de Configuration .................................................................................................... 36
Les Interruptions .................................................................................................................. 36
Le mode SLEEP ................................................................................................................... 37
Brochage du PIC16F877 .......................................................................................................... 38
Conclusion................................................................................................................................ 38
-2-
Introduction
Dans un passé pas très lointain, l’électronique pour les amateurs (éclairés) se
résumait essentiellement aux circuits analogiques et éventuellement en logique
câblée (portes logiques, compteurs, registres à décalage…). L’usage des
microprocesseurs était plutôt réservé à un public averti d’ingénieurs sachant les
interfacer avec différents circuits périphériques (eprom, ram…) et programmer en
assembleur.
Au fil du temps on a vu apparaître de nouveaux circuits regroupant dans une seule
puce le microprocesseur et ses circuits périphériques : les microcontrôleurs.
On en trouve maintenant partout : automobile, lave-vaisselle, rasoir, brosse à dent
électrique…
L’offre en microcontrôleurs s’est développée d’autant : plus de périphériques
intégrés, capacité de calcul accrue, plus de mémoire embarquée. Il y a maintenant
de nombreux fabricants de microcontrôleurs, possédant chacun plusieurs gammes
allant du circuit « généraliste », véritable couteau suisse électronique, à la puce
spécialisée dédiée par exemple, à la régulation de vitesse d’un moteur de ventilateur.
La voie royale pour tirer le maximum des performances de ces circuits est toujours la
programmation en assembleur. On accède alors au moindre bit enfoui dans
n’importe quel registre du circuit. Cela nécessite néanmoins un investissement en
temps conséquent, l’assembleur n’étant pas un langage très « naturel ». De plus,
d’un constructeur à l’autre, voire d’un circuit à l’autre dans la même gamme, il existe
des différences qui obligent à réapprendre tout ou partie du langage lorsque l’on
change de microcontrôleur. C’est un investissement intéressant pour un
professionnel qui cherche à produire un code optimisé sur la puce la moins chère
possible, mais pénible pour un amateur qui ne dispose que de relativement peu de
temps pris sur ses loisirs.
Heureusement, avec la montée en puissance des microcontrôleurs, on voit
apparaître actuellement des compilateurs en langage C (voire même C++) qui
permettent de gagner un temps considérable pour le développement et le débogage
des programmes.
Pour tous ceux qui se sont retrouvé largué sur le bord du chemin à cause de ces
de microcontrôleurs, c’est à mon avis une formidable opportunité de
sauter dans le train de l’électronique numérique et d’apprivoiser ces étranges petites
bêtes. Et pourquoi pas un ampli à tubes piloté par microcontrôleur ? Les capacités
étonnantes de ces circuits vous ouvrent un espace de créativité infini. Ce serait
vraiment dommage de se passer de leurs services…
Une fois la décision prise « je vais me lancer dans les micros ! » se pose la question
du comment. On trouve sur internet toutes les informations nécessaires, la difficulté
serait plutôt de les trier. Vous pouvez commencer par exemple par lire la
documentation de Microchip sur la gamme de PIC « mid-range », c’est une
excellente idée, mais ça va vous prendre du temps (plus de 800 pages !)
Dans le but de vous simplifier la tâche, je vais essayer dans le présent ouvrage de
synthétiser quelque peu ces informations. Et pour éviter la frustration du « je saurais
utiliser un microcontrôleur PIC, mais avant je dois me taper un bouquin de 1000
pages » je vais tâcher d’utiliser une approche progressive permettant de, très
rapidement, créer de véritables petits circuits.
-3-
Intérêt de la programmation en langage C
Tout d’abord, les inconvénients : Un compilateur C produit du code plus volumineux
et moins performant que ce que sait faire un bon programmeur en assembleur. De
plus, selon le compilateur employé, on n’accède plus difficilement, voire pas du tout à
certaines ressources de bas niveau. Et n’ayant plus besoin de plonger les mains
dans le cambouis, on risque également de moins approfondir l’étude du
microcontrôleur utilisé. Un dernier point : les compilateurs C sont souvent payants.
En contrepartie, il y a de sacrés avantages : connaître la programmation en C permet
de créer des programmes sur de multiples plateformes, à commencer par les PC.
Autrement dit, les connaissances utilisées sont en grande partie réutilisables. Le C
est un langage de « haut niveau », comparé à l’assembleur, qui permet d’écrire des
programmes nettement plus intelligibles et donc plus faciles à relire et corriger ou
modifier. Le compilateur contrôle la cohérence du code au moment de la compilation
et signale bon nombre d’erreurs, qui seront autant de bogues en moins à corriger. Le
compilateur prend en charge la gestion d’un certain nombre de mécanismes
fastidieux : par exemple, pas besoin de spécifier la page mémoire dans laquelle on
veut écrire, le compilateur s’en charge ! De plus, certains compilateurs permettent
tout de même d’accéder à des ressources de bas niveau, voir même d’insérer dans
le code des portions d’assembleur. A vrai dire, à moins d’être un « pro » de
l’assembleur, vous pourrez certainement créer avec un bon compilateur C un code
plus propre et plus robuste, en nettement moins de temps. Et, cerise sur le gâteau, le
portage d’un de vos programmes sur un nouveau microcontrôleur sera nettement
simplifié.
Pour bien fixer les idées sur la différence de niveau de langage entre assembleur et
C, je vais donner un exemple. Soit à décrire une action simple : ouvrir la fenêtre de la
pièce dans laquelle vous êtes actuellement.
En assembleur ça donnerait :
- soulever pied droit
- avancer pied droit
- poser pied droit
- soulever pied gauche
- avancer pied gauche
- poser pied gauche
- soulever pied droit
- avancer pied droit
- ….
- Sélectionner bras gauche
- Soulever bras
- Avancer bras
- Prendre poignée fenêtre dans main gauche
- Tourner poignée de -90°
- Tirer poignée
- Etc.…
En C ce serait plutôt :
- Ouvrir la fenêtre
http://www.sourceboost.com
-5-
Choix d’un PIC : le 16F877
Pour apprendre, la meilleurs solution est de se faire la main sur du concret. On va
donc étudier un vrai microcontrôleur, sachant que ce qui aura été vu sera assez
facilement transposable à d’autres PIC. Le 16F877 est un PIC de la série « Mid-
range » qui se prête particulièrement bien à la programmation en C. Les PIC de la
série inférieure sont un peu justes en performance et en capacité mémoire pour
accueillir un programme issu d’un compilateur C ; mieux vaut les programmer en
assembleur. Les gammes supérieures (16 ou 32 bits) supportent sans problème la
programmation en C, mais comme se sont des circuits plus complexes (et plus
chers), commençons par quelque chose de plus simple et de plus didactique. Le
16F877 (F comme « Flash ») convient parfaitement : mémoire programme de taille
suffisante (8K), nombreux périphériques intégrés, fréquence de fonctionnement
jusqu’à 20 MHz. Tout ce qu’il faut pour créer des applications sympa en s’amusant !
-6-
Choix du programmateur
Une fois le programme créé, il faudra le transférer dans la mémoire programme du
PIC. Pour cela, il existe plusieurs solutions :
Vous pouvez construire votre propre programmateur. De nombreuses variantes
existent, il suffit de faire une recherche sur le net pour s’en rendre compte. Ces
programmateurs se raccordent sur un port série RS232 ou parallèle. A vrai dire la
majorité des circuits ont un air de famille. Pas sûr néanmoins que tous fonctionnent.
Si vous vous engagez dans cette voie, un des « design » les plus rigoureux est
certainement celui proposé par Microchip dans une de ses « Application Note » (à
voir sur le site de Microchip).
Vous pouvez aussi acheter un programmateur tout fait, en état de marche. Il en
existe pour port série, parallèle et, USB ! Sachant que les ports série RS232 et
parallèle tendent à disparaître au profit de l’USB, cette dernière option, bien que
souvent un peu plus onéreuse semble être un bon choix. Il existe en outre des outils
permettant à la fois de programmer le microcontrôleur, mais aussi de le déboguer en
temps réel et tout ça avec le microcontrôleur en place dans son circuit d’application
(voir les outils proposés par Microchip à ce sujet).
Enfin, il y a la solution du programmateur en kit. Après m’être lancé dans un premier
temps dans la réalisation d’un programmateur « home made » (décrit dans un livre
fort onéreux) qui n’a jamais daigné fonctionner, je me suis tourné vers cette dernière
solution : Un programmateur en kit Velleman K8076 pour une quarantaine d’euros
(c'est-à-dire moins cher que le prix des composants de celui que j’ai vainement tenté
de réaliser moi-même), équipé d’un support ZIF (Zéro Insertion Force). Il permet en
outre la programmation « in-circuit », et est livré avec un logiciel de transfert
compatible avec l’essentiel de la gamme des PIC. Des mises à jour étant disponibles
sur le site de Velleman pour les circuits les plus récents. Il faut procéder au montage
soi-même, mais ça marche du premier coup ! (du moins si vous êtes rigoureux au
moment du montage). Le seul inconvénient : il s’agit ici d’un programmateur à
raccorder sur port RS232, donc impossible à raccorder sur un pc portable récent. Un
jour ou l’autre il faudra bien passer par l’USB…
http://www.velleman.be
-7-
Structure du PIC 16F877
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
-8-
Le cœur du PIC : le microprocesseur
Un microcontrôleur, c’est avant tout un microprocesseur, une unité de traitement
logique qui effectue l’une après l’autre les opérations contenues dans un
microprogramme stocké en mémoire (la mémoire FLASH). On peut le voir sur le
schéma (en jaune ci-dessous), il est essentiellement composé de l’ « ALU » (Unité
Arithmétique et Logique) qui effectue les opérations sur les donnés, le registre de
travail « W reg. », le multiplexeur « MUX », le registre de statut « status reg », le
registre « FSR reg » utilisé pour l’adressage indirect (en assembleur…), le
multiplexeur d’adresse « Addr mux », le compteur programme « Program Counter »
qui pointe les instructions à exécuter, la pile à 8 niveaux « 8 level Stack », le registre
d’instruction « Instruction reg », ainsi que les différents bus qui relient tous ces
éléments entre eux.
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
-9-
On n’entrera pas ici dans les détails du fonctionnement d’un microprocesseur ; c’est
très intéressant à connaître, indispensable même si on programme en assembleur.
Mais en ce qui nous concerne, on veut programmer en C, et c’est donc le
compilateur qui se chargera de traduire notre code source en instructions de bas-
niveau pour le microprocesseur contenu dans le PIC. C’est là le principal avantage
de la programmation en C : on prend du recul par rapport au fonctionnement intime
du système. On se concentre d’avantage sur « ce que fait le programme » que sur
« comment fonctionne le programme ».
On va tout de même jeter un petit coup d’œil sur le schéma ci-dessus, histoire de
comprendre quelques particularités du PIC, déroutantes au premier abord. On
s’aperçoit que les bus autour de l’ALU ont un format de 8 bits : le PIC 16F877
travaille sur des données de 8 bits, c’est donc bien un microcontrôleur 8 bits !
(logique…).
Pourquoi donc ce cas le « Program Bus » est-il, lui, large de 14 bits ? C’est simple,
certaines instructions peuvent être codées sur plus de 8 bits. Si ce bus n’était large
que de 8 bits, il faudrait plus d’un cycle d’horloge pour transmettre ces instructions,
alors qu’avec un bus plus large, ça passe en une fois. De plus, la mémoire
programme, indépendante du bus de données, est elle-même adressée avec un bus
large : le « Program Counter », qui pointe sur l’instruction en cours, à une largeur de
13 bits. Et avec 13 bits on peut coder environ 8000 adresses. Autrement dit, on à
8000 cases de mémoire programme pouvant contenir chacune 1 instruction
complète. Cette architecture avec bus de données et de programme séparés
(architecture « Harvard ») permet donc d’optimiser le fonctionnement du PIC. La
plupart du temps, votre PIC exécute une instruction et charge la suivante
simultanément en un seul cycle d’horloge. En comparaison, un microcontrôleur 8 bits
construit selon l’architecture concurrente « Von Neumann » (mémoire programme et
données reliés au microprocesseur par un unique bus 8 bits) devra faire plusieurs
cycles pour chercher les instructions en mémoire (en plusieurs fois si c’est une
instruction longues) et les exécuter ensuite. En conséquence, à fréquence d’horloge
égales, un microprocesseur « Harvard » sera plus rapide qu’un « Von Neumann ».
- 10 -
La mémoire
Sur le PIC, il n’y a pas une mais trois mémoires :
13 DATA Bus 8 PORTA
Program Counter
RA0 / AN0
FLASH RA1 / AN1
RA2 / AN2 / Vref-
Program
Memory RAM RA3 / AN3 / Vref+
8 Level Stack
( 13-bit ) File RA4 / T0CKl
Registers RA5 / AN4 / SS
Program 14 PORTB
Bus RAM Addr (1) 9
RB0 / INT
Addr MUX RB1
Instruction reg
RB2
Direct Addr 7 Indirect
8 RB3 / PGM
Addr
RB4
FSR reg RB5
RB6 / PGC
STATUS reg RB7 / PGD
8
PORTC
RC0 / T1OSO / T1CKL
3 MUX
Power-up RC1 / T1OSI / CCP2
Timer RC2 / CCP1
Instruction RC3 / SCK / SCL
Oscillator
Decode & Start-up Timer RC4 / SDI / SDA
ALU
Control RC5 / SD0
Power-on RC6 / TX / CK
Reset 8
RC7 / RX / DT
Timing Watchdog
W reg
Generation Timer PORTD
OSC1 / CLKIN Brown-out RD0 / PSP0
OSC2 / CLKOUT Reset RD1 / PSP1
In-Circuit RD2 / PSP2
Debugger RD3 / PSP3
Low-Voltage RD4 / PSP4
Programming Parallel Slave Port RD5 / PSP5
RD6 / PSP6
RD7 / PSP7
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
La Mémoire Programme, de type FLASH sur le 16F877. Capacité : 8K. C’est dans
celle-ci qu’est stocké le programme du PIC. Après compilation de votre code, le
compilateur génère un fichier « .hex », une suite de codes hexadécimaux. Celui-ci
est transféré ensuite dans la mémoire programme du PIC à l’aide du programmateur.
Cette mémoire n’est pas reliée au bus de données (DATA Bus), sa vocation est de
stocker le programme du PIC, mais PAS les variables de votre programme. Le gros
avantage de la mémoire FLASH c’est que vous pouvez la réécrire, donc implanter un
nouveau programme dans le PIC. Les PIC existent également avec d’autres versions
de mémoire programme (non-FLASH), certaines ne pouvant être programmée
qu’une seule fois.
- 11 -
La Mémoire RAM, qui fait partie de la zone d’adressage des données. Elle
comprend tous les registres spéciaux permettant de contrôler le cœur du PIC ainsi
que ses périphériques. Elle contient également des cases mémoires à usage
générique dans lesquelles pourront être stockées les variables de nos futurs
programmes.
- 12 -
La Pile et le Compteur Programme
On les a déjà évoqués dans le paragraphe « le cœur du PIC : le microprocesseur »,
mais puisqu’on vient de parler de la mémoire, une petite remarque s’impose.
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 13 -
Le « Program Counter » ou PC est le compteur qui pointe dans la mémoire
programme la prochaine instruction à exécuter. Il est lié à la pile système (Pile =
Stack en anglais) qui est sur le PIC 16F877 une pile 8 niveaux. Qu’est ce que cela
signifie ? Simplement qu’on peut avoir jusqu'à 8 niveaux d’imbrication d’appels de
sous-programme ou fonctions. Ce point est surtout critique pour la programmation en
assembleur : un sous-programme peut appeler un autre sous-programme qui appelle
à son tour un autre sous-programme… jusqu’à une « profondeur » de 8. Au-delà,
c’est la cata : votre programme est buggé et va faire n’importe quoi, étant donné que
le PIC ne peut « dépiler » que 8 niveaux. Le Compteur Programme n’arrivera pas à
revenir à la racine des appels. La programmation en C apporte là un peu de
souplesse : un bon compilateur veillera pour vous à ce que la limite de 8 niveaux ne
soit pas dépassée, quitte à recopier localement une fonction pour éviter un saut à
l’adresse mémoire où cette fonction est déjà présente. Au détriment donc de
l’occupation en mémoire. Ainsi, mieux vaut-il éviter de créer trop de niveaux
d’imbrication d’appels de fonctions dans nos programmes.
- 14 -
Les Ports d’Entrées/Sorties généraux : PORTA, PORTB, PORTC,
PORTD, PORTE
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 15 -
Le PIC 16F877 est généreusement doté de 5 ports, ce qui est plutôt confortable. Un
examen plus attentif du schéma ci-dessus nous montre cependant que les lignes
d’entrées/sorties (les pattes du composant) correspondantes sont également
utilisées par d’autres modules du PIC. Ainsi, les pattes du PORTA servent également
au convertisseur Analogique/Numérique, les pattes du PORTD au Port Parallèle
Esclave, etc. Il faudra faire des choix au moment de la conception du schéma
électronique ! On voit également que les ports B, C et D ont 8 lignes d’entrée/sortie,
alors que le port A n’en a que 6 et le port E que 3. Ils sont tous connectés au bus de
donnée (DATA BUS), on pourra donc librement les adresser pour y lire ou écrire des
données, et donc allumer des LED, commander des moteurs pas à pas, des
afficheurs LCD, lire les données envoyées par un clavier ou un bouton poussoir…
On peut configurer les entrées/sorties de chaque port en entrée ou en sortie, grâce à
un registre spécial dédié à chaque port.
De plus, un des ports (le port B) possède des résistances de « pull-up » internes qui
peuvent êtres validées ou non par logiciel.
- 16 -
Le Port Parallèle Esclave (PSP : Parallel Slave Port)
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
Le Port Parallèle Esclave est un port 8 bits permettant d’interfacer le PIC avec, par
exemple, un autre microprocesseur. Les données transitent via les lignes PSP0 à
PSP7, qui physiquement utilisent les mêmes broches que le PORTD. Le flux de
données est contrôlé par les lignes RD, WR et CS qui correspondent aux broches du
PORTE.
C’est le microprocesseur externe qui est le chef d’orchestre : il valide notre PIC par la
ligne CS (Chip Select), et indique au PIC s’il lit ou écrit grâce aux lignes RD (Read) et
WR (Write). D’où l’appellation de port parallèle ESCLAVE. Esclave, puisque c’est le
microprocesseur externe qui donne les ordres, notre PIC ne fait qu’exécuter.
- 17 -
Le circuit de génération d’horloge
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
Pour faire battre le cœur de notre PIC, on a besoin d’un circuit de génération
d’horloge. Avec les PIC « Mid Range », plusieurs options possibles : circuit RC
(résistance + condensateur), ou circuit résonateur céramique, ou oscillateur à
quartz... Le mode de fonctionnement est déterminé au moment de la programmation
du PIC par des « bits de configuration » qui sont en fait des emplacements de
mémoire non-volatile. Pour générer un « cycle d’instruction », il faut 4 cycles
d’horloge. Autrement dit, si votre quartz bat à 20 MHz, les instructions du programme
s’exécutent à une cadence de 5 MHz.
- 18 -
Le TIMER0
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
Dans le passé, le Timer0 s’appelait RTCC. C’est un compteur 8 bits (0 à 255) simple,
qui compte des impulsions soit internes, soit d’une source externe. On peut par
ailleurs lui appliquer une pré-division programmable entre 1 et 256.
On peut librement lire ou écrire dans le registre de comptage associé. On peut donc
le pré charger avec une valeur, à partir de laquelle il comptera jusqu’à atteindre 255.
Une fois le registre de comptage plein, il peut générer une interruption.
Étant donné qu’une fois configuré il fonctionne quasi-indépendamment du
microprocesseur, on pourra s’en servir comme base de temps.
- 19 -
Le TIMER1
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 20 -
Le Timer1 fonctionne sur le même principe que le Timer0, mais avec un registre de
comptage plus gros : 16 bits au lieu de 8, ce qui étend notablement ces capacités de
comptage. De plus, il possède un mode de fonctionnement particulier : on peut
l’utiliser en association avec un des modules CCP (modules de capture et de
comparaison, voir plus loin). Voyons rapidement le mode « capture » : lorsqu’un
événement survient sur l’entrée du module CCP, la valeur du Timer1 est lue. Comme
on connaît la fréquence de comptage, on peut en quelque sorte « chronométrer » la
survenue d’un événement. Exemple : si l’entrée du module CCP est reliée à un
capteur qui délivre une impulsion à chaque tour de l’arbre d’un moteur, la valeur
contenue dans le registre du Timer1 au moment de l’impulsion est le reflet de la
vitesse de rotation.
Voyons maintenant le mode « comparaison » : Le Timer1 compte en continu, et une
interruption est générée chaque fois que la valeur du compteur est égale à celle
qu’on aura pré chargée dans le registre de comparaison. On peut s’en servir pour,
par exemple, générer un signal carré.
- 21 -
Le TIMER2
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 22 -
Les modules CCP1 et CCP2
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 23 -
On en a parlé au moment de voir les Timer1 et Timer2 ; on a deux modules CCP sur
le PIC. CCP pour « Capture, Compare, PWM ».
En association avec les deux timers, ils vont nous permettre de générer des signaux
à modulation de largeur d’impulsion (PWM) pour, par exemple, faire varier la vitesse
d’un moteur à courant continu, réguler le courant (et donc la luminosité) dans une
ampoule…
Ils vont également nous permettre de comparer l’occurrence d’un signal en entrée
avec la valeur du compteur Timer1, réalisant ainsi un chronométrage de l’événement
en question (par exemple : indication de la fréquence de rotation d’un moteur).
Ils vont encore nous permettre de générer des signaux carrés, et cela de manière
quasi-indépendante du reste du microcontrôleur qui pourra continuer à vaquer à ses
occupations.
- 24 -
Le convertisseur Analogique – Digital 10bits :
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 25 -
Le convertisseur A/D convertit le signal analogique présent sur une de ses 8 entrées
en son équivalent numérique, codé sur 10 bits. Les pattes AN2 et AN3 peuvent être
utilisées comme références de tension ou comme entrées analogiques standard, les
références de tension étant dans ce dernier cas prises sur les tensions
d’alimentations du PIC : VDD et VSS. (VDD pour le + et VSS pour le -).
On peut donc numériser jusqu’à 8 signaux analogiques. Pas tous en même temps,
bien sûr, étant donné qu’il n’y a qu’un seul module de conversion pour 8 signaux
d’entrée multiplexés. Mais si vos signaux n’évoluent pas trop vite (fréquence basse),
vous pouvez numériser le signal sur la patte AN0, puis celui sur AN1…
Les paramètres important dont il faudra tenir compte sont :
• La résolution du convertisseur. Ici 10 bits, donc meilleur qu’un convertisseur 8
bits, mais moins précis qu’un 12 bits…
• Le temps de conversion.
• La rapidité d’évolution des signaux présents sur les entrées (leur fréquence
pour des signaux périodiques).
• Le nombre de signaux à numériser.
- 26 -
L’USART
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 27 -
L’USART ou Universal Synchronous Asynchronous Receiver Transmitter est l’un des
deux modules de communication série du PIC ou SCI en anglais (Serial
Communication Interface).
Comme son nom l’indique, elle peut établir une liaison synchrone ou asynchrone,
recevoir et transmettre des données, selon la manière dont elle est configurée.
C’est son côté « je peux tout faire » qui lui vaut l’attribut « Universal ».
Concrètement, l’USART permet de communiquer avec le reste du monde : un
ordinateur ou tout autre matériel équipé d’une interface série RS232, des circuits
intégrés convertisseurs Numérique/Analogique ou Analogique/Numérique, des
EEPROMs série…
L’USART peut être configurée selon 3 modes :
• Asynchrone (Full Duplex)
• Synchrone Maître (Half Duplex)
• Synchrone Esclave (Half Duplex)
- 28 -
Le SSP, Synchronous Serial Port
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 29 -
Le module SSP est la deuxième interface de communication série du PIC.
En fait, il s’agit d’un port Maître, donc l’appellation exacte est plutôt MSSP pour
« Master Synchronous Serial Port ».
Il est utile pour communiquer avec d’autres modules ou microcontrôleurs, des
EEPROMs séries, des registres à décalage, des afficheurs, des convertisseurs A/N
ou N/A…
Il peut fonctionner dans deux modes de communication :
• Le mode SPI (Serial Peripheral Interface)
• Le mode I²C (Inter-Integrated Circuit)
- 30 -
La logique de RESET
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 31 -
La logique de reset comprend plusieurs modules :
- 32 -
L’In-Circuit Debugger
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 33 -
Low-Voltage Programming et ICSP (In-Circuit Serial Programming)
PORTE
RE1 / AN6 / WR
RE2 / AN7 / CS
Timer0 Timer1 Timer2 10-bit A/D
Synchronous
Data EEPROM CCP1,2 USART
Serial Port
- 34 -
A quoi peut bien servir ce module « Low-Voltage Programming » ?
- 35 -
Les Bits de Configuration
Pour « customiser » notre PIC, il existe ce que l’on appelle les bits de configuration.
Ce sont des bits spéciaux de la mémoire programme qui permettent de spécifier le
mode de fonctionnement d’un certain nombre de fonctionnalité du PIC. À savoir :
- L’oscillateur : utilisation d’un quartz ou d’un circuit RC, plage de fréquence
- Utilisation ou nom du Watchdog
- Utilisation de la patte MCLR ou non
- Validation ou non du Power-Up Timer
- Validation ou non du Brown-Out Reset
- Protection de la mémoire programme et de la mémoire EEPROM
Les Interruptions
- 36 -
Le mode SLEEP
Le mode Sleep est un mode de fonctionnement particulier du PIC dans lequel celui-ci
réduit sa consommation électrique au minimum. Il est presque entièrement
désactivé, son oscillateur est éteint. Le PIC est en mode « veille » !
Pour sortir de cette torpeur, il faut un des événements suivant :
- Reset du circuit, ou
- Réveil par le Watch-Dog Timer (ci celui-ci est activé, il continue de
fonctionner en mode SLEEP)
- Interruption générée par un module périphérique (Timer, convertisseur
A/D, changement d’état de port, SSP….)
Ce mode peut être particulièrement intéressant pour une application fonctionnant sur
pile ou batterie et qui ne requiert le fonctionnement du microprocesseur qu’à la
survenue d’événements particuliers. On prolonge ainsi considérablement
l’autonomie.
- 37 -
Brochage du PIC16F877
MCLR/Vpp 1 40 RB7/PGD
RA0/AN0 2 39 RB6/PGC
RA1/AN1 3 38 RB5
RA2/AN2/VRef- 4 37 RB4
RA3/AN3/VRef+ 5 36 RB3/PGM
RA4/T0CKI 6 35 RB2
RA5/AN4/SS 7 34 RB1
PIC 16F877
RE0/RD/AN5 8 33 RB0/INT
RE1/WR/AN6 9 32 VDD
RE2/CS/AN7 10 31 VSS
VDD 11 30 RD7/PSP7
VSS 12 29 RD6/PSP6
OSC1/CLKIN 13 28 RD5/PSP5
OSC2/CLKOUT 14 27 RD4/PSP4
RC0/T1OSO/T1CKI 15 26 RC7/RX/DT
RC1/T1OSI/CCP2 16 25 RC6/TX/CK
RC2/CCP1 17 24 RC5/SDO
RC3/SCK/SCL 18 23 RC4/SDI/SDA
RD0/PSP0 19 22 RD3/PSP3
RD1/PSP1 20 21 RD2/PSP2
Conclusion
Ainsi s’achève notre survol du PIC 16F877. Vous savez maintenant ce qui se cache
dans la boîte, et avec quels outils nous allons le programmer. Notre prochain objectif
sera de le faire fonctionner. On pourra passer ensuite à l’étude un peu plus détaillée
des différents périphériques.
- 38 -