Club Robotique INSA Toulouse

Microcontrôleur dsPIC30F et Programmation

A- L’ASPECT MATÉRIEL ..................................................................................................................... 2

1/ PRÉSENTATION....................................................................................................................................22/ BRANCHEMENT D’UN DSPIC...............................................................................................................23/ FRÉQUENCE DE FONCTIONNEMENT....................................................................................................3

B- L’ASPECT LOGICIEL .................................................................................................................... 4

1/ OÙ TROUVER DE L’INFORMATION SUR LE DSPIC ?..........................................................................42/ LE MODULE D’E/S................................................................................................................................43/ LE MODULE D’INTERRUPTIONS...........................................................................................................64/ LE MODULE TIMER1............................................................................................................................65/ LE MODULE PWM...............................................................................................................................76/ LE MODULE ADC................................................................................................................................7

C- LA PROGRAMMATION ................................................................................................................. 8

1/ PARTICULARITÉS DE LA PROGRAMMATION C30...............................................................................82/ Programme : Faire clignoter une LED à 5Hz.......................................................................................9

A- L’aspect matériel

1/ Présentation

Un microcontrôleur est une sorte de mini ordinateur embarqué. Comme tout ordinateur, il possède un processeur voué au calcul, de la mémoire, une carte mère qui lui permet d’utiliser des périphériques, et des périphériques.

Le processeur d’un dsPIC est un processeur 16-bits. Ce qui veut dire qu’il peut réaliser des opérations élémentaires (additions, soustractions) directement sur des entiers codés sur 16-bits. Par exemple, il peut additionner d’un seul coup 12352 avec 24896 (rappel : un entier sur 16 bits est compris entre 0 et 65535). En 2007, nous utilisions des processeurs 8-bits, bien plus limités en terme de calcul (8-bits 0..255).De plus, le processeur du dsPIC est accompagné d’un cœur DSP (Digital Signal Processing). Ce cœur est une espèce de processeur annexe dédié aux calculs mathématiques. Ce qui confère au dsPIC la possibilité de réaliser rapidement multiplications, divisions, calculs trigonométriques… Cette puissance de calcul est d’un confort remarquable, surtout lorsqu’on programme en C.En effet, il est facile d’écrire « x = 45*658; » en C, or sur un microcontrôleur classique, cette seule ligne d’instruction pourrait prendre jusqu’à 1 seconde à s’exécuter. Sur un dsPIC, ça ne prendra que quelques µsecondes.

Côté mémoire, le dsPIC possède 2ko pour stocker des variables (équivalent de la RAM d’un PC), 4ko pour stocker pour stocker le programme, et 4ko d’EEPROM pour stocker des variables qui ne se perdent pas lorsqu’on débranche l’alimentation (équivalent du disque dur d’un PC).

En ce qui concerne les périphériques, le dsPIC est assez fourni. Le premier périphérique est le module Entrée/Sortie, qui permet de lire où d’écrire des valeurs binaires sur la 20aine de pattes qui compose un dsPIC. On peut mettre une sortie à 5V ou à 0V, et on peut lire une entrée pour savoir si la patte est à 0V ou à 5V.Il possède aussi 3 timers, sorte de chronomètres permettant de réaliser des temps d’attente, on d’activer un certain nombre d’actions de manière périodique.Nous avons a notre disposition 3 modules PWM, permettant de générer des signaux en créneau à fréquence et rapport cyclique variable (en général, ce module constitue une sortie vers le monde analogique).Il y a 6 convertisseurs analogique-numérique 10-bits et 3 modules capture and compare (sert à mesurer des fréquences et à comparer des signaux logiques).Enfin, il possède toute une gamme de modules dédiés à la communication avec l’extérieur (liaison série, I2C, SPI, CAN).

En ce qui concerne l’utilisation d’un dsPIC, nous le programmerons en C. Nous détaillerons comment la couche matérielle est prise en compte dans le langage C. (Comment utiliser les périphériques).

Voilà pour un petit survol de ce matériel, maintenant nous allons détailler comment il fonctionne et comment l’utiliser.

2/ Branchement d’un dsPIC

[Photo EAGLE]

Pour alimenter un dsPIC en régime de fonctionnement normal, il faut lui fournir une tension comprise entre 4.5V et 5.5V. Cette tension sera appliquée entre ses pattes Vdd et Vss. Il faut noter qu’il possède plusieurs pattes Vdd et Vss, ceci afin de proposer plusieurs solutions d’intégration : Selon la disposition des composants sur la carte, il sera peut être plus facile d’utiliser certaines pattes Vdd-Vss que d’autres.

Pour qu’un dsPIC fonctionne correctement, il faut relier la patte MCLR (Master Clear) au 5V par une résistance de 10kohm. A ce stade, un programme peut tourner.

Pour programmer un dsPIC, il faut relier les pattes MCLR, PGC, PGD, ainsi que le 5V et le 0V à l’ICD2 (un module à brancher en USB sur un PC). Sur les cartes allant dans le robot, on a décidé de ne pas mettre le connecteur de l’ICD2. Par contre il y a 2-3 cartes de développement ou ce connecteur y est, on les utilise pour faire des tests quand on n’a pas les cartes définitives, et pour programmer les cartes définitives.

Ensuite, toutes les autres pattes sont utilisables par les différents modules du dsPIC comme indiqué sur le nom des pattes.Exemple : RE0 est accessible comme entrée sortie et comme sortie PWM1.

3/ Fréquence de fonctionnement

Comme tout processeur, pour fonctionner il doit être muni d’une horloge. Le dsPIC possède une horloge interne, mais pour une question de commodité, nous préférons utiliser une horloge externe. Ce choix est tout à fait discutable.

L’horloge externe est un cristal de quartz (matériau piézo-électrique) de 10MHz (fréquence d’oscillation propre du matériau). Pour fonctionner correctement, il doit être relié aux entrées OSC1 et OSC2 du dsPIC, et muni de deux condensateurs de 22pF (voir illustration du chapitre II).

Il fourni une horloge à 10MHz qu’il est possible de multiplier à l’aide d’un module dit de PLL. Nous choisissons de la multiplier par 4 (PLL x4). Or, pour exécuter une instruction, le processeur à besoin de 4 cycles d’horloge ; ce qui divise par 4 la fréquence de fonctionnement. On arrive ainsi à une fréquence de fonctionnement finale de 10MHz, soit 100ns / instruction.

B- L’aspect logiciel

1/ Où trouver de l’information sur le dsPIC   ?

Vous allez être amené à utiliser deux documents : dsPIC30F Familly Reference manual dsPIC30F4012 Datasheet

Le premier document est un descriptif complet et ultra détaillé de la famille de composant dsPIC30F. Il y présente le fonctionnement et la configuration de tous les modules existants sur dsPIC.Le second document est lui, dédié au dsPIC30F4012 (le modèle que nous utilisons pour l’année 2008). Il y présente les caractéristiques du modèle en question, et un résumé du fonctionnement des divers modules qui le compose.

Ces deux documents sont indissociables, le premier est indispensable pour pouvoir configurer un module (la description d’un module dans le 2ème fait plus office d’aide mémoire). Le deuxième est nécessaire pour obtenir des informations telles que le brochage des périphériques (quelle patte fait quoi).

Tout au long de cette initiation, je vais faire référence à ces deux documents (le manuel, et la datasheet).

2/ le module d’E/S

Le premier module que nous allons aborder est le module d’entrée sortie. Ce module est le plus simple de tous, et les concepts qui vont être développés ici s’appliqueront à tous les autres modules.

Cette illustration se trouve dans la section « Pin Diagrams » de la datasheet. Elle est démonstrative du brochage de ce composant. Nous observons que la majorité des pattes possèdent un nom du type Rxy où x est une lettre allant de B à F, et y un chiffre allant de 0 à 15. Cette dénomination décrit la possibilité de ces pattes à être utilisées comme entrées/sorties.Toutes les pattes du microcontrôleur sont organisées en port, c’est la lettre x. Sur ce port, chaque patte à son propre numéro y. Ainsi, la patte No 26, « RE0 » est la patte 0 du port E.

Tous les ports ne sont pas complets (aucun même sur ce microcontrôleur), c'est-à-dire qu’ils n’ont pas tous tout les chiffres possibles. Si on avait utilisé le dsPIC30F ayant le plus de pattes, on aurait eu tous les ports de complets.

Pour utiliser une patte en entrée/sortie il faut définir 2 choses : Est-ce une entrée ou une sortie ? Quelle est sa valeur (de sortie ou d’entrée) ?

Pour répondre à ces questions, nous allons utiliser des registres de configuration. Un registre est une zone de la mémoire qui est directement utilisée par le matériel pour piloter son fonctionnement. C’est une sorte de variable, mais qui possède un impact direct et intrinsèque. Chaque périphérique utilise des registres pour fonctionner.Pour le module I/O, ces registres se nomment TRISx, PORTx et LATx (Section « 11.2 I/O Port Control Register »). Le manuel décrit l’utilisation de ces registres, mais il faut se référer à la page 59 de la datasheet (« 8-1 I/O Port Register Map ») pour voir à quels bits de configuration nous avons accès sur notre modèle de dsPIC. On retrouve bien que ces registres ne sont pas complets, il y a juste les bits dont les pattes sont disponibles. Il est impératif de toujours utiliser ces tables pour avoir le nom exact des bits de configuration et des registres (indispensable lors de la phase de programmation où on utilisera directement ces noms).

Le registre TRISx sert à donner la direction d’une patte : entrée ou sortie. D’après le manuel, si on met le bit TRISE0 du registre TRISE à 0, alors la patte No 26 (RE0) est définit comme étant une sortie. De même, si on met le bit TRISF2 du registre TRISF à 1, alors la patte No 18 (RF2) sera définit comme étant une entrée.

Ce qui va suivre est une simplification du fonctionnement des registres LATx et PORTx.

Lorsqu’une patte est définit en sortie, on lui affecte une valeur en utilisant le registre LATx. Par exemple, si on veut mettre la patte No 26 (RE0) à 5V, il suffit de positionner le bit LATE0 du registre LATE à 1.

Si la patte est définit en sortie, on lit sa valeur en regardant la valeur du registre PORTx. Par exemple si la patte RF2 est à 0V, alors le bit RF2 du registre PORTF sera à 0.

Note 1 : En ce qui concerne les Register Map, il y a tout à droite le « Reset State », qui donne la valeur par défaut (à la mise sous tension) de ces bits. « u » signifie que la valeur sera aléatoire.

Note 2 : Il faut toujours garder à l’esprit que le PORTB est couplé en entrée avec les convertisseurs analogiques numériques. Et que par défaut, si on passe une patte du PORTB en entrée, elle est configurée comme une entrée analogique. Il ne faut pas oublier d’aller modifier le registre ADPCFG du module convertisseur analogique numérique (voir page 17-10 du manuel).

3/ Le module d’interruptions

A priori, un microcontrôleur n’est capable d’exécuter qu’un seul programme à la fois. Or, dans le cadre d’applications en temps réel (c’est souvent le cas sur microcontrôleur) il est nécessaire de pouvoir réagi de façon dynamique à des changements de l’environnement. C’est là le rôle du module d’interruption.Prenons un exemple : Vous avez votre programme principal (main) qui tourne. D’un coup, l’utilisateur appuie sur un bouton qui est censé allumé une LED. Vous pouvez alors utiliser le module « Change Notification » (un sous module du I/O Port, voir page 11-7 du manuel) qui génère une interruption lors d’une changement d’état sur une entrée : le programme principal se met en pause, l’exécution se déplace dans la fonction d’interruption Change Notification où l’ont me le code correspondant à l’allumage de la LED. Une fois le programme d’interruption exécuter, le main reprend là ou il s’était arrêté.

Plusieurs modules peuvent générer des interruptions sous plusieurs conditions qui sont à chaque fois décrite dans la section correspondant au module en question dans le manuel.Pour configurer ces interruptions, il faut agir sur 3 registres qui sont décrits page 6-14 du manuel (Section « Interrupt Control and Status Register »). Nous allons agir uniquement sur les registres IFSx, IECx et IPCx.

Le registre IECx (Interrupt Enable Control Register)   : Ce registre sert à définir quelles sont les interruptions qui sont autorisées. Vu qu’il y a beaucoup d’interruptions possibles, un seul registre ne suffit pas, il y en a donc 3 (IEC0, IEC1, IEC2). Pour autoriser l’interruption change notification, on observe page 6-24 qu’il faut positionner le bit CNIE du registre IEC0 à 1.

Le registre IFSx (Interrupt Flag Status Register)   : Ce registre indique au processeur quelle interruption il doit traiter. Page 6-18 du manuel on voit que si le bit CNIF du registre IFS0 est à 1, alors le processeur doit exécuter le programme d’interruption correspondant au Change Notification. Ce bit ne se remet pas à zéro tout seul, il faut donc systématiquement le remettre à 0 à la fin du programme d’interruption.

Le registre IPCx (Interrupt priority Control Register)   : Ce registre sert à définir la priorité d’une interruption. Cette priorité permet de résoudre les conflits d’interruptions (plusieurs interruptions en même temps). La priorité la plus haute, sur une échelle de 0 à 7, passe en premier (0 jamais exécuté). Si on veut mettre une priorité de 4 pour le Change Notification, il faut écrire la valeur 4 sur les 3 bits CNIP du registre IPC3 (voir page 6-33 du manuel).

4/ Le module Timer1

Ce module est un compteur. Dans son utilisation la plus basique, il compte le nombre de cycles d’horloge. Mais on peut aussi le configurer pour compter le nombre de changements d’états sur une entrée.

Si on regarde le manuel, on voit qu’il existe plusieurs types de timer (A, B et C). Or, page 63 de la datasheet, une note nous informe que le Timer1 est un timer de type A. Son fonctionnement est alors décrit page 12-3 du manuel (puis viennent les registres de configuration, et enfin une descriptions détaillé de l’action de tout ces registres).

Nous allons détailler le fonctionnement du Timer1 comme compteur d’horloge chronomètre.

Page 66 de la datasheet, on observe que ce module utilise 3 registres.

TMR1 est la valeur actuelle du compteur. PR1 est la valeur max du compteur : lorsque TMR1 = PR1, le compteur se remet à 0 et recommence à compter. Le module peut alors générer une interruption s’il en à l’autorisation (grâce au bit T1IE du registre IEC0, page 6-24 du manuel). T1CON est le registre de configuration du module. Son utilisation est décrite succinctement à la page 12-6 du manuel.

T1CON   : TCS permet de choisir ce qu’il faut compter. Pour compter les cycles de l’horloge interne, et donc le temps, il faut positionner TCS à 0 (Internal Clock (Fosc / 4)). (Fosc / 4 fait référence au fait qu’il faut 4 cycles pour réaliser une instruction).TSYNC n’est pas à utiliser. En effet, il est indiqué d’ignorer ce bit si TCS = 0.

TCKPS est un groupe de 2 bits servant à définir au bout de combien d’évènements à compter, la valeur de TMR1 est incrémentée de 1. Ici l’évènement à compter est « une période d’horloge ». A priori, on veut donc que TMR1 augmente de 1 à chaque période d’horloge. En réalité, tout dépend du temps que l’on veut compter. Car il ne faut pas oublier que TMR1 est un registre 16 bits, et donc, il ne peut prendre qu des valeurs entre 0 et 65535. Si TCKPS est à 0 (1 période une incrémentation de TMR1), alors on ne pourra compter que 6.5535 ms (en considérant que 1 instruction 100 ns). On peut alors choisir de perdre en précision, mais de gagner en longévité. Pour cela on pourra par exemple positionner TCKPS à 1 (8 périodes d’horloge 1 incrémentation de TMR1). La précision sera alors de 800ns, mais on pourra compter jusqu’à 52.428 ms. On peut ainsi régler ce prescaler (changement d’échelle) pour un rapport de 1:1, 1:8, 1:64 ou 1:256.

TGATE ne sera pas utilisé ici, voir page 12-12 du manuel pour sa description complète).

TSIDL permet de dire si le module doit continue de compter ou non lorsque le microcontrôleur passe en mode veille. En mettant TSIDL à 0, on pourra ainsi mettre le dsPIC en veille, et le réveiller via une interruption au bout d’un certain temps.

TON sert à activer ou non le comptage. Il est préférable d’activer le timer après d’avoir configuré tout le reste.

Cette description succincte du Timer1 n’illustre qu’une façon de l’utiliser, mais c’est une des plus courantes.

5/ Le module PWM

6/ Le module ADC

C- La programmation

1/ Particularités de la programmation C30

Le langage utilisé pour programmer les dsPIC est le C30. C’est du C classique auquel viennent se rajouter quelques petites particularités que nous allons détailler. Le logiciel utiliser pour programmer se nomme MPLAB, il est fournit gratuitement par Microchip. Pour le compilateur C30, il est payant, mais gratuit pour les étudiants (il faut créer un compte sur le site de Microchip avec son adresse mail INSA).Pour la prise en main du logiciel MPLAB, et son utilisation pour faire de la simulation, je vous renvoi au PDF « Interface MPLAB ».

Pour débuter un nouveau projet, utilisez le modèle de projet fourni avec ce cours, il constitue une bonne base que nous allons décrire. Je vous invite également à utiliser au maximum les librairies crées par le club pour utiliser les différents modules du dsPIC, comme la librairie CAN pour communiquer avec le PC. Chaque librairie devrait avoir sa documentation associée à terme.

Voici la liste non exhaustive des spécificités du langage C30   :

1/ #include "p30fxxxx.h"Cette ligne permet d’inclure un fichier qui indique au compilateur C la correspondance entre les noms de registres que vous allez utiliser, et leur emplacement dans la mémoire du microcontrôleur.

2/ // Internal FRC Oscillator_FOSC(XT_PLL4)_FWDT(WDT_OFF & WDTPSA_512)_FBORPOR(PBOR_ON & BORV_27)_FGS(CODE_PROT_OFF)

Ces lignes servent à configurer le fonctionnement général du microcontrôleur. Il ne vaut mieux pas y toucher.La seule ligne intéressante est la ligne « _FOSC(XT_PLL4) ». Elle configure le microcontrôleur comme utilisant une horloge externe (XT) avec une PLL x4 (_PLL4). On peut utiliser l’horloge interne couplé d’une PLL x4 en mettant _FOSC(FRC_PLL4). (voir page 7-31 du manuel)

Ce bout de code remplace le réglage des « Configuration bits » de MPLAB décrit page 7 du PDF « Interface MPLAB ». Il ne faut donc pas le faire.

3/ LATEbits.LATE0 = 1;Cette ligne positionne le bit LATE0 du registre LATE à 1. D’une manière générale, il convient de lire le nom des bits et des registres dans les Register Map de la datasheet, et d’opérer ainsi pour accéder à la valeur : « [Nom du registre]bits.[Nom du bit] ».

Pour lire la valeur de la patte RF2 configurée comme une entrée, il faut faire :« int x = PORTFbits.RF2 ; ».

Pour activer le Timer1 il faut faire : « T1CONbits.TON = 1 ; »

4/ void _ISRFAST _T1Interrupt(void){

/* Code du programme d’interruption */IFS0bits.T1IF = 0 ;

}

La ligne « void _ISRFAST _T1Interrupt(void) » est complètement spécifique au langage C30. C’est ainsi qu’on déclare un programme d’interruption. La syntaxe générique est la suivante : « void _ISRFAST _[Nom de l’interruption]Interrupt(void) »Pour connaître la valeur de [Nom de l’interruption] il faut se référer à la table 5-1 de la page 40 de la datasheet : s la colonne Interrupt Source on trouve le nom de l’interruption, et son origine. Par exemple : « T1 – Timer 1 », le nom étant T1 et l’origine Timer 1.

Note : L’entête de la fonction d’interruption pour le Change Notification est : « void _ISRFAST _CNInterrupt(void) ». La datasheet ne précise pas le nom, il est juste indiqué « Input Change Interrupt ».

Il convient ensuite de placer dans ce programme d’interruption le corps du programme, puis de ne surtout pas oublier de remettre le Interrupt Status Flag à 0 pour rendre la main au main à la fin de la fonction.

5/ while(1) ;Sur un PC, lorsqu’un programme a fini de s’exécuter, il quitte. Or, on ne peut pas « quitter » sur un microcontrôleur. Il faut donc impérativement que lorsque le programme principal se termine (main) il arrive sur une boucle infini (while(1)) : au lieu de quitter, on lui demande simplement de ne rien faire indéfiniment. Si vous oublier cette boucle infinie, le microcontrôleur va se mettre à faire n’importe quoi de façon aléatoire.

2/ Programme   : Faire clignoter une LED à 5Hz

La LED est branchée sur la patte No 26, RE0. Pour obtenir une fréquence de 5Hz, il faut changer l’état de la LED toutes les 0.1 secondes car une période complète équivaut à deux changements d’état.

#include "p30fxxxx.h"

// Internal FRC Oscillator_FOSC(XT_PLL4)_FWDT(WDT_OFF & WDTPSA_512)_FBORPOR(PBOR_ON & BORV_27)_FGS(CODE_PROT_OFF)

int main(void){

//Configuration du module I/OTRISEbits.TRISE0 = 0; //Definition en sortieLATEbits.LATE0 = 0; //La LED est initialement éteinte

//Configuration du module Timer1T1CONbits.TCS = 0 ; //Source : Internal Clock (10MHz)T1CONbits.TCKPS = 3 ; //Prescaler de 1:64 (on peut compter de 0 à 0.42sec avec une

précision de 6.4 µsec)T1CONbits.TSIDL = 0 ; //Continue de compter en mode veille

//Réglage de la période du timer1PR1 = 15625 ; //TMR1 recommence lorsqu’il vaut 15625 : 0.1sec=15625 * 64 * 100ns

//Configuration de l’interruptionIFS0bits.T1IF = 0 ; //Remise à 0 du flagIEC0bits.T1IE = 1 ; //On autorise l’interruptionIPC0bits.T1IP = 4 ; //priorité de 4/7

//On active le timerT1CONbits.TON = 1 ;

//Fin du programme principalwhile(1) ;

}void _ISRFAST _T1Interrupt(void){

//Changement d’état de la LEDif(LATEbits.LATE0 == 0)

LATEits.LATE0 = 1 ;else

LATEbits.LATE0 = 0 ;

//On rend la main au programme principalIFS0bits.T1IF = 0 ;

}

Normalement, vous devriez avoir compris l’intégralité de ce programme qui commence par configurer le port de sortie et le timer, puis qui toutes les 0.1sec change l’état de la LED.