Comprendre et utiliser les interruptions sur Arduino

Qu’est-ce qu’une interruption ?

En programmation Arduino, une interruption est un mécanisme qui permet à la carte de réagir immédiatement à un événement externe, sans attendre la fin de la boucle loop(). Cela permet une grande réactivité pour gérer des signaux rapides, comme un bouton appuyé très brièvement, une impulsion d’un capteur, ou la réception d’un signal.

Pourquoi utiliser des interruptions ?

Sans interruption, on utilise souvent un code comme celui-ci :

void loop() {
  if (digitalRead(2) == HIGH) {
    // Faire quelque chose
  }
}

Mais si le programme est occupé ailleurs (par exemple, un long delay()), il peut rater un appui rapide sur un bouton.

Les interruptions permettent de réagir immédiatement, indépendamment de ce que fait le programme principal.

Le principe d’une interruption

Lorsqu’une interruption se déclenche :

• Le programme s’interrompt temporairement.

• Une fonction spéciale, appelée "routine d’interruption", est exécutée.

• Ensuite, le programme reprend là où il s’était arrêté.

Les broches utilisables pour les interruptions

Sur la plupart des cartes Arduino, comme l’UNO, seules certaines broches peuvent générer des interruptions externes :

Carte ArduinoBroches utilisablesUNO / NANO2 et 3Mega 25602, 3, 18, 19, 20, 21Leonardo0, 1, 2, 3, 7ESP32Toutes les broches (sauf certaines spéciales)

Syntaxe de base

attachInterrupt(digitalPinToInterrupt(pin), fonction, mode);

• pin : le numéro de la broche (ex : 2)

• fonction : le nom de la fonction à exécuter quand l’interruption se déclenche

• mode : le type de déclenchement :

  • RISING : front montant (LOW → HIGH)

  • FALLING : front descendant (HIGH → LOW)

  • CHANGE : changement d’état (HIGH ↔ LOW)

  • LOW : tant que c’est à l’état bas (rarement utilisé)

  • HIGH (ESP32 uniquement)

Exemple : allumer une LED quand on appuie sur un bouton

const int bouton = 2;
const int led = 13;
volatile bool etatLed = false;

void setup() {
  pinMode(bouton, INPUT_PULLUP);
  pinMode(led, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(bouton), changementEtat, FALLING);
}

void loop() {
  if (etatLed) {
    digitalWrite(led, HIGH);
  } else {
    digitalWrite(led, LOW);
  }
}

void changementEtat() {
  etatLed = !etatLed;
}

⚠️ Attention :

• La variable modifiée dans l’interruption doit être déclarée avec le mot-clé volatile.

• La fonction changementEtat() doit être courte et rapide : pas de delay(), Serial.print(), etc.

Bonnes pratiques avec les interruptions

✅ À faire :

• Utiliser volatile pour les variables partagées.

• Garder la routine très courte.

• Se servir des interruptions pour des événements brefs et critiques.

❌ À éviter :

• Faire un Serial.print() dans la fonction d’interruption.

• Mettre des délais (delay(), millis(), etc.).

• Exécuter des tâches longues dans la routine.

Exemple d’usage avancé : compteur d’impulsions

Si tu veux compter combien de fois un capteur a été déclenché :

volatile int compteur = 0;

void setup() {
  attachInterrupt(digitalPinToInterrupt(2), incrementer, RISING);
  Serial.begin(9600);
}

void loop() {
  Serial.println(compteur);
  delay(1000);
}

void incrementer() {
  compteur++;
}

Conclusion

Les interruptions sont un outil puissant pour rendre ton Arduino réactif et précis. Bien utilisées, elles permettent de gérer plusieurs événements en parallèle sans rater d'information, même lorsque ton programme principal est occupé.