Vous êtes sur la page 1sur 43

MICROCHIP PICs

Travaux Pratiques

Objectifs : Ces TPs ont pour but d'illustrer le fonctionnement des PICs et de découvrir les outils de développement proposés par Microchip pour programmer ce type de microcontrôleur. On s'intéresse ici au PIC 16F84, qui fait partie des PICs milieu de gamme de Microchip. On se familiarisera d'abord avec le jeu d'instructions assembleur du processeur pour ensuite aborder un langage de plus haut niveau grâce au compilateur C de HI-TECH Software.

L'énoncé des TPs est situé dans la 2 e partie du document après une présentation des outils.

I) Présentation de la carte

Le PIC 16F84 est ici intégré sur une carte d'application permettant la commande d'un afficheur 7 segments et de 5 LEDs. Un bouton poussoir est relié au bit 0 du port B (RBB 0 ) ce qui peut permettre de générer une interruption matérielle.

RA 4 RA 3 RA 2 RA 1 RA 0 Logique négative (0 = allumé)
RA 4
RA 3
RA 2
RA 1
RA 0
Logique négative
(0 = allumé)
RB 7
connecteur
RJ 12
RB
RB 6
2
RB 1
Logique positive
(1 = allumé)
Logique négative
(RB 0 = 0 si appui)
RB
RB 5
3
RB 0
RB 4

1

Le connecteur RJ12 sert à relier la carte à l'interface ICD2 qui permet ici la programmation du PIC et également l'alimentation de la carte (jusqu'à 200 mA). La programmation se fait suivant le protocole ICSP (In-Circuit Serial Programming) défini par Microchip (voir datasheet DS30277d du fabricant)) : la broche /MCLR est maintenue à 12 V pour faire entrer le PIC en mode programmation et les instructions sont transmises bit par bit de façon synchrone sur la broche RB 7 du port B au rythme de l'horloge appliquée sur RB 6 . Le schéma électrique de la carte est donné dans l'annexe 1.

II) Environnement de travail

La chaîne d'outils utilisée pour le développement est MPLAB, fournie gratuitement par MICROCHIP. Il s'agit d'un IDE (Integrated Development Environment) qui intègre tous les outils nécessaires pour la mise au point d'un projet :

éditeur de fichier source compilateur + assembleur éditeur de lien (permet d'obtenir le fichier exécutable de sortie) débuggeur (simulateur et/ou vrai débuggeur si le circuit cible le permet) programmateur

Un IDE offre l'avantage de pouvoir effectuer toutes ces opérations dans une même

fenêtre de travail et facilite grandement les interactions entre les modules (gestion et mise à jour automatique des fichiers d'échanges, exécution d'un seul clic des modules permettant

l'obtention du ficher exécutable

)

d'où un gain de productivité.

MPLAB peut être interconnecté directement au PIC in situ sur sa carte d'application grâce au module d'interface ICD2, relié d'un côté au port USB du PC et de l'autre au PIC via les 3 broches de contrôle mentionnées plus haut. Cette interface permet la programmation des PICs mais surtout permet d'exploiter le module ICD (In Circuit Debugger) qui est intégré dans certains PICs. L'ICD, disponible sur les PICs haut de gamme, autorise un "vrai" debbugage en exécutant le programme sur le PIC et en renvoyant le contenu des registres à MPLAB via l'interface ICD2. On peut ainsi tester le programme ou seulement certaines parties, en mode pas à pas, continu… comme avec un simulateur mais avec l'intérêt de contrôler véritablement les sorties du PIC et d'être en interaction avec le système.

Le PIC16F84 ne possède pas de module ICD et l'on se contentera donc d'une

Le PIC16F877

simulation pour valider les programmes de cette 1 ère partie de TPs d'initiation

2

dispose lui de l'ICD et l'on consultera le paragraphe "utilisation de l'interface ICD2" pour le développement du projet qui suivra les TPs.

Les activités de TP se déroulent sous forme d'exercices dont les fichiers à lire ou à modifier sont enregistrés dans les sous répertoires TP1, TP2… du répertoire TPs_PIC accessible depuis la page WEB www.enseirb-matmeca.fr/~bedenes (onglet MICROCHIP). On commencera par effectuer une copie de ce répertoire sur le compte UNIX

Le descriptif ci-dessous est à exploiter en fonction des différentes opérations à mener dans les exercices.

III) Présentation du logiciel MPLAB

Lancer le logiciel MPLAB IDE à partir du lien situé sur le bureau. La fenêtre qui s'ouvre fait apparaître une interface avec l'utilisateur relativement classique :

in terface avec l'utilisateur relativement classique : En haut on observe une barre de menus dé

En haut on observe une barre de menus déroulants avec en dessous des icones permettant d'actionner les principales commandes (barre évolutive en fonction de l'étape où l'on se trouve dans le projet). Dans l'espace de travail, 2 fenêtres sont ouvertes et vides au lancement du logiciel :

"untitled workspace" qui correspond au gestionnaire de fichier, et "output" qui correspond à la fenêtre d'informations pour l'utilisateur dès que celui-ci effectue une manipulation sur le fichier exécutable de sortie.

3

1) Création d'un projet

Un fichier source assembleur ( .asm ) ou C ( .c ) peut être édité simplement avec la commande FILE > NEW. Il peut ensuite être assemblé ou compilé individuellement dans le but d'obtenir un fichier exécutable de sortie. On préférera cependant l'intégrer à un projet qui inclura éventuellement d'autres fichiers sources à lier, de manière à avoir une approche bien structurée (projet découpé en fonctions élémentaires, code relogeable…) et exploiter au mieux les possibilités offerte par MPLAB notamment au niveau du debuggage.

On va donc commencer par créer un projet. Cette opération peut être effectuée directement par PROJECT > NEW PROJECT, mais il est conseillé de lancer l'assistant pour la création de projet PROJECT > PROJECT WIZARD… qui permet de configurer tous les paramètres qu'il faudra de toutes façons définir.

choisir le composant cible dans la liste : 16F84A définir le logiciel qui devra "compiler" le(s) fichier(s) source(s) du projet :

"compiler" le(s) fichier(s) source(s) du projet : MPASM pour un fichier en assembleur ( .asm )

MPASM pour un fichier en assembleur (.asm )

du projet : MPASM pour un fichier en assembleur ( .asm ) HI TECH pour un

HI TECH pour un fichier en C (.c )

Indiquer le nom du projet exo… et son emplacement (H:/TP_PICs/TP…/) MPLAB va ainsi créer un fichier .mcp contenant les paramètres du projet. Il crée aussi un fichier .mcw qui permettra de sauvegarder l'espace de travail à la fermeture du projet (fenêtres ouvertes, paramètres…) pour pouvoir le restaurer à l'identique à la prochaine ouverture du projet.

4

Si des fichiers sources sont déjà existants, on peut les indiquer dès maintenant

sont déjà exista nts, on peut les indiquer dès maintenant On ajoutera également un fichier de

On ajoutera également un fichier de commande nécessaire à l'éditeur de lien MPLINK qui dépend du composant cible. On choisira pour les TPs celui associé au 16F84 : C:\Program Files\Microchip\MPASM Suite\LKR\16f84.lkr. Ce fichier n'est cependant pas indispensable si il n'y a qu'un seul fichier source dans le projet et/ou que l'on ne souhaite pas générer de fichier objet (cf partie III-3).

La lettre majuscule qui précède le chemin du fichier ajouté indique de quelle manière sera référencé le fichier :

U (User reference) : le fichier sera référencé par un chemin relatif au répertoire du projet

S (System) : le fichier sera référencé par un chemin absolu

A

(Automatic) : laisse le choix à MPLAB de choisir relatif ou absolu (si le fichier est dans le répertoire du projet il choisira relatif)

C

(Copy) : dans les 3 modes ci-dessus, MPLAB ne fait que créer un lien sur le fichier source. Ce dernier mode effectue une copie du fichier dans le répertoire du projet et un référencement relatif

La dernière fenêtre récapitule les principaux paramètres du projet

5

2) Affectation du registre de configuration Tous les PICs possèdent un registre de configuration situé

2) Affectation du registre de configuration

Tous les PICs possèdent un registre de configuration situé dans un emplacement (adresse 0x2007) associé à la mémoire programme. Ce registre est très important puisqu'il définit notamment le type d'oscillateur qui sera utilisé pour générer l'horloge.

exemple : registre CONFIG du PIC 16F84

le type d'oscillateur qui sera utilisé pour générer l'horloge. exempl e : registre CONFIG du PIC

6

Le registre CONFIG est accessible de la même façon que la mémoire en utilisant le protocole ICSP. On effectue en général sa programmation en même temps que la mémoire programme. Le contenu qui sera chargé dans ce registre peut être défini de 2 manières :

dans le fichier source en utilisant une directive appropriée TP) directement à partir du menu CONFIGURE de MPLAB

CONFIG

(voir exemples du

partir du menu CONFIGURE de MPLAB CONFIG (voir exemples du Cette fenêtre permet aussi de visualiser

Cette fenêtre permet aussi de visualiser le paramétrage défini par la

directive

du fichier source si la case "Configuration Bits

set in code" est cochée tel que ci-dessus

CONFIG

3) Compilation du projet

La compilation du projet a pour but d'obtenir, à partir du ou des fichiers sources (.asm, .c) voire de fichiers objets (.o , .lib), un fichier de sortie (.hex , voir annexe 2 pour plus d'informations) correspondant au code exécutable qui pourra ensuite être implanté en mémoire programme du PIC lors de la phase de programmation. D'autres fichiers de sortie sont également disponibles dans le répertoire du projet (mapping mémoire, données pour le débuggage…), comme on peut le voir sur la figure suivante qui représente toutes les étapes de la compilation :

7

MPLAB IDE utilise la chaine d'outils "M PASM suite" qui intè gre les 3 modules

MPLAB IDE utilise la chaine d'outils "MPASM suite" qui intègre les 3 modules :

MPASM : logiciel d'assemblage qui permet à partir d'un fichier source .asm en assembleur d'obtenir un fichier objet .o contenant le code exécutable correspondant, non affecté à des adresses fixes en mémoire programme pour le moment (code relogeable) et dont les registres sont désignés par des symboles (références) qui n'ont pas encore d'adresse en mémoire RAM.

MPLIB : logiciel pour créer une librairie d'objets c'est-à-dire une association de fichiers objets plus simple à manipuler (un seul fichier à désigner)

MPLINK : logiciel d'édition de liens pour relier tous les fichiers objets (voire des librairies) pour obtenir le fichier exécutable .hex. Ce module a besoin pour cela d'un fichier de commande .lkr qui définit les sections ou le code peut être alloué en mémoire programme ainsi que l'emplacement des registres. Un fichier de commande type est proposé pour chaque PIC (C:\Program Files\Microchip\MPASM Suite\LKR\16f84.lkr pour le PIC 16F84, voir annexe 3).

Un compilateur C peut aussi être utilisé pour obtenir un fichier objet à partir d'un fichier source en langage C (sur la figure MPLAB C18, mais pour nous ce sera HI-TECH PICC Lite).

8

La compilation du projet s'effectue simplement par la commande PROJECT > BUILD ALL (raccourci CTRL + F10) après avoir éventuellement modifié les options dans PROJECT > BUILD OPTIONS > PROJECT. Attention, les fichiers sources concernés sont ceux définis dans le projet et ne sont pas nécessairement ceux ouverts dans l'espace de travail !! La sauvegarde des fichiers modifiés est par contre automatique à chaque compilation.

On notera que dans le cas d'un fichier source unique, MPASM peut directement fournir un fichier exécutable .hex sans générer dans ce cas de fichier objet .o. Cette compilation particulière ("QUICKBUILD") est implicite lorsqu'on omet de spécifier dans le projet le fichier de commande .lkr pour l'éditeur de lien MPLINK dont l'exécution n'est pas nécessaire dans ce cas. Un QUICKBUILD peut aussi être effectué à partir de tout fichier source .asm sans avoir créé de projet (commande PROJECT > QUICKBUILD). Cette méthode n'est cependant à utiliser que dans le cas de projets très simples (TP1…) ou pour tester rapidement une routine d'un programme car elle ne fait pas appel à MPLINK qui génère des fichiers bien utiles pour le débuggage (.map, .cof voir annexe 4 pour plus d'informations)

4) Simulation

Quand le PIC cible ne possède pas de module de debuggage ICD ou que le PIC ne peut être relié à la station de développement, le simulateur de MPLAB permet de faciliter la mise au point du programme grâce à une interface simple et convivial. Il faut commencer par activer le simulateur par DEBUGGER > SELECT TOOL > MPLAB SIM.

Fenêtres de visualisation

Pour visualiser le contenu des registres SFR : VIEW > SPECIAL FUNCTION REGISTERS ou de tout le contenu de la RAM : VIEW > FILE REGISTERS

Pour visualiser le contenu d'un registre quelconque du programme : VIEW > WATCH puis choisir les registres à observer dans la liste (+ Add Symbol)

On peut aussi observer la pile système VIEW > HARDWARE STACK

Le déroulement du programme peut s'observer sur le fichier source mais aussi sur le fichier assemblé (code machine + assembleur) que l'on peut faire apparaître avec VIEW > DISASSEMBLY LISTING ou sous forme plus brute avec VIEW > PROGRAM MEMORY. L'utilisation de la fenêtre STOPWATCH (DEBUGGER > STOPWATCH) permet d'observer la durée effective de l'exécution (vérifier la fréquence de l'horloge).

9

Exécution

Il faut d'abord compiler le projet. Une flèche verte doit apparaître sur le fichier source au niveau de la 1 ère instruction.

fichier source au niveau de la 1 è r e instruction. Il suffit ensuite de lancer

Il suffit ensuite de lancer la simulation par les différentes commandes du menu DEBUGGER ou plus directement avec les icônes de raccourci (voir illustration dans la partie utilisation de l'ICD2) ou touches de fonction:

Reset (F6) : initialise le PC à 0, on peut aussi simuler un RESET matériel (idem + RAZ des timers…) ou simplement remettre à 0 le chien de garde

Run (F9) :

Animate : idem mais au ralenti pour voir évoluer les registres Step into (F7) : exécution pas à pas Step over (F8) : exécution continue puis stoppe à la fin du prochain sous-programme (ou fonction en C) Step out : exécution continue puis stoppe à la fin du sous-programme en cours (ou fonction en C)

exécution continue (stop par F5)

10

On peut poser des points d'arrêt (breakpoints) pour exécuter des blocs d'instructions. Pour cela pointer sur le début de la ligne de programme avec la souris et double-cliquer sur la touche de droite. Pour annuler le point d'arrêt recommencer la même opération ou supprimer tous les points d'arrêt à l'aide du menu déroulant disponible avec un clic droit.

Simulation d'événements extérieurs

Il est possible de simuler l'activation d'une des broches d'entrées du PIC avec la commande DEBUGGER > STIMULUS > NEW WORKBOOK. Choisir l'onglet "async" pour activer une entrée à l'aide de la souris indépendamment du déroulement du programme. Définir la broche dans la colonne "Pin / SFR" ainsi que l'action à effectuer dans la colonne "Action".

à eff ectuer dans la colonne "Action". Un clic dans la colonne "Fire" eff ectue

Un clic dans la colonne "Fire" effectue l'action correspondante immédiatement (l'affichage des registres n'est cependant mis à jour qu'après l'exécution de la prochaine instruction). On peut ainsi simuler l'appui sur le bouton poussoir relié à RB0 dans le TP1 par exemple.

On peut aussi modifier à tout moment le contenu d'un registre en changeant sa valeur dans la fenêtre "Special Function Registers" ou "WATCH".

En conclusion, l'utilisation du simulateur est de façon générale assez intuitive (naviguer dans le menu DEBUGGER et consulter l'aide HELP > TOPICS > DEBUGGERS > MPLAB SIM pour découvrir les autres fonctionnalités).

11

5) Programmation avec le module ICD2

L'opération de programmation consiste à transférer le fichier exécutable .hex dans la mémoire programmme (FLASH) ainsi que la programmation du registre CONFIG voire de la mémoire EEPROM si le PIC en dispose. L'opération s'effectue selon le protocole ICSP avec un transfert de données série (bit par bit sur la broche PGD), synchrone (au rythme de l'horloge appliquée sur la broche PGC) et séquentiel (les emplacements mémoires sont remplis les uns à la suite des autres depuis l'adresse 0). L'interface ICD2 permet une programmation très rapide grâce sa liaison USB avec le PC, selon le schéma suivant :

Auparavant, le boitier ICD2 doit être raccordé, d'une part au PC via le bus USB et d'autre part à l'application comportant le microcontrôleur à programmer, en respectant l'ordre suivant :

On sélectionne ensuite l'outil de débuggage via l'interface ICD2 avec DEBBUGER >
On sélectionne ensuite l'outil de débuggage via l'interface ICD2 avec DEBBUGER >

Remarque : on a la possibilité d'alimenter la carte d'application par l'intermédiaire du boitier ICD2 (bloc d'alimentation relié à la prise jack) mais la tension fournie via le connecteur RJ12 sera imposée à 5 V pour un courant max de 200 mA. C'est cette technique qui a été retenue pour alimenter la carte de TP de manière à optimiser son coût et sa compacité. Dans tous les cas, il faut appliquer une source d'alimentation (sur l'ICD2 ou la carte d'application) idem à celle du PIC car les lignes PGC et PGD de l'interface sont en sortie "collecteur ouvert" et nécessite donc un "pull-up" pour fixer le niveau logique haut.

12

Pour

information,

le

schéma

de

raccordement

du

module

ICD2

avec

la

carte

d'application est donné ci-dessous ainsi que le brochage du connecteur RJ12 qui est utilisé.

ainsi que le brochage du connecteur RJ12 qui est utilisé. Etablir la connexion avec le module
ainsi que le brochage du connecteur RJ12 qui est utilisé. Etablir la connexion avec le module

Etablir

la

connexion

avec

le

module

ICD2

:

PROGRAMMER > MPLAB ICD2

pour le PIC 16F84 :

PGC = RB 6 PGD = RBB 7

PROGRAMMER

>

SELECT

Les différentes étapes de la connexion sont visualisées dans la fenêtre "output" :

PROGRAMMER > SELECT Les différentes étapes de la connexion s ont visualisées dans la fenêtre "output"

13

Ce type d'erreur à plusieurs origines possibles :

- soit le câble USB n'est pas connecté sur le bon port, c'est-à-dire celui choisi lors de l'installation du pilote (dépend de la salle mais en principe c'est le connecteur du haut)

- soit l'interface ICD2 n'était pas encore reliée au moment du lancement de MPLAB et il suffit dans ce cas de fermer et relancer celui-ci.

- soit le module ICD2 est HS !

Une fois la connexion établie programmer le circuit avec l'icône

connexion établie programmer le circuit avec l'icône Remarque : il n'y a pas de bouton de

Remarque

:

il

n'y

a

pas de bouton de RESET sur la carte, la remise

commandée via l'ICD2 depuis MPLAB :

par exemple

à 0 pouvant être

réinitialise l'ICD2
réinitialise l'ICD2

désactive le RESET

active le RESET

(/MCLR=1)

(/MCLR=0)

Il est à noter qu'une fois le PIC programmé, l'ICD2 maintien le RESET activé (par défaut) et PGC=PGD=0. Pour utiliser le PIC il faut donc désactiver le RESET, et si l'on souhaite pouvoir contrôler RB6 et RB7 (c'est-à-dire PGC et PGD) il faut aussi réinitialiser l'ICD2 pour mettre ces sorties de l'interface en haute impédance.

En cas de doute sur le fonctionnement de la carte, on pourra charger et exécuter le fichier dEMo.hex situé dans le répertoire de projet (utiliser FILE>Import… dEMo.hex pour permettre la programmation sans créer de projet)

14

6) Debuggage avec le module ICD

Si l'on utilise un PIC avec module de débuggage intégré (ICD) on a tout intérêt à privilégier ce mode plutôt que la simulation pour tester le programme. L'avantage du débugger est que le programme tourne réellement sur le PIC qui est de plus relié au système via ses entrées/sorties. On obtient ainsi un test beaucoup plus réaliste si ce n'est que toutes les ressources du PIC ne sont pas disponibles dans ce mode (cf doc du PIC). Pour un debuggage encore plus efficace, il existe des émulateurs (MPLAB ICE 2000, REAL ICE…) qui se branche à la place du PIC et qui exécute le programme de la même façon tout en renvoyant des informations à MPLAB (utilisent en général un processeur plus puissant) pour un coût relativement plus élevé.

L'utilisation de l'ICD nécessite une interface matérielle avec le PC telle que le module ICD2. MPLAB permettra ensuite de récupérer le contenu des registres pour les visualiser et de contrôler le déroulement du programme sur le PIC avec les mêmes outils qu'en simulation.

On choisit le module ICD2 dans la liste des interfaces proposées pour le débuggage avec DEBUGGER > SELECT TOOL > MPLAB ICD2. On accède ainsi aux mêmes commandes que celles vues en simulation, avec notamment les icônes permettant de contrôler l'exécution du programme :

perm ettant de contrôler l'exécution du programme : Il faut tout d'abord établir la connexion av

Il faut tout d'abord établir la connexion avec le boitier ICD2 en cliquant par exemple sur l'icône ci-dessus "Connexion avec l'ICD2", la procédure étant la même que pour la programmation.

Une fois la connexion établie, il faut programmer le PIC (icône "Program Target Device") après avoir compilé le projet. A noter que cette opération est nécessaire même si la programmation a déjà été faite directement par le menu PROGRAMMER (cf section 5) car le débuggage nécessite une routine supplémentaire que MPLAB charge en mémoire programme ainsi que l'activation du bit "DEBUG" du registre CONFIG.

15

On se reportera à la section "4) Simulation" pour connaître les différentes possibilités de déroulement du programme et l'observation des registres.

16

ANNEXES

17

ANNEXE 1 : schéma de la carte

ANNEXE 1 : schéma de la carte 19

19

ANNEXE 2 : format INTEL HEX

ANNEXE 2 : format INTEL HEX 20
ANNEXE 2 : format INTEL HEX 20

20

ANNEXE 3 : fichier de commande 16f84.lkr

ANNEXE 3 : fichier de commande 16f84.lkr ANNEXE 4 : limitations liées à un "quickbuild" 21

ANNEXE 4 : limitations liées à un "quickbuild"

ANNEXE 3 : fichier de commande 16f84.lkr ANNEXE 4 : limitations liées à un "quickbuild" 21

21

TPs

TP 1

Objectifs

Découverte de MPLAB Manipulation des instructions des PICs et gestion des entrées / sorties

I) Programme BP

1) Ouvrir le fichier BP.asm dans le répertoire TP1 :

Observer le rôle des quelques directives d'assemblage utilisées. (le fichier p16F84.inc issu du répertoire C:\Program Files\Microchip\MPASM Suite\ est fourni en annexe TP1-2)

Compléter le fichier pour afficher le chiffre "1" lorsqu'on appui sur le bouton poussoir et "0" au repos. On n'oubliera pas de définir l'argument de la directive CONFIG

2) Créer un projet TP1.mcp avec comme fichier source BP.asm puis effectuer sa compilation. Dans ce 1 er TP on effectuera un "QUICKBUILD" sans utiliser l'éditeur de lien (cf section III-3). Observer tous les fichiers créés dans le répertoire TP1 (on pourra se reporter à l'annexe TP1-3 pour identifier les fichiers), ouvrir les fichiers BP.lst , TP1.hex, et identifier leur contenu. Le format INTEL HEX32 (format par défaut de MPLAB mais le HEX8 pourrait suffire) du fichier .hex ainsi que la liste des différents fichiers générés par MPLAB sont donnés en annexe 2 et TP1-3.

3) Programmer le PIC sur la carte d'application et tester le programme.

4) Simuler le programme (même si celui-ci fonctionne !) :

On visualisera le contenu des registres SFR.

On simulera l'appui sur le poussoir comme indiqué dans la partie III-4.

25

II) Programme CHENILLARD 1

1) Ouvrir le fichier chen1.asm du répertoire TP1 (voir copie en annexe TP1-1). Observer les différentes parties de ce fichier et identifier le rôle des directives d'assemblage utilisées. Analyser le sous-programme de temporisation "tempo" et calculer sa durée d'exécution.

2) Ecrire le programme principal pour qu'il fasse allumer l'une après l'autre une LED de gauche à droite puis de droite à gauche…etc sur la carte d'application. La durée d'allumage d'une LED sera calibrée par l'appel au sous-programme "tempo".

3) Ajouter ce nouveau fichier source au projet TP1 et supprimer le lien sur le fichier BP.asm. Compiler, programmer, tester. Pour bien comprendre le fonctionnement de la pile on simulera le programme en observant sont déroulement dans la fenêtre "desassembly listing" (on neutralisera la temporisation, trop longue à simuler, en mettant provisoirement le bloc de cette routine en commentaire).

III) Programme MAXIMUM

On cherche maintenant à créer un programme permettant de rechercher le nombre le plus élevé dans une liste de 10 nombres.

1)

Créer un nouveau fichier max.asm. Définir une zone de variables contenant les éléments :

MAX de 1 octet TAB de 10 octets

2) Ecrire le programme permettant de placer dans la variable MAX le nombre le plus élevé de la liste dont le 1 er élément est pointé par TAB (on recopiera les parties utiles du programme chen1.asm pour gagner du temps). On utilisera pour cela un pointeur (registre FSR) pour scruter la liste en effectuant un adressage indirect.

3) La carte d'application ne possédant pas d'unité d'affichage permettant d'indiquer clairement la valeur de MAX, on effectuera le test de ce programme uniquement en simulation (une compilation directe sans définir de projet pourra suffire). On remplira au préalable la liste des 10 valeurs à la main dans la fenêtre FILE REGISTERS (on verra dans le TP2 une possibilité de déclarer des variables initialisées).

26

ANNEXE TP1-1 : fichier chen1.asm

LIST

#include <p16F84.inc>

p=16F84

; Définition de processeur ; Définitions de variables

CONFIG

_CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC

;

; sa programmation. Les définitions sont dans le fichier include.

; Voici les valeurs et leurs définitions :

'

CONFIG'

précise les paramètres encodés dans le processeur au moment de

; _CP_ON

; _CP_OFF

; _PWRTE_ON

; _PWRTE_OFF

; _WDT_ON

; _WDT_OFF

; _LP_OSC

; _XT_OSC

; _HS_OSC

; _RC_OSC

Code protection ON : impossible de relire

Code protection OFF

Timer reset sur power on en service

Timer reset hors-service

Watch-dog en service

Watch-dog hors service

Oscillateur quartz basse vitesse

Oscillateur quartz moyenne vitesse

Oscillateur quartz grande vitesse

Oscillateur à réseau RC

;*********************************************************************

*

;*********************************************************************

;

ASSIGNATIONS

TRISA_VAL

EQU

H'XX' ; Valeur à charger dans registre TRISA

TRISB_VAL

EQU

H'XX' ; Valeur à charger dans registre TRISB

INIT_PORTA

EQU

H'XX' ; Valeur initiale à charger dans registre PORTA

INIT_PORTB

EQU

H'XX' ; Valeur initiale à charger dans registre PORTB

;*********************************************************************

*

;

;*********************************************************************

DEFINE

#DEFINE BOUTON

PORTB,0

; bouton-poussoir

;*********************************************************************

*

;*********************************************************************

;

MACRO

BANK0

macro

; défini une macro "BANK0"

bcf

STATUS , RP0

; passer banque0

endm

; fin de la macro

BANK1

macro

bsf

STATUS , RP0

; passer banque1

endm

;*********************************************************************

*

;

;*********************************************************************

DECLARATIONS DE VARIABLES

CBLOCK 0x00C

; début de la zone de variables (pour exemple)

VAR : 1 TABLEAU : 10

; déclare une variable "VAR" de 1 octet (adresse 0x00C) ; réserve une zone mémoire de 10 octets (0x00D - 0x017)

cmpt1 : 1

; (TABLEAU est le 1er élément) ; compteur de boucles 1

27

cmpt2 : 1 cmpt3 : 1

; compteur de boucles 2 ; compteur de boucles 3

ENDC

; Fin de la zone

;**********************************************************************

*

;**********************************************************************

;

DEMARRAGE SUR RESET

org 0x000

reset

goto

; fixe l'adresse d'implantation en mémoire programme ; de l'instruction qui suit

start

;*********************************************************************

*

;*********************************************************************

;

INITIALISATIONS

init

BANK1

movlw TRISA_VAL movwf TRISA movlw TRISB_VAL movwf TRISB

BANK0

movlw INIT_PORTA movwf PORTA movlw INIT_PORTB movwf PORTB return

;*********************************************************************

*

;*********************************************************************

;

SOUS-PROGRAMME DE TEMPORISATION

tempo movlw 2 movwf cmpt3

boucle3

clrf cmpt2

boucle2

clrf cmpt1

boucle1

nop

decfsz

cmpt1 , f

goto boucle1

decfsz

cmpt2 , f

goto boucle2

decfsz

cmpt3 , f

goto boucle3

return

;*********************************************************************

*

;*********************************************************************

;

PROGRAMME PRINCIPAL

start

call init

END

; directive fin de programme

28

ANNEXE TP1-2 : fichier p16F84.inc

LIST

; P16F84.INC Standard Header File, Version 2.00 Inc.

NOLIST

Microchip Technology,

;

This header file defines configurations, registers, and other useful bits

of

;

information for the PIC16F84 microcontroller. These names are taken to

match

;

the data sheets as closely as possible.

;

Note that the processor must be selected before this file is

;

included. The processor may be selected the following ways:

;

1. Command line switch:

;

C:\ MPASM MYFILE.ASM /PIC16F84

;

2. LIST directive in the source file

;

LIST P=PIC16F84

;

3. Processor Type entry in the MPASM full-screen interface

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

;

;

Revision History

;

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

;Rev:

Date:

Reason:

;2.00

07/24/96 Renamed to reflect the name change to PIC16F84.

;1.01

05/17/96 Corrected BADRAM map

;1.00

10/31/95 Initial Release

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

;

;

Verify Processor

;

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

IFNDEF

16F84

MESSG "Processor-header file mismatch. Verify selected

processor."

ENDIF

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

;

;

Register Definitions

;

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

W

EQU

H'0000'

F

EQU

H'0001'

 

29

;----- Register Files------------------------------------------------------

INDF

EQU

H'0000'

TMR0

EQU

H'0001'

PCL

EQU

H'0002'

STATUS

EQU

H'0003'

FSR

EQU

H'0004'

PORTA

EQU

H'0005'

PORTB

EQU

H'0006'

EEDATA

EQU

H'0008'

EEADR

EQU

H'0009'

PCLATH

EQU

H'000A'

INTCON

EQU

H'000B'

OPTION_REG

EQU

H'0081'

TRISA

EQU

H'0085'

TRISB

EQU

H'0086'

EECON1

EQU

H'0088'

EECON2

EQU

H'0089'

;----- STATUS Bits --------------------------------------------------------

IRP

EQU

H'0007'

RP1

EQU

H'0006'

RP0

EQU

H'0005'

NOT_TO

EQU

H'0004'

NOT_PD

EQU

H'0003'

Z

EQU

H'0002'

DC

EQU

H'0001'

C

EQU

H'0000'

;----- INTCON Bits --------------------------------------------------------

GIE

EQU

H'0007'

EEIE

EQU

H'0006'

T0IE

EQU

H'0005'

INTE

EQU

H'0004'

RBIE

EQU

H'0003'

T0IF

EQU

H'0002'

INTF

EQU

H'0001'

RBIF

EQU

H'0000'

;----- OPTION Bits --------------------------------------------------------

NOT_RBPU

EQU

H'0007'

INTEDG

EQU

H'0006'

T0CS

EQU

H'0005'

T0SE

EQU

H'0004'

PSA

EQU

H'0003'

PS2

EQU

H'0002'

PS1

EQU

H'0001'

PS0

EQU

H'0000'

;----- EECON1 Bits --------------------------------------------------------

EEIF

EQU

H'0004'

WRERR

EQU

H'0003'

WREN

EQU

H'0002'

WR

EQU

H'0001'

RD

EQU

H'0000'

 

30

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

;

;

RAM Definition

;

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

MAXRAM

H'CF'

BADRAM

H'07', H'50'-H'7F', H'87'

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

;

;

Configuration Bits

;

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

_CP_ON

EQU

H'000F'

_CP_OFF

EQU

H'3FFF'

_PWRTE_ON

EQU

H'3FF7'

_PWRTE_OFF

EQU

H'3FFF'

_WDT_ON

EQU

H'3FFF'

_WDT_OFF

EQU

H'3FFB'

_LP_OSC

EQU

H'3FFC'

_XT_OSC

EQU

H'3FFD'

_HS_OSC

EQU

H'3FFE'

_RC_OSC

EQU

H'3FFF'

LIST

 

31

ANNEXE TP1-3 : fichiers manipulés par MPLAB

32
32

Objectifs

TP 2

Gestion du timer Programmation avec interruption Utilisation du mode SLEEP, réveil par WATCHDOG Utilisation de fichiers sources multiples avec code objet relogeable

I) Programme CHENILLARD2 (tempo avec timer)

Pour avoir une information sur le temps qui s'écoule, il est plus simple et précis d'utiliser un timer plutôt qu'une boucle logicielle. Le TIMER0 du PIC peut fonctionner en en compteur d'événement ou bien en timer classique incrémenté par les fronts d'horloge du PIC après division par 4 + prescaler (cf poly description des PICs)

1) Recopier dans le répertoire TP2 le fichier chen1.asm de TP1 en le renommant chen2.asm. Modifier le sous-programme de temporisation pour que celle-ci soit calibrée par le timer0. On remarquera qu'il faudra faire déborder le timer plusieurs fois pour obtenir la même durée, même en réglant le prescaler sur le rapport de division le plus élevé (256). On utilisera donc un compteur de débordement en introduisant une variable cmpt qu'on incrémentera (ou décrémentera si plus simple…) à chaque débordement repéré par le flag T0IF. On n'oubliera pas de compléter le sous-programme d'initialisation pour configurer convenablement le timer.

2) Créer dans le répertoire TP2 le projet TP2.mcp et lui associer le fichier source chen2.asm. Tester le fonctionnement sur la carte et débugger avec MPSIM si nécessaire.

II) Programme CHENILLARD3 (tempo avec timer déclenchant une interruption)

L'utilisation du timer pour temporiser apporte une précision et une simplicité au niveau de l'écriture du code. Mais le processeur est mal exploité puisqu'il ne fait qu'attendre le débordement du timer (scrutation de T0IF) sans pouvoir effectuer d'autre tâche. Le timer0 étant capable de déclencher une interruption du processeur, il sera donc préférable d'utiliser ce procédé pour n'occuper le processeur qu'au moment du débordement du timer.

33

1) Supprimer le fichier source chen2.asm du projet TP2.mcp et le remplacer par le fichier chen3.asm déjà dans le répertoire. Compléter le sous-programme d'initialisation pour autoriser la source d'IT timer0.

2) Compléter la routine d'interruption de manière à décaler la LED allumée tous les n débordements du timer (n à définir afin d'obtenir la bonne temporisation). Le programme principal pourra ainsi continuer à se dérouler entre chaque débordement du timer. Pour matérialiser visuellement ce pseudo-parallélisme on fera exécuter dans le programme principal la routine principale du programme BP.asm du TP1 qu'on recopiera.

3) Tester le programme sur la carte en vérifiant que le symbole affiché évolue bien lorsqu'on appui sur le poussoir, sans perturber le défilement régulier du chenillard. Débugger avec le simulateur si nécessaire en neutralisant le prescaler pour écourter l'intervalle de temps entre débordements (mettre PSA=0 "à la main" durant la simulation après l'exécution de la routine d'initialisation)

III) Programme CHENILLARD4 (tempo avec le "chien de garde")

Une dernière façon d'obtenir une temporisation, plus marginale, consiste à utiliser un autre timer interne du PIC : le watchdog timer WDT. Ce timer est particulier puisqu'il réinitialise le PIC lorsqu'il déborde. Ceci permet de réinitialiser l'application lorsque le programme reste en attente pendant une durée anormale (cf poly PICs). Le débordement du chien de garde permet aussi un réveil du PIC lorsque celui-ci est en mode veille commandé par l'instruction SLEEP. Cette possibilité peut être exploitée, si le PIC n'a rien d'autre à faire que d'attendre, pour obtenir une temporisation tout en minimisant la consommation électrique.

Le principe est simple :

après le décalage d'une LED on placera le PIC en mode SLEEP. Le réveil du PIC sera ici provoqué par le débordement du chien de garde ou plutôt par celui du prescaler qui est utilisé ici en post-diviseur (cf poly PICs).

on choisira une durée de débordement de l'ordre de 0,5 s en prenant comme référence 18 ms pour la période de débordement du WDT.

34

1) Ouvrir le fichier chen2.asm déjà écrit et le sauvegarder sous le nom chen4.asm. On l'associera au projet TP2.mcp à la place de chen3.asm. Supprimer le sous-programme

de temporisation et remplacer l'appel CALL tempo par l'instruction SLEEP. Modifier la

routine d'initialisation pour affecter le prescaler au WDT avec le bon rapport de

division. Ne pas oublier d'activer le WDT avec la directive

CONFIG.

2) Vérifier le bon fonctionnement du programme. En cas de dysfonctionnement, le programme utilisant le WDT est également simulable : il faut définir la durée de débordement du chien de garde en incluant le post-scaler avec DEBUG > SETTINGS… dans l'onglet Break options.

IV) Programme CHENILLARD 5

On va dans cette partie réécrire le programme CHENILLARD2 en le fractionnant en plusieurs parties indépendantes de manière à découper le programme à réaliser en plusieurs sous-programmes (fonctions) élémentaires, indépendantes, que l'on pourra dans un cas plus général écrire et valider plus simplement qu'en considérant le projet dans son intégralité.

1) Associer au projet TP2.mcp les fichiers sources chen5.asm et tempo.asm présents dans le répertoire. On fera appel ici à l'éditeur de lien MPLINK pour la compilation en ajoutant le fichier de commande C:\logiciel\pic\MPLAB7_6\MPASM Suite\LKR\16f84.lkr.

A la compilation, MPASM va maintenant générer des fichiers objets associés aux

fichiers sources, que va relier MPLINK pour obtenir le fichier exécutable. Pour découper un projet en plusieurs fichiers sources, on peut aussi inclure tous les fichiers dans un fichier principal grâce à la directive "include" (ici on pourrait inclure le fichier tempo.asm dans le fichier chen5.asm). L'intérêt principal d'utiliser un éditeur de lien est qu'il permet de relier des fichiers objets qui représentent le code exécutable des fichiers sources associés, qui peut :

ne pas être alloué en mémoire programme (on parle alors de "code relogeable") manipuler des registres et dérouter le programme vers une étiquette sans spécifier leur adresse absolue. Ces étiquettes ou registres sont simplement représentés par un symbole qui pourra être exploité par d'autres fichiers liés (on parle alors de "références croisées")

On peut ainsi découper un projet en modules (fichiers objets) aussi indépendants que possible, qui pourront éventuellement être utilisés dans d'autres projets. Pour obtenir un code relogeable, on n'utilise plus la directive org mais code qui permet de définir une section de code. De même, on peut définir des sections de données initialisées (directive idata) ou non

35

(directive udata). Toutes ces sections seront allouées en mémoire à l'édition de lien à partir du fichier .lkr. Les registres ou étiquettes exportées devront être désignées par la directive global après leur déclaration. Elles seront utilisables dans d'autres fichiers sources en les déclarant par la directive extern.

2) Ouvrir les 2 fichiers sources et observer les différentes sections et la procédure utilisée pour croiser l'étiquette "tempo".

3) Effectuer une recopie du programme principal du TP1 et compiler le projet. Observer le fichier de mapping TP2.map généré par MPLINK et repérer où sont logés en mémoire les différentes sections du programme, ainsi que les variables des sections de données. Ouvrir également la fenêtre Program Memory (VIEW > PROGRAM MEMORY) qui indique ce qui sera implanté dans la mémoire du PIC à partir du fichier .hex de sortie.

On remarquera que MPLINK a crée 2 sections : données_init_i où se trouve les valeurs initiales des variables de la section données_init (l'instruction RETLW x retourne x dans le registre W), ainsi qu'une section .cinit qui est une table de correspondance ("Look Up Table") entre l'adresse de début des sections de valeurs initiales (ici il n'y en a qu'une qui est données_init_i ) et l'adresse de début de la section des variables correspondantes (ici données_init) ainsi que le nombre de variables de la section. Il est en effet nécessaire de stocker les valeurs initiales en mémoire morte (ici en mémoire programme) puisque la mémoire RAM est par définition volatile.

Si l'on exécute le programme tel quel (par simulation…) il ne sera pas opérationnel car pour initialiser les variables (ici cmpt3) il faut ajouter un programme d'initialisation qui exploite la table .cinit pour effectuer une recopie de données_init_i dans données_init. Ce programme d'initialisation est généré automatiquement par tout compilateur C. Avec MPASM, c'est à l'utilisateur de l'ajouter. Un exemple de ce type de fichier est fourni avec MPLAB.

4) Ajouter au projet le fichier source : C:\logiciel\pic\MPLAB7_6\MPASM Suite\Example\IDASM16.asm. Ouvrir le fichier, repérer le point d'entrée copy_init_data qui correspond au début du sous-programme qui effectue la recopie. Effectuer un appel (CALL) sur cette étiquette au début du programme principal dans chen5.asm en n'oubliant pas la directive extern.

5) Vérifier que l'initialisation de cmpt3 s'effectue correctement en simulation et tester le programme sur la carte. Pourquoi la temporisation n'a-t-elle plus la bonne durée à partir du 2 e appel au sous programme-tempo ?

36

Objectifs

I) Exemple

TP 3

Programmation en langage C Utilisation de la mémoire EEPROM

1) Ouvrir les fichier test.c et tempo.c dans le répertoire TP3 (voir copie en annexe TP3-1). Ce fichier est l'équivalent en langage C des fichiers chen5.asm et tempo.asm du TP2 (+ changement de sens quand on appuie sur le bouton poussoir). Observer la structure de ce programme, notamment les directives de compilation. (le fichier d'entêtes pic1684.h introduit par pic.h est fourni en annexe TP3-2)

2) Créer le projet TP3.mcp en choisissant le langage HI-TECH Universal ToolSuite et lui associer les 2 fichiers sources en C. On remarquera qu'il n'est pas possible de spécifier de fichier de commande .lkr car le compilateur C possède son propre éditeur de lien HLINK qui impose l'adresse des 3 types de sections : text psect (code), data psect (données initialisées) et bss psect (données non initialisées). Compiler et observer les 2 fichiers .lst générés par le compilateur C ainsi que le fichier .map.

II) Programme MESSAGE

On va ici écrire un programme permettant l'affichage d'un message de n caractères séquentiellement sur l'afficheur 7 segments. On souhaite pouvoir accélérer la vitesse d'affichage à chaque appui sur le poussoir. La temporisation de défilement sera mémorisée dans l'EEPROM de donnée du PIC 16F84; ainsi l'affichage reprendra à une même cadence après une coupure de l'alimentation (l'intérêt est bien sûr ici de voir comment contrôler logiciellement la mémoire EEPROM du PIC !)

Le message sera stocké dans l'EEPROM au moment de la programmation grâce à la

DATA 8) qui permet de

directive

programmer des octets 8 par 8.

EEPROM_DATA

(DATA 1, DATA 2,…

,

37

On codera les caractères à afficher par l'octet :

a b c d e f g 0

de manière à

pouvoir charger directement cette valeur dans le port B.

La temporisation sera obtenue à partir du débordement du timer0 qui générera une interruption.

L'appui sur le poussoir générera également une interruption qui modifiera alors le rapport de division du prescaler stocké lui aussi dans l'EEPROM.

La fonction main sera donc réduite à l'appel de la fonction init. (on pourra y ajouter le programme chenillard test.c pour visualiser le fonctionnement par interruption)

Les rebonds du bouton poussoir seront neutralisés par une boucle de temporisation de l'ordre de 10 ms).

Le programme est à écrire dans le fichier mes.c préformé.

38

ANNEXE TP3-1 : fichier test.c + tempo.c

fichier test.c

#include <pic.h>

CONFIG

(HS&WDTDIS&PWRTEN);

char led=0xfe; extern tempo (void);

init (void)

{

TRISA = 0x00; PORTA = 0xff; TRISB = 0x01;

PORTB = 0x00; OPTION = 0x00;

}

main (void)

{

init ();

// inclut des macros + pic1684.h

// directive pour programmer le registre CONFIG

// la fonction extern est défini dans un autre fichier

while (1)

{

while (led != 0xef && INTF != 1)

{

led = led << 1 | 0x01;

PORTA = led; tempo ();

}

INTF = 0;

while (led != 0xfe && INTF != 1)

{

led = led >>1 | Ox80; PORTA = led; tempo ();

}

INTF = 0;

}

}

/*

ILLUSTRATIONS

*/

/* valeur = eeprom_read(ADRESSE);

permet de lire l'EEPROM avec 0x00 =< ADRESSE <= 0x3F

*/

permet d'écrire dans l'EEPROM

*/

/* eeprom_write (0x00,tempo); /* asm("sleep");

permet d'introduire une instruction assembleur */

/*

#asm

on peut aussi écrire toute

*/

/*

SLEEP

une routine en assembleur

*/

/* #endasm

*/

39

/* void interrupt bouton (void)

routine d'interruption (le nom n'a pas d'importance)

{

INTF=0;

le contexte est sauvegardé mais il faut réinitialiser le flag de la source d'IT

}

*/

#include <pic.h>

tempo (void)

{

long i;

for (i=1; i<=10000 ; i++);

}

fichier tempo.c

40

ANNEXE TP3-2 : fichier pic1684.h

#ifndef _HTC_H_ #warning Header file pic1684.h included directly. Use #include <htc.h> instead. #endif

/*

*

Header file for the Microchip

*

PIC 16CR83 chip

*

PIC 16F83 chip

*

PIC 16C84 chip

*

PIC 16F84 chip

*

PIC 16F84A chip

*

PIC 16CR84 chip

*

Midrange Microcontrollers

*/

static volatile unsigned char RTCC @ 0x01; static volatile unsigned char TMR0 @ 0x01;

@ 0x02;

static volatile unsigned char STATUS

static

static volatile unsigned char PORTA @ 0x05; static volatile unsigned char PORTB @ 0x06;

unsigned char FSR @ 0x04;

static volatile unsigned char PCL

@ 0x03;

static volatile unsigned char EEDATA

static volatile unsigned char EEADR @ 0x09;

@ 0x08;

static

unsigned char PCLATH

@ 0x0A;

static volatile unsigned char INTCON

@ 0x0B;

static static volatile static volatile

static volatile unsigned char bank1 EECON1 static volatile unsigned char bank1 EECON2

unsigned char bank1 OPTION

@ 0x81; TRISA @ 0x85; TRISB @ 0x86; @ 0x88; @ 0x89;

unsigned char bank1 unsigned char bank1

/* STATUS bits */ static volatile bit

RP0

@ (unsigned)&STATUS*8+5;

static volatile bit

TO

@ (unsigned)&STATUS*8+4;

static volatile bit

PD

@ (unsigned)&STATUS*8+3;

static volatile bit

ZERO @ (unsigned)&STATUS*8+2;

static volatile bit

DC

@ (unsigned)&STATUS*8+1;

static volatile bit

CARRY @ (unsigned)&STATUS*8+0;

/*

PORTA bits

*/

static volatile bit

RA4

@ (unsigned)&PORTA*8+4;

static volatile bit

RA3

@ (unsigned)&PORTA*8+3;

static volatile bit

RA2

@ (unsigned)&PORTA*8+2;

static volatile bit

RA1

@ (unsigned)&PORTA*8+1;

static volatile bit

RA0

@ (unsigned)&PORTA*8+0;

/*

PORTB bits

*/

static volatile bit

RB7

@ (unsigned)&PORTB*8+7;

static volatile bit

RB6

@ (unsigned)&PORTB*8+6;

static volatile bit

RB5

@ (unsigned)&PORTB*8+5;

static volatile bit

RB4

@ (unsigned)&PORTB*8+4;

static volatile bit

RB3

@ (unsigned)&PORTB*8+3;

static volatile bit

RB2

@ (unsigned)&PORTB*8+2;

41

static volatile bit

/* INTCON bits */

RB1

@ (unsigned)&PORTB*8+1;

static volatile bit

RB0

@ (unsigned)&PORTB*8+0;

static volatile bit

INT

@ (unsigned)&PORTB*8+0;

static volatile bit

GIE

@ (unsigned)&INTCON*8+7;

static volatile bit static volatile bit static volatile bit static volatile bit static volatile bit static volatile bit static volatile bit

EEIE @ (unsigned)&INTCON*8+6; T0IE @ (unsigned)&INTCON*8+5; INTE @ (unsigned)&INTCON*8+4; RBIE @ (unsigned)&INTCON*8+3; T0IF @ (unsigned)&INTCON*8+2; INTF @ (unsigned)&INTCON*8+1; RBIF @ (unsigned)&INTCON*8+0;

/* OPTION

bits */

static bank1 bit RBPU @ (unsigned)&OPTION*8+7; static bank1 bit INTEDG @ (unsigned)&OPTION*8+6; static bank1 bit T0CS @ (unsigned)&OPTION*8+5; static bank1 bit T0SE @ (unsigned)&OPTION*8+4;

static bank1 bit PSA static bank1 bit PS2 static bank1 bit PS1 static bank1 bit PS0

@ (unsigned)&OPTION*8+3; @ (unsigned)&OPTION*8+2; @ (unsigned)&OPTION*8+1; @ (unsigned)&OPTION*8+0;

/*

TRISA bits

*/

static volatile bank1 bit

TRISA4

@ (unsigned)&TRISA*8+4;

static volatile bank1 bit

TRISA3

@ (unsigned)&TRISA*8+3;

static volatile bank1 bit

TRISA2

@ (unsigned)&TRISA*8+2;

static volatile bank1 bit

TRISA1

@ (unsigned)&TRISA*8+1;

static volatile bank1 bit

TRISA0

@ (unsigned)&TRISA*8+0;

/*

TRISB bits

*/

static volatile bank1 bit

TRISB7

@ (unsigned)&TRISB*8+7;

static volatile bank1 bit

TRISB6

@ (unsigned)&TRISB*8+6;

static volatile bank1 bit

TRISB5

@ (unsigned)&TRISB*8+5;

static volatile bank1 bit

TRISB4

@ (unsigned)&TRISB*8+4;

static volatile bank1 bit

TRISB3

@ (unsigned)&TRISB*8+3;

static volatile bank1 bit

TRISB2

@ (unsigned)&TRISB*8+2;

static volatile bank1 bit

TRISB1

@ (unsigned)&TRISB*8+1;

static volatile bank1 bit

TRISB0

@ (unsigned)&TRISB*8+0;

/* EECON1 bits */ static volatile bank1 bit

EEIF @ (unsigned)&EECON1*8+4;

static volatile bank1 bit static volatile bank1 bit

WRERR @ (unsigned)&EECON1*8+3; WREN @ (unsigned)&EECON1*8+2;

static volatile bank1 bit

WR

@ (unsigned)&EECON1*8+1;

static volatile bank1 bit

RD

@ (unsigned)&EECON1*8+0;

#define CONFIG_ADDR

0x2007

/*osc configurations*/

#define RC

0x3FFF

// resistor/capacitor

#define HS

0x3FFE

// high speed crystal/resonator

#define XT

0x3FFD

// crystal/resonator

#define LP

0x3FFC

// low power crystal/resonator

/*watchdog*/ #define WDTEN

0x3FFF

// enable watchdog timer

#define WDTDIS

0x3FFB

// disable watchdog timer

42

/*power up timer*/ #if defined (_16C84) #define PWRTEN #define PWRTDIS #else #define PWRTDIS #define PWRTEN #endif

/*power up timer*/ #if defined (_16C84) #define PWRTEN #define PWRTDIS #else #define PWRTDIS #define PWRTEN #endif
/*power up timer*/ #if defined (_16C84) #define PWRTEN #define PWRTDIS #else #define PWRTDIS #define PWRTEN #endif
/*power up timer*/ #if defined (_16C84) #define PWRTEN #define PWRTDIS #else #define PWRTDIS #define PWRTEN #endif

0x3FFF

0x3FF7

0x3FFF

0x3FF7

/* enable power up timer*/ /* disable power up timer */

/* enable power up timer*/ /* disable power up timer */

/* disable power up timer */ /* enable power up timer */

/* disable power up timer */ /* enable power up timer */

#if defined (_16CR83) || defined(_16CR84)

#define DP 0x3F7F // data code is protected

0x008F

// alternative definition #define DATPROT 0x3F7F #define DATUNPROT 0x3FFF

#define PROTECT

// program code is protected

// use DP // use UNPROTECT

#elif defined (_16C84) #define PROTECT

#elif defined (_16F83) || defined(_16F84) || defined(_16F84A)

#define PROTECT #endif

0x3FEF

0x000F

// program code is protected

// program code is protected

#define UNPROTECT 0x3FFF

// do not protect the code

43