Chapitre 6Livre « Arduino sous le capot »

Les interruptions externes

Réagir instantanément à un événement extérieur, avec Arduino puis avec les registres, sans perdre une impulsion

Un programme qui doit réagir à un événement – un appui, une impulsion de capteur, un front sur une ligne – peut le guetter en permanence ou laisser le matériel le prévenir. La seconde solution, l’interruption, garantit qu’aucun événement n’est manqué et qu’il est traité en quelques microsecondes, quoi que fasse le programme principal.

Ce chapitre explique d’abord ce qu’est une interruption et ce qui se passe dans le microcontrôleur lorsqu’elle survient. Il présente ensuite la fonction Arduino attachInterrupt() et les règles d’écriture d’une routine d’interruption, puis la programmation directe par les registres de l’ATmega. Il consacre une partie au mot-clé volatile et au partage des données entre la routine et loop(), source d’erreurs difficiles à trouver. Il se termine par des exemples : compteur d’impulsions, anti-rebond, encodeur rotatif, compte-tours, et interruptions sur toutes les broches.

Objectifs du chapitre

  • Comparer scrutation et interruption, et décrire le traitement d’une interruption par le processeur.
  • Utiliser attachInterrupt() avec le bon mode de déclenchement et écrire une routine d’interruption courte.
  • Configurer une interruption externe avec les registres EICRA, EIMSK, EIFR et SREG.
  • Partager des données entre une interruption et loop() avec volatile et une copie protégée.
  • Utiliser les interruptions de changement d’état PCINT sur n’importe quelle broche.

Prérequis

Les registres et la pile (chapitre 2), les entrées numériques et l’anti-rebond (chapitre 3), millis() et micros() (chapitre 4).

Plan du chapitre

  1. Partie I – Principe
  2. 6.1Scruter ou interrompre ?
  3. 6.2Ce qui se passe dans le microcontrôleur
  4. Partie II – Avec Arduino
  5. 6.3attachInterrupt() et les règles d’une ISR
  6. Partie III – Avec les registres
  7. 6.4Configurer une interruption par les registres
  8. Partie IV – Le mot-clé volatile
  9. 6.5Partager des données avec une ISR
  10. Partie V – Exemples
  11. 6.6Compter des impulsions
  12. 6.7Encodeur rotatif et compte-tours
  13. 6.8Les interruptions PCINT
  14. Partie VI – Évaluation et ressources
  15. 6.9À retenir et QCM
  16. 6.10Sources et références

Chapitre 6 · Partie I

Principe

Avant d’écrire la moindre interruption, il faut comprendre en quoi elle diffère d’un appel de fonction et ce que le processeur fait pour l’exécuter puis reprendre le programme là où il l’avait laissé.

Chapitre 6 · Section 6.1

Scruter ou interrompre ?

Il existe deux façons de détecter un événement : le programme vérifie sans cesse s’il est arrivé, ou le matériel le surveille et prévient le processeur. On parle de scrutation dans le premier cas, d’interruption dans le second.

Scrutation et interruption : deux programmes et leurs différences.
Figure 6.1 – Scrutation et interruption : deux programmes et leurs différences.

6.1.1Deux stratégies

En scrutation (polling), le programme demande sans cesse : « l’événement est-il arrivé ? ». C’est regarder régulièrement par la fenêtre si le facteur passe. Pendant que le programme fait autre chose, il ne regarde pas :

void loop() {
  if (digitalRead(2) == LOW) {   // on regarde
    traiter();
  }
  autreTravail();                // pendant ce temps, on ne regarde pas
}

Avec une interruption, le matériel surveille la broche et prévient le processeur dès que l’événement arrive. C’est la sonnette : inutile de guetter.

void setup() {
  attachInterrupt(digitalPinToInterrupt(2), traiter, FALLING);
}
void loop() {
  autreTravail();                // traiter() s’exécute dès l’appui
}
CritèreScrutationInterruption
Temps de réactiondépend de la durée d’un tour de loop()quelques microsecondes, quoi que fasse loop()
Événement brefpeut passer inaperçumémorisé par le matériel, jamais manqué
Programmationsimple, tout se passe dans loop()données partagées : volatile, accès protégé

6.1.2Fonction ou interruption ?

Figure 6.2 interactif – Logigramme comparé d’un appel de fonction et d’une interruption : déclenchez un front sur D2 et suivez l’exécution pas à pas.

Une fonction ordinaire est appelée par une ligne du programme, toujours au même endroit : dans la figure 6.2, compter() s’exécute une fois par tour de loop(), qu’un front soit arrivé ou non ; la variable n compte alors les tours de boucle, pas les fronts. Une routine d’interruption (ISR, Interrupt Service Routine) n’est appelée par aucune ligne de loop() : c’est le matériel qui la déclenche, entre deux instructions quelconques, dès qu’un front arrive. Chaque front est compté au moment où il se produit.

Figure 6.3 interactif – Qui s’exécute au cours du temps ? Comparez un appel de fonction et une interruption.
FonctionInterruption (ISR)
Appelée parle programme, à un endroit écrit dans le codele matériel, à n’importe quel moment
Retouraprès la ligne d’appelà l’instruction interrompue
Paramètreslibresaucun, type void
Duréelibrela plus courte possible
Pendant ce tempsrien d’autre ne s’exécuteles autres interruptions attendent

Définition – Routine d’interruption (ISR)

Fonction exécutée automatiquement par le processeur lorsqu’un événement matériel autorisé se produit. Elle suspend le programme principal, s’exécute, puis lui rend la main à l’instruction interrompue.

✎ Signaler une erreur dans cette section

Chapitre 6 · Section 6.2

Ce qui se passe dans le microcontrôleur

Entre le front sur la broche et le retour dans loop(), le processeur effectue une séquence précise d’opérations. La connaître explique les règles que doit respecter une routine d’interruption.

Du front sur D2 au retour dans loop(), et le début de la table des vecteurs de l’ATmega328P.
Figure 6.4 – Du front sur D2 au retour dans loop(), et le début de la table des vecteurs de l’ATmega328P.

6.2.1Du front au retour

Prenons l’exemple d’un bouton relié à D2, la broche de l’interruption externe INT0. Lorsqu’un front se produit sur cette broche, le microcontrôleur réagit toujours de la même façon, en cinq étapes, du signalement de l’événement jusqu’à la reprise du programme principal (figure 6.4).

  1. Un front arrive sur D2 : le matériel met le drapeau INTF0 à 1. Il reste mémorisé même si le processeur est occupé.
  2. Si l’interruption INT0 est autorisée (registre EIMSK) et si les interruptions sont permises globalement (bit I du registre SREG), la demande est acceptée à la fin de l’instruction en cours.
  3. L’adresse de retour est rangée dans la pile (chapitre 2), le bit I passe à 0 et INTF0 est effacé : les autres interruptions attendent.
  4. Le processeur saute au vecteur INT0, qui mène à la routine d’interruption. Celle-ci commence par sauvegarder les registres qu’elle utilise.
  5. L’ISR s’exécute, restaure les registres, puis se termine par l’instruction reti : retour à l’instruction interrompue, bit I remis à 1.

L’entrée dans l’ISR prend au moins 4 cycles d’horloge, soit 0,25 µs à 16 MHz. Avec attachInterrupt(), qui passe par une fonction intermédiaire et sauvegarde davantage de registres, il faut compter quelques microsecondes.

Chaque source d’interruption possède son propre vecteur, rangé au début de la mémoire programme dans la table des vecteurs : RESET d’abord, puis INT0, INT1, les PCINT, les timers, la liaison série, le convertisseur… (figure 6.4). Ce rang fixe aussi la priorité : si deux demandes arrivent en même temps, la source au plus petit numéro passe en premier, INT0 avant INT1. L’autre attend la fin de la première routine ; son drapeau reste à 1 et elle n’est pas perdue.

Définition – Drapeau d’interruption

Bit d’un registre que le matériel met à 1 lorsqu’un événement se produit. Il mémorise la demande jusqu’à ce qu’elle soit traitée : un événement bref n’est donc jamais manqué, même si le processeur est occupé à ce moment-là.

Exercices

1. Un capteur produit des impulsions de 5 µs. Un programme qui le scrute a une boucle qui dure 2 ms. Quelle fraction des impulsions voit-il ?

Une impulsion n’est vue que si une lecture tombe pendant ses 5 µs. Avec une lecture toutes les 2 ms, la probabilité est d’environ 5 / 2 000 = 0,25 % : la quasi-totalité des impulsions est perdue. Avec une interruption, le drapeau mémorise chacune d’elles.

2. Pourquoi le processeur met-il le bit I à 0 en entrant dans une ISR ?

Pour qu’une autre interruption ne vienne pas interrompre la routine en cours. Les demandes qui arrivent entre-temps restent mémorisées dans leurs drapeaux et seront traitées après reti, qui remet I à 1.

✎ Signaler une erreur dans cette section

Chapitre 6 · Partie II

Avec Arduino

La fonction attachInterrupt() associe une fonction à une broche et à un type de front. Elle est simple à utiliser, à condition de respecter quelques règles d’écriture.

Chapitre 6 · Section 6.3

attachInterrupt() et les règles d’une ISR

Les interruptions externes ne sont disponibles que sur certaines broches, et leur numérotation diffère entre le microcontrôleur, la carte et Arduino. Une fois la bonne broche choisie, il reste à choisir le mode de déclenchement et à écrire une routine courte.

6.3.1Les broches d’interruption

Sur la Uno et la Nano, seules D2 (INT0) et D3 (INT1) acceptent une interruption externe. Pour les autres broches, on utilise les interruptions PCINT (section 6.8). La Mega 2560 en offre six : D2, D3 et D18 à D21. La figure 6.5 donne, pour chaque broche, la source du microcontrôleur, le numéro renvoyé par digitalPinToInterrupt() et, sur la Mega, l’autre rôle de la broche.

Les broches d’interruption externe de la Uno et de la Mega 2560, et leurs trois numérotations.
Figure 6.5 – Les broches d’interruption externe de la Uno et de la Mega 2560, et leurs trois numérotations.

Attention – Trois numérotations

Sur la Mega, la broche D2 est la source INT4 du microcontrôleur, mais l’interruption numéro 0 pour Arduino. Écrivez toujours digitalPinToInterrupt(broche) : le code reste juste quelle que soit la carte. D20 et D21 ne servent pas d’interruption pendant qu’un module I²C les utilise, et leurs résistances de pull-up ne peuvent pas être désactivées.

6.3.2Les modes de déclenchement

On appelle attachInterrupt(digitalPinToInterrupt(broche), fonction, mode) dans setup(), après pinMode(). Le premier argument est le numéro d’interruption de la broche, le deuxième est le nom de la routine, sans parenthèses. Le troisième, le mode, fixe l’instant où la routine est appelée : RISING à chaque front montant, FALLING à chaque front descendant, CHANGE à chaque changement d’état et LOW tant que la broche est à 0. Avec un bouton en INPUT_PULLUP, FALLING réagit à l’appui : c’est le mode le plus utilisé. CHANGE réagit à l’appui et au relâchement ; la routine lit alors la broche pour savoir lequel des deux s’est produit. LOW rappelle l’ISR sans arrêt tant que la broche reste à 0, si bien que loop() n’avance presque plus ; il est rarement utile. À l’inverse, detachInterrupt(digitalPinToInterrupt(broche)) désactive l’interruption de la broche : la routine n’est plus appelée jusqu’à un nouvel appel à attachInterrupt(). On s’en sert pour ignorer momentanément un signal ou pour changer de mode en cours de programme. La figure 6.6 permet de comparer les quatre modes sur un même signal.

Figure 6.6 interactif – Quand l’ISR est-elle appelée ? Choisissez un mode et observez les instants de déclenchement sur un signal.

6.3.3Les règles d’une routine d’interruption

Une routine d’interruption suspend le programme principal à n’importe quel moment, et pendant qu’elle s’exécute les autres interruptions attendent. Elle doit donc rendre la main le plus vite possible et respecter quelques règles :

  • Courte : lever un drapeau, compter, noter un instant. Le reste du travail se fait dans loop().
  • Une fonction void, sans paramètre.
  • Les variables partagées avec loop() sont déclarées volatile (section 6.5).

À éviter dans une ISR

  • delay() ne fonctionne pas ; millis() n’avance pas pendant l’ISR ; micros() devient faux au-delà de 1 à 2 ms.
  • Serial.print() est lent, et des caractères reçus pendant l’ISR peuvent être perdus.
  • Une boucle d’attente bloque toutes les autres interruptions.

La structure la plus sûre est le modèle « drapeau » : l’ISR se contente de noter que l’événement a eu lieu, et loop() fait le travail long.

const int BP = 2;
volatile bool appui = false;       // partagé

void isrBouton() {                 // ISR très courte
  appui = true;
}
void setup() {
  pinMode(BP, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(BP), isrBouton, FALLING);
  Serial.begin(9600);
}
void loop() {
  if (appui) {
    appui = false;
    Serial.println("Appui !");     // travail long ici
  }
}

Exercices

1. Un capteur de choc tire sa sortie à 0 V à chaque choc. Il est câblé sur D19 d’une Mega. Écrivez l’appel à attachInterrupt().

pinMode(19, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(19), choc, FALLING); – digitalPinToInterrupt(19) renvoie 4, mais il est inutile de le savoir.

2. Pourquoi le modèle drapeau est-il préférable à un Serial.println() dans l’ISR ?

À 9 600 bauds, « Appui ! » et le retour à la ligne représentent 9 octets, soit plus de 9 ms. Pendant tout ce temps, les autres interruptions seraient bloquées, dont celle du Timer0 (millis()) et celle de réception série. Le drapeau rend l’ISR quasi instantanée.

✎ Signaler une erreur dans cette section

Chapitre 6 · Partie III

Avec les registres

Sans passer par attachInterrupt(), on configure une interruption externe en écrivant dans quatre registres et l’on écrit la routine avec la macro ISR(). Le code est plus court et plus rapide, mais propre au microcontrôleur.

Chapitre 6 · Section 6.4

Configurer une interruption par les registres

Une interruption externe dépend de trois conditions, chacune réglée dans un registre : le drapeau doit être levé, l’interruption doit être autorisée individuellement, et les interruptions doivent être permises globalement.

6.4.1Les registres de la Uno et de la Mega

Les deux cartes utilisent les mêmes registres, organisés de la même façon ; seul leur nombre de bits utiles change avec le nombre de sources. L’ATmega328P de la Uno gère deux interruptions externes, INT0 et INT1 ; l’ATmega2560 de la Mega en gère huit, INT0 à INT7, dont six sont reliées à un connecteur de la carte. La figure 6.7 affiche les registres de chaque carte : choisissez une source et un déclenchement pour voir les bits concernés et les lignes de code correspondantes.

Figure 6.7 interactif – Les registres d’interruption externe de la Uno et de la Mega 2560 : choisissez la carte, la source et le déclenchement.
  • EICRA choisit le déclenchement, avec deux bits ISCn1 et ISCn0 par source. Sur la Uno, il règle INT0 et INT1 ; sur la Mega, il règle INT0 à INT3, et un second registre, EICRB, absent de la Uno, règle INT4 à INT7. Les valeurs 00, 01, 10 et 11 correspondent aux modes LOW, CHANGE, FALLING et RISING ;
  • EIMSK est le masque : un 1 dans le bit n autorise INTn. La Uno n’en utilise que les deux premiers bits, la Mega les huit ;
  • EIFR contient les drapeaux INTF0 à INTF7, sur le même modèle : un 1 signale une demande en attente. Le drapeau est effacé à l’entrée de l’ISR, ou en y écrivant 1 ;
  • SREG contient le bit I, autorisation générale, identique sur les deux cartes : sei() le met à 1, cli() à 0. Arduino le met à 1 au démarrage.

Attention – Même broche, registres différents

La broche D2 correspond à INT0 sur la Uno, réglée dans EICRA, mais à INT4 sur la Mega, réglée dans EICRB. Un programme écrit directement avec les registres pour une carte ne fonctionne donc pas tel quel sur l’autre. attachInterrupt() associé à digitalPinToInterrupt() masque cette différence.

À retenir

L’ISR n’est exécutée que si le drapeau INTFn, le masque INTn et le bit I sont tous les trois à 1.

6.4.2Un programme complet

Figure 6.8 interactif – Générateur de code : choisissez la source et le déclenchement, et lisez les valeurs des registres, le programme et son équivalent Arduino.

Pour compter les fronts descendants sur D2 (INT0), il faut configurer la broche, effacer puis régler le mode, effacer un éventuel ancien drapeau, autoriser INT0, puis permettre les interruptions. La routine se déclare avec la macro ISR() et le nom du vecteur, imposé (figure 6.8) :

volatile unsigned int compteur = 0;

void setup() {
  DDRD  &= ~(1 << PD2);                      // D2 en entrée
  PORTD |=  (1 << PD2);                      // pull-up interne
  EICRA &= ~((1 << ISC01) | (1 << ISC00));  // efface le mode
  EICRA |=   (1 << ISC01);                   // 10 : front descendant
  EIFR   =   (1 << INTF0);                   // efface un ancien drapeau
  EIMSK |=   (1 << INT0);                    // autorise INT0
  sei();                                      // bit I = 1
}
ISR(INT0_vect) {                              // nom imposé
  compteur++;
}

On écrit EIFR = (1 << INTF0) et non |= : écrire 1 dans un drapeau l’efface, et un OU recopierait les autres drapeaux à 1, ce qui les effacerait aussi.

Attention – Registres ou attachInterrupt(), pas les deux

Si le programme utilise aussi attachInterrupt(), Arduino définit déjà les vecteurs des interruptions externes : l’édition de liens échoue avec le message « multiple definition of __vector_… ». Pour autoriser ou bloquer toutes les interruptions, sei() équivaut à interrupts() et cli() à noInterrupts().

Exercices

1. Quelle valeur donner aux quatre bits bas d’EICRA pour déclencher INT0 sur front montant et INT1 sur tout changement ?

INT0 en front montant : ISC01 ISC00 = 11. INT1 en changement : ISC11 ISC10 = 01. EICRA = 0b0111 = 0x07.

2. Un programme configure correctement EICRA et EIMSK mais l’ISR ne s’exécute jamais, alors que cli() a été appelé au début de setup(). Pourquoi ?

cli() a mis le bit I de SREG à 0 : la troisième condition n’est pas remplie. Il faut appeler sei() à la fin de la configuration.

✎ Signaler une erreur dans cette section

Chapitre 6 · Partie IV

Le mot-clé volatile

Une variable modifiée par une interruption et lue par loop() pose deux problèmes subtils : le compilateur peut ne pas la relire, et le processeur peut la lire à moitié. Le premier se règle avec volatile, le second avec une copie protégée.

Chapitre 6 · Section 6.5

Partager des données avec une ISR

Le compilateur optimise le code en supposant que seules les instructions qu’il voit modifient une variable. Une routine d’interruption, qui n’est appelée nulle part dans loop(), échappe à ce raisonnement.

Figure 6.9 interactif – L’effet du mot-clé volatile : déclenchez des fronts sur D2 avec et sans volatile et observez la copie de la variable dans un registre.

6.5.1Pourquoi volatile ?

Dans le programme de la figure 6.9, la routine ISR_blink() inverse une variable state, et loop() recopie state sur une LED dans deux boucles while. Rien dans loop() ne modifie state, et ISR_blink() n’y est jamais appelée : le compilateur en déduit que state ne peut pas changer pendant la boucle. Il la lit une seule fois et garde sa copie dans un registre. Les fronts sur D2 modifient la variable en mémoire, mais le programme ne le voit jamais : la LED reste figée.

Le mot-clé volatile interdit cette optimisation : il oblige le compilateur à relire la variable en mémoire à chaque accès, car elle peut changer à tout moment.

volatile byte state = LOW;      // modifiée par l’ISR, lue par loop()

Définition – volatile

Qualificatif du C qui indique au compilateur qu’une variable peut être modifiée en dehors du flot normal du programme (interruption, périphérique). Chaque lecture et chaque écriture se font alors réellement en mémoire.

6.5.2Lire une variable partagée sans erreur

Une lecture en deux temps interrompue par l’ISR, et la copie protégée.
Figure 6.10 – Une lecture en deux temps interrompue par l’ISR, et la copie protégée.

volatile ne suffit pas toujours. Un processeur 8 bits lit un int de 2 octets en deux instructions. Supposons que compteur vaille 0x00FF (255) : loop() lit l’octet bas, 0xFF ; l’ISR survient et incrémente compteur, qui devient 0x0100 (256) ; loop() lit alors l’octet haut, 0x01. La copie vaut 0x01FF, soit 511 : ni 255, ni 256 (figure 6.10).

Le problème touche les types de plus d’un octet (int, long, float) et les lectures-modifications comme compteur = 0 ou compteur-- exécutées dans loop(). Un byte ou un bool est lu en une seule instruction et n’est pas concerné. La solution consiste à copier la variable avec les interruptions bloquées, puis à travailler sur la copie :

volatile unsigned long compteur = 0;
void loop() {
  noInterrupts();                   // bit I = 0
  unsigned long copie = compteur;   // copie d’un bloc
  interrupts();                     // bit I = 1
  Serial.println(copie);            // travail sur la copie
}

Une interruption arrivée pendant la copie n’est pas perdue : son drapeau reste à 1 et l’ISR s’exécute juste après interrupts(). On bloque cependant le moins longtemps possible : seulement la copie. La bibliothèque avr-libc propose une variante, ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { … }, dans <util/atomic.h>.

À retenir

  • Toute variable partagée entre une ISR et loop() est volatile.
  • Une variable de plus d’un octet se lit, ou se modifie dans loop(), entre noInterrupts() et interrupts().

Exercices

1. Une ISR met à 1 une variable bool fin et loop() attend avec while (!fin) { }. Faut-il volatile ? Faut-il une copie protégée ?

volatile est indispensable : sans lui, le compilateur peut lire fin une seule fois et la boucle ne se termine jamais. Une copie protégée est inutile : un bool est lu en une instruction.

2. Dans loop(), on remet à zéro un compteur volatile unsigned int incrémenté par une ISR. Écrivez la remise à zéro.
noInterrupts();
compteur = 0;      // deux octets écrits sans interruption entre les deux
interrupts();

✎ Signaler une erreur dans cette section

Chapitre 6 · Partie V

Exemples

Les exemples suivants appliquent les interruptions à des problèmes concrets de comptage et de mesure, puis étendent la technique à toutes les broches grâce aux interruptions PCINT.

Chapitre 6 · Section 6.6

Compter des impulsions

Compter les impulsions d’un capteur – passage d’objets, tours de roue, gouttes de pluie – est l’application type des interruptions : chaque impulsion doit être vue, même si le programme est occupé ailleurs.

6.6.1Deux programmes

Le premier programme scrute le capteur et détecte les fronts descendants en comparant chaque lecture à la précédente. Mais loop() contient aussi un affichage et un delay(200) qui représentent le reste du travail : pendant ce temps, le capteur est aveugle.

const int CAPTEUR = 2;
unsigned long compteur = 0;
int ancien = HIGH;
void setup() {
  pinMode(CAPTEUR, INPUT_PULLUP);
  Serial.begin(9600);
}
void loop() {
  int lu = digitalRead(CAPTEUR);
  if (ancien == HIGH && lu == LOW) {   // front descendant
    compteur++;
  }
  ancien = lu;
  Serial.println(compteur);
  delay(200);                           // autre travail : capteur aveugle
}

Le second confie le comptage à une interruption. Le delay(200) ne gêne plus rien :

const int CAPTEUR = 2;
volatile unsigned long compteur = 0;
void compter() {                        // ISR
  compteur++;
}
void setup() {
  pinMode(CAPTEUR, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CAPTEUR), compter, FALLING);
  Serial.begin(9600);
}
void loop() {
  noInterrupts();
  unsigned long copie = compteur;
  interrupts();
  Serial.println(copie);
  delay(200);                           // ne gêne plus le comptage
}
Figure 6.11 interactif – Simulation des deux compteurs : réglez la fréquence des impulsions et la durée de loop().

La simulation de la figure 6.11 envoie des impulsions de 5 ms. Dès que la durée de loop() dépasse celle d’une impulsion, la scrutation en manque une partie, d’autant plus que les impulsions sont fréquentes ; l’interruption les compte toutes.

6.6.2Anti-rebond dans une ISR

Un bouton rebondit : chaque rebond est un front, donc une interruption. Sans filtre, un appui compte 3, 5 ou 10 fois. On ignore les fronts qui suivent le précédent de moins de 50 ms :

const int BP = 2;
volatile unsigned int nbAppuis = 0;

void isrBouton() {
  static unsigned long tDernier = 0;   // garde sa valeur
  unsigned long t = millis();          // valeur figée pendant l’ISR
  if (t - tDernier > 50) {             // rebond si moins de 50 ms
    nbAppuis++;
    tDernier = t;
  }
}
void setup() {
  pinMode(BP, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(BP), isrBouton, FALLING);
  Serial.begin(9600);
}
void loop() {
  noInterrupts(); unsigned int n = nbAppuis; interrupts();
  Serial.println(n);
  delay(100);
}

millis() se lit dans une ISR : elle renvoie l’heure d’entrée dans la routine, mais n’avance pas pendant son exécution. Le mot-clé static permet à tDernier de garder sa valeur d’un appel à l’autre sans être une variable globale.

Solution matérielle

Un filtre RC (10 kΩ et 100 nF) suivi d’une porte à hystérésis (trigger de Schmitt, 74HC14) donne un front unique et propre : l’ISR reste la plus simple possible.

✎ Signaler une erreur dans cette section

Chapitre 6 · Section 6.7

Encodeur rotatif et compte-tours

Les interruptions permettent aussi de suivre un mouvement : le sens et la position d’un bouton rotatif, ou la vitesse d’un axe à partir de l’instant de chaque impulsion.

Figure 6.12 interactif – Un encodeur rotatif : tournez dans un sens ou dans l’autre et observez les signaux A et B et la position.

6.7.1Encodeur rotatif

Un encodeur rotatif incrémental produit deux signaux rectangulaires, A et B, décalés d’un quart de période. Le sens de rotation se lit dans ce décalage : au front descendant de A, B est à 1 dans un sens et à 0 dans l’autre (figure 6.12). Il suffit d’une interruption sur A :

const int A = 2, B = 4;            // A sur une broche d’interruption
volatile long position = 0;

void isrA() {                      // front descendant sur A
  if (digitalRead(B) == HIGH) position++;   // sens horaire
  else                        position--;   // sens inverse
}
void setup() {
  pinMode(A, INPUT_PULLUP);
  pinMode(B, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(A), isrA, FALLING);
}

Le sens dépend du câblage : s’il est inversé, il suffit d’échanger A et B. Le module le plus courant, le KY-040, intègre aussi un bouton poussoir.

6.7.2Compte-tours

Figure 6.13 interactif – Le compte-tours : montage, calcul, et simulation d’un axe portant un ou deux aimants devant un capteur à effet Hall.

Un aimant fixé sur l’axe passe devant un capteur à effet Hall (A3144…) une fois par tour. La sortie du capteur, à collecteur ouvert, tire D2 à 0 V : un front descendant à chaque passage. L’ISR note l’instant de chaque impulsion avec micros() et calcule la période :

const int HALL = 2;                       // 1 impulsion par tour
volatile unsigned long periode = 0;       // µs entre deux impulsions

void isrCapteur() {
  static unsigned long tPrec = 0;
  unsigned long t = micros();             // instant de l’impulsion
  periode = t - tPrec;
  tPrec = t;
}
void setup() {
  pinMode(HALL, INPUT_PULLUP);            // sortie à collecteur ouvert
  attachInterrupt(digitalPinToInterrupt(HALL), isrCapteur, FALLING);
  Serial.begin(9600);
}
void loop() {
  noInterrupts(); unsigned long p = periode; interrupts();
  if (p > 0) {
    float tpm = 60000000.0 / p;           // tours par minute
    Serial.println(tpm);
  }
  delay(500);
}

Une période de 20 ms, soit 20 000 µs, correspond à 60 000 000 / 20 000 = 3 000 tr/min. micros() se lit sans problème au début d’une ISR courte ; elle ne deviendrait fausse que si l’ISR durait plus de 1 à 2 ms. Si l’axe s’arrête, periode garde sa dernière valeur : c’est à loop() de le détecter, par exemple en notant l’instant de la dernière impulsion. Pour des mesures de période plus précises, l’unité Input Capture du Timer1 fait mieux encore (chapitre 9).

Exercices

1. Le compte-tours affiche une période de 7 500 µs. Quelle est la vitesse ? Et s’il y a deux aimants sur l’axe ?

60 000 000 / 7 500 = 8 000 tr/min avec un aimant. Avec deux aimants, il y a deux impulsions par tour : la vitesse réelle est la moitié, 4 000 tr/min.

2. Comment faire afficher 0 tr/min lorsque l’axe est arrêté depuis plus d’une seconde ?

On mémorise dans l’ISR l’instant de la dernière impulsion (volatile unsigned long tDerniere = t;). Dans loop(), après une copie protégée, si micros() - tDerniere > 1000000, on affiche 0 au lieu de la vitesse calculée.

✎ Signaler une erreur dans cette section

Chapitre 6 · Section 6.8

Les interruptions PCINT

INT0 et INT1 ne sont disponibles que sur D2 et D3. Les interruptions de changement d’état, ou PCINT (Pin Change Interrupt), existent sur toutes les broches, au prix d’une routine partagée par tout un port.

6.8.1Trois groupes

Groupe (PCICR)BrochesMasqueVecteur
PCIE0D8 à D13PCMSK0PCINT0_vect
PCIE1A0 à A5PCMSK1PCINT1_vect
PCIE2D0 à D7PCMSK2PCINT2_vect

Sur la Mega 2560, PCINT0 à 7 sont sur D53–D50 et D10–D13, PCINT16 à 23 sur A8–A15.

6.8.2INT ou PCINT ?

Avec INT0 et INT1, chaque broche a sa routine et l’on choisit le front. Avec PCINT, une seule routine sert tout un port, et elle est déclenchée à chaque changement d’état de n’importe quelle broche surveillée. Elle doit lire PINx pour savoir quelle broche a changé et dans quel sens :

volatile unsigned int nb = 0;
void setup() {
  pinMode(8, INPUT_PULLUP);          // D8 = PB0 = PCINT0
  PCMSK0 |= (1 << PCINT0);           // surveiller D8
  PCIFR   = (1 << PCIF0);            // effacer un ancien drapeau
  PCICR  |= (1 << PCIE0);            // activer le groupe D8–D13
}
ISR(PCINT0_vect) {                   // tout changement sur D8–D13
  if (!(PINB & (1 << PB0))) {        // D8 à 0 : front descendant
    nb++;
  }
}

Pour éviter les registres, les bibliothèques PinChangeInterrupt ou EnableInterrupt offrent une fonction proche de attachInterrupt().

Exercices

1. On veut une interruption sur A2 d’une Uno. Quels registres et quel vecteur utiliser ?

A2 = PC2 = PCINT10, dans le groupe 1 : PCMSK1 |= (1 << PCINT10); PCIFR = (1 << PCIF1); PCICR |= (1 << PCIE1); et la routine ISR(PCINT1_vect), qui teste PINC & (1 << PC2).

2. Deux boutons sont sur D9 et D10, surveillés par PCINT0. Comment savoir dans l’ISR lequel a changé ?

On mémorise l’état précédent du port dans une variable static byte ancien. Dans l’ISR, byte change = PINB ^ ancien; donne les bits qui ont changé : bit 1 pour D9, bit 2 pour D10. On met ensuite ancien = PINB;.

✎ Signaler une erreur dans cette section

Chapitre 6 · Partie VI

Évaluation et ressources

Une synthèse des fonctions, registres et règles du chapitre, un questionnaire et les sources pour aller plus loin.

Chapitre 6 · Section 6.9

À retenir et QCM

Le tableau suivant résume les éléments essentiels des interruptions externes. Le questionnaire de la figure 6.14 permet de vérifier qu’ils sont acquis.

ÉlémentRôle
attachInterrupt(digitalPinToInterrupt(b), f, mode)Associe l’ISR f à la broche b : RISING, FALLING, CHANGE ou LOW
EICRA / EICRBMode de déclenchement : 2 bits ISCn1, ISCn0 par source
EIMSK · EIFRAutorisation de chaque source · drapeaux des demandes en attente
sei() / cli() · ISR(INT0_vect)Bit I de SREG à 1 ou 0 · définition de la routine avec les registres
volatileVariable modifiée par une ISR : relue en mémoire à chaque accès
noInterrupts() / interrupts()Copier sans erreur une variable de plus d’un octet

Bonnes habitudes

  • ISR courte : Un drapeau ou un compteur ; le travail long dans loop().
  • Pas de delay() : millis() n’avance pas pendant une ISR, Serial est à éviter.
  • volatile : Pour toute variable partagée entre ISR et loop().
  • Copie protégée : Lire int et long entre noInterrupts() et interrupts().

6.9.1Se tester

Le QCM comporte vingt et une questions. Choisissez une réponse à la souris ou avec les touches 1 à 4, puis validez avec Entrée. En fin de questionnaire, chaque question manquée renvoie à la section qui donne les explications.

Figure 6.14 interactif – QCM d’évaluation du chapitre 6.

✎ Signaler une erreur dans cette section

Chapitre 6 · Section 6.10

Sources et références

La référence Arduino décrit attachInterrupt() et ses règles ; les fiches techniques détaillent les registres ; la documentation d’avr-libc donne les noms des vecteurs et les outils d’accès atomique.

Référence du langage Arduino

Fiches techniques

avr-libc

Pour aller plus loin

✎ Signaler une erreur dans cette section