partie étude usb - emrecmic.files.wordpress.com · nous le programmerons en langage c avec les...

1

Partie étude USB

I. Objectif L’objectif de ce document est de faire une méthode pas à pas pour utiliser une liaison USB dans un projet électronique. Nous utiliserons ici un microcontrôleur PIC de Microchip qui intègre la norme USB. Nous utilisons le 18F4550 mais il en existe d’autres, plus compacts. II. Norme USB

Ici nous n’expliquerons pas le fonctionnement de l’USB mais plutôt les divers modes de communication proposés par ce bus :

- communication CDC (convertisseur USB-série) - communication HID (human interface device) - communication mass Storage - communication générique (transfert brut des données)

CDC : Le mode CDC sert à émuler un port série donc l’ordinateur voit le périphérique comme un port série et le dialogue se réalise comme tel avec les mêmes bibliothèques qu’un port série. HID : Ce mode est utilisé pour les souris, claviers et autres périphériques basse vitesse à transferts de données faibles. Mass Storage : Mode utilisé pour les clés USB et autres périphériques de stockage. Générique : Mode utilisé dans ce tutoriel, il permet une vitesse maximum de 480 Mbits/s, 12 Mbits/s, 2 Mbits/s. Les bibliothèques fournies avec ce mode nous permettent de donner la quantité d’information à envoyer dans un temps que l’on peut fixer.

III. PIC18F4550 Le PIC intègre l’USB et Microchip fournit tout un panel d’outils pour utiliser ce mode de communication.

2

Le 18F4550 comporte 40 broches, il est composé de CNA, de CAN, de ports série, d’un bus SPI, … Il permet donc une adaptation à toutes sortes de projets. Nous le programmerons en langage C avec les logiciels MPLAB et C18 de Microchip, tous les deux disponibles gratuitement. MPLAB est l’environnement de programmation et C18 un plugin pour pouvoir programmer en C. IV. Pilote et firmware USB de Microchip Microchip fournit des pilotes et des exemples d’applications pour le PC et des programmes pour le PIC. Ils les distribuent sous le nom de MCHPFSUSB. Il contient des documents, un dossier pour le microcontrôleur et un dossier pour le PC. Ce qui concerne le microcontrôleur se résume à un Bootloader, un exemple de communication CDC, d’un exemple de communication HID, d’un exemple de programme basique utilisé avec le Bootloader et d’un exemple de communication générique. Le dossier PC comporte les drivers de l’USB lorsqu’on branche le microcontrôleur sur le PC, des bibliothèques pour la communication générique et des exemples de programmes sur PC, et d’un programmateur utilisé avec le Bootloader. V. Bootloader

Le Bootloader est un programme résidant dans le PIC en haut de la mémoire. Il permet de mettre à jour le programme contenu dans le PIC en écrivant directement dans la mémoire sans passer par un programmateur dédié. Le Bootloader est protégé contre les écritures dans la zone réservée à son code. Nous l’utiliserons ici avec la liaison USB. Au démarrage du PIC, celui-ci scrute un bouton ; s’il est enfoncé, il passe en mode programmation, sinon il exécute le programme. En mode programmation il dialogue avec un programme du PC et efface l’ancien programme pour mettre le nouveau. Les étapes pas à pas pour commencer un projet sont : Etape 1 : Utiliser un programmateur de PIC pour programmer le Bootloader dans le PIC18.

3

Nous avons utilisé un kit de développement de Microchip contenant un ICD2, programmateur débogueur, et une carte de développement PICDEM mais tout autre programmateur compatible avec le 18F4550 conviendra. Il faut donc mettre le microcontrôleur sur la PICDEM, brancher l’ICD2, ouvrir MPLAB, compiler le Bootloader et programmer la puce. Si vous utilisez un PIC18F2550, un 18F87J50 ou un schéma différent (oscillateur au lieu du quartz, …), il faudra modifier un peu la source du Bootloader, pour cela se servir de la doc du microcontrôleur et d’internet (site de liens en annexe). Etape 2 : Réaliser un prototype intégrant au minimum le schéma suivant :

Nous pouvons voir ici le PIC, son quartz de 20 MHz, le bouton de reset, celui pour entrer dans le mode Bootloader et le port USB. Etape 3 : Connecter l’USB et première détection.

4

Connectez l’USB, ce qui alimente la carte. Entrez dans le mode Bootloader en maintenant enfoncé le bouton S2, puis appuyez sur S1. Normalement, Windows détecte un périphérique USB inconnu. Etape 4 : Installation du pilote. Une fenêtre Windows s’ouvre alors pour installer manuellement le pilote. Sélectionnez « Ne pas se connecter a internet » puis rechercher manuellement puis donner le répertoire où se trouvent les pilotes Microchip : \MCHPFSUSB\PC\MCHPUSB driver\release. Etape 5 : Utilisation du Bootloader. Nous allons maintenant utiliser le Bootloader pour programmer un programme d’exemple : demo2 de Microchip. Avec MPLAB, ouvrir le projet demo2, le modifier si nécessaire et le compiler Rentrer dans le mode Bootloader en pressant S2 et S1 et relâcher S2 après S1. Ouvrir le logiciel \MCHPFSUSB\Pc\Pdfsusb\PDFSUSB.exe Sélectionner PICDEM FS USB 0 (Boot) dans la liste Cliquer sur Load HEX File" : "C:\MCHPFSUSB\fw\Demo02\Demo02.hex" Cliquer sur programme Appuyer sur S1 pour reseter le microcontrôleur et vérifier le bon fonctionnement du programme. Etape 6 : Créer un programme sur PC en utilisant les bibliothèques fournies par Microchip ou les bibliothèques de liaison série standards. Etape 7 : Créer votre propre programme en vous inspirant de l’exemple « démo », CDC ou HID pour le dialogue USB.

VI. Software PC Il est maintenant nécessaire de faire un programme sur le PC qui interagira avec votre montage. Il est conseillé de commencer par un simple petit programme qui allume une led lorsque l’on appuis sur un bouton a l’écran et un voyant qui s'allume sur votre fenêtre lorsque vous mettez a un une broche du microcontrôleur.

5

Nous avons utilisé l’environnement de delphi6 (langage pascal) pour réaliser notre programme mais il est possible de le créer sous n’importe quel autre langage. Les bibliothèques fournit par Microchip sont situé dans le dossier : « MCHPFSUSB\Pc\Mpusbapi ». On y trouve une dll et ses sources. Pour utiliser une dll avec Delphi il faut passer par un fichier bibliothèque qui interprète la dll (fournit en annexe). Pour les autres langages la façon de l’utiliser dépend du compilateur utilisé. Utilisation de la dll : Il y a une zone à modifier et deux fonction a utiliser, la zone a modifier concerne les codes des commandes a envoyer et la taille des paquets reçut et émis (buffer) : READ_VERSION = $00; // commandes pour le Bootloader READ_FLASH = $01; WRITE_FLASH = $02; ERASE_FLASH = $03; READ_EEDATA = $04; WRITE_EEDATA = $05; READ_CONFIG = $06; WRITE_CONFIG = $07; UPDATE_LED = $32; RESET_DEVICE = $FF; // commandes personnelles STOP = $20; CHANGE = $21; Et les fonctions à utiliser sont : GetSummary() qui cherche les périphériques connecté et retourne 0 si elle n’en trouve aucun et sinon le nombre trouvé. Function EnvoiReception(SendData :PByteBuffer; SendLength : DWORD ; ReceiveData : PByteBuffer; var ReceiveLength : DWORD):DWORD; Celle-ci sert à envoyer recevoir les données

6

Exemple d’utilisation : // Fonction qui envoi la commande stop procedure TCNC1.arret; var RecvLength : DWORD; // variables utilisé par la fonction send_buf : TByteBuffer; receive_buf :TByteBuffer; begin // remplissage des buffer d’envoi send_buf[0] := STOP; // nom de la commande à envoyer send_buf[1] := 2; // longueur de l’émission RecvLength := 2; // longueur de la reception if (EnvoiReception(@send_buf,send_buf[1],@receive_buf,RecvLength) = 2) Then Begin if (receive_buf[0] = STOP) then // si la commande renvoyé correspond bien Memo1.lines.add('STOP OK') Else Memo1.lines.add('Mauvais renvoit de commande!') end Else Memo1.lines.add('USB Operation Failed'); // si il y a eu une erreur end; Toute autres opérations ce fera de la même manière, ce qui diffère ce sont les commandes, les donnés à envoyer, à recevoir. Un exemple plus complet est donné plus loin.

VII. Firmware PIC Pour programmer le PIC18F4550 nous utilisons l’environnement de programmation MPLAB de Microchip.

7

Étude du PIC 18F4550 1 - Caractéristiques du microcontrôleur PIC 18F4550

Fosc max = 48 MHz => Fcyc max = 12 MHz Tosc mini = 20,83 ns => Tcyc mini = 83,33 ns Instructions codeÅLes sur 16 bits : 75 instructions en mode standard + 8 en mode eÅLtendu (pour optimisation) DonneÅLes en RAM sur 8 bits

10

1.2 - La mémoire programme (Flash)

11

1.3 - La RAM

12

1.4 - Reset du microcontrôleur Il existe plusieurs sources de Reset : Instruction RESET : Reset réalisé par le logiciel Stack pointer : Pointeur de pile (dépassement du nombre de saut logiciel) MCLR : Borne externe du microcontrôleur (durée mini imposée voir doc PDF) WDT : Chien de garde Power-on Reset (POR) : Mise sous tension du microcontrôleur (front montant sur VDD) Brown-out Reset (BOR) : Détection d'une chute de tension sur l'alimentation du microcontrôleur Il existe 2 sources qui permettent de maintenir le microcontrôleur en "RESET" après la mise sous tension : Power-up Reset (PWRT) : Durée d'environ 65,5 ms que l'on peut ajouter Oscillator Start-up (OST) : Attente de la stabilisation de l'horloge (dans le cas des quartz) Après la phase de Reset, le microcontrôleur commence a` exécuter la première instruction présente à l'adresse 0x0000 de la mémoire Flash. 1.5 - Les bits de configuration du microcontôleur Pour les configurer il faut utiliser la doc PDF du microcontro^leur ainsi que l'aide dans MPLAB IDE : Fichier d’aide dans MPLAB IDE : Help ® Topics… ® PIC18 Config Settings

13

Bit Fonction

Utiliser un fichier pour configurer ces bits dans votre projet MPLAB, voir le paragraphe "Configuration de l’Horloge" ci-dessous.

14

1.5.1 - Accès manuel aux Bits de Configuration avec l’environnement MPLAB IDE Il est fortement déconseillé de l’utiliser dans un projet. Il vaut mieux les paramétrer en C ou en assembleur.

1.5.2 - Paramétrage des Bits de Configuration avec le compilateur C18

• Créer un fichier que l’on nommera par exemple "Config.h". • Dans ce fichier il faut utiliser la directive du processeur en C18 :

#prama config • Consulter l'aide dans l'environnement MPLAB IDE (indiquer ci-

dessous) et la doc PDF du microcontrôleur. Exemple de configuration en C18 : On dispose d'un quartz à 4 MHz connecté entre les bornes OSC1 et OSC2 associé avec 2 condensateurs de 27 pF. On souhaite configurer le microcontrôleur avec :

• Une horloge pour le CPU de 48 MHz • Une horloge pour l'USB de 48 MHz • Une horloge pour les périphériques internes du microcontrôleur de 48

MHz

15

1.5.3 - Paramétrage des Bits de Configuration en Assembleur • Créer un fichier que l’on nommera par exemple "Config.inc". • Dans ce fichier il faut utiliser la directive du processeur en C18 :

CONFIG • Consulter l'aide dans l'environnement MPLAB IDE (indiquer ci-

dessus) et la doc PDF du microcontrôleur. Exemple de configuration en assembleur : On dispose d'un quartz à 4 MHz connecté entre les bornes OSC1 et OSC2 associé avec 2 condensateurs de 27 pF. On souhaite configurer le microcontrôleur avec :

• Une horloge pour le CPU de 48 MHz • Une horloge pour l'USB de 48 MHz • Une horloge pour les périphériques internes du microcontrôleur de 48

MHz

16

1.6 - Configuration de l’Horloge 1.6.1 - Schéma complet

17

Fcyc : Fréquence du cycle instruction (représente la durée de l'exécution d'une instruction) 4 paramètres permettent de gérer l’Horloge : PLLDIV CPUDIV USBDIV FOSC Ces paramètres sont présents dans la mémoire Flash à partir de l'adresse 0x300000 1.6.2 - Détail des 4 paramètres de configuration de l'horloge

19

1.6.3 - Exemples de configuration de l'horloge

Configuration en C18 : // Définition des pragma de configuration de l'horloge #pragma config PLLDIV = 2 #pragma config CPUDIV = OSC1_PLL2 #pragma config USBDIV = 1 #pragma config FOSC = HSPLL_HS Dans le programme principal "main" il faut placer à la première instruction le code suivant : OSCCONbits.SCS1 = 0; // Impose au Microcontrôleur de travailler avec l'horloge primaire OSCCONbits.SCS0 = 0;

20

I2 e cas : On souhaite utiliser l'horloge interne à 4 MHz sans quartz et pas d'USB.

Configuration en C18 : // Définition des pragma de configuration de l'horloge #pragma config PLLDIV = 2 // Valeur sans influence #pragma config CPUDIV = OSC1_PLL2 // Valeur sans influence #pragma config USBDIV = 1 // Valeur sans influence #pragma config FOSC = INTOSC_HS Dans le programme principal "main" il faut placer à la première instruction le code suivant : OSCCONbits.SCS1 = 1; // Impose au Microcontrôleur de travailler avec l'horloge interne OSCCONbits.SCS0 = 0; OSCCONbits.IRCF2 = 1; // Sélectionne la fréquence de 4 MHz sur le multiplexeur OSCCONbits.IRCF1 = 1; OSCCONbits.IRCF0 = 0;

21

1.7 - Les ports d'entrée / sortie 1.7.1 - Schéma interne d'une borne d'entée / sortie

Le buffer B1 est activé lorsque RD LAT est a` 1, il permet de lire la sortie de la bascule L1. Le buffer B2 est activé lorsque la sortie de la bascule L2 est a` 0 sinon la borne externe du µC est indépendante de la sortie de la bascule L1. Le buffer B3 est activé lorsque RD TRIS est a` 1, il permet de lire la sortie de la basule L2. Le buffer B4 est activé lorsque RD PORT est a` 1, il permet de lire la sortie de la bascule L3. Les "Latch" ou bascules L1 et L2 recopient sur leur sortie le contenu de la donnée présente sur le Bus de donnée sur des fronts descendants des signaux de contrôles WR LAT, WR PORT et WR TRIS.

22

13 registres permettent d'utiliser les ports : ADCON1 : configure certaines bornes en Numériques ou Analogiques TRISA, TRISB, TRISC, TRISD, TRISE : configure la borne du µC en entrée (1) ou en sortie (0) LATA, LATB, LATC, LATD, LATE : écrire sur la sortie de la bascule L1 ou lire la sortie de la bascule L1 PORTA, PORTB, PORTC, PORTD, PORTE : écrire sur la sortie de la bascule L1 ou lire la borne I/O pin. Les registres TRIS permettent de donner une direction aux bornes du microcontrôleur soit en entrée soit en sortie. Les registres LAT permettent d'accéder à la bascule L1 ci dessus en lecture et en écriture. Les registres PORT permettent d'écrire sur la sortie de la bascule L1 et de lire la borne externe du microcontrôleur. Lors de l'écriture dans le registre LAT ou PORT, la donnée se retrouvera sur la borne externe du microcontrôleur si le TRIS associé est à 0 sinon la donnée sera stockée sur la sortie de la bascule L1. La lecture du niveau logique de la borne externe du microcontrôleur se fait par la lecture du registre PORT. Cette opération active le signal de contrôle RD PORT qui permet de copier la sortie de la bascule L3 sur le bus de données du microcontrôleur.

23

1.7.2 - Cas d e l'écriture sur le Port

24

1.7.3 - Cas de la lecture sur le Port

25

1.7.4 - Cas de l'écriture sur le Latch d'un Port d'entrée / sortie

26

1.7.5 - Cas de la lecture du Latch d'un Port d'entrée / sortie

27

1.8 - Les "Timer" ou "Compteur" 1.8.1 - Fonctionnement Le Timer est un compteur qui est incrémenté par des fronts montants ou descendants (par exemple horloge). Il peut être préchargé logiciellement par une valeur et peut posséder un prédiviseur (Prescaler) et/ou un Post diviseur (Postcaler). 1.8.2 - Le Timer 0

Le Timer 0 est compteur sur 8 ou 16 bits composé de 2 registres de 8 bits : TMR0H et TMR0L accessible en lecture et en écriture. En mode 8 bits, seul le registre TMR0 est utilisé. En mode 16 bits, les 2 registres sont utilisés. Son entrée est définie soit par un signal externe au microcontrôleur branchée sur la borne T0CKI, soit par l'horloge interne du microcontrôleur (Fosc / 4). Le choix du signal d'entrée est défini par le bit T0CS du registre T0CON. Un pré-diviseur programmable peut être sélectionné par le bit PSA. A chaque front d'horloge du signal FH, le compteur TMR0 = TMR0H:TMR0L est incrémenté. En mode 8 bits, la capacité du compteur est 255 = 28 - 1 et en mode 16 bits sa capacité est 65535 = 216 - 1.

28

Lorsqu'il y a dépassement de sa capacité, le bit TMR0IF du registre INTCON est mis à 1, et le compteur repart de valeur 0. le bit TMR0IF doit être remis à 0 logiciellement. 1.8.3 - Le Timer 2

Il fonctionne avec un compteur de 8 bits TMR2, un pré-diviseur programmable, un post diviseur programmable et un registre de comparaison de 8 bits. TMR2 est incrémenté par l'horloge du microcontrôleur (Fosc / 4) et comparé au registre PR2. En cas d'égalité le post diviseur est incrémenté et le registre TMR2 est remis à 0. Lorsque le post diviseur a atteint la valeur programmée, il génère la mise a 1 du bit de dépassement TMR2IF.

29

2 - L'environnement de développement "MPLAB" 2.1 - Création d'un projet MPLAB avec "Project Wizard…"

31

2.2 - Configuration des chemins du langage de programmation C18 : Microchip C18 Toolsuite

32

2.3 - Configuration des options de compilation avec "Build Options"

33

2.5 - Ajouter un nouveau fichier dans le Projet

34

2.6 - Ajouter un fichier existant dans le Projet

35

2.7 - Définition des propriétés du fichier Afin de rendre l'écriture plus agréable, il peut être opportun de définir quelques propriétés sur la feuille de travail dans l'environnement MPLAB IDE.

36

2.8 - Gestion des fenêtres dans MPLAB IDE Les fenêtres de travail dans MPLAB IDE peuvent être "Dockable". C'est à dire qu'elles peuvent être fixées et qu'elles ne bougeront plus.

37

2.9 - Utilisation de l'ICD2 L'ICD2 est un "Programmeur / Débogueur" de chez Microchip et utilisable dans l'environnement de travail MPLAB. 2.9.1 - Le connecteur RJ11 de l'ICD2

38

2.9.2 - Le câblage avec la carte de développement 2.9.3 - L'ICD2 et MPLAB IDE

39

2.10 - Utilisation de MPLAB IDE en Simulateur Ce mode permet de tester le programme sans utiliser de matériel :

• Il contient un analyseur logique "Simulator Logic Analyzer" qui permet de visualiser les signaux de sortie du microcontrôleur.

• Il contient une fonction "Stimulus" qui permet de simuler les entrées numériques.

• Il contient une fenêtre "Watch" qui permet de visualiser le contenu des registres et des variables (contenu de la RAM).

• On peut placer des points d’arrêt dans le programme "Break Point". Pour utiliser ce mode, il faut sélectionner "Debugger > Select Tool > 5 MPLAB SIM" :

2.11 - Utilisation de MPLAB IDE en Débogueur avec l'ICD2 Ce mode permet de tester le programme sur la maquette :

• Il contient une fenêtre "Watch" qui permet de visualiser le contenu des registres et des variables (contenu de la RAM).

• On peut placer des points d’arrêt dans le programme "Break Point". Pour utiliser ce mode, il faut sélectionner "Debugger > Select Tool > 2 MPLAB ICD2" :

41

2.12 - Les différentes fenêtres en mode Déboguer " MPLAB SIM " ou " MPLAB ICD2 " :

43

3 - La programmation 3.1 - Généralités L'objectif du programme est d'écrire une suite d'instructions séquentielles, qui sera traduite en binaire (rôle des compilateurs ou de l'assembleur). L'Assembleur est le logiciel qui permet d'écrire directement le programme avec le jeu d'instruction donné par le constructeur dans sa "Datasheet", et de traduire ce programme en langage binaire. Les compilateurs réalisent la même opération que l'Assembleur mais permettent d'écrire le programme dans un langage plus lisible que ce dernier.

45

3.3 - Structuration des fichiers dans un projet écrit en C Les objectifs : Il est impératif de découper le projet en plusieurs fichiers, cela permet :

• d'éviter des fichiers très long et illisibles • la réutilisation de certains fichiers dans d'autres projets

Il est aussi impératif de déclarer les chemins dans les fichiers en mode relatif, par exemple #include "../Sources/Main.h". cela permet de rendre le projet indépendant du dossier dans lequel on l'a placé. On pourra le copier n'importe où sur le disque dur pour le compiler. Pour comprendre l'organisation et la stratégie il faut regarder l'exemple donné dans le "Projet 1" à la page 59 Les explications : Les 3 fichiers incontournables : (voir exemple page 59)

• Le fichier "Config.h" : représente les bits de configuration du microcontrôleur. Il est essentiel au démarrage du composant. Il permet entre autre de configurer l'horloge utilisée, l'utilisation du chien de garde, la configuration des différents Reset, etc... Attention ce fichier ne doit être déclaré qu'une seule fois dans tout le projet.

• Le fichier "Main.c" : il contient au minimum les éléments suivants • Fla fonction principale "main()" • le fichier "Config.h" déclaré sous la forme #include

"../Sources/Config.h" • le fichier "Main.h" déclaré sous la forme #include

"../Sources/Main.h" • Le fichier "Main.h" : il est la clé de voute du projet. Il va contenir tous

les chemins relatifs des fichiers que l'on va ajouter dans le projet, par exemple #include "../Sources/Port.h". Tous les autres fichiers : Ils doivent tous commencer par la ligne : #include "../Sources/Main.h". Exemple d'utilisation des fichiers " Port.c " et " Port.h "

• Le fichier "Port.c" : c'est celui qui va nous permettre de configurer les ports du microcontrôleur. Il sera associé au fichier "Port.h". Il faudra placer à la 1ere ligne le code qui permettra de rendre les fichiers "Port.c" et "Port.h" disponibles dans l'ensemble du projet : #include "../Sources/Main.h".

• Le fichier "Port.h" : Il est forcément associer au fichier "Port.c". On placera dans ce fichier tous les prototypes des fonctions écrits dans le fichier "Port.c". Et on pourra aussi ajouter des "#define" qui seront alors disponibles dans tous les fichiers du projet car ils seront inclus

46

dans le "Main.h". On n'oubliera pas de compléter le fichier "Main.h" avec la directive : #include "../Sources/Port.h". Les avantages de cette stratégie: Si l'on souhaite utiliser le Timer0 alors on fera de même. On ajoutera 2 fichiers "Timer0.c" et "Timer0 .h" de la même manière que "Port.c" et "Port.h"et on complétera le fichier "Main.h" avec la ligne : #include "../Sources/Timer0.h" L'ensemble des fichiers "Port.c" et "Port.h" sera ensuite exploitable dans un autre projet. C'est à dire qu'il suffira de les copier dans le nouveau projet et d'ajuster le contenu de ces fichiers pour l'adapter au nouveau projet. C'est un gain de temps donc de performance et de flexibilité.

49

3.6 - Jeu d'instruction du PIC18F4550

54

4 - Le Compilateur C18 et ses librairies Le fichier d’aide du compilateur C18 se trouve dans le dossier : "C:/mcc18/doc/ hlpC18ug.chm" Le fichier d’aide des librairies C18 se trouve dans le dossier : "C:/mcc18/doc/ hlpC18Lib.chm" 4.1 - Adresser un registre ou un bit du microcontrôleur en C18 Tous les registres et les bits contenus dans la documentation pdf du microcontrôleur sont rassemblés sous forme de structure dans le fichier d'en-tête de Microchip <p18cxxx.h>. 4.1.1 - Ecrire ou Lire dans un registre du microcontrôleur en C18 Pour faire cette opération il suffit d'écrire le nom du registre que l'on veut lire ou écrire en majuscule tel qu'il est écrit dans la documentation PDF. Exemple : On souhaite écrire la valeur 0b11000101 sur le Port D du microcontrôleur avec une fonction EcritPortD() et lire le Port B pour stocker sa valeur dans une variable de type octet avec une fonction LitPortB(). #include <p18cxxx.h> // fichier d'en tete de Microchip qui déclare tous les

55

registres du microcontrôleur unsigned char i; // variable pour stocker la valeur lue sur le port B void EcritPortD (void) { PORTD = 0b11000101; // Ecriture sur le Port D } void LitPortB (void) { i = PORTB; // Lecture du Port B } 4.1.2 - Ecrire ou Lire un bit d'un registre du microcontrôleur en C18 Pour faire cette opération il faut écrire le nom du registre en majuscule suivi du mot "bits." puis du nom du bit en majuscule tel qu'il est écrit dans la documentation PDF. Exemple : On souhaite mettre le bit RB2 à 1 et lire le bit ADIF du registre PIR1 dans une fonction nommée TesteBit(). #include <p18cxxx.h> // fichier d'en tête de Microchip qui déclare tous les registres du microcontrôleur unsigned char i; // variable pour stocker la valeur lue sur le bit ADIF void TesteBit (void) { PORTBbits.RB2 = 1; // Ecrit 1 sur RB2 i = PIR1bits.ADIF; // Stocke la valeur du bit ADIF dans la variable i }

56

4.2 - Les variables du compilateur C18

57

4.2.1 - Variables locales Une variable déclarée dans une fonction est une variable locale. Cette variable n'est vue que la fonction où elle est déclarée et sa valeur n'est pas visible à l'extérieur de cette fonction. Néanmoins si l'on veut conserver la valeur de cette variable inchangée lorsqu'on quitte la fonction et qu'on y retourne, il faut ajouter l'attribut "static" devant la déclaration de la variable. Exemple de deÅLclaration : void LecturePort(void) { static unsigned char a; // permet de garder le contenu de "a" identique par rapport à la // dernière exécution de cette fonction a = PORTC; } La variable "a" ne change pas de valeur lorsqu'on quitte la fonction "LecturePort()" cependant elle n'est pas visible par les autres fonctions. 4.2.2 - Variables Globales avec l'attribut " extern " Une variable déclarée en entête du fichier .c et à l'extérieur des fonctions est une variable globale. Elle est vue par toutes les fonctions du fichier et peut être lue et modifiée par toutes les fonctions du fichier. Lorsqu'un projet comporte plusieurs fichiers qui utilisent la même variable globale, il faut utiliser l'attribut "extern". Exemple de déclaration : Fichier1.c #include <p18cxxx.h> // fichier d'en tete de Microchip qui déclare tous les registres du microcontrôleur unsigned char b; // variable globale void LecturePortC (void) { b = PORTC; // Lecture du port C et écriture dans la variable b. } Fichier2.c #include <p18cxxx.h> // fichier d'en tete de Microchip qui déclare tous les registres du microcontrôleur extern unsigned char b; // variable globale redéclarée void FonctionFichier2 (void) {

58

PORTD = 2 * b; // Utilisation de la variable globale b } Fichier3.c #include <p18cxxx.h> // fichier d'en tête de Microchip qui déclare tous les registres du microcontrôleur extern unsigned char b; // variable globale redéclarée void FonctionFichier3 (void) { PORTD = 4 * b; // Utilisation de la variable globale b } 4.2.3 - Variables Globales avec l'attribut " static " Dans un projet comportant plusieurs fichier .c, il est possible d'avoir une variable globale uniquement dans un fichier et invisible pour les autres. Fichier1.c #include <p18cxxx.h> // fichier d'en tête de Microchip qui déclare tous les registres du microcontrôleur static unsigned char b; // variable globale vue que dans ce fichier void LecturePortC (void) { b = PORTC; // Lecture du port C et écriture dans la variable b. } Fichier2.c #include <p18cxxx.h> // fichier d'en tête de Microchip qui déclare tous les registres du microcontrôleur void FonctionFichier2 (void) { unsigned char b; // Déclaration d'une variable b différente de celle du Fichier1.c PORTD = 0x1a; } IUT Marseille GEII page 46 / 73 Info Indus Compilateur C18 4.2.4 - Les variables globales dans les interruptions ave c l'attribut " volatile " Le problème des interruptions est qu'elles apparaissent à n'importe quel moment. Si une variable doit être modifiée par l'interruption, il est essentiel qu'elle soit déclarée en variable globale. Un autre problème apparait par rapport au compilateur c'est qu'il cherche à optimiser le code. Malgré que la variable soit globale, lorsqu’une

59

interruption apparait il se peut que le compilateur ne la traite plus comme globale et donc il y a perte de l'information. Afin de résoudre ce problème, il suffit d'ajouter l'attribut "volatile" qui indique au compilateur qu'il ne doit pas optimiser cette variable. Exemple : Fichier "Main.c" #include <p18cxxx.h> // fichier d'en tete de Microchip qui déclare tous les registres du microcontrôleur volatile unsigned char b; // la variable b est déclarée en global sans optimisation du compilateur void main (void) { while(1); } Fichier "Interrupt.c" extern volatile unsigned char b; // la variable b est redéclarée dans le fichier "Interrupt.c" grace à extern void Interrupt_High(void) { if(INTCONbits.INT0IF == 1) { b = b + 1; } } 4.2.5 - Gestion de l'espace mémoire pour les variables dépassant 256 octets Si on veut déclarer un tableau qui comporte plus de 256 octets, le compilateur refuse. Il est cependant possible de le faire en redimensionnant la répartition mémoire du microcontrôleur. Il faut modifier le fichier ".lkr". L'espace mémoire du PIC18F4550 est découpé en 8 banques de 256 octets, soit un total de 2048 octets. On trouve dans le fichier "18f4550.lkr" ou "18f4550_g.lkr" tout dépend de la version du compilateur C18, le découpage en banque de mémoire. Chaque banque porte un nom : "gpr0" à "gpr7" avec l'adresse de départ et de fin de la banque. Exemple : On veut déclarer le tableau suivant int Tableau[200]; Ce tableau comporte 400 octets, il est plus grand qu'une banque de mémoire. Le compilateur refuse de compiler. Solution du proble`me: F On va indiquer au compilateur de modifier la taille des banques mémoire.

60

Procédure à réaliser : ➢ Créer dans votre projet MPLAB un dossier "Lkr" au même niveau que le dossier "Sources". ➢ Copier le fichier "18f4550_g.lkr", qui se trouve dans le dossier "C:Ämcc18ÄbinÄLKR", vers le dossier "Lkr" de votre projet. ➢ Déclarer le fichier "18f4550_g.lkr" dans votre projet. ➢ Ouvrir ce fichier "18f4550_g.lkr" de votre projet. On remarque les lignes suivantes : Chaque ligne représente une banque de mémoire avec son adresse de début et de fin et un nom de section. La section correspondant à la banque 1 porte le nom de "gpr1" commence à l'adresse 0x100 et fini à l'adresse 0x1FF. Cette section contient 128 octets. ➢ Modifier le fichier "18f4550_g.lkr" de votre projet comme indiqué ci dessous : La section "gpr2" n'existe plus et la section "gpr1" contient maintenant 512 octets. Il faut maintenant déclarer notre tableau de 400 octets dans notre projet MPLAB à partir de l'adresse 0x100. Pour se faire le compilateur C18 nous impose de le déclarer en variable globale. Suite de la procédure : ➢ Ecrire les lignes suivantes dans l'un des fichiers ".c" du projet dans la zone des variables globales :

➢ Si l'on souhaite utiliser la variable Tableau dans un autre fichier C du projet, alors il faut écrire les lignes suivantes :

61

➢ Modifier les Build Options :

Et c'est fait !!!!! 4.3 - Les opérateurs logiques et arithmétiques du compilateur C18 4.3.1 - Les opérateurs arithmétiques + addition – soustration * multiplication / division % modulo (a % b : le résultat est le reste de la division de a par b) 4.3.2 - Les opérateurs logiques sur les bits ~ Complément à 1 ! Complément à 1 & ET logique | OU logique ^ OU Exclusif >> Décalage à droite, multiplication par 2 << Décalage à gauche, division par 2 4.3.3 - Les opérateurs logiques dans les test > Supérieur à >= Supérieur ou Egal à < Inférieur à

62

<= Inférieur ou Egal à = = Egal à ! = Différent de ! Complement à 1 de && ET logique | | OU logique 4.3.4 - L'opérateur conditionnel x = condition ? y : z Si la condition est vrai (différent de 0) alors x prend la valeur y sinon x prend la valeur z. Cette opération est équivalente à : if (condition) x = y; else x = z; 4.4 - Création d'un type de variable et d'une structure de variable 4.4.1 - Création d'une structure avec l'instruction " struct " struct MON_TYPE { char DataL; char DataH; }; MON_TYPE est une structure composée de 2 champs DataL et DataH. Sa taille est de 16 bits. Pour la déclarée dans un programme il suffit de faire : struct MON_TYPE a, b; Les variables a et b sont du type MON_TYPE. Pour affecter une valeur au champ DataL de la variable "a" il faut écrire : a.DataL = 12; 4.4.2 - Création d'un type de variable avec l'instruction " typedef " typedef struct { char DataL; char DataH; } MON_TYPE; MON_TYPE est un type de variable au même titre que "int" ou "char" composée ici d'une structure de 2 champs DataL et DataH. Sa taille est de 16 bits. Pour déclarée 2 variables a et b du type MON_TYPE dans un programme il suffit de faire :

63

MON_TYPE a, b; Les variables a et b sont du type MON_TYPE. Pour affecter une valeur au champ DataH de "a" il faut écrire : a.DataH = 0xc4; 4.4.3 - Définition d'une union de type de variable " typedef union " Il est parfois intéressant de créer une variable structurée contenant plusieurs types de variables. Par exemple on souhaite adresser un octet soit par une valeur qui modifie la totalité de l'octet soit par une valeur qui modifie un seul bit. Déclaration : typedef union { unsigned char Data; struct { unsigned b0:1; // bit de poids faible unsigned b1:1; unsigned b2:1; unsigned b3:1; unsigned b4:1; unsigned b5:1; unsigned b6:1; unsigned b7:1; // bit de poids fort }; } UCHAR; UCHAR est l'union de 2 types de variables l'une sous forme de type char et l'autre de type bits. Sa taille est de 8 bits. Dans un programme on déclarera la variable Tmp de type UCHAR de la manière suivante : UCHAR Tmp; // Tmp est une variable de type UCHAR Tmp.Data = 0xc7; // attribut la valeur 0xc7 à la variable Tmp Tmp.b1 = 0; // modifie uniquement le bit 1 de la variable Tmp, donc Tmp.Data = 0xc5

64

4.4.4 - Application au Convertisseur Numérique Analogique MCP4822

On souhaite réaliser une structure de variable que l'on nommera "MCP4822" et qui permette d'adresse les 16 bits du registre soit par un entier, soit par 2 octets, soit par bits. typedef union { unsigned int Data; struct { unsigned char DataL; unsigned char DataH; }; struct { unsigned L :8; unsigned H :4; unsigned SHDN :1; unsigned GA :1;

65

unsigned :1; unsigned AB :1; }; } MCP4822; Déclaration dans un programme : MCP4822 VoieA; VoieA.Data = 0xa000; // Affectation par valeur entière VoieA.AB = 0; // modification uniquement du bit AB IUT Marseille GEII page 51 / 73 Info Indus Compilateur C18 4.5 - Les interruptions des microcontrôleurs PIC18 avec le compilateur C18 4.5.1 – Généralités

66

4.5.2 - Le principe des interruptions

67

4.5.3 - La gestion des interruptions du PIC18F4550

Le microcontrôleur possède 2 niveaux d’interruption (Prioritaire et Non Prioritaire). Le vecteur d’interruption Prioritaire pointe à l’adresse 0x08.

68

Le vecteur d’interruption Non Prioritaire pointe à l’adresse 0x18. Le bit IPEN du registre RCON, permet de définir si l’on souhaite utiliser les niveaux de priorité des interruptions. IPEN = 1 alors les niveaux de priorité sont activées. IPEN = 0 alors toutes les interruptions arrivent a` l’adresse 0x08, ce qui les rendent compatible avec le PIC16. Tous les périphériques, exceptée l'interruption externe INT0, possèdent 3 bits de configuration qui finissent tous par IF, IE et IP (respectivement Interrupt Flag, Interrupt Enable et Interrupt Priority). INT0 est toujours Prioritaire donc pas de bit INT0IP. Par exemple le Timer 0 possède les 3 bits suivants : TMR0IF, TMR0IE et TMR0IP. TMR0IF se trouve dans le registre INTCON, il indique que le Timer 0 a effectué un dépassement TMR0IE se trouve dans le registre INTCON, il permet d’activer l’interruption TMR0IP se trouve dans le registre INTCON2, il permet de définir le niveau de Priorité de l’interruption. Le bit GIE du registre INTCON permet d'interdire toutes les interruptions (voir schéma ci dessous) Le bit PEIE du registre INTCON permet d'interdire les interruptions de certains périphériques (voir schéma ci dessous)

69

4.5.4 - Ecriture des interruptions en C18 Problème : Lorsqu’une interruption prioritaire arrive, le programme s’interrompt pour aller à l’adresse 0x0008. Partant de cette adresse, le programme d’interruption ne pourrait excéder 16 octets sinon il empièterait sur le vecteur d’interruption Non Prioritaire qui est à l’adresse 0x0018 (0x18 – 0x8 = 16 octets). Solution : Lorsqu’on arrive à l’adresse 0x0008, on redirige le programme vers une autre adresse. Ce qui se traduit en assembleur par une instruction : GOTO NouvelleAdresse.

70

C’est cette instruction que l’on va écrire en C18 où NouvelleAdresse représentera l’adresse de la fonction en C qui gère cette interruption.

72

#pragma interrupt Interrupt_High Cette directive du compilateur C18 permet d'indiquer au compilateur qu'il faut traduire l'appel de la fonction Interrupt_High() par GOTO Interrupt_High et non par CALL Interrupt_High. #pragma code Adr_Interrupt_High = 0x08 Cette instruction est une directive du compilateur C18 qui lui indique de placer le code de programme en C qui suit à l’adresse 0x08. void interrupt_at_high_vector(void) { Interrupt_High(); // Aller à la fonction : Interrupt_High } L'appel de la fonction Interrupt_High() sera traduite par le compilateur par l’instruction GOTO Interrupt_High qui permet de rediriger le programme vers une adresse (en l’occurrence celle du label Interrupt_High). #pragma code Cette directive du compilateur C18 permet de libérer le compilateur de l'obligation d'écrire à la suite du programme précédent. Il ne reste plus qu'à compléter la fonction d'interruption : void Interrupt_High(void) { // A compléter }

73

5 - Projet 1 : Utilisation du Bouton Poussoir en scrutation 5.1 – Objectif

Cahier des charges : L'appui sur le bouton poussoir BP doit permettre d'allumer la led LED0. On souhaite dans le programme reprendre les mêmes notations que sur le schéma structurel pour le bouton poussoir BP et la led LED0. Fréquence de travail du CPU à 48 MHz (Fcyc = 12 MHz). 5.2 - Algorithme Programme principal : dans le fichier "Main.c" Début Appel de la fonction InitPort() Répéter SI BP enfoncé Appel de la fonction AllumeLed() Fin SI Fin Répéter Fin

74

Fonction InitPort : dans le fichier "Port.c" Pas de paramètre de passage Pas de paramètre de retour Début Configurer LED0 en sortie Configurer BP en entrée Eteindre la led LED0 Fin Fonction AllumeLed : dans le fichier "Port.c" Pas de paramètre de passage Pas de paramètre de retour Début Allume la led LED0 Fin 5.3 - Préparation du projet MPLAB Ouvrir l'explorateur Windows et créer les dossiers suivants dans le dossier

Vérifier les "Build Options" Fermer votre projet Aller dans l'explorateur Windows et vérifier que dans le dossier "Mes documents / Projets MPLAB / Projet1 – Allume Led" vous avez au moins les dossiers et fichiers suivants :

75

Ouvrir votre projet en double cliquant sur l'un des 2 fichiers comportant le logo de "Microchip"

78

6 - Projet 2 : Utilisation du Bouton Poussoir en interruption On reprend le projet précédant et on va le modifier afin d'utiliser le bouton poussoir en interruption. Le cahier des charges ne change pas, seul l'algorithme est un peu différent 6.1 - Algorithme Programme principal : dans le fichier "Main.c" Début Appel de la fonction InitPort() Autoriser toutes les interruptions Répéter Fin Répéter Fin Fonction InitPort : dans le fichier "Port.c" Pas de paramètre de passage Pas de paramètre de retour Début Configurer LED0 en sortie Configurer BP en entrée Eteindre la led LED0 Activer l' interruption sur BP Fin Fonction AllumeLed : dans le fichier "Port.c" Pas de paramètre de passage Pas de paramètre de retour Début Allume la led LED0 Fin Fonction d'interruption prioritaire : dans le fichier "Interrupt.c" Pas de paramètre de passage Pas de paramètre de retour SI BP enfoncé Appel de la fonction AllumeLed() Fin SI

79

6.2 - Préparation du projet MPLAB Ouvrir l'explorateur Windows et créer les dossiers suivants dans le dossier "Mes documents"

Créer le projet MPLAB (voir page 20) que vous nommerez "Bouton Poussoir Interruption" dans le dossier : "Mes documents / Projets MPLAB / Projet2 – Allume Led" Créer les fichiers suivants dans votre Projet MPLAB (voir page 24) : Main.c Main.h Config.h Port.c Port.h Interrupt.c Interrupt.h Vérifier les "Build Options" (voir page 23) Fermer votre projet Aller dans l'explorateur Windows et vérifier que dans le dossier "Mes documents / Projets MPLAB / Projet2 – Allume Led" vous avez au moins les dossiers et fichiers suivants :

80

Ouvrir votre projet en double cliquant sur l'un des 2 fichiers comportant le logo de "Microchip"

85

7 - Quelques règles de conception Ce chapitre a pour but de donner des indications pour le choix et le placement des composants de découplage et quelques règles qui permettent de réaliser proprement une carte. 7.1 - Le découplage des circuits 7.1.1 – Description

Le circuit U1, alimenté par le régulateur U2, consomme un courant de polarisation (courant continu qui permet entre autre le fonctionnement correct des transistors à l'intérieur de U1) et des courants variables qui sont dus aux commutations des transistors de U1. La piste de cuivre qui relie U1 à U2 n'est pas parfaite et comporte en particulier un composante inductive. Voici à quoi pourrait ressembler le signal VDD sans découplage ou un mauvais découpage :

partie étude usb - emrecmic.files.wordpress.com · nous le programmerons en langage c avec les...

Documents