LPC810, partie 7, les interruptions

Dans cet article je discute des interruptions sur les LPC81x. En fait le contrôleur d'interruption fait partie du coeur ARM Cortex M0+, donc son fonctionnement est le même sur tous les MCU qui utilise les CPU M0 et M0+.

Le contrôleur d'interruption

Dans le jargon de la compagnie ARM ce contrôleur s'appelle NVIC pour Nested Vector Interruptupt Controller. Comme son nom l'indique il s'agit d'un contrôleur multi-niveaux utilisant une table de vecteurs. Par multi-niveaux on entend qu'une interruption en cours peut-être interrompue par une autre interruption de priorité supérieure. Il y a 4 niveaux de priorités numérotées de 0 à 3. 0 étant la plus haute et 3 la plus basse.

Lorsqu'on crée un projet utilisant CMSIS_CORE_LPC8xx dans LPCXpresso, on retrouve dans le dossier src du projet un fichier appelé cr_startup_lpc8xx.c et à l'intérieur de celui-ci se trouve la déclaration de toutes les fonctions de gestions d'interruptions. void SPI0_IRQHandler(void) ALIAS(IntDefaultHandler); void SPI1_IRQHandler(void) ALIAS(IntDefaultHandler); void UART0_IRQHandler(void) ALIAS(IntDefaultHandler); void UART1_IRQHandler(void) ALIAS(IntDefaultHandler); void UART2_IRQHandler(void) ALIAS(IntDefaultHandler); void I2C_IRQHandler(void) ALIAS(IntDefaultHandler); void SCT_IRQHandler(void) ALIAS(IntDefaultHandler); void MRT_IRQHandler(void) ALIAS(IntDefaultHandler); void CMP_IRQHandler(void) ALIAS(IntDefaultHandler); void WDT_IRQHandler(void) ALIAS(IntDefaultHandler); void BOD_IRQHandler(void) ALIAS(IntDefaultHandler); void WKT_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT0_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT1_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT2_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT3_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT4_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT5_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT6_IRQHandler(void) ALIAS(IntDefaultHandler); void PININT7_IRQHandler(void) ALIAS(IntDefaultHandler); //***************************************************************************** // // Processor ends up here if an unexpected interrupt occurs or a specific // handler is not present in the application code. // //***************************************************************************** __attribute__ ((section(".after_vectors"))) void IntDefaultHandler(void) { while(1) { } }

Comme on le voit il s'agit d'alias pour un gestionnaire par défaut qui contient une boucle while infinie. Donc si dans votre programme vous activez une interruption sans créer un gestionnaire pour celle-ci, lorsque cette interruption sera déclenchée votre programme va bloqué.

Pour créer un gestionnaire d'interruption il suffit de créer une fonction avec le nom du gestionnaire définie dans ce fichier. Par exemple le gestionnaire pour le périphérique MRT (Multi Rate Timer) s'appelle MRT_IRQHandler.

Utilisation d'une interruption

A titre d'exemple on va créer un projet MRT-multi-blink et utiliser le périphérique MRT pour faire clignoter 3 LEDs à des vitesses différentes l'une de l'autre. Ce projet va utiliser une interruption MRT_IRQHandler. Le MRT contient 4 minuteries et chacune d'elle peut-être programmée pour un délais différent. Chaque fois qu'un délais expire l'interruption est déclenchée. Le gestionnaire vérifie qu'elle canal du MRT a déclenché l'interruption et inverse l'état de la LED correspondante.

Créez un nouveau "C project" appelé "MRT-multi-blink" et utilisez la librairie CMSIS_CORE_LPC8xx. Copiez le code source suivant dans le fichier main.c.

/* =============================================================================== Name : MRT-multi-blink.c Author : $(author) Version : Copyright : $(copyright) Description : démo d'utilisation d'une interruption 3 LEDs clignote à des rythmes différents. Le MCU fonctionne avec l'horloge par défaut soit l'IRC à 12MHz =============================================================================== */ #ifdef __USE_CMSIS #include "LPC8xx.h" #endif #include <cr_section_macros.h> // TODO: insert other include files here #define SYS_CLOCK (12000000) // bits dans PINENABLE0 #define DIS_ACMP_I1 (1<<0) // analog compare input 1 on PIO0_0 #define DIS_ACMP_I2 (1<<1) // analog compare input 2 on PIO0_1 #define DIS_SWCLK (1<<2) // single wire debug clock on PIO0_3 #define DIS_SWDIO (1<<3) // single wire debug data i/o on PIO0_2 #define DIS_XTALIN (1<<4) // disable crystal in on PIO0_8 #define DIS_XTALOUT (1<<5) // disable crystal out on PIO0_9 #define DIS_RESET (1<<6) // disable reset on PIO0_5 #define DIS_CLKIN (1<<7) // disable clkin on PIO0_1 #define DIS_VDDCMP (1<<8) // disable Vdd compare on PIO0_6 #define m_disable_function(pins) LPC_SWM->PINENABLE0 |= (pins) #define LED_RED (1) // PIO0_1 #define LED_GREEN (2) // PIO0_2 #define LED_BLUE (3) // PIO0_3 // gestionnaire d'interruption pour le Multi Rate Timer void MRT_IRQHandler(void){ if (LPC_MRT->Channel[0].STAT&1){ // canal 0 LPC_GPIO_PORT->NOT0=(1u<<LED_RED); // inverse l'état de la sortie LED rouge LPC_MRT->Channel[0].STAT=1; // réinitialise l'indicateur d'interruption } if (LPC_MRT->Channel[1].STAT&1){ // canal 1 LPC_GPIO_PORT->NOT0=(1u<<LED_GREEN); // inverse l'état de la sortie LED verte LPC_MRT->Channel[1].STAT=1; // réinitialise l'indicateur d'interruption } if (LPC_MRT->Channel[2].STAT&1){ // canal 2 LPC_GPIO_PORT->NOT0=(1u<<LED_BLUE); // inverse l'état de la sortie LED bleu LPC_MRT->Channel[2].STAT=1; // réinitialise l'indicateur d'interruption } }// f(); // TODO: insert other definitions and declarations here int main(void) { //désactivation des fonctions fixes pour que les GPIO est accès aux broches // le registre PINENABLE0 contient les bits d'activations // on désactive les 2 entrées du comparateur analogique // les 2 broches pour le single wire debug SWCLK et SWDDIO // la broche CLKIN // la fonction RESET demeure active. m_disable_function(DIS_ACMP_I1|DIS_ACMP_I2|DIS_CLKIN|DIS_SWCLK|DIS_SWDIO); // réinitialisation des GPIO // activation AHB clock pour les GPIO (bit 6) et le MRT (bit 10) LPC_SYSCON->SYSAHBCLKCTRL |= (1u<<6)+(1u<<10); // configuration PIO0_1, PIO0_2 et PIO0_2 en mode sortie. LPC_GPIO_PORT->DIR0 |= (1u<<LED_RED)|(1u<<LED_GREEN)|(1u<<LED_BLUE); // configure les 3 canaux du MRT utilisés. 0-2 // canal 0 LED_RED LPC_MRT->Channel[0].STAT=1; // réinitialise l'indicateur d'interruption LPC_MRT->Channel[0].CTRL=1; // active le canal en mode interruption répétitive LPC_MRT->Channel[0].INTVAL=SYS_CLOCK/3; // démarre la minuterie, intervalle = 0,333333 sec. // canal 1 LED_GREEN LPC_MRT->Channel[1].STAT=1; // réinitialise l'indicateur d'interruption LPC_MRT->Channel[1].CTRL=1; // active le canal en mode interruption répétitive LPC_MRT->Channel[1].INTVAL=SYS_CLOCK/4; // démarre la minuterie, intervalle = 0,25 sec. // canal 2 LED_BLUE LPC_MRT->Channel[2].STAT=1; // réinitialise l'indicateur d'interruption LPC_MRT->Channel[2].CTRL=1; // active le canal en mode interruption répétitive LPC_MRT->Channel[2].INTVAL=SYS_CLOCK/2; // démarre la minuterie, intervalle = 0,5 sec. // configuration de l'interrption MRT // niveau de priorité 3 NVIC_SetPriority(MRT_IRQn,3); // plus basse priorité //activation de l'interrption MRT NVIC_EnableIRQ(MRT_IRQn); while(1) { // il ne se passe rien ici. } return 0 ; }

Analyse du programme.

Ce programme utilise le signal d'horloge par défaut soit l'IRC sans PLL. Donc le CPU tourne à 12Mhz. Dans la fonction main on commence par désactiver les fonctions fixes ACMP_I1, ACMP_I2, CLKIN, SWCLK et SWDIO. Ces fonctions sont activées/désactivés par des bits dans le registre LPC_SYSCON->PINENABLE0. la macro m_disable_function simplifie cette configuration.

Par défaut les périphériques sur le bus AHB sont désactivés. On doit donc les activés dans le registre LPC_SYSCON->SYSAHBCLKCTRL. Ici on active le clock pour les GPIO et pour le MRT. Se sont les 2 périphériques que ce programme utilise.

À la ligne suivante on met les broches sur lesquelles les LEDs sont branchées en mode sortie en mettant les bits correspondants dans LPC_GPIO_PORT->DIR0 à la valeur 1. un bit à 0 dans ce registre correspond à une entrée.

Ensuite on configure les 3 canaux du MRT. Le registre STAT contient un bit indicateur d'interruption. Pour mettre ce bit à zéro il faut écrire un 1 dans le bit (ce n'est pas une erreur, mettre 1 pour réinitialiser). Le registre CTRL contient le bit d'activation/désactivation en position 0. et 2 bits de sélection du mode de fonctionnement en position 2:1. On active le canal en laissant le mode à zéro qui correspond au mode interruption répétitive. Dans ce mode une interruption est déclenchée lorsque le compteur arrive à zéro (le comptage est à rebours). La valeur initiale est rechargée automatiquement et le cycle recommence. On obtient donc une interruption à intervalle régulier.

Le compteur démarre au moment ou on inscris la valeur de l'intervalle désiré dans le registre INTVAL.

On programme ensuite la priorité d'interruption au plus bas niveau avec la fonction NVIC_SetPriority(). Finalement on active cette interruption avec la fonction NVIC_EnableIRQ().

Le gestionnaire d'interruption est très simple. On vérifie quels sont les canneaux qui ont l'indicateur d'interruption à 1 et pour ceux-ci, on inverse l'état de la sortie GPIO associé.

Pour en savoir plus sur l'interface de programmation des interruptions il faut lire le fichier d'entête core_cm0plus.h qui fait parti de la librairie CMSIS_CORE_LPC8xx.

---

Liens vers les articles précédents:

1. Introduction au LPC810 (ARM M0+)
2. LPC810, partie 2, anatomie
3. LPC810, création d'un projet
4. LPC810, partie 4, programmation
5. LPC810, partie 5, module SCT et PWM
6. LPC810, partie 6, system clock et PLL