introduction au PIC32MX

C'est en 2007 que Microchip a débuté la mise en marché des ses microcontrolleurs 32 bits. Contrairement à ses autres MCU le core des PIC32 n'a pas été développé à l'interne mais ils ont plutôt choisi d'acheter une licence d'utilisation du core M4K de MIPS technologies. C'est microcontrolleurs n'ont donc rien à voir avec les autres PIC en ce qui concerne l'architecture du core et des instructions assembleurs. Le core M4K est de type LOAD/STORE comme les AVR, les MSP430 et les ARM. c'est à dire que les opérations arithmétiques et logiques sont effectuées sur des arguments stockés dans la banque de registres internes au core. Cette banque comprend 32 registres généraux de 32 bits. Donc pour additionner par exemple 2 variables il faut d'abord aller les chercher dans la mémoire RAM pour les mettre dans deux deux registres, ensuite faire l'addition et réécrire le résultat dans une variable en RAM.

Ce qui est intéressant pour les hobbyistes c'est que Microchip fournis plusieurs modèles de PIC32MX en format DIL-28 broches 300mil. Ce qui n'est pas le cas des contrôleurs à core ARM. A ma connaissance il n'y a que NXP qui vend un modèle de MCU 32 bits(core ARM) en format DIL soit le LPC1114FN28. Mais il n'est jamais en inventaire chez Digikey ou Newhark. Donc si on veut avoir un MCU 32 bits en format DIL il faut se tourner vers les PIC32MX1xxxx/2xxxx. Les PIC32MX sont groupés en familles identifiées par le premier chiffre après le 'X'. Présentement il y en a 7. Les seules familles qui ont des représentants au format DIL-28 sont les familles 1xxx et 2xxx. Le plus plus économique est le PIC32MX110F016B-I/SP. Les 3 chiffres après le 'F' indiquent la quantité d'octets flash, dans cette exemple il y en a 16Ko + 3Ko flash boot. Et ce MCU contient 4Ko de RAM. Présentement il se vend 3,26CAN$ chez Digikey.ca à l'unité.

Pour les premières expérimentations avec ce MCU le matériel suivant est requis.

• 1 MCU PIC32MX110F016B-I/SP
• 1 résistance 10 ohm
• 3 résistances de 470 ohm
• 1 résistance 10 Kohm
• 3 LED
• 2 condensateurs 20pF
• 3 condensateurs 100nF céramique
• 1 crystal 10Mhz
• 1 petite alimentation 3.3Volt DC
• 1 programmeur pickit3 ou ICD2 ou IDC3

Montage sans-soudures

Problème possible avec le Pickit 3

Si vous utilisez un Pickit 3 dont le numéro assy# est 10-000424-R4 ou antérieur il est probable que vous n'arriverez pas à programmer les PIC32MX. Le message d'erreur est le suivant: pickit 3 missing memory object. J'ai cherché longtemps avant de trouver la solution. Heureusement il y en a une mais elle exige de hacker le pickit 3. Il faut court-circuiter 3 résistances de 100 ohm sur la plaquette de circuit. Pour plus d'information téléchargez le document pdf ETN 32 pickit 3 operation at low voltage - Modification. Ce n'est qu'après avoir effectué cette modification que j'ai réussi à programmer un PIC32MX. Bizarrement il n'y a qu'avec les PIC32 que j'ai eu ce problème, jamais avec des PIC10,12,14,18,24. Il est moins risqué de souder un petit bout de fil entre les 2 extrémités des résistances plutôt que d'essayer de les enlever pour les remplacer par un court-circuit. Ces résistances SMD sont très petites, il faut une pointe de fer à souder très fine pour faire ce travail.

Environnement de travail

Que ce soit sous windows ou linux l'environnement de travail est le même, il faut télécharger et installer la dernière version de MPLABX et le compilateur XC32 qui se trouve sur la même page de téléchargement.

MPLABX est gratuit mais pour XC32 c'est quelque peut différent. Vous pouvez l'utiliser gratuitement mais dans cette version gratuite le compilateur ne fait pratiquement pas d'optimisation. Vous pouvez aussi utiliser la version professionnelle avec l'optimisation complète gratuitement pour 60 jours. Après cette échéance le logiciel retourne en mode gratuit à moins que vous n'achetiez une licence. 3 différentes options vous seront présentés lors de l'installation. Enregistrement immédiat d'une licence. Version d'essai de 60 jours et version gratuite à utilisation illimitée mais sans optimisation.

Présentation du PIC32MX110F016B

Les PIC32MX1xxx et 2xxx peuvent fonctionner avec une fréquence d'horloge de 50Mhz. Contrairement aux autre PIC qui utilient 4 cycles d'horloge pour chaque instruction, les PIC32MX en utilisent seulement 2 et grâce à un pipiline à 5 étages il peut exécuter les instructions plus rapidement.
Voici les principales caractéristiques du PIC32MX110F016B

• Fréquence maximale de fonctionnement 50Mhz
• mémoire flash de 19Ko, 16Ko général + 3Ko boot
• mémoire RAM 4Ko
• 5 timers de 16bits, les timers 2,3 et 4,5 peuvent-être groupés pour former deux timers 32 bits.
• 2 UART
• 3 comparateurs
• 2 SPI/I2S
• 2 I2C
• 1 PMP (parrallel master port)
• 4 canaux DMA (Direct Memory Access)
• 10 canaux de conversion analogique/numérique de 10bits
• 1 circuit RTCC avec l'entrée pour le crystal 32768Khz
• 1 circuit JTAG pour le déboggage
• reconfiguration des périphériques sur différentes broches

Premier projet

Créez un nouveau projet appellé blinky et choississez le compilateur XC32.

Comme d'habitude pour apprivoiser un MCU on commence par le plus simple, question de savoir si on a vraiment compris la documentation concernant la configurations des bits de démarrage et des entrés/sorties numériques. On va donc configurer les bits de démarrage pour utiliser l'oscillateur externe 1 et que le PLL multiplie la fréquence du crystal par 5. Nous aurons donc Fsys de 50Mhz. On va faire clignoté les 3 LED à l'unisson à un fréquence d'environ 1Hz dans un premier temps en utilisant un délais par boucle simple et dans un deuxième temps on va utilisé le`CoreTimer avec un interruption et un fonction delay().

La façon la plus simple de programmer les bits de démarrage est d'utiliser l'outil disponible dans MPLABX. Menu Windows - Pic Memory Views - Configuration bits

Dans la fenêtre configuration bits on peut sélectionné pour chaque option la valeur désirée dans une liste de choix. Ensuite on clique sur generate source code output. Le résultat apparaît alors dans la fenêtre output et de là on sélectionne et colle le résultat dans le fichier source.

// PIC32MX110F016B Configuration Bit Settings #include <p32xxxx.h> // DEVCFG3 // USERID = No Setting #pragma config PMDL1WAY = OFF // Peripheral Module Disable Configuration (Allow multiple reconfigurations) #pragma config IOL1WAY = OFF // Peripheral Pin Select Configuration (Allow multiple reconfigurations) #pragma config FUSBIDIO = ON // USB USID Selection (Controlled by the USB Module) #pragma config FVBUSONIO = ON // USB VBUS ON Selection (Controlled by USB Module) // DEVCFG2 #pragma config FPLLIDIV = DIV_2 // PLL Input Divider (2x Divider) #pragma config FPLLMUL = MUL_20 // PLL Multiplier (20x Multiplier) #pragma config FPLLODIV = DIV_2 // System PLL Output Clock Divider (PLL Divide by 2) // DEVCFG1 #pragma config FNOSC = PRIPLL // Oscillator Selection Bits (Primary Osc w/PLL (XT+,HS+,EC+PLL)) #pragma config FSOSCEN = OFF // Secondary Oscillator Enable (Disabled) #pragma config IESO = OFF // Internal/External Switch Over (Disabled) #pragma config POSCMOD = HS // Primary Oscillator Configuration (HS osc mode) #pragma config OSCIOFNC = OFF // CLKO Output Signal Active on the OSCO Pin (Disabled) #pragma config FPBDIV = DIV_1 // Peripheral Clock Divisor (Pb_Clk is Sys_Clk/1) #pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection (Clock Switch Disable, FSCM Disabled) #pragma config WDTPS = PS1 // Watchdog Timer Postscaler (1:1) #pragma config WINDIS = OFF // Watchdog Timer Window Enable (Watchdog Timer is in Non-Window Mode) #pragma config FWDTEN = OFF // Watchdog Timer Enable (WDT Disabled (SWDTEN Bit Controls)) #pragma config FWDTWINSZ = WISZ_25 // Watchdog Timer Window Size (Window Size is 25%) // DEVCFG0 #pragma config JTAGEN = OFF // JTAG Enable (JTAG Disabled) #pragma config ICESEL = ICS_PGx1 // ICE/ICD Comm Channel Select (Communicate on PGEC1/PGED1) #pragma config PWP = OFF // Program Flash Write Protect (Disable) #pragma config BWP = OFF // Boot Flash Write Protect bit (Protection Disabled) #pragma config CP = OFF // Code Protect (Protection Disabled)

Blinky version 1

#include <plib.h> /* * configuration pré-runtime du MCU * j'utilise un crystal à 10Mhz * avec cette configuration PLL la fréquence Fsys= 50Mhz, le maximum * */ // code généré par l'utilitaire de configuration des bits de démarrage. // PIC32MX250F128B Configuration Bit Settings // DEVCFG3 // USERID = No Setting #pragma config PMDL1WAY = OFF // Peripheral Module Disable Configuration (Allow multiple reconfigurations) #pragma config IOL1WAY = OFF // Peripheral Pin Select Configuration (Allow multiple reconfigurations) #pragma config FUSBIDIO = ON // USB USID Selection (Controlled by the USB Module) #pragma config FVBUSONIO = ON // USB VBUS ON Selection (Controlled by USB Module) // DEVCFG2 en utilisant un crystal 10Mhz cette configuration du PLL donne 50Mhz pour Fosc, le maximum. #pragma config FPLLIDIV = DIV_2 // PLL Input Divider (2x Divider) #pragma config FPLLMUL = MUL_20 // PLL Multiplier (20x Multiplier) #pragma config FPLLODIV = DIV_2 // System PLL Output Clock Divider (PLL Divide by 2) // DEVCFG1 #pragma config FNOSC = PRIPLL // Oscillator Selection Bits (Primary Osc w/PLL (XT+,HS+,EC+PLL)) #pragma config FSOSCEN = OFF // Secondary Oscillator Enable (Disabled) #pragma config IESO = OFF // Internal/External Switch Over (Disabled) #pragma config POSCMOD = HS // Primary Oscillator Configuration (HS osc mode) #pragma config OSCIOFNC = OFF // CLKO Output Signal Active on the OSCO Pin (Disabled) #pragma config FPBDIV = DIV_1 // Peripheral Clock Divisor (Pb_Clk is Sys_Clk/2) #pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection (Clock Switch Disable, FSCM Disabled) #pragma config WDTPS = PS1 // Watchdog Timer Postscaler (1:1) #pragma config WINDIS = OFF // Watchdog Timer Window Enable (Watchdog Timer is in Non-Window Mode) #pragma config FWDTEN = OFF // Watchdog Timer Enable (WDT Disabled (SWDTEN Bit Controls)) #pragma config FWDTWINSZ = WISZ_25 // Watchdog Timer Window Size (Window Size is 25%) // DEVCFG0 #pragma config JTAGEN = OFF // JTAG Enable (JTAG Disabled) #pragma config ICESEL = ICS_PGx1 // ICE/ICD Comm Channel Select (Communicate on PGEC1/PGED1) #pragma config PWP = OFF // Program Flash Write Protect (Disable) #pragma config BWP = OFF // Boot Flash Write Protect bit (Protection Disabled) #pragma config CP = OFF // Code Protect (Protection Disabled) int main(int argc, char** argv) { mPORTBWrite(0); mPORTBDirection(~(BIT_6|BIT_7|BIT_8)); // PB6,PB7,PB8 en mode sortie digitale while (1){ unsigned long i; mPORTBToggleBits(BIT_6|BIT_7|BIT_8); // commutation de l'état des bits for(i=0;i<16000000;i++); } return (EXIT_SUCCESS); } Dans tout projet on commence par include le fichier plib.h, qui contient toutes les macros et fonctions qui permettent de configurer le MCU et les périphériques. Pour voir le contenu d'un fichier inclus in clique avec le bouton droit de la souris sur le nom du fichier et dans le menu surgissant on choisi navigate - goto declaration

Cette fonction est très pratique pour découvrir les macros et fonctions disponibles dans les librairies. Lorsqu'il s'agit d'une macro le nom commence par m sinon c'est une fonction. Les constantes sont en majuscules.

Donc dans procédure main on commence par initialiser le PORT B pour avoir des sorties numérique sur les bits 6,7 et 8 là où sont connectés les 3 LED. la macro mPORTBWrite(0) mets tous les bits du port à zéro. Ensuite mPORTBDirection() mets les bits 6,7,8 à zéro (mode sortie). Dans la boucle while mPORTBToggleBits() inverse la valeur des bits 6,7,8 à chaque appel. Lorsque les bits passe à Vdd les leds alluments et éteignent lorsqu'ils passe à Vss. La boucle for est utilisé pour le délais. Avec une valeur de 16 millions la fréquence de clignotement est d'environ 0,8Hz.

Blinky version 2

Le PIC32MX110F016B possède 5 périphériques timers de 16 bits mais le core M4K lui-même possède un compteur 32 bits qui est incrémenté à tout les 2 cycles de Fsys. Donc pour un Fsys de 50Mhz, il est incrémenté à tous les 40nSec. Dans blinky 2 on va se servir de ce compteur appellé CoreTimer pour créer un compteur sys_tick qui lui va incrémenté à toutes les milli-secondes. On va initialiser ce compteur avec la valeur Fsys/2/1000 et générer une interruption chaque fois qu'il arrive à zéro. De plus on va ajouter une fonction delay() qui va utiliser sys_tick. Avec ça on va contrôler précisément la vitesse de clignotement des leds à 1Hz.

#include <plib.h> /* * configuration pré-runtime du MCU * j'utilise un crystal à 10Mhz * avec cette configuration PLL la fréquence Fsys= 50Mhz, le maximum * */ // configuration des bits généré par l'outil inclus dans MPLABX // PIC32MX250F128B Configuration Bit Settings // DEVCFG3 // USERID = No Setting #pragma config PMDL1WAY = OFF // Peripheral Module Disable Configuration (Allow multiple reconfigurations) #pragma config IOL1WAY = OFF // Peripheral Pin Select Configuration (Allow multiple reconfigurations) #pragma config FUSBIDIO = ON // USB USID Selection (Controlled by the USB Module) #pragma config FVBUSONIO = ON // USB VBUS ON Selection (Controlled by USB Module) // DEVCFG2 en utilisant un crystal 10Mhz cette configuration du PLL donne 50Mhz pour Fosc, le maximum. #pragma config FPLLIDIV = DIV_2 // PLL Input Divider (2x Divider) #pragma config FPLLMUL = MUL_20 // PLL Multiplier (20x Multiplier) #pragma config FPLLODIV = DIV_2 // System PLL Output Clock Divider (PLL Divide by 2) // DEVCFG1 #pragma config FNOSC = PRIPLL // Oscillator Selection Bits (Primary Osc w/PLL (XT+,HS+,EC+PLL)) #pragma config FSOSCEN = OFF // Secondary Oscillator Enable (Disabled) #pragma config IESO = OFF // Internal/External Switch Over (Disabled) #pragma config POSCMOD = HS // Primary Oscillator Configuration (HS osc mode) #pragma config OSCIOFNC = OFF // CLKO Output Signal Active on the OSCO Pin (Disabled) #pragma config FPBDIV = DIV_1 // Peripheral Clock Divisor (Pb_Clk is Sys_Clk/2) #pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection (Clock Switch Disable, FSCM Disabled) #pragma config WDTPS = PS1 // Watchdog Timer Postscaler (1:1) #pragma config WINDIS = OFF // Watchdog Timer Window Enable (Watchdog Timer is in Non-Window Mode) #pragma config FWDTEN = OFF // Watchdog Timer Enable (WDT Disabled (SWDTEN Bit Controls)) #pragma config FWDTWINSZ = WISZ_25 // Watchdog Timer Window Size (Window Size is 25%) // DEVCFG0 #pragma config JTAGEN = OFF // JTAG Enable (JTAG Disabled) #pragma config ICESEL = ICS_PGx1 // ICE/ICD Comm Channel Select (Communicate on PGEC1/PGED1) #pragma config PWP = OFF // Program Flash Write Protect (Disable) #pragma config BWP = OFF // Boot Flash Write Protect bit (Protection Disabled) #pragma config CP = OFF // Code Protect (Protection Disabled) // macros #define mGetSystemClock() (50000000UL) // 50Mhz #define mGetPeripheralClock() (mGetSystemClock()) // FPBDIV = DIV_1 #define CORE_TICK_RATE (mGetSystemClock()/2/1000) // system tick 1msec volatile unsigned long sys_tick; // compteur pour les milli-secondes //déclaration du gestionnaire d'interruption void __ISR(_CORE_TIMER_VECTOR, ipl2) CoreTimerHandler(void){ sys_tick++; UpdateCoreTimer(CORE_TICK_RATE); mCTClearIntFlag(); }; // délais en millisecondes void delay(unsigned long msdelay) { unsigned long startTime = sys_tick; while(sys_tick - startTime < msdelay); } int main(int argc, char** argv) { mPORTBWrite(0); mPORTBDirection(~(BIT_6|BIT_7|BIT_8)); // PB6,PB7,PB8 en mode sortie digitale // configuration du coretimer pour générer une interruption à toute les milliseconde. OpenCoreTimer(CORE_TICK_RATE); mConfigIntCoreTimer((CT_INT_ON | CT_INT_PRIOR_2 | CT_INT_SUB_PRIOR_0)); INTEnableSystemMultiVectoredInt(); while (1){ mPORTBToggleBits(BIT_6|BIT_7|BIT_8); // commutation de l'état des bits delay(500); } return (EXIT_SUCCESS); }

Les PIC32 sont des MCU très complexe mais heureusement les librairies fournies par Microchip nous simplifient grandement le travail. La façon de déclarer les interruptions ressemble beaucoup à ce qu'on doit faire dans Atmel studio à la différence que les PIC32 possède un gestionnaire d'interruption programmable. Chaque interruption a un niveau de priorité de 1 à 7 et un sous-niveau de priorité de 0-3. Plus le chiffre est élevé plus la priorité est grande. Lorsque 2 interruptions de même priorité sont en concurence c'est le niveau de sous-priorité qui décide laquelle sera exécutée en premier. Dans notre exemple la macro mConfigIntTimer() défini que l'interruption pour le CoreTimer aura une priorité de 2 et une sous-priorité de 0.

Dans la routine ISR du CoreTimer on incrémente la variable sys_tick, on réinitialise le compteur du CoreTimer et finalement on remet à zéro l'indicateur d'interruption pour éviter que cette interruption se redéclenche en boucle infinie.

Dans la boucle while de la routine main on a remplacé la boucle for par un appel à la fonction delay() que nous avons ajouté au code. Cette routine utilise simplement la variable sys_tick pour compter les milli-secondes écoulées. Avec un argument de 500msec les leds clignotes à 1Hz.

Dans une prochaine chronique on verra comment utiliser le UART et assigner les périphériques aux broches car les PIC32 permettent de choisir sur quel broche sera connecté un périhérique.