28 Mars 2014

Arduino leçon 10 : les interruptions

Nous allons reprendre le montage "feu piétons" pour aborder une nouvelle notion : l'interruption.

Présentation

Ce mode de fonctionnement n'existe pas en informatique de gestion. C'est une particularité très utilisée en info industrielle qui consiste à prendre en compte un évènement extérieur (hardware) à n'importe quel moment du déroulement d'un programme.
Arduino permet de prendre en compte une modification sur 6 entrées.
Ces 6 interruptions (ou quelques-unes seulement) doivent être validée par le programme avant d'être utilisées.
Chacune renvoit à un sous-programme précis.

validation d'une interruption

L'instruction qui permet de faire que le programme prendra l'interruption en compte est
attachInterrupt( numéro , sous-programme, mode);
dans laquelle
- numéro est le numéro de l'interruption
- 0 pour la pin 2
- 1 pour la pin 3
- 2 pour la pin 21
- 3 pour la pin 20
- 4 pour la pin 19
- 5 pour la pin 18
- sous-programme est celui qui est appelé quand l'interruption se produit
- mode est le changement qui déclenche l'interruption. Ce peut être
• LOW = L’entrée est au niveau bas
• RISING = L’entrée passe d’un niveau bas à un niveau haut
• FALLING = L’entrée passe d’un niveau haut à un niveau bas
• CHANGE = L’entrée a changé de niveau. Elle est passé d’un niveau bas vers un niveau haut ou inversement.

Que se passe-t-il lors d'une interruption ?

- le programme est interrompu (ben oui, on a parlé d'interruption)
- l'adresse de l'instruction qui aurait dû suivre est mémorisée
- le sous programme est exécuté
- quand il est fini le programme principal reprend à l'endroit où il s'était interrompu.

les limitations

Pendant l'exécution d'une interruption, le comptage du temps est bloqué. On ne peut pas utiliser delay() ni millis().

Le programme

On va reprendre le montage feu_pieton. On met l'interrupteur sur la broche 19, ce qui nous permet d'utiliser l'interruption numéro 4.
On récupère le programme feu_pieton.ino et on le sauve sous le nom interruption.ino.
On modifie le programme pour utiliser l'interruption :
on enlève la lecture du bouton
on garde les sous-programmes
on ajoute un sous-programme pour gèrer l'interruption
Les modifications sont en rouge.

/* interruption.ino
gestion d'une interruption */

#define V1 2
#define O1 3
#define R1 4
#define V2 7
#define R2 8
#define bouton 19

byte i;
byte phase=0; // numéro de la phase en cours
long finPhase; // heure de fin de la phase en cours
void changePhase(void); // déclaration de fonction
void interruption(void); // déclaration de fonction

void setup() {
for ( i=2 ; i<10 ; i++){
pinMode( i, OUTPUT);
digitalWrite( i, LOW);
}
digitalWrite(V1, HIGH);
digitalWrite(R2, HIGH);
attachInterrupt( 4, interruption, RISING);
}

void loop () {
// on ne cherche plus l'état du bouton
if ( phase > 0 ) {
if ( millis()>= finPhase) {
phase=phase+1 % 6 ; // % est le signe de 'modulo'
changePhase();
}
}
}

void interruption(void) {
phase=1;
changePhase();
}

void changePhase(void) {
switch (phase) {
case 0 :
digitalWrite(R1, LOW);
digitalWrite(V1, HIGH);
break;
case 1 :
digitalWrite(V1, LOW);
digitalWrite(O1, HIGH);
finPhase=millis() + 1000;
break;
case 2 :
digitalWrite(O1, LOW);
digitalWrite(R1, HIGH);
finPhase=millis() + 1000;
break;
case 3 :
digitalWrite(R2, LOW);
digitalWrite(V2, HIGH);
finPhase=millis() + 5000;
break;
case 4 :
cligno();
break;
case 5 :
digitalWrite(R2, HIGH);
finPhase=millis() + 1000;
break;
}
}
void cligno(void) {
for ( i=0 ; i<3 ; i++){
digitalWrite(V2, LOW);
delay(500);
digitalWrite(V2, HIGH);
delay(500);
}
digitalWrite(V2, LOW);
}

intérêt des interruptions

Il faut surtout penser au cas où plusieurs interruptions sont possibles.
La méthode du polling (lire successivement toutes les entrées), prend du temps si on a une autre tâche en cours. Elle peut produire aussi une mauvaise interprétation de la 1ère interruption survenue dans le cas ou 2 interruptions se produisent presque en même temps : le processeur verra la prochaine dont c'est le tour d'être lue même si une autre est survenue avant.

Avec la méthode par interruption "hard" (gérée par les processeur) ce risque d'erreur n'existe plus.

Évidemment, si plusieurs sont possibles, le programme devra invalider les autres par noInterrupts() pendant le traitement d'une d'entre elles.
Après ce traitement, on les autorise à nouveau par interrupts()

Ces fonctions sont expliquées sur cette page.

haut de la page

Page Précédente : les phases Page Suivante : ULA