travaux pratiques de microcontrôleur - lsis.org · formation au développement d'applications...

Master Sciences de l'information et des Systèmes

Université Paul Cézanne

Travaux Pratiques de

Microcontrôleur

Julien [email protected]

Marc [email protected]

mailto:[email protected]

mailto:[email protected]

http://www.univ-cezanne.fr/


http://www.lsis.org/master/indexPro.html




Formation au développement d'applications en Assembleur et C sur un microcontrôleur Mircrohip PIC 18F4520 en utlisant l'environnement MPLAB IDE et le compilateur C18.

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 PICSTART Plus........................................................................................2

3. Gestion de vos fichiers...................................................................................................................2

4. TP n°1 : Initiation à MPLAB IDE............................................................................................... 34.1. Programme « Interrupteur ».....................................................................................................34.2. Édition et Compilation du programme.................................................................................... 44.3. Simulation................................................................................................................................54.4. Programmation du microcontrôleur.........................................................................................74.5. Programme « Clignotant ».......................................................................................................8

5. TP n°2 : Ecriture d'un driver pour LCD.................................................................................. 115.1. Les afficheurs LCD................................................................................................................115.2. Fonctions de gestion.............................................................................................................. 125.3. Écrire une chaine de caractères..............................................................................................16

6. TP n°3 : Interruptions et Périphériques....................................................................................176.1. Programme « Clignotant » avec interruption.........................................................................176.2. Chronomètre.......................................................................................................................... 186.3. Générer un signal rectangulaire avec un module PWM........................................................ 196.4. Utilisation du module de conversion A/D............................................................................. 206.5. Gestion d'interruptions multiples........................................................................................... 20

7. TP n°4 : Initiation à la programmation en langage C..............................................................227.1. Introduction : assembleur et compilateur C...........................................................................227.2. Génération d'un signal carré.................................................................................................. 237.3. Édition et Compilation du programme.................................................................................. 247.4. Simulation et programmation du micro-contrôleur............................................................... 257.5. Applications........................................................................................................................... 25

8. TP n°5 : Gestion de Périphériques et Interruptions.................................................................278.1. Communication série : RS232............................................................................................... 278.2. Applications........................................................................................................................... 29

9. TP n°6 : Panneau d'affichage lumineux.................................................................................... 319.1. Gestion de l'afficheur LCD.................................................................................................... 319.2. Gestion de l'EEPROM........................................................................................................... 339.3. Panneau d'affichage............................................................................................................... 34

10. TP n°7 : Station Service............................................................................................................ 3610.1. Automate de Pompe.............................................................................................................3610.2. Communication avec l'automate de caisse...........................................................................37

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 soit en langage assembleur soit 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 reproduits 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.

Une part importante de la difficulté pour programmer un micro-contrôleur réside dans l'acquisition d'informations. Pour acquérir cette compétence, nous vous invitons à vous référer fréquemment à la documentation technique du micro-contrôleur, ainsi qu'à la documentation technique de la carte d'évaluation, cf. les documentations électroniques.

M1 SIS 1 2011/2012

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.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.

2.3. Le programmateur PICSTART PlusIl permet de transférer le programme directement de MPLAB dans le micro-contrôleur via le port série (RS232)

d'un PC.

3. Gestion de vos fichiersPour chacun des binômes, un compte utilisateur a éré créé. Pour ne pas oublier votre nom d'utilisateur et votre

mot de passe. vous pouvez le noter ci-dessous. Attention windows faire la déifférence entre les majuscules et les minuscules.

Nom d'utilisateur :

Mot de passe :

Avec votre compte vous avez droit à un espace de stockage sur le serveur. Cette espace de sotckage apparait dans « Poste de Travail » sous le nom de « voir le nom ». C'est ici que vous devez stocker tous vos documents afin qu'ils vous soient disponibles sur toutes les machines de TP.

Il vous est fortement conseillé de bien ranger vos documents tout au long des séances. pour chacun des TP, faîtes un répertoire associé ex: tp3 pour le tp n°3. Puis pour chaque question si c'est nécessaire faîtes des sous réperoires question5 par exemple.

Les documentations techniques nécessaires au TP sont disponibles à l'adresse:e:http://www.lsis.org/master/index.php?espace_etudiant=1&doc=103

M1 SIS 2 2011/2012

http://www.lsis.org/master/index.php?espace_etudiant=1&doc=103



http://sitedeflavien.free.fr/uc




4. TP n°1 : Initiation à MPLAB IDELe but de ce TP est de se familiariser avec la suite logicielle « MPLAB Integrated Development Environment »

(v7.6) de Microchip afin de pouvoir utiliser les fonctions de bases de cet outil développement à savoir : créer un projet, éditer et compiler un programme en assembleur, simuler son fonctionnement et enfin programmer le microcontrôleur (µC). Les différentes fonctions sont expliquées à travers deux programmes qui vous sont donnés.

4.1. Programme « Interrupteur »Le programme « Interrupteur » boucle à l’infini sur les tâches ci-dessous afin de reproduire le fonctionnement

d’un interrupteur.

– Tâche 1 : lire l’état du bouton poussoir S2, broche RA4– Tâche 2 : si le bouton est appuyé, on allume la diode électro-luminescente (LED) L1, broche RB0, sinon on

l’éteint.

On notera que les boutons poussoirs sont branchés au microcontrôleur en logique négative. L'état « bouton appuyé » correspond donc à un 0 logique. Les LED sont câblées en logique positive, elles s'allument pour un 1 logique. Le fonctionnement demandé peut être reproduit par l'algorigramme ci-dessous.

L'algorigramme peut se traduire en assembleur de la manière suivante :

LIST P=18F4520#include <P18F4520.inc>#include <CONFIG.inc>

Définition du µC utilisé, des constantes spécifiques au µC et des paramètres de configuration encodés lors de la programmation.

org h'0000' Adresse de départ après un reset du µC. init clrf PORTB

movlw b'00000000'movwf TRISBclrf PORTAmovlw b'00010000'movwf TRISA

Initialisation :Remise à zéro des bascules D des différents ports utilisés et configuration des entrées/sorties.

boucle btfsc PORTA,4goto eteindrebsf PORTB,0goto boucle

eteindre bcf PORTB,0goto boucle

END

Boucle infini :Allume ou éteint la LED en fonction de l’état du bouton poussoir.

Tout au long des travaux pratiques, nous vous demandons d'établir un glossaire des différentes instructions rencontrées avec leur explication en français. Ce glossaire vous sera

très utile pour les différents programmes que vous serez amener à réaliser.

M1 SIS 3 2011/2012

Figure 2: Algorigramme du programme « Interrupteur »

RA4 = 0S2 appuyé

RB0 = 1Allumer L1

RB0 = 0Eteindre L1

oui non

Initialisation du µC

ASM


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

4.2.1. Démarrage– Avant de commencer, créer le répertoire tp1 puis dans ce répertoire créer à nouveau un répertoire

interrupteur.– Copier dans ce dernier répertoire les fichiers P18F4520.inc et CONFIG.inc– Lancer la suite logicielle MPLAB IDE à partir de l’icône qui se trouve sur votre bureau.

4.2.2. Création d’un nouveau projet avec « 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 MPASM Toolsuite » et « MPASM Assembler » afin de

pouvoir programmer en Assembleur.– Cliquer sur Suivant > puis dans le champ « Project Name » saisir le nom du projet (ex : interrupteur) et

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

– Cliquer sur Suivant > et ajouter les fichiers P18F4520.inc et CONFIG.inc au projet à l’aide du bouton « Add » >>

– Cliquer sur Suivant > puis sur Terminer.

4.2.3. É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 asm (ex : prog.asm)MPLAB Editor se lanceSaisir le programme « Interrupteur » et enregistrer.

Penser à ajouter des commentaires au programme pour montrer que vous avez bien compris les différentes instructions. Une ligne de commentaire commence par « ; ».

4.2.4. Compilation

– Cliquer sur Project >> Build All … ou sur l’icône de la barre de menu ou encore Ctrl+F10 pour compiler le projet complet. 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

M1 SIS 4 2011/2012

Figure 3: MPLAB IDE, Mode Edition

WorkspaceArchitecture et contenu du projet

OutputInterface MPLAB Développeur

EditorEdition des fichiersde programme,de configuration, …


ligne concernée dans votre programme.

4.3. SimulationAvant d’envoyer un programme au µC, vous pouvez tester son fonctionnement dans le simulateur (Debugger)

MPLAB SIM. Pour lancer le simulateur, cliquer sur Debugger >> Select Tool >> MPLAB SIM. Une nouvelle barre d’outils est ajoutée ainsi qu’un onglet « MPLAB SIM » dans la fenêtre Output. Le simulateur fonctionne selon trois modes :

– le mode Step By Step qui permet de faire une exécution pas à pas du programme (vous êtes alors l’horloge du µC).

– le mode Animate qui exécute automatiquement le programme mais à une vitesse réduite pour que l’on puisse suivre l'éxécution.

– le mode Run où le programme est exécuté automatiquement à la vitesse du PC.

Dans les deux premiers modes, nous obtenons des résultats au fur et à mesure de la simulation alors que dans le dernier, les résultats ne sont visibles que lorsque la simulation est stoppée. Dans ce paragraphe, nous nous intéressons aux modes Animate et Step By Step car ils nous permettent de voir qu’elle est l’influence des entrées sur les sorties.

Le réglage de la fréquence de l’oscillateur utilisé se fait dans Debugger >> Settings …. Dans notre cas c’est 4 Mhz.

4.3.1. Entrées : StimulusComme son nom l’indique cette fonctionnalité permet de prévoir les événements d'entrées de manières

synchrones (les dates sont connues avant la simulation) et asynchrones (les événements sont déclenchés durant la simulation par l’utilisateur). Les différents événements sont enregistrés dans une table (Workbook). Pour en créer une, cliquer sur Debugger >> Stimulus >> New Workbook.

Dans le cadre du projet « interrupteur » on souhaite créer les événements suivants :

– à t = 0, initialisation de RA4 à 1 (bouton S2 relâché), – à t = 10 cycles, on appuie sur S2 (RA4 = 0),– à t = 25 cycles, on relâche le bouton (RA4 = 1).– on veut également pouvoir inverser l’état de RA4 quand on le souhaite.

L’onglet « Pin / Register Actions » de la fenêtre « Stimulus » permet la saisie des événements en programmant leurs dates d’arrivée (événements synchrones).

Démarche de création d’événements synchrones :

– Ajouter une colonne RA4 au tableau d’événement (bouton « Clic here to Add Signals »)– Rechercher RA4 dans la liste « Available Signals » et l’ajouter à la liste « Selected Signals »– Remplir la table d’événement (Time, RA4) avec (0,1) (10,0) (25,1)– Choisir cyc (cycle) comme base de temps dans menu « Time Units »– Enregistrer la table (bouton « Save Workbook »)

L’onglet « Asynch » de la fenêtre « Stimulus » permet de pré-programmer des boutons (colonne « Fire ») à la génération d’événement (événements asynchrones).

Démarche de création d’événement asynchrone :

– Saisir RA4 dans la colonne « Pin/SFR » de la première ligne– Le menu de la colonne « Action » propose cinq types d’action :

– Set High : RA4 = 1 – Set Low : RA4 = 0– Toggle : RA4 = RA4– Pulse High : RA4 = – Pulse Low : RA4 =

– Choisir « Toggle » pour inverser RA4– Enregistrer la table (bouton « Save Workbook »)

M1 SIS 5 2011/2012

la largeur de l’impulsion est réglée dans les colonnes « Width » et « Units ».


– Appliquer l’échéancier d’événement (bouton « Apply »)

Après chaque changement dans l’échéancier d’événement, cliquer sur « Apply » afin que ces changements soient pris en compte par la simulation.

4.3.2. Sorties : Watch & Logic AnalyzerAfin de suivre et de visualiser les résultats de simulation, MPLAB SIM intègre divers outils dont :

– La fenêtre « Watch » (menu View >> Watch) qui affiche le contenu des différents registres du µC et des différentes variables du programme. La sélection et la validation des registres et variables à afficher se fait à travers les deux menus déroulants et les deux boutons « Add SFR » et « Add Symbol ». Un clic droit sur un des éléments observés permet l’accès à la boîte de dialogue « Properties » afin de régler le format d’affichage de l’élément (ex : Hex, Binary, Single Bit, ...) mais aussi de sauvegarder, exporter, … le tableau « Watch ». Il est aussi possible de faire glisser des éléments de la fenêtre « Editor » vers la fenêtre « Watch ».

– La fenêtre « Logic Analyzer » permet l’affichage des éléments logiques (1 bit) en fonction du « Time Base ». Le choix des éléments à afficher se fait à l’aide du bouton « Channels ».

Pour le projet « interrupteur », on souhaite afficher :

– les registres TRISA et TRISB sous forme hexadécimale– les registres PORTA, PORTB et W sous forme binaire– les bits RA4 et RB0

Configurer correctement les fenêtres « Watch » et « Logic Analyzser ».

M1 SIS 6 2011/2012

Figure 4: Stimulus Synchrones et Asynchrone

Déclencher


4.3.3. Simulation du programme en mode Animate Maintenant que les entrées et sorties de la simulation sont configurées, on peut lancer la simulation. Avant toutes

choses, afin d’initialiser le µC, il est nécessaire d’effectuer un « Reset » en cliquant sur le bouton puis cliquer sur le bouton « Animate » et observer les fenêtres « Watch » et « Logic Analyzer ».

Arrêter l’animation à l’aide du bouton , faire un nouveau « Reset », relancer l’animation, ouvrir l’onglet « Asynch » de la fenêtre « Stimulus », agir sur RA4 et observer les résultats.

Vous pouvez également faire avancer le programme pas à pas (mode « Step By Step ») avec le bouton « Step Into » . On notera que les boutons « Step Over » et « Step Out » permettent respectivement une exécution pas à pas avec une exécution automatique des sous-programmes et une exécution jusqu’à la fin des sous-programmes.

4.4. Programmation du microcontrôleurCette phase consiste à envoyer le code hexadécimal du programme dans le µC. Une fois le programme compilé

avec succès, le code hexadécimal du programme se trouve dans le fichier avec l'extension hex (ex : prog.hex). Vous pouvez visualiser le fichier avec la fenêtre « Program Memory » du menu « View ». Le code de trouve sous l'onglet « Opcode Hex ».

Démarche de transfert :– Connecter le programmateur PICSTART Plus sur le port série du PC et au secteur

– Placer le µC sur le programmateur (Attention au sens !)

– Dans MPLAB, sous le menu Programmer > Select Programmer chosir « 1 PICSTART Plus ». Un nouvel onglet est alors ajouté à la fenêtre « Output ».

– Configurer le port COM sur lequel est connecté le programmateur (COM1), menu Programmer > Settings ...

– Activer le programmateur, menu Programmer > Enable Programmer, une nouvelle barre d'outils est ajoutée.

– Envoyer votre programme, menu Programmer > Program ou en cliquant sur , le transfert est terminé lorsque la LED jaune Activate du programmateur est éteinte et que le message « Programming/Verification completed successfully! » apparaît dans la fenêtre Output.

M1 SIS 7 2011/2012

Figure 5: MPLAB IDE, Mode Simulation

EditorLa flèche verte symbolise le ProgramCounter

WatchAffichage de l’état courantdes registres et variables

Logic AnalyzerGraphe d’évolutionde bits


– Désactiver le programmateur, menu Programmer > Disable Programmer

– Placer le µC sur la carte PICDEM 2 Plus (Attention au sens !) mettre la carte sous tension et ça marche ...

Lors des phases de manipulation du microcontrôleur, vérifier que la carte PICDEM 2 Plus ne soit pas sous tension et faîtes attention aux pattes, elles sont fragiles.

4.5. Programme « Clignotant »

4.5.1. Analyse et compréhension du programmeLe programme ci-après fait clignoter la LED L1, broche RB0, à une fréquence d’environ 1Hz. L’état de la LED

change donc toutes les 500ms.

LIST P=18F4520#include <P18F4520.inc>#include <CONFIG.inc>

Définition du µC utilisé, des constantes spécifiques au µC et des paramètres de configuration encodés lors de la programmation.

org h'0000' Adresse de départ après un reset du µC. ;----- Déclaration de variables

CBLOCK 0x00t1 : 1t2 : 1

ENDC

Les variables t1 et t2 sont rangées dans la bank 0 de la ram (adresse 0x00) et ont pour taille un octet.

;----- InitialisationInit clrf PORTB

movlw h'00'movwf TRISB

Remise à zéro des bascules D du port B et définition du port B en sortie.

;----- Programme Principalboucle movlw h'80'

xorwf PORTBcall tempo250mscall tempo250msgoto boucle

Boucle infini :Allume et éteint la LED toutes les 500ms.

;----- Sous-programmetempo250ms

movlw t10movwf t1

comp1 dcfsnz t1returnmovlw t20movwf t2

comp2 dcfsnz t2goto comp1goto comp2

END

Sous programme de temporisation (à compléter)On réalise deux boucles imbriquées qui « occupe » le µC durant environ 250 ms.

M1 SIS 8 2011/2012

Figure 6: MPLAB IDE, Code hexadécimal du programme


Comprendre le programme « clignotant » et réaliser l'algorigramme associé. Expliquer l’utilité de xorwf dans le programme principal (utiliser une table de vérité). Calculer les valeurs d’initialisation t10 et t20 pour que le sous programme de temporisation s’exécute en 250 ms

± 1 ms. Le nombre de cycle requis par chaque instruction est donné dans le jeu d’instruction. Créer un nouveau projet dans MPLAB et le sauver dans le répertoire tp1/cligno puis saisir le programme

précédent en remplaçant t10 et t20 par leur valeur (pour informer le compilateur de la base dans laquelle la valeur est écrite on précède la valeur de la première lettre de la base, ainsi 192 en décimal s’écrit d’192’, h’C0’ en hexadécimal ou encore b’11000000’ en binaire).

Compiler votre programme et passer à la partie simulation.

N’oubliez pas de copier les fichiers P18F4520.inc et CONFIG.inc dans le répertoire tp1/cligno.

4.5.2. SimulationVous pouvez simuler le programme de la même manière que le programme « interrupteur » mais vous vous

apercevrez très vite que c’est très long du fait de l’animation et de la temporisation. (Vous pouvez tout de même le faire pour bien comprendre mais en initialisant t10 et t20 à 3 et 5 par exemple.) Nous allons donc faire les simulations en mode Run, exécution automatique.

Pour notre programme, nous n’avons besoin d’aucun événement d’entrée mais si besoin avait été on aurait pu saisir un échéancier comme précédemment. En mode « Run » le programme s’exécute donc de façon automatique et ne s’arrête que lorsqu’il rencontre un point d’arrêt ou à la fin du programme. Il faut donc placer correctement les points d’arrêt afin de valider le fonctionnement de notre programme. Pour observer la durée de la temporisation il faut donc mettre un point d’arrêt sur la ligne d’appel du sous programme de temporisation et un autre sur la ligne suivante. Pour ajouter un point d’arrêt , double cliquer sur la ligne du programme où vous le souhaitez, ou alors utiliser le menu Debugger >> Breakpoints … disponible depuis la touche F2.

Nous allons suivre l’exécution du programme à l’aide de la fenêtre « Simulator Trace » disponible dans le menu « View ». Nous allons nous intéresser plus particulièrement à la colonne « Time ». Vous pouvez changer l’unité de temps de cette colonne par un clic droit menu « Display Time ». Lorsque vous affichez le temps en toutes autres unités que cycle, la valeur affichée dépend de la fréquence de l’oscillateur du µC.

– Lancer la simulation, bouton – Observer la fenêtre « Simulator Trace » lorsque la simulation s’arrête au premier point d’arrêt et noter le

temps d’appel de la temporisation (ex : ti = 250303 cycles)– Relancer la simulation, bouton – Noter à nouveau le temps de la fenêtre « Simulator Trace » (ex : tf = 500602 cycles)

Vous pouvez alors calculer la durée de la temporisation d = tf – ti = 250299 cycles soit 250,299 ms avec un oscillateur à 4 MHz. Utiliser cette méthode pour valider vos initialisations de t10 et t20.

M1 SIS 9 2011/2012

Figure 7: Placement des points d'arrêt


Une fois les simulations terminées transférer le programme dans le microcontôleur.

M1 SIS 10 2011/2012

Figure 8: Simulator Trace aux différents points d'arrêt

Breakpoint call tempo250ms Breakpoint goto boucle


5. TP n°2 : Ecriture d'un driver pour LCDL'objectif de ce TP est d'écrire et de tester un ensemble de fonctions assembleurs 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.

5.1. Les afficheurs LCDLes afficheurs à cristaux liquides généralement appelés LCD (Liquid Crystal Display) sont des modules

compacts qui nécessitent peu de composants pour leur mise en oeuvre. Plusieurs afficheurs sont disponibles sur le marché, ils se différencient les uns des autres par leurs dimensions (de 1 à 4 lignes de 6 à 80 caractères). Certains sont également dotés de fonctions de rétroéclairage. L'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 communiquer avec l'extérieur tout afficheur à besoin d'un circuit spécialisé de gestion appelé « contrôleur d'affichage », il en existe différents modèles sur le marché mais ils ont tous le même fonctionnement. La carte d'évaluation est équipée du modèle HD44780U de SHARP. Le contrôleur sert donc d'interface entre le microcontrôleur et l'afficheur (cf. figure 9). 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.

Figure 9: Communication avec l'afficheur LCD

Le 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). Ordres ou données sont envoyés sur le bus DATA sous forme d'octets (8 bits). Mais pour ne pas utiliser toutes les broches de sorties d'un microcontrôleur pour communiquer avec un LCD, les contrôleurs d'affichage fonctionnent également en 4 bits, un nombre codé sur 4 bits s'appelle un quartet. En mode 4 bits, un octet est envoyé en deux fois : le quartet de poids fort puis le quartet de poids faible.

Le bus CONTROL est constitué de trois lignes :– La ligne RS (Register Select) qui 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) qui informe le contrôleur d'affichage qu'un quartet (mode 4 bits) ou un octet (mode 8

bits) est disponible. Cette ligne est active sur front descendant. Elle réalise la syncronisation entre le microcontrôleur et l'afficheur.

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

D'après le tableau 1 quel est le mode de fonctionnement du contrôleur d'affichage ?

M1 SIS 11 2011/2012

Contôleurd'affichage

HD44780U

LCD16 × 2

COM 16

SEG 40

µC

PIC18F4520 CONTROL 3

DATA 4 ou 8


Bus

CONTROL

Contrôleur Microcontrôleur

RS RA3

RW RA2

E RA1

DATA

DB7 RD3

DB6 RD2

DB5 RD1

DB4 RD0

Extrait de PICDEM 2 Plus User's Guide (p 18)

Tableau 1: Connexion entre le contrôleur d'afffichage et le microcontrôleur

Attention : On a Power-on Reset, RA5 and RA3:RA0 are configured as analog inputs and read as ‘0’. RA4 is configured as a digital input... (cf datasheet p224)

5.2. Fonctions de gestion

5.2.1. Transfert d'un octetL'écriture d'un ordre ou d'une donnée en mode 4 bits se fait selon la séquence reproduite en figure 10, l'octet à

transférer étant b7b6b5b4b3b2b1b0 avec b7 bit de poids fort.

– Phase I : RW=0 et E=0. RS et DB7...4 sont positionnés à la valeur souhaitée : quartet de poids fort (MSB)– Phase II : E=1.– Phase III : E=0, le quartet transféré (poids fort) est pris en compte par le contrôleur lors du front descendant.– Phase IV : DB7...4 sont positionnés à la valeur souhaitée : quartet de poids faible (LSB)– Phase V : E=1.– Phase VI : E=0, le quartet transféré (poids faible) est pris en compte par le contrôleur lors du front

descendant.

Réaliser l'algorigramme et écrire la fonction « lcd_ecrire_quartet » qui génère la séquence IV, V, VI sans tenir compte de l'état de RS pour l'instant, E étant déjà initialisé à 0. Le quartet à écrire est stocké dans les 4 bits de poids faible du registre de travail « W ». La ligne E restant à l'état haut durant 2 cycles. Vous pourrez utiliser les instructions nop, bsf, bcf, movwf, andlw (cf. datasheet). Tester cette fonction avec le simulateur de MPLAB.

Nous allons maintenant écrire la fonction « lcd_ecrire_octet » (c'est à dire la séquence I ...VI) en utilisant bien

évidemment la fonction « lcd_ecrire_quartet ». On ne tient toujours pas compte de l'état de RS et E étant initialisé à 0. L'octet complet à transférer se trouve dans le registre « W » et sera sauvegardé dans la variable « lcd_db » stockée en ram. L'instruction swapf pourrait vous être utile. Écrire et tester cette fonction en simulation.

Les fonctions d'écriture sont maintenant quasiment terminées. 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 « lcd_ecrire_octet ». Réaliser les algorigrammes et écrire les deux fonctions « lcd_ecrire_ordre » et « lcd_ecrire_donnee ».

M1 SIS 12 2011/2012

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


5.2.2. Lecture de l'état du contrôleur d'affichageLorsque que l'on demande au contrôleur d'éxé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.

– Phase I : RW=1 et RS = 0, il s'agit d'une instruction (ordre) de lecture et E=0– Phase II : E passe à 1 pour demander le quartet de poids fort.– Phase III : On vient lire la valeur du quartet MSB sur DB7...DB4.– Phase IV : E passe à 0 pour signaler la fin de la lecture du premier quartet.– Phase V : E repasse à 1 pour demander le quartet de poids faible.– Phase VI : On vient lire la valeur du quartet LSB sur DB7...DB4.– Phase VII : E repasse à 0 pour signaler la fin de la lecture du deuxième quartet.

Note : Pour venir lire DB7...DB4 il faut que les broches RD3...RD0 soient configurées en entrées. Mais il faut pense à les remettre en sortie pour la suite.

Sur la figure 13, 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 mémorisée.

Réaliser l'algorigramme puis écrire la fonction « lcd_dispo » 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. Au début de la fonction mettre les broches RD3...RD0 en entrée et penser à les remettre en sortie avant de quitter celle-ci, gérer également les lignes RS et RW. Avant de lire le quartet on attend 2 cycles. Tester ce sous-programme avec le simulateur.

M1 SIS 13 2011/2012

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


5.2.3. Procédure d'initialisation du contrôleur d'affichageQuand 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 12, 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).

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

En analysant la procédure on remarque qu'il y a trois temporisations (>15ms, >4,1ms et >100µs). Pour simplifier le code nous allons écrire deux fonctions de temporisation, une d'environ 5 ms (15 = 5×3) et une autre d'environ 100µs.

En vous inspirant de la temporisation réalisée au TP n°1. Réaliser les algorigrammes puis écrire les fonctions

M1 SIS 14 2011/2012


« tempo_5ms » et « tempos_100us » et les valider par simulation. Si besoin est vous pouvez créer des variables en mémoire.

La dernière partie de la procédure consiste à régler les caractéristiques de l'écran. Dans notre cas nous prendrons :

– N = 1 pour fonctionner sur deux lignes.– F = 0 règle la taille des caractères (5×8 dots).– 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 « lcd_init » qui réalise cette procédure, pensez à utiliser les fonctions que vous avez déjà créées. Intégrer l'intialisation des ports dans « lcd_init ». Valider la procédure par simulation.

5.2.4. Basculement entre les lignesLe 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 13: DDRAM du contrôleur

En utilisant vos différentes fonctions écrire les fonctions « lcd_l1 » et « lcd_l2 » permettant de choisir la ligne sur laquelle on souhaite écrire.

Écrire la fonction « lcd_cls » qui efface tout l'écran. (cf. figure 12)Modifier la fonction « lcd_ecrire_octet » afin d'attendre que le contrôleur est pris en compte l'action.

5.2.5. Tests des différentes fonctionsVoilà nous sommes maintenant prêt à utiliser l'afficheur LCD. Pour faciliter l'utilisation des fonctions que vous

venez de créer il est conseillé de toutes les mettre dans un fichier « lcd.asm » afin de pouvoir les inclure dans vos futurs programmes. L'utilisation de ce fichier par la suite est très simple, il suffit de taper la commande « #include lcd.asm » à l'endroit de votre programme où vous souhaitez intégrer vos fonctions et de définir les variables « lcd_db, ... » au début de votre programme. Le fichier « lcd.asm » doit se trouver dans le même répertoire que votre programme.

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

I n f o

I n d u s

Si vous taper « movlw 'I' » le registre « W » sera chargé avec le code ascii du caractère I.

M1 SIS 15 2011/2012


5.3. Écrire une chaine de caractèresLa méthode qui nous a permis de tester les fonctions de gestion de l'afficheur n'est pas des plus efficace car il est

nécessaire de retaper le même code pour chacun des caractères. Nous allons donc écrire une fonction qui affiche une chaine de caractères complète. La chaine de caractères est stockée dans la mémoire programme. Pour stocker une chaîne en mémoire programme, il suffit d'utiliser la directive « db » comme dans l'exemple suivant :

...org h'0000'goto main

ch db "Microcontroleur",'\0' ;ecrire en mémoire programme

main nop ...

La chaîne « Microcontroleur » est stockée dans la mémoire programme, elle se termine par le caractère « \0 ». Le label « ch » pointe vers le premier caractère de la chaîne, c'est donc l'adresse de début de la chaine. Dans la mémoire programme du PIC 18F4520, les adresses sont codées sur 21 bits donc 3 octets. Comme nous disposons d'un microcontrôleur 8 bits nous utiliserons les directives « UPPER(ch), HIGH(ch), LOW(ch) » pour obtenir respectivement l'octet de poids le plus fort, de poids intermédiaire et de poids faible.

Pour lire dans la mémoire programme, il faut tout d'abord initialiser le pointeur d'adresse de mémoire programme « TBLPTR » avec l'adresse de l'octet à lire. Pour lire un octet on utilse l'instruction « TBLRD » qui transfère le contenu de la mémoire dans le registre « TALBAT ».

Consulter la datasheet du pic p73-76 et p305.

Configurer correctement l'instruction « TBLRD ».Réaliser l'algorigramme de la fonction « lcd_ecrire_chaine ».Écrire et tester cette fonction.

L'afficheur LCD ne peut afficher que 16 caractères par ligne...

M1 SIS 16 2011/2012


6. 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 Assembleur et dans un programme unique.

6.1. Programme « Clignotant » avec interruptionNous devons maintenant faire clignoter la led L1, broche RB0, à une fréquence de 2Hz 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 14 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 14: 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 à intialiser pour activer l'interruption du TIMER0 ?Expliquer la configuration du registre T0CON.

L'énoncé demande de faire clignoter la led à une fréquence de 2Hz 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 15.

Figure 15: Interruption de débordement du TIMER0

Calculer la valeur min pour avoir une fréquence de comptage de 1s excatement.Réaliser l'algorigramme du programme demandé, écrire et tester ce programme.

6.2. ChronomètreNous allons maintenant réaliser un chornomè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 :

M1 SIS 17 2011/2012

ASM

max

T

Interruptions de débordement

0

max

T-t

Interruptions de débordement

0min


m m - - s s

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 2: 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!

6.3. Générer un signal rectangulaire avec un module PWMEn partant du programme précédent, on souhaite maintenant ajouter une fonctionnalité : à chaque appui sur le

bouton poussoir S3 connecté à RB0, on souhaite activer le transducteur piézo-électrique (pendant la durée de l'appui). Le transducteur piézo-électrique peut être commandé grâce à la broche RC2 du micro-contrôleur.

Un transducteur piézo-électrique est un composant électronique constitué d’une lamelle de matériau piézo-électrique. Cette lamelle est déformée si une tension alternative est appliquée aux bornes du transducteur piézo-électrique.

M1 SIS 18 2011/2012


Figure 16: Le transducteur piézo-électrique

Le mouvement de la lamelle dans l’air génère un son. La fréquence du son émis est directement lié à la nature et à la fréquence du signal appliqué aux bornes du transducteur piézo-électrique.

Sur la carte d’évaluation PICDEM 2 Plus, le transducteur piézo-électrique peut être commandé grâce à la broche RC2 du micro-contrôleur. Le montage électronique utilisé pour commander le transducteur piézo-électrique permet de l’alimenter avec une tension bipolaire (+5V, -5V).

Pour générer un son, on doit donc générer un signal rectangulaire (grâce au module PWM) que l'on appliquera au transducteur piézo-électrique si l'utilisateur appuie sur le bouton poussoir S3. Il faudra initialiser tous les modules nécessaires à la génération d'un signal rectangulaire (module CCP1, TIMER2) (voir p.159 du « data-sheet ») et initialiser le PORTC. À partir du programme précédent, apporter les modifications nécessaires :

lors de l'initialisation :

– Configurer le PORTC en entrée excepté la broche RC2 en sortie,– Configurer le module PWM, placer la valeur 0x80 dans le registre PR2 (fixe la fréquence du signal

rectangulaire), régler le duty time (rapport cyclique) à 0.5, on placera la valeur 0x00 dans le registre CCP1CON,

– Activer le TIMER2, placé le « postscaler » à 1:1, placé le « prescaler » à 4,

dans le programme principal : on testera la valeur sur la broche RB0,

– Dans le cas où RB0 est à l'état haut on activera le transducteur piézo-électrique en agissant sur le registre CCP1CON,

– Dans le cas où RB0 est à l'état bas on désactivera le transducteur piézo-électrique en agissant sur le registre CCP1CON,

– Dans le cas où la valeur sur la broche RB0 est égale à la dernière valeur acquise on ne fera rien.

Attention : Le Duty Time est le temps pendant lequel le signal est à l’état haut. Il faut adapter ce temps en fonction de la fréquence du signal généré pour garder un rapport cyclique égale à 0,5. Pour cela lisez la documentation technique et trouver la relation qu’il doit exister entre les valeurs des registres PR2 et CCPR1L:CCP1CON<5:4> pour que le rapport cyclique reste égale à 0.5.

Donner la relation qu’il doit exister entre les valeurs des registres PR2 et CCPR1L:CCP1CON<5:4> pour que le rapport cyclique reste égale à 0.5 et proposer un partie de programme (le plus simple possible) en langage Assembleur qui permet d’adapter le rapport cyclique (contrôlé par les registres CCPR1L:CCP1CON<5:4>) en fonction de la fréquence (contrôlée par le registre PR2) du signal généré.

Réaliser l'algorigramme du programme demandé, Écrire le programme sur ordinateur avec MPLAB, simuler son fonctionnement et le valider sur la carte

d'évaluation.

Dans un premier temps, modifier le programme précédent pour qu’il génère un signal rectangulaire (en utilisant le module PWM) sur la broche RC2. Puis vous prendrez en compte la gestion du bouton RB0. En séparant les deux problèmes, la difficulté est réduite.

6.4. Utilisation du module de conversion A/DOn souhaite maintenant pouvoir faire varier la tonalité du son émis par le transducteur piézo-électrique. Pour

M1 SIS 19 2011/2012


cela, on va faire varier la fréquence (contrôlée par le registre PR2) du signal rectangulaire généré dans la partie précédente. Pour faire varier la fréquence du signal, on va utiliser le potentiomètre R16. À chaque fois que l'on activera le transducteur piézo-électrique, on va mesurer la tension sur la broche RA0 en utilisant le module de conversion A/D, on utilisera la valeur de la tension sur la broche RA0 pour déterminer la fréquence du signal rectangulaire. Les modifications portées au programme sont les suivantes,

lors de l'initialisation,

– configurer le PORTA de manière à ce que la broche RA0 soit en entrée,– activer le module de conversion A/D (voir page 227 du « datasheet »),– initialiser les registres ADCON0, ADCON1 (les autres registres sont correctement configurés par défaut),

dans le programme principal,

– réaliser une acquisition de la valeur de la tension sur la broche RA0 en réalisant une conversion A/D,– modifier la valeur du registre PR2 (fréquence du signal généré) en utilisant les bits de poids forts du

résultat de la conversion A/D,– ajuster le rapport cyclique pour qu'il reste égale à 0.5.


d'évaluation.

6.5. Gestion d'interruptions multiplesOn souhaite maintenant que le micro-contrôleur gère par interruption l'appui sur le bouton poussoir. Ainsi à

chaque appui sur le bouton poussoir S3, on souhaite activer ou désactiver le transducteur piézo-électrique. Quand le transducteur piézo-électrique sera activé, le programme principal réalisera une acquisition de la tension sur la broche RA0 et mettra à jour la fréquence et le rapport cyclique du signal rectangulaire. Quand le transducteur piézo-électrique ne sera pas activé, le programme principal ne réalisera aucune opération. Pour gérer les appuis sur le bouton poussoir S3, on utilisera l'interruption INT0. À partir du programme précédent, il faudra modifier :

– la configuration des interruptions pour prendre en compte la nouvelle interruption INT0,– simplifier le programme principal en transférant une partie du code vers la routine d'interruption.


d'évaluation.

M1 SIS 20 2011/2012


7. TP n°4 : Initiation à la programmation en langage C

7.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 17. 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 17) qui permet de configurer correctement l'éditeur de lien pour le micro-contrôleur utilisé.

7.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

M1 SIS 21 2011/2012

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

Compilateur CAssembleur

Fichiers pré-compilés

script de configuration de l'éditeur de lien

C


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.

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

7.3.1. Démarrage

– Avant de commencer, créer le répertoire « tp4 » 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 ».

M1 SIS 22 2011/2012


– Lancer la suite logicielle MPLAB IDE à partir de l’icône qui se trouve sur votre bureau.

7.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.

7.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.

7.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.

7.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.

7.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é.

7.5. Applications

7.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 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).

M1 SIS 23 2011/2012


Écrire et tester ce programme.

7.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}.


7.5.3. Chenillard multiple et gestion des interruptionsL'objectif de ce dernier exercice est de permettre de changer régulièrement le motif du chenillard en utilisant

les interruptions générées par le TIMER0. 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-arpès les éléments du code source pour ce faire.

//-------------------------------------------------// 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).

M1 SIS 24 2011/2012


– 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 l'algorigramme du chenillard défini par le couple de séquences {0x01, 0x02, 0x04, 0x08} et {0x01, 0x02, 0x04, 0x08, 0x04, 0x02}, le changement de séquence étant commandé par interruption du TIMER0 par période de 4 secondes, approximativement.


M1 SIS 25 2011/2012


8. TP n°5 : Gestion de Périphériques et Interruptions

8.1. Communication série : RS232Le module « Enhanced Universal Synchronous Receiver Transmitter » (EUSART) est le module du Pic18F4520

permettant une communication série de type RS232. Ce type de connexion étant également disponible sur un PC. Nous utiliserons le programme « hyperterminal » de Windows pour dialoguer avec le µC.

RS232 est une norme qui standardise les communications séries. La transmission de données pouvant se faire sur 7 ou 8 bits, avec ou sans contrôle de parité, celle-ci pouvant être gérées de façons paire ou impaire. Une trame RS232 commence par un bit de start et se termine par un ou deux bits de stop. La figure suivante illustre une des configurations possibles. La vitesse de transfert pouvant également varier d'une application à l'autre. La vitesse se mesure en Bauds (nombre de symbole transmis par seconde). Une connexion RS232 est asynchrone car entre l'émetteur et le récepteur, il y a seulement les lignes de données Rx et Tx (pas de ligne d'horloge).

Nous utiliserons la configuration suivante :

– Vitesse : 9600 Bauds– Taille des données : 8 bits,– Parité : Aucune,– Bit de Stop : 1.

Sur un PC le port série est appelé COMX, avec X le numéro du port.

8.1.1. L'hyperterminalL'hyperterminal est un programme livré avec Windows qui permet de se connecter à des hôtes distants

(ordinateurs, sites telnet, oscilloscope, ...) à l'aide d'un modem, d'un câble null-modem (liaison série) ou d'une connexion TCP/IP. A chaque fois qu'un caractère est saisi, il est envoyé sur le support de communication, tout caractère reçu est affiché.

L'hyperterminal est accessible dans le menu Démarrer > Tous les programmes > Accessoires > Communications > Hyperterminal (Win XP) ou alors via la commande « hyperterm » dans menu Démarrer > Exécuter. Lorsqu'il s'ouvre, il vous demande de configurer la connexion :

– saisir un nom (ex: Pic) et cliquer sur OK,– configurer le type de connexion, généralement COM1 et cliquer sur OK,– configurer les propriétés de la connexion (9600 Bauds, 8 bits, aucune parité, 1 bit de stop, pas de contrôle

de flux) et cliquer sur OK,– enregistrer la connexion dans votre répertoire pour ne pas avoir à la recréer (menu Fichier > Enregister

sous ...).

8.1.2. Programme « echo »Le programme « echo » renvoie sur la liaison série tout octet reçu sur celle-ci, l'envoi et la réception des octets

est réalisé sans interruption.

M1 SIS 26 2011/2012

Figure 19: Trame RS232, 7 bits, parité, 2 bits de stop

b6 b5 b4 b3 b2 b1 b0 par stp stpstr

Figure 18: Communication PC-µCPicdem 2 Plus PC

µC InterfaceMAX232

Liaison série 0-5V

PortCOM

HyperterminalRS232

C


✗ Configuration du module « EUSART »

Les registres à initialiser sont,

– BAUDCON, 'Baud Rate Control Register' qui initialise la vitesse via le registre SPBRGH:SPBRG dont la valeur est calculée en utilisant les tableaux reproduits en page 205-208 du datasheet. BAUDCON autorise également les interruptions, la réception, ...

– RCSTA, 'Recieve Status And Control Register' pour configurer la réception– TXSTA, 'Transmit Status And Control Register' pour configurer l'émission

✗ Émission et Réception

L'octet reçu est placé dans le registre RCREG (Recieve Register) et l'octet à envoyer est à placer dans TXREG (Transmit Register).

Même lorsque que les interruptions sont interdites, on peut utiliser les flags pour connaître l'état (vide ou plein) des registres RCREG et TXREG. Les flags se trouvent dans le registre PIR1 (Peripheral Interrupt Request Flag Register 1).

Pour savoir si un octet est disponible, il suffit simplement de regarder le flag associé à RCREG (réception d'un octet).

La procédure d'émission est représentée par le schéma bloc, ci-dessous (extrait du datacheet).

Lorsqu'un octet est placé dans TXREG, il est « coupé » dans TSR (Transmit Shift Register) qui comme son nom l'indique effectue un décalage à la vitesse imposée par SPBRGH:SPBRG. On notera que l'état de TXREG est visible dans TXIF et que l'information de transmission en cours se situe dans TRMT. Le schéma bloc de la réception se trouve en page 213 du « datasheet ».

Utiliser le datacheet pour initialiser les registres BAUDCON, RCSTA et TXSTA.(Pour régler 1 bit de stop, le bit SENDB du registre TXSTA doit être à 0)

Écrire et tester le programme « echo », utiliser le câble série du programmateur pour communiquer avec la carte µC.

8.2. Applications

8.2.1. Chenillard à motif variableOn souhaite créer un chenillard à motif variable. Un motif étant défini par une séquence d'éclairage des LED

comme par exemple {'0000', '0001', '0010', '0100', '1000'}, cette séquence est répétée à l'infini.Le changement de séquence se fait par l'envoi du numéro de la séquence par liaison RS232 à l'aide de

l'hyperterminal. Ainsi la saisie de 1 au clavier jouera la séquence 1, etc. Le code ASCII des chiffres du pavé numérique

M1 SIS 27 2011/2012

Figure 20: Schéma bloc du module d'émission


étant :

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 3: Code ASCII des chiffres

Toutes les 500ms, l'état des LED est modifié en utilisant une fonction de delays.h. Le changement de séquence est géré sur interruption de réception (EUSART), quand un octet est reçu par le µC, il le renvoi pour l'afficher dans l'hyperterminal. Si la séquence demandé n'existe pas, le µC renvoi '?' au PC et ne modifie pas le choix de séquence.

Écrire et tester ce programme

Note : La valeur du chiffre associé au code ASCII peut être obtenue par une soustraction. En C, le premier élément du tableau est 0. Une matrice est un tableau de tableau.

8.2.2. DevinetteLe programme « Devinette » est un jeu entre le µC et vous, les communications se faisant via le PC

(hyperterminal). Le principe est simple, le µC choisi un nombre entre 0 et 255 et doit vous le faire deviner en un temps donné, 1 min. Le temps restant est visible sur les 4 LEDs (1 led correspondant à 25s). Si vous trouvez le nombre choisi avant 1 min, le µC vous donne le temps que vous avez mis en secondes, sinon il vous informe que vous avez perdu et vous donne la réponse, puis le jeu recommence.

✗ Fonctions de communications :

Écrire et tester les fonctions de communications (RS232) suivantes : com_init qui initialise les registres de l'EUSART. com_recieve qui attend l'arrivée d'un octet et le renvoie. com_transmit qui permet d'envoyer un octet vers le PC. com_string_transmit qui envoie une chaîne de caractères (tableau d'octets) au PC. com_string_receive qui permet de recevoir une chaîne de caractère envoyée par le PC, cette fonction reçoit en

paramètre l'adresse du tableau (chaîne) où l'on veut stocker la chaîne reçue. (La fin de la saisie dans l'hyperterminal peut être signalée par l'appui sur la touche Entrée)

Dans l'hyperterminal, le caractère '\n' permet de passer à la ligne suivante (touche CTRL+Entrée) et '\r' de faire un retour chariot, retour en début de ligne (touche Entrée). Une chaîne se termine par le caractère '\0'.

✗ Fonction de génération « aléatoire » du nombre :

Cette fonction doit renvoyer le nombre mystère. Pour cela elle incrémente un entier n codé sur 8 octets (de type unsigned char) tant qu'aucune donnée n'est reçue sur la liaison série. Quand n = 255, si on ajoute 1 on a n = 256 qui se code sur 9 bits mais comme n est sur 8 bits, on aura n = 0. Écrire cette fonction.

✗ Fonctions de gestion du temps

Le temps maximal pour trouver la solution est définit dans le programme principal (main). Le temps restant est une variable globale (commune à toutes les fonctions). On mesure le temps avec le TIMER 0.

Écrire les fonctions : timer_init qui initialise les registres du timer, des interruptions, timer_go qui lance le décompte et les interruptions, timer_stop qui arrête le décompte et les interruptions, timer_interrupt qui décrémente le temps et met à jour les LED (une LED correspond à 25 secondes restantes).

✗ Programme complet

M1 SIS 28 2011/2012


Lorsque le programme démarre, le µC envoie un message au joueur en lui demandant d'appuyer sur une touche pour commencer, ce qui permet de générer le nombre mystère. Dès l'appui le chrono est lancé, lorsque une proposition est faire, le µC informe le joueur du fait que le nombre mystère est supérieur ou inférieur à sa proposition. Si le joueur trouve, il est informé de son temps sinon le nombre mystère lui est donné. A la fin d'une partie le programme se relance.

Écrire et tester le programme « devine », la conversion d'une chaîne de caractère en entier peut se faire avec la fonction atoi de la bibliothèque stdlib.h, il y a également la fonction inverse itoa.

Le temps peut se terminer lorsque le µC est en attente d'une saisie du joueur. Le jeu se joue avec le pavé numérique du clavier, tout appui sur une autre touche peut faire bugger le programme. Si vous avez le temps, vous pouvez détecter les erreurs de saisie et demander une nouvelle saisie.

M1 SIS 29 2011/2012


9. TP n°6 : Panneau d'affichage lumineuxAfin de permettre à la secrétaire de la formation de vous diffusez plus facilement divers messages nous allons

réaliser un système d'affichage à partir de l'afficheur LCD de la carte. L'affichage se fait sur deux lignes :– Le titre du message sur la première ligne, il est centré et ne doit pas dépasser 16 caractères.– Le corps du message qui défile en boucle sur la seconde ligne.

Pour mettre à jour le titre et/ou le corps du message la secrétaire utilisera « hyperterminal » (liaison rs232), elle aura aussi la possibilité de désactivé l'afficheur. Le message ainsi que l'état de l'afficheur « actif » et « inactif » devront être sauvegardé même en cas de coupure de courant.

9.1. Gestion de l'afficheur LCD

9.1.1. Conversion des fonctions de bas niveau du driver en CDans le TP n°3, nous avons écris le driver de l'afficheur en assembleur, il n'est donc pas directement utilisable

dans un programme C. Le compilateur MCC18 permet l'intégration de code assembleur dans le code C en utilisant les directives « _asm » et « _endasm ». Contrairement au compilateur MPASMWIN, le compilateur C ne connait pas les options par defaut des intructions (cf. jeu d'instructions) il faut donc rajouter toutes les options à votre code assembleur. Ainsi la fonction lcd_ecrire_quartet deviendra :

void lcd_ecrire_quartet(char q){WREG=q;_asm

andlw 0x0Fbcf PORTD,3,0bcf PORTD,2,0bcf PORTD,1,0bcf PORTD,0,0

...

_endasm}

Compléter la fonction « void lcd_ecrire_quartet(char q) » Sur le même principe écrire « void lcd_dispo(void) »

Nous avons maintenant codé les deux fonctions de base pour la gestion du lcd, les autres fonctions vont être recodées en C.

Écrire la fonction « void lcd_ecrire_octet(char lcd_db) ». Dans MCC18 l'instruction swapf est remplacée par la fonction Swapf. Pour inverser les quartets MSB et LSB de « w », il suffit d'écrire « Swapf (WREG,0,0); ».

Écrire les fonctions « void lcd_ecrire_ordre(char o) » et « void lcd_ecrire_donnee (char d) ».Écrire les fonctions « void lcd_cls(void) », « void lcd_l1(void) » et « void lcd_l2(void) ».Écrire les fonctions « void lcd_init(void) » en utilisant la bibliothèque « delays.h » pour les temporisations.Créer la fonction « void lcd_curseur_position(char l, char p) » qui permet de positionner le curseur d'affichage à

la « p »ième position de la ligne « l ». (cf figure, page )Tester ses fonctions sur la carte d'évaluation.

9.1.2. Création de fonctions de haut niveauLe langage C nous permet d'écrire très simplement des fonctions plus évoluées pour la gestion de l'afficheur.

Écrire la fonction « void lcd_lcls(char l) » qui efface la ligne « l ».Écrire la fonction « void lcd_ecrire_chaine(char *ch) » qui affiche une chaine de caractère sur la ligne active.Écrire la fonction « void lcd_ecrire_chaine_centre(char *ch, char l) » qui affiche une chaine de caractère en la

centrant sur la ligne « l », selon le principe ci dessous.- Cas d'une chaine de longueur paire :

M1 SIS 30 2011/2012

C


C H A I N E

- Cas d'une chaine de longueur impaire : (plus d'espace à droite). C H A I N E S

Tester ses fonctions sur la carte.

9.1.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 21.

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 21: 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

M1 SIS 31 2011/2012


#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'utilerons 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.

9.2. Gestion de l'EEPROMLa mémoire EEPROM (Electrically-Erasable Programmable Read-Only Memory ou mémoire morte effaçable

électriquement et programmable) (aussi appelée E2PROM ou E²PROM) est un type de mémoire morte. C'est à dire utilisée pour enregistrer des informations qui ne doivent pas être perdues lorsque l'appareil qui les contient n'est plus alimenté en électricité. Toutes les informations nécessaires à la lecture est à l'écriture dans l'EEPROM interne se trouvent dans la datasheet pages 83 à 87. Le PIC 18F4520 dispose de 256 octets de mémoire EEPROM interne qui sont réparties de la manière suivante :

– l'état du panneau (1 octet)– le titre du message (17 octets : 16 caractères + le caractère '\0' de fin de chaine)– le corps du message (237 octets : 236 caractères + le caractère '\0')

Écrire les fonctions « char eeprom_lire(char ad) » et «void eeprom_ecrire(char data, char ad) » qui permettent respectivement de lire et d'écrire à l'adresse « ad » de l'EEPROM. L'adresse mémoire varie entre 0x00 et 0xFF.

Dans la fonction d'écriture l'interdiction des interruptions est nécessaire seulement si celle-ci ont été activée et on ne doit pas quitter cette procédure tant que l'enregistrement dans la mémoire n'est pas terminé. Vous pouvez tester les fonctions d'écriture et de lecture dans l'EEPROM avec le simulateur de MPLAB à condition de désactiver l'attente de fin d'écriture... Aller dans le menu View > EEPROM en double cliquant sur un espace mémoire vous pouvez le modifier.

Pour notre panneau d'affichage, nous allons venir lire la chaine (ligne 1) ou une partie de la chaine (ligne 2) dans l'EEPROM. Pour cela vous allez écrie la fonction « void eeprom_lire_chaine( char *ch, char len, char ad) ». Cette fonction copie dans la chaine « ch » le contenu de l'EEPROM à partir de l'adresse « ad » jusqu'à ce que le caractère '\0' soit rencontrer ou que la chaine « ch » soit de longeur « len »

Quel sont les plages d'adresse en EEPROM de l'état de l'afficheur, le titre et le corps du message ?Écrire la fonction eeprom_lire_chaine. Simuler cette fonction avec MPLABSIM.

9.3. Panneau d'affichage

9.3.1. Panneau à message fixe

Écrire un programme qui affiche le titre du message sur la première puis fait défiler en continu le corps du message sur la seconde ligne: le corps du message commence à apparaître sur la droite de l'écran, puis défile vers la gauche. Quand la dernière lettre du corps du message sort de la gauche de l'écran, le défilement recommence. Dans ce programme, vous devez également gérer l'état du panneau : si l'état vaut 0, le texte ne défile pas et "Hors Service" est affiché sur le panneau, si l'état vaut 1, le corps du message défile. La vitesse de défilement est de 500 ms/caractère. Lorsque l'afficheur est en service la led connectée à RB0 est allumée, en hors service elle clignote à une fréquence de 1 Hz.

Vous pouvez programmer l'EEPROM interne du µC via MPLAB afin d'initialiser le texte à afficher. Vous pouvez initialiser vous même le texte à afficher dans l'EEPROM en respectant les plages mémoires, les valeurs et le caractères '\0' ou alors importer directement le fichier « tp6_eeprom.mch » qui vous est fourni. Lors de la programmation du µC, l'EEPROM le sera également.

Tester ce programme sur la carte, penser à essayer le cas où le panneau est actif et celui où il est hors service.

M1 SIS 32 2011/2012


9.3.2. Panneau à message variableLe programme que vous venez d'écrire est très utile pour diffuser un message mais peu pratiques. En effet, si à

chaque fois que la secrétaire veut modifier le message elle doit prendre un programmateur et reprogrammer l'EEPROM, elle ne voudra pas l'utiliser : c'est compliqué, ça prend du temps, il faut sortir le microcontrôleur du panneau...

Pour régler ce problème vous allez mettre en place un système de mise à jour à distance en utilisant le protocole RS232 comme vous l'avez dans le TP n°5. Via hyperterminal la secrétaire accèdera à une interface d'administration qui lui permettra de modifier l'état du panneau, le titre et le corps du message.

Le programme va donc afficher en continu le message et basculer en mode mise à jour lorsque la commande sera reçue. Les différentes commandes et la procédure de mise à jour sont définis dans l'algorigramme figrue 22 page suivante.

Compléter le progammme précédent pour intégrer l'interface d'administration. Commentez bien ce programme afin d'expliquer ce que vous faîtes et pourquoi.

Penser à gérer la taille maximale des chaines et le carctère '\0' en cas de dépassement de la taille maximale en informé la secrétaire (hyperterminal).

Figure 22: Algorigramme de l'interface d'administration du panneau

L'application réalisée ici est très proche d'un cas d'utilisation réelle si ce n'est que l'afficheur aurait peut être plus de lignes. La différence majeure serait dans l'interace d'administration elle ne serait pas réalisée avec hyperterminal, mais avec un programme spécial en C, C++, etc ... qui serait écrit avec des boîtes de dialogues beaucoup plus conviales pour la secrétaire.

M1 SIS 33 2011/2012

Valeur dansRCREG ?

RCREG='d' RCREG='e' RCREG='s' RCREG='u'

Mettre le panneauhors service Mettre le panneau

en service

Renvoyer l'état du panneauet le contenu du t it re et du

corps du message dans hyperterminal

Mettre le panneauhors service

Afficher « Mise à jour »sur le panneau

Récupérer le nouveautit re du message

Récupérer le nouveaucorps du message

Afficher dans hyperterminal,que la commande a été effectuée


10. TP n°7 : Station ServiceDans ce TP nous allons réaliser de la manière la plus réaliste possible le programme de commande d'un automate

de pompe à essence.

10.1. Automate de PompeLe bouton poussoir connecté à RB0 représente la poignée de distribution de carburant. Lorsque le bouton est

appuyé, la distribution est en cours, le moteur de la pompe est alors est alors activé (led RB3 éclairée). Un débitmètre mesure le débit de carburant afin de calculer le volume, il donne une impulsion à chaque centilitre versé. Ici, il sera simulé par le timer 0 qui effectura une impulsion toute les 15 ms environ.

Écrire un premier programme qui initialise les entrées sorties utilisées, le timer 0, autorise les interruptions puis à l'infini éxécute :

moteur pompe arrêtédébimètre arrêtétant que Poignée Accrochée fairefin fairemoteur pompe activédébimètre activétant que Poignée Décrochée fairefin faire

Pour tester ce programme lors d'une interruption, inverser l'état de RC2 afin d'envoyer un signal d'environ 50 Hz sur le transducteur piézo-électrique.

Nous allons maintenant intégré au programme les calculs de volume et de prix. Le volume est compté en centilitres de 0 à 9999 cl. Il peut donc être stocker dans une variable de type entier (16 bits). Le prix du litre est fixé à 1,08€, un centilitre vaut donc 1,08 centime d'euro. Le prix maximun peut atteindre 108,00 €. Le prix sera donc un nombre de centièmes de centimes variant entre 0 et 1079892, il doit être codé sur entier long (32 bits).

Chaque interruption du timer 0 correspond à un centrilitre versé. Le sous programme d'interruption incrémentre le volume (+1cl) et le prix en centième de centime (+108c). On aurait également pu calculé le prix en multipliant le volume par le prix au litre mais cela aurait nécessité des multiplications, plus longues à effectuer que les additions.

Modifier votre programme pour intégrer ces calculs, puis assurez-vous en simulation que le volume et le prix évoluent correctement.

L'afficheur LCD va nous permettre (via la librairie écrite au TP n°6) d'afficher le prix et le volume lorsque la distribution est en cours. Le volume est un entier compris entre 0 et 9999 et nous voulons l'afficher à l'écran sous la forme décimale :

< m > < c > , < d > < u > loù < m >, ..., < u > représentent respectivement le chiffre des milliers, centaintes, dizaines et unités. Si on effectue la division euclidienne de la variable volume par 1000, < m > est le quotient et le reste représente centaines, dizaines, unités ...

En C, le quotient de la division euclidienne est donnée pas l'opérateur / et le reste par %.

Ajouter ces calculs au programme précédent, et le simuler. Vérifier l'exactitude des différents chiffres à afficher. Puis en utilisant les points d'arrêt, mesurer la durée d'éxécution du code de calcul des chiffres à afficher.

Pour accélérer les calculs, nous allons utiliser l'algorithme suivant, donné ici pour le chiffre <m>. Les calculs étant effectué dans la variable vol afin de ne pas modifier la variable volume.

m = 0vol = volumetant que vol >= 1000 faire

m = m + 1vol = vol – 1000

fin faire

M1 SIS 34 2011/2012

C


Après avoir bien compris cet algorithme, remplacer toutes les divisions de votre programme par ces boucles (fonction : deux valeurs sont à retourner effectuer un passage par adresse pour l'une des deux ...). Simuler le fonctionnement et mesurer la durée d'éxécution. Attention ! La durée dépend du chiffre à déterminer. Faites des essais avec le volume à 1 puis avec les valeurs qui donneront la plus grande durée. Avons nous gagné beaucoup de temps ?

Le prix et le volume sont affichés de la manière suivante :G a z o l e 1 , 0 8 E / l

x x , x x l y y y , y y E

On calcule le prix à afficher de la même façon que le volume. Quel est le premier chiffre à afficher ? Écrire le code corresspondant au calcul des yyy,yy €.

Lorsque que le client raccroche la poignée, la pompe est bloquée tant que celui-ci n'a pas payé. La validation du paiement étant reçue de l'automate de caisse. Pour l'instant un appui sur RA4 validera la paiement et permettra au client suivant de se servir en carburant. Intégrer également la contrainte que le volume ne doit pas dépasser pas 9999cl, sinon la pompe s'arrête et attends le paiement.

Écrire et tester ce programme sur la carte.

10.2. Communication avec l'automate de caisseGénéralement une station service est constituée de plusieurs pompes. On ne peut donc pas utiliser une connexion

de type RS232 pour communiquer avec l'automate de caisse ou alors il faut, à chaque client, aller brancher le câble sur la bonne pompe... Heuresement il existe d'autres manières de communiquer afin de mettre plusieurs entités en réseau. Le PIC 18F4520 intègre un module MSSP de communication série (Master Synchronous Serial Port) qui gère entre autre le protocole I²C que nous allons utiliser.

10.2.1. Le bus I²CI²C (pour Inter Integrated Circuit Bus) est le nom du bus historique, développé par Philips pour les applications

de domotique et d’électronique domestique au début des années 1980, notamment pour permettre de relier facilement à un microprocesseur les différents circuits d’une télévision « moderne ». Le bus I²C est un bus série synchrone constitué de deux lignes : Serial Data Line (SDA) et Serial Clock Line (SCL) qui assurent la communication entre différents modules.

Figure 23: Architecture I²C

Le module qui demande le transfert de données et qui génère l’horloge est le maître, le module qui répond est un esclave. Un même système peut disposer de plusieurs maîtres, on le nomme alors multimaître. Dans ce cas, il faut arbitrer la discussion entre les différents modules. Nous ne verrons ici seulement le cas d'un seul maître avec plusieurs esclaves. Le bus I²C travaille à une vitesse de 100 kbits/s en mode standard et 400 kbits/s en mode rapide. Les lignes SDA et SCL sont bidirectionnelles. Au repos, elles sont au niveau haut.

Le format d'une trame standard est reproduit dans le tableau 4. Un transfert type I²C est reproduit en figure 25.

S Adresse RW A Donnee A ... Donnee A P

Tableau 4: Trame I²C

– S : bit de start, est la condition de départ : SDA passe de l’état haut à l’état bas pendant que SCL est au niveau haut (cf. figure 24).

– Adresse : représente celle du module à laquelle on veut s ‘adresser, elle est composée de 7 bits A6A5A4A3A2A1A0, A6A5A4A3 sont fixés par l’I²C commitee A2A1A0 sont libres pour nous permettre de

M1 SIS 35 2011/2012

SDASDASCL

Maitreémetteur, récepteur

Escalve németteur, récepteur

Esclave 1émetteur, récepteur ...


mettre plusieurs fois le même esclave sur le bus (au maximum 8).– RW (Read Write) : est le bit de mode de transmission. S’il est à 0, on est en mode écriture, c’est le maître

qui envoie des données à l’esclave. S’il est à 1, on est en mode lecture, c’est l’esclave qui envoie des données au maître. L’Adresse et R/W sont transmis ensemble ce qui forme un mot de 8 bits.

– A : bit d’acquittement, il a lieu à la fin de chaque transmission d’un mot pour dire que le récepteur a bien reçu les données. Après, l’envoi du mot de 8 bits, au coup d’horloge, le récepteur force SDA à l’état bas.

– Donnée : sont les huit bits de données que l’on transmet.– P : bit de stop, est la condition de stop. SDA passe de l’état bas à l’état haut pendant que SCL est au niveau

haut (cf. figure 24).

Figure 24: Bus I²C, Bit de Start et Bit de Stop

D’après le protocole de transfert, on peut voir que le nombre maximal d’esclaves est 27 soit 128. Comme les lignes SDA et SCL sont au repos au niveau haut, les composants (maîtres, esclaves) I²C ne peuvent donc que les forcer qu’à l’état bas. Ce fonctionnement impose aux circuits des sorties à collecteur (figure 26) ouvert ou à drain ouvert pour SDA et SCL (cf. Documentation I²C).

M1 SIS 36 2011/2012

Figure 25: Transfert de données sur le bus I²C

l'émetteur émet les données, le maître gère l'horloge.

Le maître émet l'adresse de l'esclave, RW et gère l'horloge.

Le maître émet l'adresse de l'esclave, RW et gère l'horloge.

l'émetteur émet les données, le maître gère l'horloge.


Pour stopper une transmission, en mode lecture le maître n’acquitte pas le dernier mot transmis et génère un bit de stop. En mode écriture, si l’esclave n’acquitte pas le dernier mot, le maître génère le bit de stop. Les données ne sont valides que sur un niveau haut de SCL. Une extension de l'I²C permet d'avoir plus de périphériques en codant l'adresse sur 10 bits, nous ne verrons pas ce cas dans ce tp.

Figure 26: Connexions à collecteur ouvert

Sur un bus I²C, le pic peut être soit maître soit esclave. Dans notre application qui jouent les rôles de maître et d'esclave ? Justifier votre réponse.

10.2.2. Échange entre les automates de caisse et de pompesLes tableaux suivants représentent les échanges entre les automates :

Message

En attente de client 'c'Distribution en cours 'o'Distribution terminée, attente de validation du paiement 'ayyyyy'*

Tableau 5: Communication Automate de pompe vers caisse

Message

Validation du paiement 'v'

Tableau 6: Communication Automate de caisse vers pompe

* : yyyyy sont les chiffres du montant à payer.

10.2.3. Le bus I²C et l'automate de caisseNous allons commencer par étudier le programme de l'automate de caisse. Ce programme permet via

hyperterminam de communiquer avec les pompes. Pour connaître le statut d'une pompe, il suffit de saisir son numéro dans hyperterminal à l'aide du pavé numérique. Nous nous intéressons seulement à la partie I²C du programme dans le TP.

Expliquer, commenter les fonctions de l'automate de caisse reproduite dans le tableau 7. À partir de ces fonctions de gestion du bus, écrire les fonctions de communication « void i2c_master_to_slave(

char adresse, char donnee ) » et « char i2c_slave_to_master( char adresse ) » réalisant respectivement le transfert d'un octet du maître vers l'esclave et de l'esclave vers le maître.

Les chronogrammes page 192 et 193 de la datasheet pourraient vous être utile. Quelles modifications faut-il apporter aux fonctions que vous venez d'écrire pour qu'elles soient utilisables dans

le cas de la station service ?

M1 SIS 37 2011/2012


void i2c_master_init( void ){TRISCbits.TRISC3=1;TRISCbits.TRISC4=1;SSPCON1=0b00101000;SSPSTATbits.SMP=1;SSPADD=9;SSPCON2=0;}

void i2c_master_start_bit( void ){SSPCON1bits.SSPEN=1;SSPCON2bits.SEN=1;while(SSPCON2bits.SEN);}

void i2c_master_restart_bit( void ){SSPCON2bits.RSEN=1;while(SSPCON2bits.SEN);}

void i2c_master_stop_bit ( void ){SSPCON2bits.PEN=1;while(SSPCON2bits.PEN);SSPCON1bits.SSPEN=0;}

void i2c_master_ack( void ){SSPCON2bits.ACKDT=0;SSPCON2bits.ACKEN=1;while(SSPCON2bits.ACKEN);}

void i2c_master_nack( void ){SSPCON2bits.ACKDT=1;SSPCON2bits.ACKEN=1;while(SSPCON2bits.ACKEN);}

char i2c_master_ecrire( char octet ){SSPBUF=octet;while(SSPSTATbits.R_W);return SSPCON2bits.ACKSTAT;}

char i2c_master_lire( void ){SSPCON2bits.RCEN=1;while(SSPCON2bits.RCEN);return SSPBUF;}

Tableau 7: Fonction I²C Automate de Caisse

10.2.4. Le bus I²C et l'automate de pompeIntéressons nous maintenant au programme d'un automate de pompe, la pompe étant intérrogé par l'automate de

caisse. L'adresse de l'automate de pompe sur le bus I²C est codée sur 7 bits et correspond au code ASCII du numero de la pompe. Ainsi l'adresse de la pompe n°1 sera 0x31 qui se code bien sur 7 bits. La plage d'adresse est de 0x31 à 0x38. L'adresse doit être stockée dans les bits de poids fort du registre correspondant, le bit 0 de ce registre restant à zéro. Les lignes SCL et SDA sont connectées respectivement aux broches RC3 et RC4, broches qui doivent être configurées en entrée. Nous utiliserons le mode de fonctionnement standard et sans interruptions de bits de Start et de Stop.

C'est l'automate de caisse qui va venir demander à l'automate de pompe la somme à encaisser. Lorsque

l'automate de caisse veut faire une demande, il envoi sur le bus l'adresse de la pompe intérrogée (mode lecture). Si l'automate de pompe reconnaît son adresse et le flag SSPIF se lève. Si les interruptions ont été autorisée le programme passe alors à la routine associée.

L'automate de pompe fonctionnant en mode esclave il est donc nécessaire d'utiliser les interruptions car sinon, le programme va passer son temps à surveiller le bus et ne pourra pas effectuer la distribution de carburant. D'autant plus que la demande de l'automate de caisse peut intervenir n'importe quand. (Nous utiliserons les messages reproduits en tableau 5.)

M1 SIS 38 2011/2012

Bit de Start

Bit de Stop

Acquittement du récpeteur si ce n'est pas la fin du transfert

Acquittement de l'esclave

A6

A5

A0 D

7D

6D

5...0RW


Compléter la fonction d'initialisation (ci-après) du module MSSP pour l'utilisation en mode I²C dans le cas d'un automate de pompe. Expliquer vos initialisations.

void i2c_slave_init(void){TRISCbits.TRISC3 = ...TRISCbits.TRISC4 = ...SSPCON1 = ... //CKP=1 ...SSPCON2=0;SSPSTAT=0;SSPSTATbits.SMP = ...SSPADD = ...IPR1bits.SSPIP = 1... = ...... = ...}

En utilisant la datasheet du pic, quels sont les bits à initialiser pour autoriser l'interruption du module I²C ? Rajouter ces initialisations à la fonction « void i2c_slave_init( void ) ».

En regardant la datasheet on s'aperçoit quand mode esclave, il y'a 3 bits qui permettent de connâitre l'état de la communication I²C. Tout le reste étant gérer par le module MSSP et donc transparent pour nous. Ceux sont les bits R_W, D_A et BF du registre SSPSTAT.

Quelles sont les informations que nous donnent chacun de ces bits ?

L'étude des chronogrammes page 176 et 177 de la datasheet montrent les différentes configurations possibles de ces bits lors d'une interruption du module I²C :

D_A R_W BF Point de vue Maître Point de vue Esclave0 0 11 0 10 1 01 1 0

1 0 0 Mode lecture : le maître a généré un ACK signifiant la fin de la lecture.

Fin de l'envoi, ce cas n'est pas obliger d'être traiter dans le programme.

Tableau 8: I²C, esclave, interruption MSSP : Différentes configurations possibles

Compléter le tableau 8. En fonction de la configuration de « D_A, R_W, BF », expliquer ce que veut le mettre et ce que doit faire l'esclave.

Lors d'une requête de lecture, le module I²C esclave du PIC force SCL à 0 pour empêcher que le maître reprenne le contrôle du bus avant qu'il est pu préparer la donnée à transmettre. Une fois que la donnée à transmettre est prêtre il faut repositionner le bit CKP du registre SSPCON1 à 1 afin de relâcher l'horloge. On parle de clock stretch.

Erratum Microchip Mode I²C : Dans la datasheet du PIC18F4520, il est dit que dans le cas d'une lecture du maître, la réception de l'octet d'adresse ne positionne pas le bit BF, or ce n'est pas le cas ! Tenez compte de cette erreur dans l'écriture de votre routine d'interruption I²C.

Intégrer les fonctions I²C au programme de l'automate de pompe et tester son fonctionnement. Le programme de l'automate de caisse vous est fournit. Lisez la partie suivante avant de tester votre programme sur la carte.

10.2.5. Connexion I²C entre deux cartes PICDEM 2 PlusComme on peut le voir sur la figure 26, la partie physique d'un bus I²C est réalisée par trois lignes électriques : la

masse (GND), les données (SDA) et l'horloge (SCL). Comme les composants connectés sont de types collecteur ouvert

M1 SIS 39 2011/2012


ou drain ouvert, les lignes SDA et SCL doivent être maintenues à l'état haut par une résistance. Ces résistances sont dites de « pull-up » et sont caculées en fonction du nombre de composants, de la longueurs du bus ... (cf. documentation I²C de Phillips).

Dans le cas des cartes PICDEM 2 Plus, chacune d'entre elle a déjà ses résistances puisqu'elles disposent d'un capteur de température et d'une EEPROM I²C. Donc si on connecte directement deux cartes ensemble, on se retrouve avec les deux résistances en parallèle sur chaque ligne (le courant est donc multiplié par 2) et on a deux fois le même composant sur le bus (cela ne serait pas grave si les composants n'avait pas la même adresse, hors les deux cartes sont identiques). Pour vos tests, vous devez donc utiliser le microcontrôleur pour lequel le support a été modifié : les broches RC3, RC4 et GND ont été remplaçées par des fils connectés à une autre carte PICDEM 2 Plus.

Figure 27: Connexion en I²C de deux cartes PICDEM 2 Plus

Dans le programme de caisse, si vous taper le caractère 't' dans hyperterminal, la temperature sera affichée en utilisant le capteur TC74 connecté au bus à l'adresse 0x4D.

Rédiger un petit bilan sur l'ensemble des travaux pratiques : Qu'est ce qui vous a plu, déplu, ennuyé ? Qu'avez vous appris, retenu ? Y'a t'il des choses à améliorer pour les futurs étudiants ? ...

M1 SIS 40 2011/2012

PIC24

L256

TC74

SDA

SCLGND

PICDEM 2 Plus - I

GND

RC3 RC4

PIC

24L2

56

TC74

SDA

SCLGND

PICDEM 2 Plus - II

GND

RC3 RC4

R R+5 V

R R+5 V


Notes :

M1 SIS 41 2011/2012

Travaux Pratiques de Microcontrôleur