C'est une fonction qui est définis sur une broche. Lorsque la broche change d'état (paramètrable dans le code), le code en cour est stoppé et le sous programme mis en argument vas être démarré.

Utilité: Je devais faire un chrono (pour la course en cours, si des gens connaissent).

Seulement, il fallait ce dire: la voiture peut partir à tout moment.

Alors au début j'avais dans l'idée de mettre une condition dans le bloc while(), mais très mauvaise idée! Surtout que la course est au ms près!

Alors j'ai découvert les interruptions .

Mise en place:

La fonction de arduino est: attachInterrupt( pin, ISR, mode);

pin -> entre 0 et 5, elle correspond à des broches définis suivant le type de carte:

ISR -> C'est le sous programme à executé, il dois être sans argument.

Mode -> Mode de détection: LOW, CHANGE, RISING, FALLING,  HIGH.

Exemple de code:

Mon code de chronométre "normal":

#include <Wire.h>
#include <Adafruit_RGBLCDShield.h>

Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();

volatile int time_start = 0; 
volatile int time_stop = 0;
volatile int time_final = 0;
volatile boolean isrunning = false;
volatile boolean isended = false;
boolean display_wait = false;
boolean display_running = false;
boolean display_ended = false;

void setup() {
  lcd.begin(16, 2);
  attachInterrupt(0, count_start, RISING);
  attachInterrupt(1, count_stop, RISING);
  lcd.print("En attente...");
}

void loop() {
  if (isrunning == true){
    if (display_running == false){
      display_wait = false;
      display_ended = false;
      display_running = true;
      lcd.clear();
      lcd.print("Comptage...");
    }
  }else if (isended == true){
   if (display_ended == false){
      display_wait = false;
      display_running = false;
      display_ended = true;
      lcd.clear();
      lcd.print("Temps : " + time_final);
      lcd.print(" ms");
   } 
  }else{
    if (display_wait == true){
      display_running = false;
      display_ended = false;
      display_wait = true;
      lcd.clear();
      lcd.print("En attente...");
    }
  }
}

void count_start() {
  if (isrunning == false) {
  display_running = false;
  display_ended = false;
  display_wait = false;
  time_start = millis();
  isended = false;
  isrunning = true;
  }
}

void count_stop(){
  if (isrunning == true){
    time_stop = millis();
    time_final = time_stop - time_start;
    isended = true;
    isrunning = false;
  }
}

Mon code de chronométre "POO"(plus légé et plus rapide):

#include <Wire.h>
#include <Adafruit_RGBLCDShield.h>

enum Status{
 isNull,
 isWaiting,
 isRunning,
 isEnded
};

struct Time {
  int Start;
  int Stop;
  int Final = Stop - Start;
};

Status chrono_status;
Status display_status;
volatile Time chrono_time;
Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();

void setup(){
  lcd.begin(16, 2);
  attachInterrupt(0, chrono_start, RISING);
  attachInterrupt(1, chrono_stop, RISING);
  display_status = isNull;
  chrono_status = isWaiting;
}

void loop(){
  switch (chrono_status) {
    case isWaiting:
      if (display_status != isWaiting){
        lcd.clear();
        lcd.print("En attente...");
        display_status = isWaiting;
      }
      break;
    case isRunning:
      if (display_status != isRunning){
        lcd.clear();
        lcd.print("Comptage...");
        display_status = isRunning;
      }
      break;
    case isEnded:
      if (display_status != isEnded){
        lcd.clear();
        lcd.print("Temps: ");
        lcd.print(chrono_time.Final);
        lcd.print(" ms");
        display_status = isEnded;
      }
      break;
  }
}

void chrono_start() {
  if (chrono_status != isRunning){
    chrono_time.Start = millis();
    chrono_status = isRunning;
  }
}

void chrono_stop() {
  if (chrono_status == isRunning){
    chrono_time.Stop = millis();
    chrono_status = isEnded;
  }
}

Voila, j'espère que ce petit tuto vous a plus!

Pour plus d'informations: http://www.arduino.cc/en/Reference/AttachInterrupt