Certaines broches ont une autre fonction qu’on verra plus loin.

4.4 Initialisation

L’initialisation consiste à définir les broches des ports a et b en entrées ou en sorties selon l’utilisation qu’on veut en faire. 

Les registres qui nous intéressent pour l’initialisation sont : 

TRISA en Bank 1

PORTA en Bank 0 

TRISB en Bank 1

PORTB en Bank 0

STATUS indifféremment de la banque 

Exemple : initialisation du port B 

C’est grâce au registre “status” qu’on peut accéder à “Bank 1” ou à “Bank 0”. Ce registre se trouve à l’adresse 0x03 ou 0x83 et c’est la valeur de son bit 5 qui définit l’une ou l’autre banque. Ce registre “status” ou registre d’état contient entre autre des éléments binaires indiquant l’état électrique dans lequel se trouve le PIC. C’est donc son tableau de bord. 

Bit 5 = 0    è On accède à Bank 0

Bit 5 = 1    è On accède à Bank 1 

Pour configurer une broche du port B en sortie, on doit mettre le bit correspondant du registre TRISB à 0 (zéro). Pour le configurer en entrée, on met le bit correspondant de TRISB à 1.

(0 = Output, 1 = Input) 

Exemple :

Bit 0 du registre TRISB = 0 è La broche RB0 du port B est en sortie

Bit 1 du registre TRISB = 1 è La broche RB1 du port B est en entrée

Pour initialiser le port B, on place à 1 le bit 5 du registre “status” pour accéder au registre “trisb” puis on met à 0 tous ses bits, ce qui configure le port B en sortie.

On remet le bit 5 du registre “status” à 0 pour accéder au “portb”, ce qui s’écrit (voir Travail #1) :

bsf    status,05    ; Sélection de bank1 pour l'accès au trisb

clrf    trisb           ; Déclaration du port B en sortie

bcf    status,05    ; Sélection de bank0 pour accès au port B

clrf    portb         ; Place toutes les sorties du port B au niveau logique 0

L’initialisation du port A est identique à celle du port B. Notez que sur le même port, on peut configurer une ou plusieurs broches en entrées et les autres en sorties.

5.1 Explication du tableau d’instructions

Ce tableau vous permet d’un simple regard de vous informer de la manière dont fonctionne chaque instruction.

• La première colonne indique le MNÉMONIQUE et les OPÉRANDES pour chaque opération. Les mnémoniques sont des mots réservés (donc que vous ne pouvez utiliser que pour cet usage) compris et interprétés par le programme d’assemblage.

Vous allez donc trouver à cet emplacement les instructions proprement dites que vous allez pouvoir encoder dans votre programme.

L’opérande complète l’instruction (adresse du registre à utiliser, nombre à manipuler, registre de destination du résultat etc.)

• La seconde colonne du tableau donne un bref descriptif de l’instruction.

• La troisième colonne donne le nombre de cycles de l’instruction. Notez que toutes les instructions nécessitent un seul cycle, sauf les sauts qui en nécessitent 2, et les opérations de test avec saut, lorsque le résultat du test engendre le saut (instructions notées 1(2)).

• La 4è colonne donne ce qu’on appelle l’ OPCODE ou code d’opération, c’est à dire le mot binaire que MPLAB va générer à partir du mnémonique. Vous ne vous en servirez donc pas.

• La 5è colonne est primordiale, car elle donne les INDICATEURS D’ETATS ou STATUS FLAGS affectés (modifiés) une fois l’instruction effectuée. Nous verrons ces indicateurs en détail, car ils constituent les clés de la programmation.

5.2 Les indicateurs d’état

Ces indicateurs sont indispensables pour la programmation. Il est donc absolument nécessaire d’avoir compris leur fonctionnement (du moins pour Z et C). Tous les indicateurs sont des bits du registre STATUS.

Le registre "STATUS" (0x03 et 0x83) est le registre d’état

Bit 7 : IRP (Register Bank Select Bit)

Sélectionne la banque à utiliser. Il fonctionne en lecture/écriture.

Passe à 0 après "Power On Reset"

Passe à 0 après reset externe (MCLR)

Passe à 0 après un "watchdog timer reset"

Ce bit n’est pas utilisé avec le 16F84 et doit être maintenu à 0

Bit 6 : RP1 (Register Bank Select Bit)

Sélectionne la banque à utiliser. Il fonctionne en lecture/écriture.

Passe à 0 après "Power On Reset"

Passe à 0 après reset externe (MCLR)

Passe à 0 après un "watchdog timer reset"

Ce bit n’est pas utilisé avec le 16F84 et doit être maintenu à 0

Bit 5 : RP0 (Register Bank Select Bit)

Sélectionne la banque à utiliser. Il fonctionne en lecture/écriture.

Passe à 0 après "Power On Reset"

Passe à 0 après reset externe (MCLR)

Passe à 0 après un "watchdog timer reset"

RP0 = 0 sélectionne la banque 0 (BANK0)

RP0 = 1 sélectionne la banque 1 (BANK1)

Sans effet sur les adresses de la mémoire RAM

Bit 4 : NOT_TO (Time Out Bit)

Fonctionne en lecture seulement

Repère le dépassement de délai du watchdog

Passe 1 après "Power On Reset"

Passe 1 après l’instruction "CLRWDT"

Passe 1 après l’instruction "SLEEP"

Passe à 0 après "WDT Time Out"

Bit 3 : NOT_PD (Power Down Bit)

Fonctionne en lecture seulement

Passe 1 après "Power On Reset"

Passe 1 après l’instruction "CLRWDT"

Passe 0 après l’instruction "SLEEP"

Bit 2 : Z (Zero Bit) ou indicateur d’état « Z »

C’est l’indicateur Zéro, il fonctionne de la manière suivante :

Si le résultat d’une opération POUR LEQUEL IL EST AFFECTÉ, donne un résultat égal à 0, le flag Zéro passe à 1.

La colonne 5 du tableau d’instructions indique les instructions qui modifient Z.

Donc, si on fait une addition avec ADDWF et que le résultat obtenu est 0, le bit Z sera à 1. Si le résultat est <>0 (différent de 0), le bit Z vaudra 0. Dans les 2 cas il est modifié.

Par contre, si on stocke une valeur avec l’instruction MOVWF, le bit Z ne sera pas modifié, même si la valeur vaut 0. Ces remarques sont valables pour les autres flags.

Ce bit fonctionne en lecture/écriture

Z = 1 si le résultat de l’opération précédente est 0

Z = 0 si le résultat de l’opération précédente est différent de 0

Bit 1 : DC (Digit Carry)

Fonctionne en lecture/écriture

DC = 1 si le résultat de l’opération précédente crée un dépassement du 4^e bit du résultat (bit 3 dépassant sur le bit 4).

DC = 0 si le résultat de l’opération précédente ne crée pas un dépassement du 4^e bit du résultat.

Bit 0 : C (Carry) ou indicateur d’état « C »

C’est l’indicateur pour Carry (report). Si le résultat d’une opération entraîne un débordement, le bit C sera positionné. Il s’agit en fait du 9^e bit de l’opération.

Exemple :

Si vous ajoutez B’11111110’ (254) + B’00000011’ (3)

Vous obtenez B’100000001’, (257) donc 9 bits.

Comme les registres du PIC ne font que 8 bits, vous obtiendrez B’00000001’ (1) et C positionné à 1 (en fait le 9^e bit, car 2⁸ = 256). Donc le résultat final est de 256 + 1 = 257.

Remarquez que si vous aviez ajouté B’11111110’ et B’00000010’, vous auriez obtenu B’00000000’.

Dans ce cas, vous auriez eu C à 1 ET Z à 1, ce qui signifie résultat nul, mais avec report (donc résultat = 256).

Ce bit fonctionne en lecture/écriture

C = 1 si le résultat de l’opération précédente a crée un dépassement du 8^e bit du résultat (en fait C est le 9^e bit).

C = 0 si le résultat de l’opération précédente n’a pas crée un dépassement du 8^e bit du résultat.

Après une soustraction, C = 1 si le résultat est positif ou nul

Exemple : subwf X,W (X – W) è W

Si Z=1 et C=1, c’est que X = W

Si Z = 0 et C = 1, c’est que X – W est positif

Si Z = 0 et C = 0, c’est que X – W est négatif

La commande CLRF STATUS va mettre à 0 les trois bits supérieurs du registre et à 1 le bit Z, les autres restant inchangés soit status = "0 0 0 i i 1 i i" (où i = inchangé).

5.3 Les instructions « orientées octet »

Ce sont des instructions qui manipulent les données sous forme d’octets (bytes). Elles sont codées de la manière suivante :

• 6 bits pour l’instruction : logique, car comme il y a 35 instructions, il faut 6 bits pour pouvoir les coder toutes.

• 1 bit de destination (d) pour indiquer si le résultat obtenu doit être conservé dans le registre de travail de l’unité de calcul (W pour Working) ou sauvé dans l’opérande (F pour File).

• Reste 7 bits pour encoder l’opérande (File). 7 bits ne donnent pas accès à la mémoire RAM totale, donc voici ici l’explication de la division de la RAM en deux banques. Le 8^e bit est en réalité le bit RP0 du registre STATUS.

Exemple :

ADDWF Add W and F

Syntaxe: [Étiquette] ADDWF f,d

Opérande : 0 £ f £ 127

d = 0 ou 1

Opération: (W) + (f) ® (destination)

Bits de "status" affectés : C, DC, Z

Encodage : 00 0111 dfff ffff

fff ffff est l’adresse du registre F. Il y a au total 80 registres dans la bank0, donc 7 bits suffisent pour y accéder. Pour accéder aux adresses de la bank1, un 8^e bit est rajouté, c’est le 5^e du registre STATUS.

Description: Le contenu du registre W est additionné au contenu du registre F. Si d=0, le résultat est placé dans le registre W et si d=1, le résultat est placé dans le registre F

Mots : 1

Cycles : 1

Cycle d’activité (quadrature = 4 cycles d’horloge): Q1, Q2, Q3, Q4.

Application : ADDWF FSR, 0

Avant l’instruction

W = 0x17

FSR = 0xC2

Après l’instruction

W = 0xD9

FSR = 0xC2

5.4 Les instructions « orientées bits »

Ce sont des instructions destinées à manipuler directement des bits d’un registre particulier. Elles sont codées de la manière suivante :

• 4 bits pour l’instruction (dans l’espace resté libre par les instructions précédentes)

• 3 bits pour indiquer le numéro du bit à manipuler (2³=8 possibilités, manipulation des bits 0 à 7)

• 7 bits pour indiquer l’opérande.

Exemple :

BCF Bit Clear f

Syntaxe: [Étiquette] BCF f,b

Opérande: 0 £ f £ 127

0 £ b £ 7

Opération: 0 ® (f<b>)

Bits de "status" affectés: Aucun

Encodage: 01 00bb bfff ffff

Description: Le bit "b" du registre F est mis à zéro.

Mots : 1

Cycles: 1

Cycle d’activité (quadrature = 4 cycles d’horloge): Q1, Q2, Q3, Q4.

Application : BCF FLAG_REG, 7

Avant l’instruction

FLAG_REG = 0xC7

Après l’instruction

FLAG_REG = 0x47

5.5 Les instructions littérales et de contrôle

Les instructions littérales : Ce sont les instructions qui manipulent des données qui sont codées dans l’instruction directement. Nous verrons ceci plus en détail lorsque nous parlerons des modes d’adressage.

Elles sont codées de la manière suivante :

• L’instruction est codée sur 6 bits
• Elle est suivie d’une valeur IMMEDIATE codée sur 8 bits (donc de 0 à 255).

Exemple #1 :

ADDLW Add literal and W

Syntaxe: [Étiquette] ADDLW k

Opérande : 0 £ k £ 255

Opération: (W) + k ® (W)

Bits de "status" affectés : C, DC, Z

Encodage : 11 111x kkkk kkkk

Description: Le contenu du registre W est additionné aux 8 bits du nombre k, le résultat est placé dans le registre W

Mots : 1

Cycles : 1

Cycle d’activité (quadrature = 4 cycles d’horloge): Q1, Q2, Q3, Q4.

Application : ADDLW 0x15

Avant l’instruction

W = 0x10

Après l’instruction

W = 0x25

Exemple #2 :

DECFSZ Decrement f, Skip if 0

Syntaxe: [ label ] DECFSZ f,d

Opérande: 0 £ f £ 127

d Î [0,1]

Opération: (f) - 1 ® (destination);

   Skip if result =0

Application : ICI DECSFZ COMPTEUR, 1

GOTO ICI

SUITE

Avant l’instruction

PC = Adresse ICI

Après l’instruction

COMPTEUR = COMPTEUR-1

Si COMPTEUR = 0

PC=Adresse SUITE

Si COMPTEUR ≠ 0

PC=Adresse ICI + 1

Les instructions de contrôle : 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 :

• Les instructions sont codées sur 3 bits

• La destination codée sur 11 bits

Nous pouvons déjà en déduire que les sauts ne donnent accès qu’à 2K de mémoire programme (2¹¹). Ceci ne pose aucun problème, le 16F84 ne disposant que de 1K mots de mémoire. Pour coder une adresse de saut à l’intérieur de la mémoire programme, il faut donc : 10 bits (2¹⁰ = 1024 adresses = 1K).

Exemple :

GOTO Unconditional Branch

Syntaxe : [ label ] GOTO k

Opérande : 0 £ k £ 2047

Opération : k ® PC<10:0>

PCLATH<4:3> ® PC<12:11>

Bits de "status" affectés : Aucun

Encodage : 10 1kkk kkkk kkkk

Description : GOTO est un branchement inconditionnel. Les 11 bits de la valeur immédiate sont charges dans le PC bits <10:0>. Les bits supérieurs du PC sont charges à partir de PCLATH<4:3>. GOTOutilise deux cycles d’instruction.

Mots : 1

Cycles : 2

Cycle d’activité (quadrature = 4 cycles d’horloge) : Q1, Q2, Q3, Q4

	Q1	Q2	Q3	Q4
Premier cycle	Décode l’instruction	Lit le nombre k	Traite les données	Écrit dans le PC
Deuxième cycle	Pas d’opération	Pas d’opération	Pas d’opération	Pas d’opération

Application : GOTO PAUSE

Après l’instruction

PC = Adresse PAUSE

Application des instructions FSR et INDF

Les registres FSR et INDF (0x04 et 0x00)

Ces deux registres permettent aux instructions d’accéder aux informations qu’elles manipulent par un adressage indirect.

Pour comprendre le fonctionnement de ces deux registres, on analyse une routine qui permet d’effacer la RAM. À la mise sous tension, la RAM contient des valeurs aléatoires qu’on va supprimer pour éviter des surprises. 

La RAM disponible à l’utilisateur commence à l’adresse 0x0C et finit à l’adresse 0x50. L’effacement se fera en deux étapes :

• On efface les cases mémoires de 0x0C à 0x40 

• On efface ensuite les cases mémoires allant de 0x41 à 0x50

 ;=========================================================================================================

; Effacer RAM

; ********* 

movlw            0x0c            ; Initialisation du pointeur (1^e adresse RAM)

movwf            fsr               ; Pointeur d'adressage indirect se place à l’adresse 0x0C 

Init

clrf            indf                   ; Effacer la ram à l’adresse pointée par “FSR”

incf            fsr,f                  ; Pointer sur suivant (adresse précédente + 1)

btfss            fsr,6              ; Tester si la fin de zone est atteinte (=40)(Bit 6 du registre FSR

                 ; égal à 1 lorsque son contenu est 0x40 soit 64 décimal

goto            init                 ; Non, boucler

btfss            fsr,4             ; Tester si la fin de zone est atteinte (=50)(Bit 4 du registre FSR

      ; égal à 1 lorsque son contenu est 0x50 soit 80 décimal

goto            init               ; Non, boucler

clrf            indf                ; Effacer la ram à l’adresse 0x50

clrf            portb              ; Éteindre toutes les lumières du portb 

;========================================================================================================= 

Explications : 

MOVLW   0x0C

MOVWF   FSR 

Ces deux instructions installent dans le registre FSR l’adresse de la première case mémoire à effacer. Ce registre FSR pointe donc sur l’adresse du registre à effacer. Le contenu de cette case mémoire est transféré dans le registre virtuel INDF. 

CLRF    INDF 

Cette instruction efface la case mémoire dont l’adresse se trouve dans le registre FSR. Le registre INDF (INDIRECT FILE) n’existe pas physiquement. Ce n’est qu’un procédé qui permet d’accéder à l’adresse pointée par le registre FSR (il facilite la construction électronique interne du PIC). 

INCF    FSR, F 

Cette instruction incrémente l’adresse pointée par le registre FSR soit nouvelle adresse = adresse précédente +1 = 0x0C + 1 = 0x0D 

BTFSS  FSR, 6 

Vérifie si le bit 6 du registre FSR est égal à 1, ce qui se produit lorsque l’adresse pointée est 0100 0000 soit 0x40 

Si c’est le cas alors les cases mémoires de 0x0C à 0x3F sont effacées. On saute l’instruction suivante et on va à : 

BTFSS  FSR, 4 

On est à l’adresse 0x40 et on continue à incrémenter le registre FSR. Cette instruction vérifie si le bit 4 du registre FSR est égal à 1, ce qui se produit lorsque l’adresse pointée est 0101 0000 soit 0x50 

Si c’est le cas alors les cases mémoires de 0x40 à 0x4F sont effacées. On saute l’instruction suivante, on efface la case mémoire 0x50 et on continue la suite du programme. 

     Le registre FSR sert donc à pointer une adresse et le registre INDF permet d’y accéder.

7.1 Présentation :

MPLAB est un outil de développement pour les PIC 16F84 et autres, il présente l’énorme avantage d’être gratuit. On le télécharge sur le site http://www.microchip.com. Il contient :

• un éditeur

• un assembleur

• un simulateur

Il permet (voir figure suivante):

• La rédaction du fichier source en langage assembleur (fichier.ASM)

• Sa transformation en fichier objet (fichier.HEX) prêt à être chargé dans la mémoire programme du microcontrôleur

L’ensemble des fichiers nécessaires à ces opérations est regroupé dans un espace «projet» (fichier.mcw). Pour des raisons de facilité, tous les fichiers d’un même projet doivent porter exactement le même nom que le projet lui-même, seules diffèrent les extensions.

 7.2 Utilisation :

Après avoir démarrer Windows XP, le premier élément que vous voyez est le bureau, la zone de l’écran dans laquelle vous travaillez. Essayez d’imaginer le bureau comme votre espace de travail personnalisé. Plusieurs icônes (ou petites images) sont rangées sur le côté gauche du bureau. Chaque icône représente un objet, par exemple un dossier ou un programme.

Dans notre cas, c’est le dossier intitulé “Programmation de pics” qui nous intéresse.

    7.3 Édition du programme  

b)       Entrez «Lab1» comme nom de votre nouveau projet, et sélectionnez le répertoire dans lequel vous avez placé votre fichier Lab1.asm.

c)       Une fois le bouton <OK> pressé, une nouvelle fenêtre apparaît dans le coin supérieur gauche du bureau de MPLAB IDE.

d)       Dans cette fenêtre, vous voyez le nom de votre projet (Lab1.mcp), ainsi que les fichiers liés à celui-ci. Pour l’instant, vous n’en avez aucun, c’est normal.

e)       Nous allons commencer à préciser les paramètres importants de notre projet, et tout d’abord le type de pic que nous allons utiliser. Sélectionner le menu « configure, select device », une fenêtre apparaît pour vous proposer le choix du pic. Notez que par défaut, Microchip vous propose un pic de la famille 18F, promotion de nouveau produit oblige… Sélectionnez le 16F84.

f)       La fenêtre vous montre alors, à l’aide de leds vertes quels outils sont supportés par le pic sélectionné. Vous voyez donc que le simulateur intégré (MPLAB SIM) fonctionne avec ce pic, de même pour les autres outils de développement disponibles chez Microchip. Cliquez sur <OK>, la fenêtre se referme.

g)       MPLAB 7.51 dispose d’un « wizard » pour la création des projets, qui vous permet d’en créer automatiquement de nouveaux. Cependant, afin de vous permettre de localiser les principales options des projets, on ne s’en servira pas dans ce petit tutorial. Si par la suite vous désirez l’utiliser, il se sélectionne à l’aide du menu « project, wizard ».

h)       Nous allons maintenant préciser quel langage nous allons utiliser, sachant que nous travaillons en assembleur, mais que différents compilateurs sont proposés par Microchip et d’autres sociétés. Sélectionnez le menu « project -> Select langage toolsuite… ». Dans la fenêtre qui s’ouvre, sélectionnez dans le menu déroulant : « Microchip MPASM toolsuite ». MPASM est en effet l’assembleur par défaut de Microchip.

i)       Dans les fenêtres inférieures, vous voyez le nom des exécutables utilisés par MPASM, ne vous en préoccupez pas. Cliquez <OK> pour fermer la fenêtre. 

j)       Il nous faut maintenant indiquer à MPASM quel est notre ou nos fichiers source(s). Ceci s’effectue dans la fenêtre « Lab1.mcw » qui est restée ouverte dans le coin supérieur gauche. Pour ajouter un fichier source, c’est très simple : cliquez avec le bouton droit sur « source files », puis sélectionnez « Add ». Une fois sélectionné le fichier, le nom de celui-ci apparaît dans l’arborescence. Notez que MPLAB pointe par défaut sur votre répertoire de travail, précédemment choisi.

k)       Ici, il est important de bien comprendre que le fichier source choisi sera celui qui sera assemblé ou compilé. Autrement dit, si dans ce fichier se trouve une instruction « include » qui inclut un autre fichier, vous ne devez pas le sélectionner en supplément, il sera joint au projet au moment de l’assemblage. 

Par contre, si vous désirez assembler simultanément deux fichiers, et que votre premier fichier ne fait pas référence au second, alors vous devez ajouter ce fichier à l’arborescence. 

Tous nos projets ne nécessiteront d’ajouter qu’un seul fichier. Si votre projet nécessite un ou plusieurs fichier(s) supplémentaire(s), la directive « include » sera ajoutée au fichier source afin que l’assembleur intègre automatiquement ce ou ces autre(s) fichier(s). 

l)       Il nous reste un élément important à préciser, celui du système de numérotation utilisé par défaut. Sélectionnez le menu : « Project -> build options -> project ». Une fenêtre s’ouvre. Sélectionnez l’onglet « MPASM assembler ».

m)       Comme nous avons décidé de numéroter l’hexadécimal sous la forme 0x, et le binaire sous la forme B’’. Tout nombre sans préfixe sera considéré comme décimal. Cochez donc la case « Decimal ». Ne touchez pas aux autres options, vous les utiliserez peut-être lorsque vous serez devenus un « pro » et que vous voudrez adapter certains paramètres. A ce moment, leur rôle vous semblera clair. Afin d’éviter tout oubli, je vous conseille cependant de TOUJOURS placer un préfixe devant vos nombres, ceci vous évitera bien des déboires. Utilisez par exemple les syntaxes suivantes :

0x10, H’10’, ou 10h   : notations hexadécimales

B’00010000’         : notation binaire

D’18 ‘         : notation décimale

.18 : autre notation décimale (n’oubliez pas le « . »)

Un nombre écrit sous la forme sans préfixe sera interprété selon le paramètre précédemment décrit, et donc risque de poser problème si vous intégrez votre fichier dans un autre projet, ou, simplement, si vous communiquez à autrui votre fichier source sans préciser la notation par défaut.

n)       Maintenant, MPASM est prêt à assembler votre programme. Mais, il n’y a toujours rien à l’écran !

Effectivement, MPASM ne se préoccupe pas des fichiers affichés à l’écran, seuls comptent le fichier inscrit dans l’arborescence et les fichiers inclus à partir de ce fichier. Vous pouvez avoir autant de fichiers que vous voulez sur l’écran, ou ne pas en avoir du tout. MPLAB s’en moque.

Par contre, tous les fichiers ouverts lors de la sauvegarde de votre projet seront automatiquement rouverts lors de la prochaine ouverture du projet, même s’ils ne servent à rien. Cette propriété est pratique pour faire des “copier/coller” à partir d’un autre fichier ou pour voir tout en programmant ce qu’un autre a bien pu faire. 

o)       Bien entendu, nous allons afficher notre fichier source, pour voir ce qu’il contient. La méthode la plus simple est de double-cliquer sur son nom dans l’arborescence de la fenêtre Lab1.mcw. Faites-le. Voici votre fichier de départ ouvert. Mettez-le à la taille appropriée en lui faisant occuper la moitié gauche de l’écran  si vous manquez de place (vous n’aurez plus besoin de  fenêtre du projet, vous pouvez la masquer ou la réduire).

L’édition de votre programme est terminée, il faut maintenant l’assembler. 

7.5 Création du programme objet

Il s’agit de transformer ce fichier “.asm” en fichier “.hex” directement exploitable par le programmateur de PIC 

a)       Cliquer sur “Project”

b)       Cliquer sur “Make Project”. La transformation de Lab1.asm en Lab1.hex se fait. 

S’il y a des erreurs dans le programme, le message “BUILD FAILED” s’affichera. 

Correction des erreurs : ouvrir le fichier Lab1.lst qui est fabriqué par l'assembleur et contient le fichier source avec les lignes d’erreurs détectées par l’assembleur. Il indique les erreurs de codes et de syntaxes. Repérez vos erreurs puis : 

• Revenir dans la fenêtre d’écriture du fichier source (Lab1.asm), corriger les erreurs

• Recompiler en cliquant sur “Project - Make Project” et recommencer jusqu’à obtenir le message “BUILD SUCCEEDED”.

Une fois votre programme compilé, sortez de MPLAB IDE.

7.6  Enregistrement du programme dans le pic

§            Dans le dossier “Programmation de pics”, double cliquez sur “WinPic”, le logiciel qui vous permettra d’entrer votre programme dans le pic.

§         Cliquez sur File puis sur Load puis sélectionner sur votre disquette dans le répertoire Data, le fichier Lab1.hex qui contient le travail d’assemblage sous la forme prête à être gravée dans le microcontrôleur.

§         Cliquez sur Device.Config. À la case part, sélectionnez PIC16F84 puis assurez-vous que “XT” (crystal) apparaît à la case oscillator et que la case Code Protection est à OFF.

§         Cliquez sur device puis sur “Program (CODE+DATA+CONFIG)”. Attendre que l’indication de la programmation terminée s’affiche dans la barre d’état avant de quitter “WinPic”. 

7.7  Fichiers créés (voir figure précédente) :

Le fichier Source (*.asm) : il contient le programme tel qu'il a été écrit dans un traitement de texte. 

Le fichier liste (*.lst) : il est fabriqué par l'assembleur et contient le fichier source avec les lignes d’erreurs détectées par l’assembleur. Il indique les erreurs de codes et de syntaxes. 

Le fichier objet (*.cod) : il contient le travail d'assemblage ou le code source créé par l’assembleur. 

Le fichier hexadécimal (*.hex) : il contient le travail d'assemblage sous la forme binaire qui sera gravée dans le microcontrôleur 

Le fichier des erreurs (*.err) : il indique les lignes où le compilateur n’a pas pu coder les instructions. 

7.8 Simulation : 

Pour aider le programmeur à faire ses corrections, MPLAB fournit une possibilité de simulation qui permet de suivre le cheminement du programme, instruction par instruction. 

Pour passer en mode simulation :

§      Cliquer sur “Options”

§      Cliquer sur “Development Mode”

§      Sélectionner “MPLAB-SIM Simulator” puis cliquer sur OK 

Un message annonçant que certaines informations de votre projet seront perdues apparaît. Cliquer sur OK. À partir de maintenant, le simulateur est activé. 

Par Window, on peut voir le contenu des mémoires et registres après chaque exécution d’instruction et par Window - Watch Window - New Watch Window, on peut voir la valeur des variables. Il suffit alors de lancer la simulation pas à pas par F6 (reset), la ligne courante passe en surbrillance. Chaque pression sur la touche F7 fait avancer le programme. 

Pour éviter d’entrer dans les boucles du programme, ce qui pourrait être long, on appuie sur F8

On peut modifier le contenu d'une mémoire par Window – Modify. 

Ctrl F9 (Debug-Run-Animate en raccourci) provoque l’exploration complète du programme (utiliser l’icône feu rouge pour arrêter). 

• Retour au début

• Retour à microcontrôleur PIC

• Suite

• Sommaire

• Accueil