Ok, trois articles sur le sujet ça peut paraître court, mais ça constitue déjà une bonne introduction, qui devrais vous permettre d’envisager la suite par vous-même. Nous allons aujourd’hui nous pencher sur un autre élément essentiel de la programmation avr :
Les interruptions
Imaginez que vous êtes en train de souder un circuit quand tout à coups la sonnette de votre porte d’entrée résonne. Vous pouvez arrêter ce que vous étiez en train de faire (mais rien ne vous y oblige), aller répondre, et revenir à vos soudures. Et c’est exactement comme ça que se passe une interruption dans le monde informatique, ici représentée par la sonnette.
Les interruptions peuvent être matérielles (changement d’état d’une broche, timer qui arrive à une certaine valeur), ou logicielles, et le nombre d’interruption disponibles dépend du modèle d’avr.
Les différentes interruptions disponibles sur votre microcontrolleur sont visibles sur la table des vecteurs d’interruptions de la datasheet (ici, je suis toujours sur l’Attiny85)
Vecteurs d’interruption
Lorsqu’une interruption se produit, l’avr stoppe ce qu’il était en train de faire pour exécuter la fonction que vous souhaitiez rattacher à cette interruption. Pour ce faire, il utilise une table des vecteurs d’interruption, positionnée au début de sa mémoire flash, afin de faire la correspondance Interruption <–> fonction.
Afin d’utiliser une interruption sur notre avr, nous avons besoin de faire 3 choses :
- Positionner le bit Enable Interrupt (en général avec la fonction sei(), set global interrupt, mais peut aussi être positionné à la main)
- Positionner les bits de chaque interruption.
- et enfin remplir la condition de l’interruption.
Comme d’habitude, nous allons voir ensemble un petit exemple. Ce programme servira à compter les impulsions reçues sur la pin 5 de l’Attiny85. Lorsqu’il arrivera à 200 ou plus, il allumera une led sur la pin 6. Les impulsions pourront être crées avec un bouton poussoir (attention au debounce) ou un générateur de signal.
#include <avr/io.h>
#include <avr/interrupt.h>
// ___
// PB5 *|+ |* VCC
// PB3 *| |* PB2
// PB4 *| |* PB1 --> sortie led
// GND *|___|* PB0 --> entrée surveillée
//
volatile int count = 0; //compte des interrupts
int main(void)
{
//configuration de la pin de sortie
//configuration des interruptions
//Positionnement du Global Interrupt MaSK register
//Positionnement du Pin Change Mask Register
//mise en place des interrupts (set global interrupts)
for(;;)
{
//Si on a eu 200 impulsions ou plus
{
//on alume la led
}
//sinon
{
//On éteind la led
}
}
}
ISR (PCINT0_vect) { //vecteur d'interruption
// detection de front montant
{
//on ajoute 1 au décompte
}
//detection de front descendant
{
//ici on ne fais rien, juste pour l'exemple...
}
}
Voilà, déjà, on peut remarquer en fin de code la façon dont est définie le vecteur d’interruption. Un autre détail à remarquer est la déclaration de ma variable count. Cette variable étant utilisée à la fois par mon programme principal et par ma fonction, il est impératif de la déclarer en volatil, sous peine de ne jamais la voir s’incrémenter.
Voyons voir maintenant comment déclarer nos interruptions (encore une fois, les valeurs des bits sont tirés de la datasheet, cf page 53, chapitre 9.3.2) :
#include <avr/io.h>
#include <avr/interrupt.h>
// ___
// PB5 *|+ |* VCC
// PB3 *| |* PB2
// PB4 *| |* PB1 --> sortie led
// GND *|___|* PB0 --> entrée surveillée
//
volatile int count = 0; //compte des interrupts
int main(void)
{
//configuration de la pin de sortie
//configuration des interruptions
//Positionnement du Global Interrupt MaSK register
GIMSK |= (1 << PCIE); //Enable pin change interrupt for PORTB
//GIMSK = General Interrupt Mask Register
//PCIE = Pin Change Interrupt Enable
//Positionnement du Pin Change Mask Register
PCMSK = (1 << PB0); //Enable pin change interrupt for PB0 (pcint0)
//PCMSK = Pin Change Mask Register
//mise en place des interrupts (set global interrupts)
sei();
for(;;)
{
//Si on a eu 200 impulsions ou plus
{
//on alume la led
}
//sinon
{
//On éteind la led
}
}
}
ISR (PCINT0_vect) { //vecteur d'interruption
// detection de front montant
{
//on ajoute 1 au décompte
}
//detection de front descendant
{
//ici on ne fais rien, juste pour l'exemple...
}
}
Quelques petites explications complémentaires s’imposent ici. J’ai décidé de dédier une pin de mon Attiny85 à la surveillance du signal d’entrée, j’ai donc utilisé les Pin Change Interrupt. Mais si j’avais voulu utiliser ma broche pour d’autres choses en parallèle, j’aurais du utiliser les External Interrupt Request (donc positionner le bit INT0 au lieu de PCIE). Il faut également noter que par défaut, une interruption ne peut en interrompre une autre (comprendre : les interruptions sont désactivées le temps du traitement du vecteur d’interruption actuel). Il est cependant possible (mais pas franchement recommandé) de les réactiver en réutilisant sei() à l’intérieur de la déclaration du vecteur d’interruption. De la même manière, si vous souhaitez qu’une portion de votre code ne soit interrompue sous aucun prétexte, vous pouvez utiliser la fonction cei().
Voici maintenant le code complet :
#include <avr/io.h>
#include <avr/interrupt.h>
// ___
// PB5 *|+ |* VCC
// PB3 *| |* PB2
// PB4 *| |* PB1
// GND *|___|* PB0 --> entrée surveillée
//
volatile int count = 0; //compte des interrupts
int main(void)
{
//configuration de la pin de sortie
DDRB |= (1 << PORTB1); //on configure PB1 en tant que sortie
//DDRB = Port B Data Direction Register
//configuration des interruptions
GIMSK |= (1 << PCIE); //Enable pin change interrupt for PORTB
//GIMSK = General Interrupt Mask Register
//PCIE = Pin Change Interrupt Enable
PCMSK = (1 << PB0); //Enable pin change interrupt for PB0 (pcint0)
//PCMSK = Pin Change Mask Register
sei(); //mise en place des interrupts (set global interrupts)
for(;;)
{
if(count>=200) //Si on a eu 200 impulsions ou plus
{
PORTB |= (1 << PB1);
}
else
{
PORTB &= ~(1<<PB1);
}
}
}
ISR (PCINT0_vect) { //vecteur d'interruption
if (PINB & (1<<PB0)) // detection de front montant
{
count = count++;
}
else //detection de front descendant
{
//ici on ne fais rien, juste pour l'exemple...
}
}
Bon, passons sur les modifications d’état de la led, déjà abordées auparavant. Il est ici intéressant de noter comment se fait la détection d’un front montant ou descendant : à la suite d’un changement d’état, on lit l’état de la pin PB0, si elle est à l’état haut c’était un front montant, sinon, un front descendant.
Voilà, c’était le dernier article de cette série, qui sera suivi très bientôt d’une application concrète 🙂
