Licence SPI – AGE Travaux Pratiques Langage C18 · compilateur traduit des instructions...

Licence SPI – AGE

Travaux Pratiques Langage C18

Julien [email protected]

Zouhair [email protected]

Marc [email protected]

Table des matières1. Avant de commencer.....................................................................................................................1

2. Le Matériel..................................................................................................................................... 12.1. Le Kit PICDEM 2 Plus et PIC 18F4520..................................................................................12.2. MPLAB Integrated Development Environment...................................................................... 12.3. Le programmateur ICD3..........................................................................................................2

3. TP n°1 : Initiation à la programmation en langage C................................................................33.1. Introduction : assembleur et compilateur C.............................................................................33.2. Génération d'un signal carré.................................................................................................... 43.3. Édition et Compilation du programme.................................................................................... 43.4. Simulation et programmation du micro-contrôleur................................................................. 53.5. Applications............................................................................................................................. 5

4. TP n°2 : Ecriture d'un driver pour LCD.................................................................................... 74.1. Le contrôle de l'afficheurs LCD...............................................................................................74.2. Fonctions de pilotage du LCD................................................................................................. 74.3. Création de la libraire « afficheurlcd ».................................................................................. 11

5. TP n°3 : Interruptions et Périphériques....................................................................................135.1. Programme « Clignotant » avec interruption.........................................................................135.2. Chronomètre.......................................................................................................................... 14

mailto:[email protected]



Travaux Pratiques de Microcontrôleur – PIC 18F4520

1. Avant de commencer

Ces séances de travaux pratiques (TP) sont destinées à illustrer les notions qui vous ont été présentées en cours. Pour cela, vous aurez à concevoir et à tester un certain nombre de programmes en langage C.

Pour chaque tâche que vous aurez à réaliser, nous vous invitons à enregistrer votre programme sous un nom particulier pour garder une sauvegarde de travail. Pour faciliter le débogage et assurer la maintenance et la portabilité de vos codes, il est primordial que vous commenciez par rédiger un algorigramme, que vous commentiez clairement votre programme et que vous pensiez à le rendre le plus clair possible (ex : en choisissant des noms appropriés pour les labels).

Concernant l'évaluation de votre travail, nous vous demanderons de nous présenter le programme correspondant à chaque tâche que vous aurez à programmer sur le simulateur ou sur le kit de démonstration (cf. plus bas). Nous corrigerons également vos codes en portant une attention particulière à la lisibilité (pensez donc aux commentaires !). Enfin, vous devrez également nous rendre les algorigrammes qui correspondent aux codes.

2. Le Matériel

2.1. Le Kit PICDEM 2 Plus et PIC 18F4520Le kit PICDEM 2 Plus est un kit simple qui permet de mettre en évidence les capacités de différents micro-contrôleurs du fabricant Microchip à travers divers périphériques et accessoires reproduis sur le schéma de la figure 1.

Le micro-contrôleur utilisé est le PIC18F4520 de Microchip. C'est un micro-contrôleur 8 bits disposant d'une mémoire de programme de 32 Ko, de 1536 octets de RAM (Random Access Memory), d'une EEPROM (Electrically Erasable Programmable Read Only Memory) de 256 octets et de 36 entrées/sorties.

2.2. MPLAB Integrated Development EnvironmentMPLAB IDE est un environnement gratuit de programmation pour les micro-contrôleurs de la famille Microchip. L’environnement intègre un éditeur d’assembleur, un débogueur complet ainsi que tous les outils permettant de gérer les programmateurs de composants. La possibilité d’intégrer un compilateur C dans l’environnement de développement MPLAB s’inscrit directement dans la politique du service qui est d’utiliser des langages de programmation évolués dans les développements en électronique.

L3 SPI AGE S5 1

Figure 1: Le kit PICDEM 2 Plus, Périphériques et Accessoires

Microcontrôleur LCD

ContrôlesRA1...RA3

DonnéesRD0...RD3

LEDsRB0...RB3

BuzzerRC2

RS232RC6, RC7

PoussoirsRA4, RB0

Entrée AnalogiqueRA0

Reset MCLR

ICD RB6,RB7 Bus I2C

RC4, RC5(In Circuit Debugger)

(Liquid Crystal Display )

Capteur de Température

RC3


2.3. Le programmateur ICD3Il permet de transférer le programme directement de MPLAB dans le micro-contrôleur via un port USB d'un PC.

L3 SPI AGE S5 2


3. TP n°1 : Initiation à la programmation en langage C

3.1. Introduction : assembleur et compilateur CL'objectif de cette séance est de vous initier à la programmation en langage C d'un micro-contrôleur. Par

rapport à l'assembleur, le recours à un langage de « haut niveau » tel que le C s'est notablement développé en pratique car il permet de simplifier l'écriture des codes ainsi que leurs portabilités et leurs maintenabilités. Notamment, vous pourrez écrire des instructions du type « if(x==y) » ou « temp = 0x27 » pour effectuer un test d'égalité ou une affectation. Le code que vous écrirez devra être écrit en C standard ANSI. La compilation des instructions C se fera par le compilateur C18 qui permet de générer du code pour la famille des PIC 18XXXX. Comme l'assembleur, le compilateur traduit des instructions interprétables pour un opérateur humain en un code machine exécutable par le PIC. Comme nous le verrons, l'écriture et la compilation de vos programmes sources C se fera dans l'environnement MPLAB. Comme pour le développement de codes en assembleur, MPLAB sera donc l'environnement qui vous permettra d'écrire, de compiler et de déboguer vos sources C (cf., section 3 de ce TP).

On notera que, dans le cadre d'un même projet, il est possible de développer des parties en C et des parties en assembleur. Dès lors, la construction d'un code machine exécutable est illustré par le diagramme de la figure 2. Dans cet exemple, un code source en assembleur et deux codes sources en C ont été écrits. Pour chaque source, l'assembleur (MPASMWIN) ou le compilateur(MCC18) est utilisé pour générer des fichiers objets (file1.o,...,file3.o). Le fichier objet file3.o est ensuite utilisé avec un fichier pré-compilé existant file4.o de manière à former un fichier de librairie lib1.lib. Finalement, les fichiers objets restants sont utilisés avec le fichier de librairie par l'éditeur de lien (MPLINK) pour créer un exécutable output.hex. Notez bien également le fichier script.lkr (cf., figure 2) qui permet de configurer correctement l'éditeur de lien pour le micro-contrôleur utilisé.

L3 SPI AGE S5 3

Figure 2: Diagramme de construction d'un exécutable

Compilateur CAssembleur

Fichiers pré-compilés

script de configuration de l'éditeur de lien


3.2. Génération d'un signal carréPour vous familiariser avec la programmation en C du micro-contrôleur, le premier projet sera de reprendre le

programme de clignotement d'une LED que vous aviez écrit en assembleur. Le source C ci-après fait clignoter la LED L1, broche RB0, à une fréquence de 1Hz. L’état de la LED change donc toutes les 500ms.

// Author: ???//================================================// Description :// Programme de génération d'un signal carré // sur le port RB[0] de période de 1 s //================================================

En-tête du programme

//------------------------------------------------// Directives au préprocesseur//------------------------------------------------// fichier d'en-tête pour le PIC184020#include <p18f4520.h>// fichier d'en-tête pour les fonctions de tempo#include <delays.h>

// Désactivation du WatchDog#pragma config WDT = OFF

Fichiers d'en-tête pour le PIC184520 (p18f4520.h) et pour l'utilisation des fonctions de temporisation (delays.h)

Directive « pragma » de désactivation du watchdog.

// Programme Principalvoid main(){

//------------------------------------------------// Déclaration des variables locales//------------------------------------------------

// 1/2 Periode d'oscillation en Nb de cyclesTYPE DemiPeriode = ARGUMENT;

// Configuration du portBTRISB = 0x00; // PORTB en sortiePORTB = 0x00; // RAZ du PORTB// Config. RB0-RB3 en mode I/O numeriqueADCON1 = 0x0F;

Déclaration et affectation de la variable définissant le nombre de cycles nécessaire à une demi-période d'oscillation (à compléter).

Configuration du port B

// --> Boucle TantQue : On boucle indéfiniement...while(1){

// basculement du bit 0 du PORTBPORTB = PORTB ^ 0x01;// Utilisation d'une fonction de delays.h FONCTION(ARGUMENT);}

// --> Fin de boucle TantQue}

Boucle permanente de changement d'état de RB0-> basculement de RB0-> appel à la fonction de temporisation (cf. delays.h) permettant d'attendre 500ms (à compléter).

Comprendre le programme ci-dessus. Définir le type de la variable DemiPeriode. Déduire du fichier d'en-tête « delays.h » la fonction à utiliser pour une temporisation telle que la période soit de

1ms. Déduisez-en également l'argument associé. Passer à la section suivante pour créer un projet pour ce code, pour le compiler et pour effectuer la simulation.

3.3. Édition et Compilation du programmeCette partie permet d'apprendre à créer un projet MPLAB, à saisir un programme en C et à le compiler.

L3 SPI AGE S5 4


3.3.1. Démarrage

– Avant de commencer, créer le répertoire « tp1 » puis dans ce répertoire créer à nouveau un répertoire « clignotement_C ».

– Copiez dans ce répertoire les fichier « delays.h » et « 18f4520.lkr ».– Lancer la suite logicielle MPLAB IDE à partir de l’icône qui se trouve sur votre bureau.

3.3.2. Création d’un nouveau projet en utilisant l’assistant « Project Wizard … »– Cliquer sur Project >> Project Wizard …– Cliquer sur Suivant > puis sélectionner « PIC18F4520 » dans le menu déroulant « Device ».– Cliquer sur Suivant > puis sélectionner « Microchip C18 Toolsuite » afin de pouvoir développer en C.– Cliquer sur Suivant > puis dans le champ « Project Name » saisir le nom du projet (ex : clignotant_C) et

dans le champ « Project Directory » aller chercher à l’aide du bouton « Browse », le dossier créé au début : « tp4/clignotant_C ».

– Cliquer deux fois sur Suivant > et ajouter « 18f4520.lkr » au projet à l’aide du bouton Add >> – Cliquer sur Suivant > puis sur Terminer.

3.3.3. Configurer les options de compilation et d'édition de lien– Cliquer sur Project>Build Options...>Project et cliquer sur l'onglet « General ». Vérifiez que les chemins

de « Include Path » et de « Library Path » sont correctement positionnés en utilisant l'option « Browse »...– Dans l'onglet MPLINK Linker, cliquer sur l'option « Suppress COD-file generation ». Cliquer sur OK.

3.3.4. Édition du programme– Créer un nouveau fichier dans le projet, File >> Add New Files to Project… – L’enregistrer dans le répertoire projet avec l’extension c (ex : clignotant_C.c)– MPLAB Editor se lance– Saisir le programme et enregistrer.

Penser à ajouter des commentaires au programme pour montrer que vous avez bien compris les différentes instructions.

3.3.5. Compilation

La compilation et l'édition de lien se fait en cliquant sur l'icône de la barre de menu. Comme en assembleur, les erreurs et warnings sont signalés dans la fenêtre « Output » ainsi que le résultat de la compilation BUILD SUCCEEDED ou BUILD FAILED.

En double-cliquant sur une erreur ou un warning dans la fenêtre « Output », vous serez amener directement à la ligne concernée dans votre programme.

3.4. Simulation et programmation du micro-contrôleurLes procédures de simulation et de transfert du code exécutable sur le micro-contrôleur ne diffèrent pas de celles que vous avez pu mettre en oeuvre pour le développement en assembleur ; cf. l'énoncé du premier TP.

Effectuez la simulation du générateur de signal carré donné ci-avant dans l'énoncé.

3.5. Applications

3.5.1. Chenillard sans interruptionOn souhaite créer un chenillard à motif variable. Un motif étant défini par une séquence d'éclairage des LED comme par exemple {0x01, 0x02, 0x04, 0x08}, cette séquence est répétée à l'infini.

Donner l'algorigramme du chenillard défini par la séquence de motif {0x01, 0x02, 0x04, 0x08}. Chaque motif

L3 SPI AGE S5 5


devra rester allumé pendant un temps de 500 ms.

Pour définir la séquence de motifs, vous prendrez soin de déclarer un tableau de unsigned char car ce type correspond à un format 8 bits qui pourra directement être affecté sur le PORT B (cf., MPLAB C18 C COMPILER USER’S GUIDE, page 11).

Écrire et tester ce programme.

3.5.2. Chenillard multiple sans interruptionsOn souhaite ajouter un second motif distinct au chenillard de manière à permettre le choix de la séquence. On

prendra par exemple comme seconde séquence {0x01, 0x02, 0x04, 0x08, 0x04, 0x02}. La séquence considérée sera sélectionnée par une variable dans la fonction principale (ie., la fonction main()). Le motif à afficher à l'intérieur de la séquence considérée sera retourné par une fonction appelée valeur_chenillard() dont vous définirez les entrées et les sorties.

Donner l'algorigramme du chenillard défini par le couple de séquences {0x01, 0x02, 0x04, 0x08} et {0x01, 0x02, 0x04, 0x08, 0x04, 0x02}.

Écrire et tester ce programme.

L3 SPI AGE S5 6


4. TP n°2 : Ecriture d'un driver pour LCDL'objectif de ce TP est d'écrire et de tester un ensemble de fonctions pour communiquer avec un afficheur LCD. La première partie de ce TP est réalisée en simulation afin d'écrire les différentes fonctions nécessaires au bon fonctionnement de l'afficheur. Vous testerez enfin votre driver sur la plaque d'essai (le kit kit PICDEM 2 Plus). Finalement, nous terminons ce TP en créant une bibliothèque pour les utiliser par la suite.

4.1. Le contrôle de l'afficheurs LCDL'afficheur du kit PICDEM 2 Plus est un afficheur 16 × 2 c'est à dire 2 lignes de 16 caractères avec des caractères de 5×8 pixels. Pour piloter ce LCD, un composant appelé contrôleur d'affichage est requis ; dans notre cas, il s'agit du HD44780U de SHARP. Ce contrôleur d'affichage peut recevoir deux types d'information sur le bus DATA, un ordre (ex: effacer l'écran) ou une donnée (ex: le caractère A). L'ordre ou la donnée est envoyé sur le bus DATA qui est constitué de 8 ou 4 bits. Si le bus DATA est un bus 8 bits, l'ordre ou la donnée est transférée en une seule fois. Dans le cas contraire, l'octet est transféré sous la forme de deux quartets (4 bits) envoyé successivement : le quartet de poids fort puis le quartet de poids faible.

Le but du driver est de gérer le bus CONTROL afin que le contrôleur d'affichage comprenne le bus DATA et affiche ce que l'on souhaite sur l'écran LCD.

Après lecture de la documentation du contrôleur d'affichage, on comprend que le bus CONTROL est constitué de trois lignes :

– La ligne RS (Register Select) permet au contrôleur d'affichage de savoir si le contenu du bus DATA est un ordre ou une donnée ; un niveau bas indiquera un ordre et un niveau haut une donnée.

– La ligne RW (Read Write) informe le contrôleur si on vient lire ou écrire dans sa mémoire ; un niveau bas correpondant à une action d'écriture.

– La ligne E (Enable) informe le contrôleur d'affichage qu'un quartet (mode 4 bits) ou un octet (mode 8 bits) est disponible sur le bus DATA. Cette ligne est active sur front descendant.

Les connexions entre le contrôleur d'affichage et le microcontrôleur sont regroupées dans le tableau ci-dessous.

Bus

CONTROL

Contrôleur PIC18

RS RA4

RW RA5

E RA6

DATA

DB7 RD3

DB6 RD2

DB5 RD1

DB4 RD0

4.2. Fonctions de pilotage du LCD

4.2.1. Fonctions d'écritureL'écriture d'un ordre ou d'une donnée en mode 4 bits se fait selon la séquence reproduite en figure 3, l'octet à transférer étant b7b6b5b4b3b2b1b0 avec b7 bit de poids fort.

Réaliser l'algorigramme et écrire la fonction l c d _ e c r i r e _ q u a r t e t ( ) qui génère la séquence IV, V, VI sans tenir compte de l'état de RS pour l'instant et en supposant que E vaut 0. Le quartet à écrire est stocké dans les 4 bits de poids faible du registre de travail « WREG ». La ligne E restant à l'état haut durant 2 cycles.

Réalisez l'algorigramme de la fonction l c d _ e c r i r e _ o c t e t ( ) (c'est à dire la séquence I ...VI) en utilisant bien évidemment la fonction l c d _ e c r i r e _ q u a r t e t ( ) .

L3 SPI AGE S5 7


Il reste à gérer l'état ligne de la ligne RS, il suffit pour cela d'ajouter une instruction avant l'appel de la fonction «cd_ e c r i r e _ o c t e t ( ) . Réaliser les algorigrammes et écrire les deux fonctions cd_ e c r i r e _ o r d r e ( ) et cd_ e c r i r e _ d o n n e e ( ) .

4.2.2. Effacement d'écran et changement de ligneLe contrôleur d'affichage dispose d'une mémoire DDRAM représentant l'afficheur. Dans notre cas la taille de la mémoire utilisée est de 2 lignes de 16 octets chacune. Pour changer de ligne, il suffit de venir positionner l'Address Counter au début de ligne souhaitée.

Figure 4: DDRAM du contrôleur

En utilisant vos différentes fonctions écrire les fonctions lcd_ l 1 ( ) et lcd_ l 2 ( ) permettant de choisir la ligne sur laquelle on souhaite écrire. Écrire la fonction lcd_ c l s ( ) qui efface tout l'écran.

4.2.3. Lecture de l'état du contrôleur d'affichageLorsque que l'on demande au contrôleur d’exécuter une action (ordre ou commande), ce dernier met un certain temps à la réaliser. Si une nouvelle action lui est demandée alors que la précédente n'est pas encore terminée, elle ne sera pas prise en compte. Pour résoudre ce problème il est nécessaire de savoir si le contrôleur est disponible. On ne va donc plus « écrire » mais « lire » dans le contrôleur.

Sur la figure 5, l'octet reçu est de la forme BF AC6AC5AC4AC3AC2AC1AC0 avec BF bit de poids fort. BF qui signifie Busy Flag vaut 1 si l'afficheur est occupé. Les bits AC6...1 représentent l'Address Counter c'est à dire la valeur courante du pointeur de RAM du contrôleur cette information doit être lue mais ne nous est pas utile, elle ne sera donc pas

L3 SPI AGE S5 8

Figure 3: Transfert d'un octet en mode 4 bits

Figure 5: Lecture de l'état de l'afficheur en mode 4 bits


mémorisée.

Réaliser l'algorigramme puis écrire la fonction lcd_ d i s p o ( ) qui boucle tant que le bit BF n'est pas égal 0. C'est à dire tant que l'afficheur n'est pas prêt à effectuer une nouvelle action. Testez cette fonction avec le simulateur.

4.2.4. Procédure d'initialisation du contrôleur d'affichageLa procédure d'initialisation du contrôleur d'affichage peut être trouvée dans la documentation technique qui décrit le fonctionnement du contrôleur.

Figure 6: Procédure d'initialisation 4 bits du contrôleur d'affichage (extrait de la datasheet du HD44780U )

Quand le contrôleur démarre on ne sait pas si il est positionné en 4 ou 8 bits, comme le montre la procédure d'intialisation reproduite en figure 6, il est donc nécessaire d'envoyer la commande de passage en mode 8 bits (Function Set 8-Bit Interface) plusieurs fois pour qu'elle soit bien comprise. Puis on demande le passage en 4 bits (Function Set 4-Bit Interface). La dernière partie de la procédure consiste à régler les caractéristiques de l'écran. Dans notre cas nous

L3 SPI AGE S5 9


prendrons : N = 1 pour fonctionner sur deux lignes, F = 0 pour régler la taille des caractères à 5×8 points et I/D = 1 afin que le curseur se déplace vers la droite après avoir affiché un caractère.

Réaliser l'algorigramme puis écrire la fonction C lcd_ i n i t ( ) qui réalise cette procédure (pensez à utiliser les fonctions que vous avez déjà créées) ; n'oubliez pas également d'alimenter le contrôleur au travers de la broche RD7. Valider la procédure par simulation.

4.2.5. Tests des différentes fonctionsVoilà nous sommes maintenant prêt à utiliser l'afficheur LCD.

Écrire le programme qui reproduit l'écran ci-dessous sur l'afficheur.

I n f o

I n d u s

4.3. Création de la libraire « afficheurlcd »Nous disposons maintenant d'un ensemble de fonctions de gestion du LCD afin de les utiliser et de pouvoir les diffuser plus facilement nous allons les regrouper dans une librairie que l'on nomera « afficheurlcd ». Une librairie (fichier *.lib) est en fait une compilation de fichier objets. Les fichiers objets contiennent entre autres la liste des noms de fonctions ou les étiquettes (pour ASM) ainsi que leur code machine (codage binaire, ces fichiers ne sont pas éditables). Les fichiers objets (*.o) sont obtenus après compilation de votre code dans MPLAB.

Créer un nouveau projet sous MPLAB comme pour faire un programme classique.Dans le fichier source « coller » vos fonctions de gestion de l'afficheur avec les différents « #include »Compiler, une erreur vous informe que la fonction « main » n'est pas définie, c'est normal !

Dans votre répertoire projet, un fichier objet du même nom que votre programme a été créé. C'est ce fichier que nous allons maintenant convertir en librairie à l'aide de l'utilitaire de gestion de bibliothèque MPLIB. MPLIB est un programme fonctionnant en mode console sous DOS avec les options suivantes :

/c Création contenant un ou plusieurs fichiers objets/t Liste le contenu de la libraire/d Efface un objet de la librairie/r Remplace un objet existant dans la librairie/x Extrait un membre de la librairie

La syntaxe d'utilisation de MPLIB est :MPLIB /{ctdrx} nom_librairie [liste de fichiers objets]

Ouvrir une fenêtre dos (Menu démarrer, Exécuter, cmd)Se positionner dans le répertoire où vous souhaiter créer la librairie, dans l'exemple D:\tps\tp6\ (commande DOS

cd : change directory)Créer la librairie en utilisant la commande MPLIB /c afficheurlcd.lib votre_fichier_objet.

Un exemple de création est reproduit en figure 7.

L3 SPI AGE S5 10


C:\Documents and Settings\Flavien>D:D:\>cd tps\tp6D:\tps\tp6>D:\tps\tp6>mplib /c afficheurlcd.lib D:\tps\tp6\lib\lcdlib.oMPLIB 4.12, LibrarianCopyright (c) 2007 Microchip Technology Inc.Errors : 0D:\tps\tp6>

Figure 7: Création d'une librairie avec MPLIB

Pour utiliser une librairie il faut soit lui associer un fichier d'entête (*.h) dans lequel se trouve les prototypes de vos fonctions soit déclarer les prototypes dans votre programme. Le fichier d'entête étant simplement un fichier texte renomer « afficheurlcd.h ».

Créer le fichier « afficheurlcd.h » dans le même répertoire que « afficheurlcd.lib »

✗ Inclure la librairie dans un projet

Si l'on souhaite utiliser notre bibliothèque comme une bibliothèque déjà installée (avec #include<afficheurlcd.h> avec MPLAB, il est necesaire de modifier la variable d'environnement MCC_include et de modifier le fichier d'édition de liens (*.lkr). Dans le cadre des travaux pratiques nous n'utiliserons pas cette méthode.

La procédure à suivre pour utiliser la bibliothèque est la suivante :– Dans votre répertoire projet, copier-coller les fichiers « afficheurlcd.lib » et « afficheurlcd.h ». – Ajouter le fichier « afficheurlcd.lib » au dossier « Library Files » de votre projet.– Insérer la directive « #include "afficheurlcd.h" » au début de votre programme.

Tester votre librairie.

L3 SPI AGE S5 11


5. TP n°3 : Interruptions et PériphériquesCe troisième TP est divisé en quatre parties durant lesquelles vous apprendrez à gérer les interruptions et différents modules du micro-contrôleur en langage C.

5.1. Programme « Clignotant » avec interruptionNous devons maintenant faire clignoter la led L1, broche RB0, à une fréquence de 0.5Hz sans mobiliser le microcontrôleur. Il n'est donc plus question d'utiliser une temporisation pour compter le temps (cf. TP n°1). Nous allons demander à un module externe : le TIMER0, de compter le temps et de signaler la fin du comptage au microcontôleur par une interruption dite interruption de débordement. La figure 8 montre le signal de sortie du TIMER0 et les interruptions de débordement associées. Le TIMER0 compte jusqu'à la valeur max en T secondes. Toutes les T secondes, l'état de la led L1 est inversé.

Figure 8: Interruption de débordement du TIMER0

Trouver, en utilisant la datasheet, l'expression de la valeur max et de la période de comptage T en fonction de la configuration du TIMER0. (cf datasheet p123)

Qu'elle est la configuration pour une période de comptage T d'environ 1s ?Quels sont les bits à initialiser pour activer l'interruption du TIMER0 ?Expliquer la configuration du registre T0CON.

L'énoncé demande de faire clignoter la led à une fréquence de 0.5Hz donc une période de comptage de 1s. Avec la configuration choisi précédemment, on a une interruption toutes les (1+t)s, si on souhaite mesuer le temps précisement cette erreur de t seconde n'est pas négligeable.

Pour compenser cette erreur décalage, l'idée est d'initialiser les registres TMR0H TMR0L afin que le comptage ne commence pas à 0 mais à une valeur min permettant d'annuler t comme le montre la figure 9.

Figure 9: Interruption de débordement du TIMER0

Calculer la valeur min pour avoir une fréquence de comptage de 1s excatement.

Une des difficultés consiste alors à configurer correctement le TIMER0 de manière à permettre de générer les interruptions périodiquement. On donne ci-après les éléments du code source pour ce faire.

L3 SPI AGE S5 12

max

T-t

Interruptions de débordement

0min

max

T

Interruptions de débordement

0


//-------------------------------------------------// Configuration des interruptions, cf. sections 9 et // 11 du datasheet et le fichier header p18h4520.h//-------------------------------------------------

// active l'interruption pour le TIMER0INTCON = VALEUR;

// Place l'interruption TIMER0 en priorite hauteINTCON2 = VALEUR;

// Active la gestion des priorites pour les interruptionsRCONbits.IPEN = VALEUR;

// Efface le registre TMR0HTMR0H = VALEUR;// Efface le registre TMR0LTMR0L = VALEUR;

// Active le TIMER0 et configure la valeur du prescalerT0CON = VALEUR;

// Active les interruptionsINTCONbits.GIE = VALEUR;

Configuration du micro-contrôleur pour la gestion d'interruption et configuration du TIMER0 pour (à compléter).

L'objectif est alors de déclencher une interruption à chaque fois que le TIMER0 est en « overflow », cette interruption commandant le changement de motif du chenillard. A toutes fins utiles, on rappelle que le langage C ne permet pas directement de traiter les interruptions puisqu'il ne laisse pas à l'utilisateur le contrôle des adresses du programme (équivalent du org en assembleur). A la place une directive #pragma a donc été intégrée au compilateur :

– Les directives #pragma code mon_prog = @ void mon_prog(void)

{code C ... }

#pragma code

forcent le compilateur à placer le code C à l'adresse @ (cf., MPLAB C18 C COMPILER USER’S GUIDE, page 20 et 29).

– La directive#pragma interrupt ma_fonction

déclare ma_fonction comme la fonction de traitement des interruptions prioritaires (adresse 0x18).

– La directive #pragma interruptlow ma_fonction

déclare ma_fonction comme la fonction de traitement des interruptions non prioritaires (adresse 0x08).

Rappel : un exemple de programme C avec interruption est disponible dans le cours.

Donner les algorigrammes et fonctions C du programme principal et du programme d'interruption pour que la led L1 clignote toute les secondes. Écrire et tester ce programme.

5.2. ChronomètreNous allons maintenant réaliser un chronomètre simplifié en utilisant le TIMER0, l'afficheur LCD et le bouton S2, broche RA4. Le temps doit s'afficher sur le LCD sous le format :

m m - - s s

L3 SPI AGE S5 13


Le fonctionnement souhaité est le suivant :

– À la mise sous tension, le chronomètre est initialisé à « 00--00 ».

– Un premier appui sur S2 déclenche le chronomètre, le temps évolue sur l'afficheur LCD.

– Un deuxième appui sur S2 arrête le chronomètre, le temps écoulé est affiché sur le LCD.

– Un troisième appui sur S2 réinitialise le chronomètre.

Les nombres représentant les minutes et les secondes seront respectivement stockés dans les octects MIN et SEC. Le temps est mesuré par l'interruption de débordement du TIMER0. Comme il a été vu au TP précédent, l'afficheur LCD ne comprend que des caractères (code ASCII), on ne peut donc pas directement lui envoyer les octects MIN et SEC puisque ceux sont des nombres.

Caractère 0 1 2 3 4 5 6 7 8 9

Code ASCII

48(0x30)

49(0x31)

50(0x32)

51(0x33)

52(0x34)

53(0x35)

54(0x36)

55(0x37)

56(0x38)

57(0x39)

Tableau 1: Code ASCII des chiffres

Réaliser l'algorigramme puis écrire le code de la fonction « lcd_ecrire_nombre » qui affiche sur le LCD le nombre contenu dans NB sachant que ce nombre est compris entre 00 et 99. Il faut donc afficher le chiffre des dizaines puis le chiffre des unités. (NB est un octect à déclarer, vous pouvez tester cette fonction en simulation)

Réaliser l'algorigramme puis écrire le code de la routine d'interruption et de l'interruption de débordement du TIMER0.

Le bouton poussoir S2 permet à l'utilisateur d'agir sur l'état chronomètre. D'après le fonctionnement décrit ci-dessus, un appui sur le bouton change l'état du chronomètre.

Réaliser l'algorigramme et écrire la fonction « bouton_appui » qui détecte un appui sur le bouton S2, l'appui étant détecté lorsque l'utilisateur relâche le bouton.

Réaliser l'algorigramme du chronomètre puis écrire le programme principal.Transférer votre programme et chronometrez-vous!

L3 SPI AGE S5 14


Notes :

L3 SPI AGE S5 15


Travaux Pratiques de Microcontrôleur

L3 SPI AGE S5 16

Licence SPI – AGE Travaux Pratiques Langage C18 · compilateur traduit des instructions...

Documents

Transcript of Licence SPI – AGE Travaux Pratiques Langage C18 · compilateur traduit des instructions...