 |
| 7.1.
Résumé des épisodes précédents |
| |
| 7.1.1. Introduction |
Avertissement :
cette série est la suite de l´introduction aux microP
(pages 1 à 6), et ne reprend donc
pas tout ce qui a déjà été dit. Il faut
donc avoir lu (et si possible a peu près compris  )
la première partie.
 |
| PTI+ Dans
cette première partie, j´ai quelquefois
utilisé des termes simplificateurs ou “imagés” pour
certaines notions, dans le but de rendre la présentation
plus vivante. À partir de maintenant, j´utiliserai
les termes consacrés par l´usage,
qui sont malheureusement souvent en anglais, mais
cela est nécessaire — sinon vous ne
comprendrez plus rien si vous allez par exemple
vous informer sur Internet. |
|
|
|
| 7.1.2. Les éléments
constitutifs d´un microP |
L´horloge :
le fonctionnement d´un microP est “cadencé” par
une horloge, qui dans notre cas est interne au microP et à la
fréquence de 4 MHz. Un ‘tic´ d´horloge
est appelé un “cycle d´horloge”.
Le
programme : suite d´instructions exécutées
par le microP et qui réalisent, si tout va bien, le but recherché dans
le montage.
Les
entrées-sorties : le microP communique avec l´extérieur
par l´intermédiaire de “ports” (attention :
nouveau terme pour designer les E/S, entrées-sorties).
Les
registres : ce sont les mémoires de travail du
microP, divisés en “registres
spéciaux”, qui contiennent les valeurs de paramétrage
du fonctionnement, et les “registres
généraux” qui sont à notre disposition
comme zone de manœuvre.
Le
registre W : registre de travail, passage presque obligé de
toute opération, car aucune instruction ne concerne
deux registres généraux, mais toujours un registre
général et W.
Les
interruptions : le cours normal d´un programme
peut être interrompu par des événements, qui
déclenchent une séquence spécifique d´instructions
avant de revenir au programme normal.
Les
timers : registres spéciaux qui comptent les cycles
d´horloge ; les timers provoquent une interruption lorsqu´ils
passent par zéro (débordement).
| |
| 7.1.3. Les interruptions |
Un des concepts
importants des microP est l´utilisation des interruptions.
Le déroulement
d´un programme est essentiellement “linéaire”,
c'est-à-dire que les instructions sont exécutées
les unes après les autres dans l´ordre d´écriture,
et même si nous disposons d´instructions nous permettant
de se déplacer dans le programme (call,
return, goto), tout
ceci se passe sans en séquence et surtout sans interruption.
Cette partie du programme est appelée dans nos projets BouclePrincipale.
Les interruptions
sont un dispositif permettant de déclencher un autre traitement
en fonction d´événements internes ou externes.
Lorsque cet événement survient, la boucle principale
est arrêtée, le traitement spécifique est activé et
se déroule ; à la fin de ce traitement la boucle
principale reprend son cours à l´endroit où elle
s´était
arrêtée.
Il existe un grand
nombre d´interruptions possibles dans un microP, nous n´en
utiliserons que deux pour l´instant : les timers.
Les timers sont
des compteurs qui comptent les cycles d´horloge, de zéro
jusqu´à 255 pour le Timer0 et
de zéro jusqu´à 256 x 256, soit 65.536,
pour le Timer1. Lorsque le timer
arrive à ce maximum, il repasse à 0 et déclenche
l´interruption correspondante.
Le traitement
réel des interruptions est relativement complexe, mais il
est toujours le même ; je l´ai donc “caché” dans
notre fichier Param_Std_v1_0.inc ;
dans nos programmes on ne retrouve donc que les sous-programmes spécifiques à ces
interruptions.
| |
| 7.1.4. Résumé des
instructions rencontrées jusqu´ici : |
| |
 |
|
|
|
|
|
| Instruction |
Opérande |
Fonction |
|
|
|
| goto |
étiquette |
Déplace l´exécution
du programme vers un autre endroit identifié par étiquette |
|
|
|
| call |
étiquette |
Appelle un sous-programme identifié par étiquette |
|
|
|
| return |
pas d´opérande |
Fin de sous-programme, le programme revient à l´instruction
suivant le call |
|
|
|
| btfsc |
registre, bit |
Test du bit bit dans
le registre registre. Si
le bit est à 0, on saute l´instruction suivante,
sinon on l´exécute |
|
|
|
| btfss |
registre, bit |
Test du bit bit dans
le registre registre. Si
le bit est à 1, on saute l´instruction suivante,
sinon on l´exécute |
|
|
|
| movlw |
littéral |
Chargement de la valeur (le littéral)
dans W |
|
|
|
| movwf |
registre |
Copie du contenu de W dans le registre registre |
|
|
|
| bsf |
registre, bit |
Met à 1 le bit bit dans
le registre registre |
|
|
|
| bcf |
registre, bit |
Met à 0 le bit bit dans
le registre registre |
|
|
|
| xorwf |
registre, destination |
OU exclusif entre W et le registre, le
résultat est dans W si destination = ‘w´,
ou dans le registre si destination=´f |
|
|
|
| decfsz |
registre, destination |
Décrément du registre, le
résultat est dans W si destination = ‘w´,
ou dans le registre si destination=´f´, et saut
de l´instruction suivante si le résultat est zéro |
|
|
|
| clrf |
registre |
Met tous les bits du registre à zéro |
|
|
|
|
|
|
|
| 7.1.5. Ordre
et méthode |
Dans tout ce qui
concerne le petit train, vous procédez avec ordre et méthode
(du moins en principe…).
Ici aussi, les
mêmes principes s´appliquent. On a déjà vu
l´importance des commentaires (après le ; point-virgule),
on va maintenant définir quelques principes s´appliquant
au “nommage”. (Oui, je sais, ce terme est horrible, mais
son utilisation est consacrée dans l'environnement des programmeurs,
de l´anglais naming, et cela consiste à définir
des règles pour la construction des noms, ou conventions de
nommage – naming rules.)
|
| FAQ Ah,
là, là, marre de l' anglais ! — JIDÉ :
Oh, ça n'est rien... 30 pour cent de nos
mots d'informatique viennent de l'anglais, et
alors ? Pour les amateurs d'opéra,
c'est 60 pour cent d'italien ; pour les
aficionados des corridas, c'est 95 pour cent
d'espagnol... Quant aux fans de sushis, les pauvres,
n'en parlons même pas. Non, croyez-moi,
on n'a pas à se plaindre... |
|
|
Dans la programmation
de nos microP, il n'y a que quelques éléments que nous
pouvons nommer comme nous le souhaitons :
 Les étiquettes :
endroit du programme où l´on saute par un goto ;
Les
sous-programmes : appelés par un call ;
Les
registres : les registres généraux que nous utilisons
dans nos programmes ;
Les
entrées/sorties, qui sont les bits du registre GPIO.
|
| PTI+ Naming encore,
mais là c'est les programmeurs de chez Microchip
qui ont fait le travail pour nous, pour les registres spéciaux,
tels GPIO ou T1CON, et les bits de ces registres,
tels GIE ou GPIF... Tous ces noms de baptême
sont connus de MPLAB uniquement car ils figurent
dans le fameux fichier p12F675.inc que nous
lui indiquons à chaque début de programme
(fichier qu'on peut aller lire sans problème,
note pour les curieux, mais pas modifier). |
|
|
La structure des
noms est relativement libre, à condition de ne pas oublier
les règles suivantes :
Pas
de caractères accentués :
nous sommes dans un univers anglo-saxon, ils ne savent pas ce que
c´est que àéîöù ;
Pas
de caractères spéciaux :
c´est très joli d´avoir des % ou
des & dans les noms, mais
en général nos machines n´aiment pas beaucoup.
Le seul utilisé (utilisable) est le _ (underscore ou espace souligné,
celui qui est sous le 8 de votre clavier), à ne pas confondre
avec le – (tiret) qui, lui, est interdit. Attention, pas non
plus d´apostrophes (’) en forme de virgule, ce que certains
traitements de texte ajoutent gentiment sans qu'on leur demande.
Dans nos programmes,
pour s´y retrouver un peu plus facilement, nous allons donc
définir une règle de construction de ces noms, en identifiant
chaque catégorie par un préfixe :
ET_
pour une étiquette : ET_xxxxxxxxxxxxxxxx
SP_
pour un sous-programme : SP_xxxxxxxxxxxxxxxxxxx
VA_
pour une variable (registre) : VA_xxxxxxxxxxxxxxxxxxxxxx
IO_
pour une entrée-sortie : IO_xxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxx étant
le nom que nous avons choisi, dans les règles définies
ci-dessus.
|
PTI+ Noms
et adresses. — Il faut bien comprendre
que tout cela n´est qu´une “facilité” proposée
par le logiciel de programmation (nommé MPLAB). In
fine, dans notre microP, il ne reste plus
qu´une suite de bits, d´octets, définissant
des adresses et des instructions.
C´est
MPLAB qui transforme les noms en adresses, par
exemple le registre GPIO est à l´adresse
05. Donc quand j´écris dans mon programme “bsf
GPIO,2”, qui veut dire “mettre à 1
le bit 2 du registre GPIO”, MPLAB met donc
simplement à 1 le bit 2 de l´adresse
05.
Traduit
en langage machine dans notre microP, cette instruction
devient 0101 010 0000101, qui signifie :
0101
= code pour l´instruction ‘bsf´
010
= 2e bit
0000101
= de l´adresse 05
Heureusement
que nous avons MPLAB pour faire ce travail à notre
place ! |
|
|
|
|
 |
 Notre
projet de ce jour, testé dans des conditions d'esthétique
douteuses 
mais ça marche, bien sûr ! |
| |
| 7.2.1. Cahier
des charges |
(On appelle “cahier
des charges” la description des fonctions que doit remplir
un montage.) On va faire très simple ici, et à la limite
cela ne sert à rien de plus que ce que font nos 555, il
s´agit juste de faire une révision générale
de tout ce que nous avons déjà vu, et aussi
de voir comment, pas à pas, on écrit un programme.
|
|
|
 |
|
Le
montage  comprendra
donc deux boutons poussoirs, reliés à la masse
et aux pattes 2 et 3 du microP, une led et une résistance
en série de 470 ohms entre la patte 7 du microP
et la masse, sans oublier un petit condensateur de 10 µF
en parallèle sur l´alimentation du microP, pattes
1 et 8.
Difficile de
faire plus simple, et c'est le premier programme de nombreux
livres sur les PIC... Que fait le montage ? Pas grand-chose :
Au départ,
la led est éteinte ; si on appuie sur le bouton
1 (patte 2, GP5), la led s´allume, et elle clignote.
Par
appui sur le bouton 2 (patte 3, GP4), la led s´éteint
et on se retrouve au début ; allumé, éteint,
allumé...
Ça ne fait
donc rien d'extraordinaire, mais c´est si joli ! |
| |
| 7.2.2. Les préalables |
La démarche
que je vous propose est de refaire pas à pas toutes les étapes
d´écriture du programme, en partant de zéro.
Je ne fournis pas de fichier programme tout prêt, vous allez
vous-mêmes rentrer tout ça dans MPLAB.
Il faut donc avoir
installé MPLAB sur votre PC, et ouvrir en même temps
cette page et MPLAB. Si vous avez un grand écran, ce sera
plus simple !
Il est aussi préférable
de créer tout de suite quelque part le répertoire qui
va contenir notre projet, et d´y copier le fichier Param_Std_12F.inc que
nous avons déjà utilisé pour le klaxon, et un “squelette” de
fichier de programme appelé Pictrain1.asm
|
| 7.2.3. Création
du projet |
Au départ,
si votre écran est assez grand, vous devriez avoir quelque
chose comme ceci :
avec MPLAB à gauche,
et Ptitrain à droite (vous
avez le droit de les changer de côté).
7.2.4. On
va donc d´abord créer le projet MPLAB :
1.
menu Project, Project wizard… + suivant ;
2.
step one : sélection du microP, dans notre cas 12F675
+ suivant ;
3.
step two : choix des outils, en standard MPASM toolsuite + suivant ;
4.
step three : création du projet = choix du répertoire
+ nom du projet (ici je suppose PICTRAIN1) + enregistrer ;
5.
suivant ;
6.
step four : inclusion de fichiers, ici, comme vous avez en principe
déjà copié les deux fichiers, vous pouvez les
inclure dans le projet par double clic sur le nom.
|
|
|
7.
suivant
8.
dernière étape : summary : terminer
7.2.5. Voilà,
votre projet est créé, même si le programme
est vide pour l´instant. Si vous allez dans le répertoire
du projet, vous y trouverez déjà trois fichiers
supplémentaires.
Votre écran
MPLAB se présente maintenant comme ci-contre  .
Pour travailler,
il suffit d´ouvrir (double-clic) le fichier Pictrain1.asm
On
va maintenant écrire notre programme, et au fur et à mesure
on va revoir toutes les notions des microprocesseurs que nous
avons balayées durant la première partie. |
|
 |
|
PTI+ Majuscules
et minuscules. — En standard, le logiciel
MPLAB fait la distinction entre les majuscules
et les minuscules, c'est-à-dire que ‘ET_BouclePrincipale´ n´est
pas la même chose que ‘et_boucleprincipale´.
Si
cette contrainte vous est gênante, il est
possible de modifier ce contrôle : il faut
aller dans le menu Project, puis Build options… puis
Project ; ensuite, dans l´onglet MPASM Assembler,
il faut cocher la case Disable case sensitivity.
MPLAB ne tiendra plus compte des majuscules et
minuscules.
Attention
: cela n'est valable que pour un projet, il faudra
le refaire pour chaque projet.
Note
de Jidé : le plus simple encore sera de
ne pas tenter le diable ! N'essayez tout simplement
pas d'appeler une variable VitesseDuTrain et une
autre, différente, vitesseduTrain et vous
verrez comme tout ira bien... |
|
|
|
| 7.3.
Définitions |
| |
| 7.3.1. Commentaires
et présentation |
Tout programme doit
comporter le maximum de commentaires, car sinon même vous ne
vous y retrouverez plus. Un commentaire est tout ce qui se trouve
après le ; (point-virgule) sur une ligne.
On peut donc avoir
des commentaires n´importe où, lignes de commentaire “pures” ou
commentaires après une instruction.
En général,
on commence un programme en donnant quelques informations générales,
auteur, date, version… comme par exemple ci-dessous :
J´en profite
pour donner une autre recommandation : soyez “esthétique”,
c'est-à-dire joli !
Faire joli dans les microP peut sembler curieux, mais regardez ces
deux exemples : ceci 
et cela
Ils font tous les
deux strictement la même chose, mais je préfère
nettement le premier. Si vous écrivez dans le style du deuxième
exemple, je vous garantis que vous êtes complètement
perdu après 15 lignes.
Voila ce que j´appelle “faire
joli” !
| |
| 7.3.2. Définitions
générales |
Au début
du programme, on trouve un certain nombre d´indications sur
la manière de programmer et d´utiliser le microP .
Je ne donne pas
de détail, car ils n´ont pas d´importance au niveau
Pictrain où nous nous trouvons, et ce sont toujours les mêmes
lignes.
Attention cependant
de ne pas se tromper dans la ligne __CONFIG, elle peut entraîner
la destruction du microP.
|
PTI+ Horloge. — Vous
savez déjà que le rythme dans notre
microP est donné par une horloge interne,
qui fonctionne à 4 MHz, et qu´il faut
en général 4 cycles d´horloge
pour une instruction.
Cette
manière d´utiliser les microP est
la plus simple, et sera toujours utilisée
dans nos montages. Il faut cependant savoir que
ce microP peut fonctionner jusqu´à 20
MHz (5 fois plus vite), avec un oscillateur (à quartz)
externe.
Dans
l´autre sens, on peut aussi le faire fonctionner
plus lentement avec une horloge externe, jusqu´à 4
Hz par exemple, c'est-à-dire une instruction
par seconde. Cela ne présente en général
aucun intérêt, mais techniquement
c´est possible.
Il n´y
a que deux cas où cela peut être utile
:
• si
on fait fonctionner le microP moins vite, il consomme
moins de courant, utile pour les systèmes
sur piles ;
• la
fréquence de 3.276.800
hertz est utilisée pour des systèmes
devant donner une heure exacte (“horloge” au
sens traditionnel). |
|
|
| |
| 7.3.3. Constantes
et mnémoniques |
Au début
du programme, on peut aussi définir des constantes et des
mnémoniques, qui seront utilisés plus loin dans le
programme.
Pourquoi faire ?
uniquement pour des raisons de lisibilité. Par exemple, lorsque
nous utilisons dans notre programme Klaxon l´entrée-sortie
5 pour le bouton, nous écrivons GPIO,5.
On peut aussi définir, au début du programme, que notre
entrée s´appelle IO_Bouton_Declenchement,
par :
Dans toute la
suite du programme, nous utiliserons IO_Bouton_Declenchement à la
place de GPIO,5, par exemple :
Dans cet exemple
simpliste, l´intérêt semble minime, mais lorsque
vous avez toutes les entrées-sorties utilisées, et
que par ailleurs vous utiliserez des bits de registres généraux
dans vos instructions, cela va vous simplifier la vie.
De même,
on peut définir des constantes par la directive EQU (équivalence),
c'est-à-dire que l´on va nommer des valeurs. Par exemple
dans notre premier programme, klaxon, pour les valeurs qui nous permettent
d´obtenir les bonnes fréquences, on pourrait définir :
Et lorsque l´on
charge un registre, on aura :
au lieu de :
Ce ne paraît
pas grand-chose mais, lorsque les constantes sont nombreuses, cela
facilite aussi la lecture, et permet de regrouper toutes les constantes
au même endroit, plutôt que de les disséminer
dans le programme,et de faciliter la mise au point (et plus tard
la maintenance) du programme.
J´en profite
pour introduire une nouvelle norme (voir au début “Ordre
et méthode”), les noms de constantes seront de la
forme C_xxxxxxxxxxxxxxxx.
#define et EQU sont
des directives à destination du logiciel MPLAB, qui dans le
fond ne fait que remplacer dans le programme le nom ainsi défini
par la valeur donnée au début. Ce ne sont donc pas
des instructions, mais des facilités d´écriture.
|
PTI+ Instructions
et directives. — Il faut bien faire
la distinction entre “instructions” et “directive”.
Les
instructions sont les “vraies” instructions,
qui sont traduites en binaire et écrites
dans le microP pour être exécutées
par celui-ci.
Les
directives ne sont que des “ordres” donnés
au logiciel MPLAB :
• soit
pour indiquer au logiciel ce que nous souhaitons
faire ; exemple : la directive LIST
p=PIC12F675 qui indique au logiciel que
nous utilisons le microP de type 12F675 ;
• soit
pour nous faciliter la vie, comme #define ou EQU |
|
|
Revenons maintenant à notre
programme. Nous avons défini au début trois entrées-sorties,
les bouton sur les pins 4 et 5 et la led sur la pin 0, ce qui se
traduit dans le programme par GPIO,0 GPIO,4 et GPIO,5.
En appliquant
les principes ci-dessus, nous aurons donc :
Ainsi chaque entrée-sortie
est maintenant identifiée par un nom plus explicite.
| |
| 7.3.4. Variables |
Ce programme très
simple ne comporte pas de variable, c'est-à-dire d'utilisation
d'un registre général. Cependant, voilà, ci-dessous ,
les principes de la déclaration :
CBLOCK
0x020 : cette directive signale le début de la
définition des variables
VA_CPT_256
: 1 : définition d´une variable nommée VA_CPT_256
ENDC :
directive de fin de la définition des variables
En application
des conventions définies au début (par nous), le nom
d´une variable commence toujours par VA_.
|
| 7.3.5. Fin des
définitions |
A la fin des définitions,
nous trouvons l´inclusion du fichier standard
#include est également
une directive, qui inclut à cet endroit le contenu du fichier Param_Std_v1_0.inc.
Le contenu de ce fichier a été écrit spécialement
pour nos applications Pictrain, et ne devrait intéresser que
les puristes.
|
PTI+ Param_Std_v1_0.inc ? Sans
rentrer trop dans les détails, ce fichier
contient :
— La
définition de variables standards. — La
définition de BANK0 et BANK1. — Le
démarrage du programme. — Le traitement
des interruptions. — L´initialisation
de l´oscillateur. — L´effacement
de la mémoire. — L´initialisation
des registres spécifiques.
Il est
suffisant pour les projets simples que nous allons
développer pour l´instant. |
|
|
|
| 7.3.6. Rappel
sur les sous-programmes |
Le sous-programme
est un élément clé de la structure des programmes,
mais son principe en est simple : il s´agit d´une
suite d´instructions que l´on veut exécuter plusieurs
fois, à partir d´endroits différents de notre
programme.
Un sous-programme est
défini par son nom, SP_xxxxx (commençant
par SP_ selon nos conventions),
et se termine par return.
Il est appelé par l´instruction call
SP_xxxxx.
Dans notre programme
Pictrain1, nous n´avons pas de sous-programme particulier,
uniquement les deux sous-programmes standards appelés à chaque
interruption de Timer0 et Timer1.
Nous n´aurons
donc pas d´instructions call,
qui se trouvent dans le fichier de paramètres, uniquement
les deux étiquettes SP_inttimer0et SP_inttimer1. |
|
| 7.4.
Le programme |
| |
| 7.4.1. Structure
du programme |
Si vous avez créé le
programme au fur et à mesure des étapes ci-dessus,
et si vous avez inclu les lignes des deux sous-programmes inttimer0 et inttimer1,
vous devez avoir ce résultat :
En appuyant sur la
touche clavier F10 dans MPLAB, vous ne devez avoir aucun message
d’erreur, le programme fonctionne. Mais pour l’instant,
il ne fait rien ; il n’y a en effet aucune instruction
réelle de traitement de quoi que ce soit.
Nous allons donc
maintenant attaquer le programme proprement dit. Rappelez-vous qu’il
y toujours deux parties dans un programme :
L’initialisation,
effectuée une seule fois lorsque vous mettez le courant, et
qui contient toutes la préparation et l’initialisation
des variables ;
La boucle
principale, c'est-à-dire la boucle de programme exécutée
en permanence par le microP.
Dans nos programmes,
nous appellerons toujours cette boucle ET_BouclePrincipale,
il nous faut donc ajouter après l’include et avant les
sous-programmes Timer les lignes :
Notre programme ne
fait toujours rien, mais il s’organise. Nous retrouvons maintenant
les trois parties principales :
Initialisation
Boucle
principale,
Les
sous-programmes, pour l’instant uniquement les sous-programmes
des timers, mais vides (=ils ne font rien non plus).
Finalement, la programmation
ne commence que maintenant, ce n’était que des préparatifs
jusqu’à présent.
| |
| 7.4.2. Initialisations
: timer |
Dans notre programme,
nous voulons faire clignoter une led à une fréquence
qui soit visible à l’œil nu. Nous allons donc
bien entendu utiliser un timer, et cette fois-ci le Timer0 qui
compte jusqu’à 255.
Vous voyez déjà la
difficulté : si l'on a une interruption tous les 255
cycles d’horloge, la fréquence sera de 3.906
Hz, ce qui est loin du but recherché (trop rapide) .
Nous allons donc
accompagner ce timer d’une nouvelle fonction : le pré-diviseur qui
permet au compteur de ne compter (s’incrémenter) que
tous les N cycles d’horloge, N pouvant varier de 2 à 256.
Je m’explique :
si par exemple N = 4, le timer ne comptera que tous les 4 cycles
d’horloge, et les interruptions se produiront à la fréquence
de 1.000.000
/ 4 / 256 = 976 Hz. C’est encore un peu élevé,
nous allons donc utiliser N = 256, et nous aurons la fréquence
de 1.000.000
/ 256 / 256 = 15,25 Hz, qui est cette fois-ci compatible avec
le but recherché.
Rappel : à chaque
interruption, nous allumons (ou éteignons) la led (selon le
cas), la fréquence visible sera donc
15,25/2 soit d’environ 8 Hz.
En d’autres
termes, cela signifie que notre timer ne va plus s’incrémenter à chaque
millionième de seconde (µs), mais toutes les 256 µs,
et l’interruption se déclencher tous les 256 incréments,
soit tous les 256 x 256 cycles d’horloge.
C’est ce
N que l’on appelle la valeur du pré-diviseur. Vous avez
suivi ?
Représentez-vous
le principe du pré-diviseur comme certaines balances de cuisine,
où vous pouvez choisir l’échelle de 0 à 100 g
ou de 0 à 1 kg par exemple. Vous mesurez toujours les
même carottes mais à des échelles différentes.
Ici c’est pareil, on compte soit tous les cycles d’horloge
(1 µs), soit dans notre cas par paquet de 256 cycles (256 µs),
mais on ne fait que compter le temps à des échelles
différentes.
Nous allons maintenant
pouvoir initialiser les registres spécifiques à cette
interruption :
Attention BANK ! Rappelez
vous que les registres spécifiques ne sont pas tous au même
endroit dans le microP, et que pour certains il faut activer BANK1 avant
deles utiliser ; c’est le cas ici du registre OPTION_REG,
comme des registres TRISIO et WPU plus
loin.
|
|
|
On
initialise d’abord le pré-diviseur, par des bits
dans le registre OPTION_REG selon
les valeurs contenues dans ce tableau .
Dans notre
cas, pour diviser par 256, il
faut mettre à  les
trois bits (selon la dernière ligne du tableau ci-contre : 111).
Ensuite,
on active les interruptions en mettant à le
bit GIE du registre de contrôle
des interruptions INTCON.
Toutes les
autres interruptions sont désactivées (les autres
bits de INTCON sont à  ).
Attention :
ici il ne s’agit que d’une préparation (initialisations),
nous n’activons pas encore le Timer0,
cela se fera par l’appui sur le bouton poussoir. |
|
 |
| |
| 7.4.3. Initialisation
: entrées-sorties |
L’initialisation
des entrées/sorties fait en général intervenir
trois facteurs :
Le “sens” de
fonctionnement, entrée ou sortie,
La
présence de résistance de rappel,
L’initialisation
(valeur initiale) des sorties.
Chacun de ces
paramètres est indiqué dans un registre spécifique :
TRISIO
pour le sens : en
sortie, en
entrée,
WPU
pour les résistances : pour
l’activation de la résistance (n’a de sens que
pour les entrées),
GPIO :
registre effectif des entrées-sorties.
Dans ces trois
registres, les bits utilisés sont de 0 à 5, correspondant
aux entrées GP0 à GP5. — Attention :
GP3 est un peu particulière, elle ne fonctionne qu’en
entrée (ne peut être utilisée en sortie), mais
ne dispose pas de résistance de rappel !
On peut maintenant
initialiser les entrées-sorties de notre montage :
Avec ceci nous
en avons terminé avec les initialisations...
| |
| 7.4.4. Boucle
principale |
Dans ce montage élémentaire,
la boucle principale ne fait que tester les boutons poussoirs, pour
déclencher ou arrêter le clignotement de la led.
Si le clignotement
est actif, il faut tester le bouton Arrêt, si le clignotement
est inactif, il faut tester le bouton Marche.
Le clignotement
est donné par l’interruption Timer0,
on voit donc tout de suite le fonctionnement du programme :
Au
départ, Timer0 est inactif,
et on teste le bouton ‘marche’ dans la boucle principale ;
Si
le bouton est activé, on met le timer en route (la led clignote)
et on passe dans la boucle ET_Boucle_Marche ;
Dans
cette boucle, on teste le bouton Arrêt :
— Tant que
le bouton est inactif, on continue de tester le bouton Arret ;
— Si le bouton
est activé, on arrête le timer, on éteint la
led et on revient au tout début.
Remarque :
comme dans beaucoup de montages électroniques, en général
une entrée est dite active lorsqu’elle
est reliée au 0 V (la masse) ; au repos elle est
reliée au + 5 V, à cause de la résistance
de rappel reliée au +5 V.
Voici le programme
résultant :
Il n’y
a rien de neuf dans tout ça, cela devrait commencer à être
limpide.
| |
| 7.4.5. Sous-programme
Timer0 |
Ce sous-programme
est appelé à chaque interruption Timer0,
c'est-à-dire toues les 65.536 microsecondes,
et il ne fait que inverser la valeur de la sortie led. Il est donc
tout simple :
Notre programme
est maintenant terminé, il faut l’écrire dans
le microP pour le tester.
|
PTI+ Les
instructions “move”. Nous
avons maintenant passé en revue toutes
les instructions move possibles,
est vous avez dû vous rendre compte quemovfw
XXXXX et movf
XXXXX,w font la même chose, c'est-à-dire
copier le contenu du registre XXXXX dans W.
En réalité,
l’instruction movfw n’existe
pas dans la réalité, ce
n’est qu’une facilité de programmation,
le logiciel MPLAB ne fait que la traduite en movf
...,w
Nous avons donc les instructions suivantes :
movlw : copie un littéral dans W
movwf : copie le contenu de W dans le registre
movf : copie le contenu du registre dans W (si
,w), ou dans le même registre (si ,f)
movfw : n’est pas une instruction, MPLAB
le traduit en movf avec destination W.
Cette “pseudo-instruction”
a été créée
pour garder un peu de logique : avec movlw,
movwf, movfw nous avons ainsi toutes les possibilités
de copie, et movf n’est
utilisé que pour tester la valeur zéro du registre. |
|
|
|
|
Ptitrain 
