PIC24, les interruptions

Dans cet article je traite des interruptions sur les PIC24. A titre de démo je vais utiliser le cube de LEDs 4x4x4 présenté dans un article précédent. J'ai modifié le firmware de sorte que l'affichage du cube est maintenant géré par une une interruption. J'ai aussi ajouter une interface RS-232 en utilisant le périphérique UART1. La réception des caractères est aussi géré par une interruption.

Les interruptions sur PIC24/dsPIC30/dsPIC33 sont multi-niveaux avec priorité programmable. Multi-niveaux (nested en anglais) signifie qu'une interruption en cours peut-être interrompue par une autre de priorité supérieure. Lorsque l'interruption de niveau supérieur se termine l'exécution continu dans le code d'interruption de niveau inférieur qui a été interrompu. chaque table d'interruption (la principale et l'alternative) contient 126 vecteurs. C'est vecteurs sont des adresses qui correspondent au point d'entré de la routine qui sert l'interruption (ISR entry point). Les 8 premiers vecteurs servent a gérer les exceptions. En fait actuellement sur les PIC24 seulement 4 sont utilisés les autres sont réservés. Les 118 autres vecteurs sont pour les périphériques. Encore là plusieurs de ces vecteurs sont marqués comme reserved et donc inutilisés. La table des vecteurs est disponible dans le document suivant: répertoire_installation/microchip/xc16/v1.20/docs/IntVectors/PIC24F_Interrupt_Vectors.html.

Le système d'interruption des PIC24 fonctionne de façon très similaire à celui des PIC32MX on n'est donc pas dépaysé si on connais déjà ce dernier. Il y a cependant des différences, entre autre il n'y a pas de sous-priorité. Les niveaux de priorité sont de 0-15 pour le CPU mais les niveaux programmables par l'utilisateur sont de 0-7 car les niveaux 8-15 sont réservés aux exceptions (traps). La priorité est dans l'ordre numérique c'est à dire que la plus basse est 0 et la plus haute est 15. Ça peut sembler évident mais sur certains MCU c'est l'inverse.

Si 2 interruptions de priorité égales sont déclenchées en même temps c'est l'ordre dans la table des vecteurs qui détermine laquelle sera servie en premier, plus petit IRQ# en premier.

Le CPU ne réponds qu'aux interruptions de niveau supérieur au niveau pour lequel il est programmé. C'est à dire qu'il y a 3 bits dans le registre d'état (SR), IPL0, IPL1 et IPL2 qui contrôlent le niveau de réponse. le registre core control register (CORCON) contient un 4ième bit IPL4. Si IPL4 est réglé à 1 le CPU ne répond plus qu'aux exceptions. A la mise sous tension ou après un RESET matériel ou logiciel le niveau de réponse est à zéro.

Configuration des interruptions

Il y a plusieurs registres spéciaux associés à la configuration des interruptions:

• INTCON1 Contrôle global des interruptions. Contient le bit NSTDI qui sert à activer/désactiver les interruptions multi-niveaux. Contient aussi les bits qui indiquent la source d'une exception.
• INTCON2 Contient le bit ALTIVT. Lorsque ce bit est à 1 la table de vecteurs alternative est utilisée (débogage). Contient aussi le bit DISI qui indique que les interruptions sont temporairement désactivés pour un nombres de cycles déterminé par le contenu du registre DISICNT (utile dans les sections de code critiques). Contient aussi les bits INTnEP qui détermine la polarité de réponse des interruptions externes (transition positive/négative).
• SRL<7:5> IPL2:IPL0 contrôle le niveau de réponse du CPU
• CORCON<3> IPL3 contrôle le niveau de réponse du CPU
• IECn ces SFR servent à activer/désactiver l'interruption sur un périphérique particulier. Chaque périphérique a 1 bit qui lui est assigné dans un de ces registres.
• IPCn ces SFR servent à déterminer le niveau de priorité de l'interruption. Chaque périphérique a 3 bits qui lui sont assigné dans un de ces registres.
• IFSn ces SFR servent d'indicateurs booléens pour les interruptions (interrupt flag). Chaque interruption a 1 bit qui lui est réservé dans 1 de ces registres.

Si on veut que le CPU réponde à toutes les interruptions on laisse les IPLx à zéro (valeur par défaut). Mais cette valeur peut-être modifier en cours d'exécution selon les besoins.

Pour configurer une interruption sur périphérique il faut:

1. Déterminer à quel IPCn est associé le périphérique et programmer le niveau de priorité désiré. Niveau 4 par défaut.
2. Déterminer à quel IFSn est associé le périphérique et remettre à zéro son bit IFS.
3. Déterminer à quel IECn est associé le périphérique et mettre à 1 sont bit IE pour rendre active l'interruption.

Exemple: TIMER1, niveau d'interruption 7 (le plus élevé).
IPC0 &= ~(7<<12); //remet niveau à zéro T1IPL IPC0 |= 7<<12; // met niveau à 7 T1IPL IFS0bits.T1IF=0; // met à zéro l'indicateur d'interruption IEC0bits.T1IE = 1; // active l'interruption

Création de la routine de service d'interruption

Les routines d'interruption (ISR) ne doivent avoir aucun arguments et ne retournent aucune valeur pour des raisons évident elles sont donc de la forme void isr(void). Pour qu'une fonction soit reconnue comme ISR ou gestionnaire d'exception il faut lui attribué l'attibut interrupt. Exemple:
void __attribute__((interrupt,no_auto_psv)) _T1Interrupt(void){ unsigned int c,x,y,z; x= led_counter % 4; y = (led_counter>>2) % 4; z = (led_counter>>4) % 4; TRISB |=CUBE_TRISB_MASK; LATB &= ~CUBE_TRISB_MASK; if (cube[z][y][x]){ c=y<2?0:1; TRISB &=~(cathode[z][c]|anode[z][y][x]); LATB |= anode[z][y][x]; } led_counter = ++led_counter % 64; anim_delay = ++anim_delay % ANIM_DLY ; IFS0bits.T1IF=0; }// _T1Interrupt() L'attribut no_auto_psv réduit le préambule de l'interruption donc son délais de réponse (latency) en évitant la sauvegarde du registre PSV. Pour les MCU avec 16Ko de mémoire flash ou moins ce registre est toujours à zéro donc inutile de le sauvegarder. Même chose si l'application n'utilise pas la fonction program space visibility².
Les indicateurs booléens d'interruptions ne sont pas remis à zéro automatiquement il faut le faire avant de quitter la routine ISR sinon l'interruption va se déclencher en boucle.

Il existe 2 macros pour simplifier la déclaration des routines d'interruptions:
_ISR
_ISRFAST
Dans l'exemple ci-haut j'aurais plus déclarer:
_ISRFAST _T1Interrupt(void);

Désactivation globale des interruptions

Contrairement aux autres MCU PIC, les PIC24 n'ont pas de bit GIE dans INTCON ou ailleurs. Pour désactiver les interruptions de niveau 0-6 temporairement ont peut utiliser l'instruction DISI en assembleur. Pour les désactiver de façon permanente on peut modifier le niveau de réponse du CPU avec la macro SET_CPU_IPL(ipl). En mettant ipl=7 toutes les interruptions sont désactivées.

Programme démo

Ajout d'une interface RS-232 au cube.

Ce démo utilise le cube de LED 4x4x4 avec la même animation que dans l'article de présentation du cube sauf que l'affichage du cube est dirigé par une interruption sur le TIMER1 à 200µsec d'intervalle. l'ensemble du cube est donc mise à jour environ 78 fois par seconde. De plus la variable anim_delay est incrémentée en boucle dans la même ISR et est utilisée pour contrôler la vitesse de défilement de l'animation. Avec la constante ANIM_DLY servant de modulo. Pour la valeur 1000 on a un intervalle 0,2 seconde entre chaque configuration. Le programme comprends en plus 2 autres interruptions, l'une pour la transmission des caractères sur UART1 et une autre pour la réception des caractères. Transmission et réception utilisent une file circulaire, rxbuff pour la réception et txbuff pour la transmission. A partir d'un ordinateur en utilisant un émulateur de terminal on peut arrêter l'animation en envoyant le caractère 's' et la redémarrer avec le caractère 'r'. Le MCU répond à chaque commande en envoyant le message " OK\n\r".

/* * File: cube-4-4-4.c * Author: jacques Deschênes * Description : Cube de LED 4x4x4 * cablé pour le Charlieplexing. * Created on 6 décembre 2013, 11:49 * Version: 0.2 * démonstration des interruptions. */ #include <stdio.h> #include <stdlib.h> #include <p24F16KA101.h> // PIC24F16KA101 Configuration Bit Settings #include <xc.h> // FBS #pragma config BWRP = OFF // Table Write Protect Boot (Boot segment may be written) #pragma config BSS = OFF // Boot segment Protect (No boot program Flash segment) // FGS #pragma config GWRP = OFF // General Segment Code Flash Write Protection bit (General segment may be written) #pragma config GCP = OFF // General Segment Code Flash Code Protection bit (No protection) // FOSCSEL #pragma config FNOSC = PRIPLL // Oscillator Select (Primary oscillator (XT, HS, EC)) #pragma config IESO = OFF // Internal External Switch Over bit (Internal External Switchover mode disabled (Two-Speed Start-up disabled)) // FOSC #pragma config POSCMOD = XT // Primary Oscillator Configuration bits (XT oscillator mode selected) #pragma config OSCIOFNC = ON // CLKO Enable Configuration bit (CLKO output disabled; pin functions as port I/O) #pragma config POSCFREQ = MS // Primary Oscillator Frequency Range Configuration bits (Primary oscillator/external clock input frequency between 100 kHz and 8 MHz) #pragma config SOSCSEL = SOSCLP // SOSC Power Selection Configuration bits (Secondary oscillator configured for low-power operation) #pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection (Both Clock Switching and Fail-safe Clock Monitor are disabled) // FWDT #pragma config WDTPS = PS32768 // Watchdog Timer Postscale Select bits (1:32,768) #pragma config FWPSA = PR128 // WDT Prescaler (WDT prescaler ratio of 1:128) #pragma config WINDIS = ON // Windowed Watchdog Timer Disable bit (Standard WDT selected; windowed WDT disabled) #pragma config FWDTEN = OFF // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit)) // FPOR #pragma config BOREN = BOR3 // Brown-out Reset Enable bits (Brown-out Reset disabled in hardware; SBOREN bit disabled) #pragma config PWRTEN = ON // Power-up Timer Enable bit (PWRT disabled) #pragma config I2C1SEL = PRI // Alternate I2C1 Pin Mapping bit (Default location for SCL1/SDA1 pins) #pragma config BORV = V18 // Brown-out Reset Voltage bits (Brown-out Reset set to lowest voltage (1.8V)) #pragma config MCLRE = ON // MCLR Pin Enable bit (MCLR pin enabled; RA5 input pin disabled) // FICD #pragma config ICS = PGx2 // ICD Pin Placement Select bits (PGC2/PGD2 are used for programming and debugging the device) // FDS #pragma config DSWDTPS = DSWDTPSF // Deep Sleep Watchdog Timer Postscale Select bits (1:2,147,483,648 (25.7 Days)) #pragma config DSWDTOSC = LPRC // DSWDT Reference Clock Select bit (DSWDT uses LPRC as reference clock) #pragma config RTCOSC = LPRC // RTCC Reference Clock Select bit (RTCC uses LPRC as reference clock) #pragma config DSBOREN = ON // Deep Sleep Zero-Power BOR Enable bit (Deep Sleep BOR enabled in Deep Sleep) #pragma config DSWDTEN = OFF // Deep Sleep Watchdog Timer Enable bit (DSWDT disabled) #define Fosc 16384000 // fréquence sortie du PLL, 4*Fxtal #define Fcy Fosc/2 // fréquence cycle MCU // cathodes #define P1C1 (1<<0) #define P1C2 (1<<1) #define P2C1 (1<<4) #define P2C2 (1<<8) #define P3C1 (1<<9) #define P3C2 (1<<12) #define P4C1 (1<<13) #define P4C2 (1<<14) // anodes plan 1 #define P1A1 (1<<1) #define P1A2 (1<<4) #define P1A3 (1<<8) #define P1A4 (1<<9) #define P1A5 (1<<12) #define P1A6 (1<<13) #define P1A7 (1<<14) #define P1A8 (1<<15) #define P1A9 (1<<0) #define P1A10 (1<<4) #define P1A11 (1<<8) #define P1A12 (1<<9) #define P1A13 (1<<12) #define P1A14 (1<<13) #define P1A15 (1<<14) #define P1A16 (1<<15) // anodes plan 2 #define P2A1 (1<<0) #define P2A2 (1<<1) #define P2A3 (1<<8) #define P2A4 (1<<9) #define P2A5 (1<<12) #define P2A6 (1<<13) #define P2A7 (1<<14) #define P2A8 (1<<15) #define P2A9 (1<<0) #define P2A10 (1<<1) #define P2A11 (1<<4) #define P2A12 (1<<9) #define P2A13 (1<<12) #define P2A14 (1<<13) #define P2A15 (1<<14) #define P2A16 (1<<15) // anodes plan 3 #define P3A1 (1<<0) #define P3A2 (1<<1) #define P3A3 (1<<4) #define P3A4 (1<<8) #define P3A5 (1<<12) #define P3A6 (1<<13) #define P3A7 (1<<14) #define P3A8 (1<<15) #define P3A9 (1<<0) #define P3A10 (1<<1) #define P3A11 (1<<4) #define P3A12 (1<<8) #define P3A13 (1<<9) #define P3A14 (1<<13) #define P3A15 (1<<14) #define P3A16 (1<<15) // anodes plan 4 #define P4A1 (1<<0) #define P4A2 (1<<1) #define P4A3 (1<<4) #define P4A4 (1<<8) #define P4A5 (1<<9) #define P4A6 (1<<12) #define P4A7 (1<<14) #define P4A8 (1<<15) #define P4A9 (1<<0) #define P4A10 (1<<1) #define P4A11 (1<<4) #define P4A12 (1<<8) #define P4A13 (1<<9) #define P4A14 (1<<12) #define P4A15 (1<<13) #define P4A16 (1<<15) // masque TRISB pour les E/S utilisées par le cube, RB0,RB1,RB4,RB8,RB9,RB12..RB15 #define CUBE_TRISB_MASK (P1C1|P1C2|P2C1|P2C2|P3C1|P3C2|P4C1|P4C2|P4A16) const int cathode[4][2]={// il n'y a que 2 cathodes par plan {P1C1,P1C2}, {P2C1,P2C2}, {P3C1,P3C2}, {P4C1,P4C2} }; const int anode[4][4][4]={ {{P1A1,P1A2,P1A3,P1A4},{P1A5,P1A6,P1A7,P1A8},{P1A9,P1A10,P1A11,P1A12},{P1A13,P1A14,P1A15,P1A16}}, {{P2A1,P2A2,P2A3,P2A4},{P2A5,P2A6,P2A7,P2A8},{P2A9,P2A10,P2A11,P2A12},{P2A13,P2A14,P2A15,P2A16}}, {{P3A1,P3A2,P3A3,P3A4},{P3A5,P3A6,P3A7,P3A8},{P3A9,P3A10,P3A11,P3A12},{P3A13,P3A14,P3A15,P3A16}}, {{P4A1,P4A2,P4A3,P4A4},{P4A5,P4A6,P4A7,P4A8},{P4A9,P4A10,P4A11,P4A12},{P4A13,P4A14,P4A15,P4A16}}, }; char cube[4][4][4]; void cube_init(){ int x,y; for (x=0;x<4;x++){ for (y=0;y<4;y++){ cube[0][y][x]=1; } } }// cube_init() static volatile unsigned int led_counter=0; static volatile unsigned int anim_delay=0; #define ANIM_DLY 1000 void __attribute__((interrupt,no_auto_psv)) _T1Interrupt(void){ unsigned int c,x,y,z; x= led_counter % 4; y = (led_counter>>2) % 4; z = (led_counter>>4) % 4; TRISB |=CUBE_TRISB_MASK; LATB &= ~CUBE_TRISB_MASK; if (cube[z][y][x]){ c=y<2?0:1; TRISB &=~(cathode[z][c]|anode[z][y][x]); LATB |= anode[z][y][x]; } led_counter = ++led_counter % 64; anim_delay = ++anim_delay % ANIM_DLY ; IFS0bits.T1IF=0; }// _T1Interrupt() #define BUFF_SIZE 80 static volatile char head,tail; static volatile char rxbuff[BUFF_SIZE]; void __attribute__((interrupt,no_auto_psv)) _U1RXInterrupt(void){ rxbuff[tail]=U1RXREG; tail = (++tail) % BUFF_SIZE; IFS0bits.U1RXIF=0; }//_U1RXInterrupt() static volatile char txhead,txtail; static volatile char txbuff[BUFF_SIZE]; void __attribute__((interrupt,no_auto_psv)) _U1TXInterrupt(void){ if (txtail!=txhead){ U1TXREG=txbuff[txhead++]; txhead %= BUFF_SIZE; } IFS0bits.U1TXIF=0; }// _U1TXInterrupt() void timer1_init(){ // contrôle délais de la LED T1CONbits.TON=0; // désactivation minuterie PR1=1638; // valeur du délais Tdly=PS*PR1/Fcy, PS=1 // délais 200µsec TMR1=0; // initialise le compteur à 0 IPC0 &= ~(7<<12); //remet niveau à zéro IPC0 |= 7<<12; // met niveau à 7 IFS0bits.T1IF=0; // met à zéro l'indicateur d'interruption IEC0bits.T1IE = 1; // active l'interruption T1CON=(unsigned int)(1<<15); // active la minuterie sans diviseur }//timer1_init() void uart1_init(){// initialisation UART1, TX sur RB7, RX sur RB2 U1BRG= Fcy/16/38400-1; // UxBRG= Fcy/(16*BaudRate) - 1 U1MODE=0; U1MODEbits.UARTEN=1; // activation du UART U1STAbits.UTXEN=1; // activation transmission IFS0bits.U1RXIF=0; IEC0bits.U1RXIE=1; // activation interruption UART1_RX IFS0bits.U1TXIF=0; IEC0bits.U1TXIE=1; // activation ietteruption UART1_TX tail=0; head=0; } void UartPutch(char c){ //envoie d'un caractère via UART1 if (!U1STAbits.UTXBF) U1TXREG=c; else{ SET_CPU_IPL(4); // désactivation interruption UART1_TX txbuff[txtail++]=c; txtail %= BUFF_SIZE; SET_CPU_IPL(0); } }// UartPutch() char UartGetch(){ // réception d'un caractère via UART1 char ch; if (head!=tail){ ch=rxbuff[head]; head = (++head) % BUFF_SIZE; return ch; } return -1; }// UartGetch() void UartPrint(char *str){ while(*str){ UartPutch(*str++); } }//UartPrint(); void prompt(){ UartPrint(" OK\n\r"); }//prompt() static volatile char anim,p,d; void planes_sweep(){ int x,y,z; // z vertical, y profondeur, x largeur switch(anim){ case 0: for (z=0;z<4;z++){ for(x=0;x<4;x++){ for(y=0;y<4;y++){ if (z==p) cube[z][y][x]=1; else cube[z][y][x]=0; } } } p += d; if (p>3){ p=2; d=-1; }else if (p<0){ p=0; d=1; anim=1; } break; case 1: for (z=0;z<4;z++){ for(x=0;x<4;x++){ for(y=0;y<4;y++){ if (y==p) cube[z][y][x]=1; else cube[z][y][x]=0; } } } p += d; if (p>3){ p=2; d=-1; }else if (p<0){ p=0; d=1; anim=2; } break; case 2: for (z=0;z<4;z++){ for(x=0;x<4;x++){ for(y=0;y<4;y++){ if (x==p) cube[z][y][x]=1; else cube[z][y][x]=0; } } } p += d; if (p>3){ p=2; d=-1; }else if (p<0){ p=0; d=1; anim=0; } break; }//switch }//planes_sweep() /* * */ int main(void) { int x,y,z; // z vertical, y profondeur, x largeur char run,ch; p=0; d=1; anim=0; run=0; cube_init(); timer1_init(); uart1_init(); while (1){ if (run && !anim_delay){ planes_sweep(); while (!anim_delay); }else{ ch=UartGetch(); if (ch>-1) UartPutch(ch); if (ch=='S' || ch=='s'){ run=0; prompt(); }else if (ch=='R' || ch=='r'){ run=1; prompt(); } } }//while return (EXIT_SUCCESS); }

---

notes

1) Le family reference manual des PIC24F contients 66 sections disponibles ici.

2) la fonction program space visibility permet de rendre accessible en lecture une section de la mémoire flash en mémoire RAM. Cette fonction est utile lorsqu'il y a des tables de données en mémoire flash. Le registre PSVPAG détermine l'adresse de départ du segment flash à rendre visible dans la RAM. Cette adresse doit-être un multiple de 16Ko. Cette section sera visible dans la RAM à partir de l'adresse 0x8000. Lorsqu'on programme en 'C' le compilateur s'occupe de ces détails. Par exemple dans le démo ci-haut la chaîne de caractère " OK\n\r" est conservée en mémoire flash et le compilateur fait ce qu'il faut pour que UartPrint() puisse l'accéder via le program space visibility.