Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Architecture des ordinateurs Projets avec microcontrôleurs

Interruption avec Arduino : une excellente méthode pour avancer sans délai entre l'entrée et la sortie

Avec cet article, je voudrais mettre en lumière un potentiel caché d'Arduino qui permet de définir des actions d'interruption en lisant le signal d'entrée. Avec cette boucle d'action et…

https://www.electronics-engineering.com/fr/interruption-avec-arduino-methode-sans-delai-entre-entree-et-sortie/

Cette page vous a-t-elle été utile ? Notez-la :
moyenne 5,0 sur 1 vote

Avec cet article, je voudrais mettre en lumière un potentiel caché d’Arduino qui permet de définir des actions d’interruption en lisant le signal d’entrée. Avec cette boucle d’action, on évite les délais et les « if » dans le code

INTERRUPTION ET COMMUNICATION SÉRIE

Avec ce programme, Arduino génère une impulsion de 20 µs depuis la fonction loop. Cette impulsion entre sur une autre entrée d’Arduino. Une interruption de cette seconde entrée génère une commande série et une nouvelle sortie est produite. De la liaison série on obtient un 1 pour chaque impulsion, et la nouvelle sortie représente une onde carrée dont les fronts sont les instants des impulsions.

// A simple sketch to read GPS data and parse the $GPRMC string 
// see http://www.ladyada.net/make/gpsshield for more info

#include <NewSoftSerial.h>
NewSoftSerial mySerial =  NewSoftSerial(2, 3);
#define GPSRATE 4800
//#define GPSRATE 38400
int pbIn = 0;                  // Interrupt 0 is on DIGITAL PIN 2!
int ledOut = 13;                // The output LED pin
volatile int state = LOW;      // The input state toggle
int ledPin = 8;

void setup()  { 

   pinMode(ledPin, OUTPUT);      // sets the digital pin as output
   // Set up the digital pin 2 to an Interrupt and Pin 4 to an Output
  pinMode(ledOut, OUTPUT);

  //Attach the interrupt to the input pin and monitor for ANY Change
  attachInterrupt(pbIn, stateChange, RISING);
  Serial.begin(GPSRATE);
  mySerial.begin(GPSRATE);
} 
 
 
void loop()  { 
  
  digitalWrite(ledPin, HIGH);   // sets the LED on
  delayMicroseconds(17);        // waits for 17ms
  digitalWrite(ledPin, LOW);    // sets the LED off
  delay(1000);                  // wait for 1s with tune
}

void stateChange() {
  Serial.print("1");
  state = !state;
  digitalWrite(ledOut, state);
}

Introduction aux interruptions

Pourquoi aurais-je besoin d’une interruption ? Les robots passent beaucoup de temps à attendre que des choses se produisent. Exemple courant : votre robot veut avancer tout droit jusqu’à ce qu’un capteur infrarouge indique qu’un objet est trop près. Cela semble assez simple : Code :

driveForward();
while(sensor_value == DIGITAL_HIGH){
    // maybe do some other stuff, like follow a wall.
};
stop();

Ce code fait du « polling » (scrutation) du capteur. Il vérifie la valeur encore et encore, manuellement (par logiciel). Cela fonctionne bien sûr, mais que se passe-t-il si vos « autres tâches » deviennent un traitement vraiment long : vous pourriez dépasser la cible et heurter le mur. Que se passe-t-il si l’événement qu’on essaie de détecter est très bref : vous pourriez le manquer. Dans ces cas, on veut utiliser une interruption. Exemples courants où l’on utilise les interruptions :

  • Compter les impulsions d’un codeur (elles sont très brèves et arrivent très souvent)
  • Capter une impulsion brève (comme l’impulsion de 10 ms émise par un capteur UVTron)
  • Utiliser des interrupteurs ou des capteurs infrarouges numériques comme pare-chocs (avec un arrêt immédiat voulu)


Qu’est-ce qu’une interruption ?
Ce qui est vraiment génial avec les microcontrôleurs, c’est qu’ils ont un matériel sophistiqué qui sait faire des choses comme la PWM, la conversion analogique-numérique, et les interruptions. Une interruption est un petit morceau de matériel qui attend de détecter un événement déclencheur, par exemple une broche donnée qui passe de l’état bas à l’état haut. Quand cet événement se produit :

  1. l’interruption se déclenche
  2. le microcontrôleur arrête d’exécuter son programme courant
  3. le microcontrôleur commence à exécuter une routine de service d’interruption, ou ISR
  4. quand l’ISR est terminée, on revient au programme d’origine

Une interruption matérielle ressemble donc un peu à ce qui se passe quand le Président interrompt votre soirée télé pour vous annoncer que l’économie s’est effondrée. L’événement déclencheur est l’effondrement de l’économie, et dès qu’il se produit le matériel (le Président) exécute une ISR (son discours à la nation).

Dans votre ISR, vous auriez du code qui fait un certain traitement pour gérer l’événement. Par exemple, votre ISR pourrait :

  • Incrémenter la valeur d’un compteur, si vous comptiez les impulsions d’un codeur
  • Lever un drapeau « incendie trouvé » si vous surveilliez un UVTron
  • Arrêter le robot si vous utilisiez des pare-chocs à interruption

La plupart des microcontrôleurs prennent en charge une grande variété de déclencheurs d’interruption :

  • Une broche donnée qui passe de l’état bas à l’état haut
  • Une broche donnée qui passe de l’état haut à l’état bas
  • Tout changement sur une broche donnée

En général, les microcontrôleurs n’ont que quelques interruptions, sur des broches précises. Nous verrons plus bas, dans la section « Attendez, je n’ai plus d’interruptions », une légère variante. Autre point intéressant, dont on ne parlera pas beaucoup ici : la PWM et les timers/compteurs matériels reposent entièrement sur un matériel semblable aux interruptions.

Le pare-chocs piloté par interruption

Mettons maintenant en œuvre un exemple avec Arduino. L’Arduino est basé sur un AVR ATMEGA168. Cette puce a 2 interruptions matérielles (nommées 0 et 1). Les broches utilisables comme déclencheurs d’interruption correspondent respectivement aux broches numériques 2 et 3. Arduino rend l’usage des interruptions assez facile, avec la fonction AttachInterrupt(interrupt, ISR, trigger) :

  • interrupt est l’interruption matérielle 0 (numérique 2) ou 1 (numérique 3).
  • ISR est la fonction à utiliser comme ISR
  • trigger vaut RISING, FALLING ou CHANGE, pour indiquer sur quels événements déclencher

Le code ci-dessous utilisera plusieurs pseudo-fonctions que vous devrez implémenter pour votre robot :

  • DriveForward() – fait avancer le robot à une vitesse régulière
  • DriveBackward() – fait reculer le robot à une vitesse régulière
  • Stop() – arrête le robot
  • TurnLeft() – fait un petit virage à gauche, de 45 degrés environ

Pour notre exemple, nous supposons que vous avez un interrupteur de choc. Il doit être relié entre la masse et la broche d’entrée numérique (nous utiliserons une résistance de rappel à l’alimentation pour le maintenir à 5 V quand il n’est pas enfoncé).

Il se passe ici plusieurs choses. D’abord, on commence à rouler en avant. Nous avons un entier utilisé comme drapeau, qui vaut 0 tant qu’on n’a pas heurté d’objet, et 1 quand on a heurté quelque chose. Une interruption se produit quand on heurte quelque chose : elle arrête le robot pour éviter tout dommage, et lève aussi notre drapeau. Ensuite, notre boucle principale se chargera de faire reculer le robot quand elle en aura l’occasion. Il y a plusieurs raisons d’écrire notre code ainsi. Premièrement, delay() repose sur les interruptions. Deuxièmement, on ne veut jamais que des interruptions durent très longtemps, car elles empêchent en général d’autres interruptions de se produire, ce qui peut être dévastateur quand on a quelque chose comme une horloge système qui repose sur les interruptions (comme c’est le cas d’Arduino).
Code :

// Interrupt-Driver Bumper Example
// A bumper switch on the front of the robot should be tied to digital pin 2 and ground

#include 

volatile int bumper;          // have we hit something

void setup(){
    pinMode(2, INPUT);      // Make digital 2 an input
    digitalWrite(2, HIGH);  // Enable pull up resistor    

    // attach our interrupt pin to it's ISR
    attachInterrupt(0, bumperISR, FALLING);
   
    // we need to call this to enable interrupts
    interrupts();

    // start moving
    bumper = 0;
    DriveForward();
}

// The interrupt hardware calls this when we hit our left bumper
void bumperISR(){
    Stop();
    bumper = 1;
}

void loop(){
    // if bumper triggered
    if(bumper > 0){
       DriveBackward();    // set motors to reverse
       delay(1000);           // back up for 1 second
       TurnRight();            // turn right (away from obstacle)
       bumper = 0;
       DriveForward();      // drive off again...
    }
    // we could do lots of other stuff here.
}


Attendez, je n’ai plus d’interruptions !
La bibliothèque Arduino ne prend en charge que 2 interruptions de broche, parce qu’elle n’utilise que les 2 interruptions matérielles dédiées. Cependant, l’ATMEGA168 (la puce sur laquelle Arduino est construit) peut en réalité générer des interruptions sur chaque port, c’est seulement un peu plus compliqué. On les appelle les interruptions de changement de broche (Pin Change Interrupts). Chaque port de l’AVR a son propre vecteur d’interruption, et vous pouvez activer les interruptions pour autant de broches que vous voulez. Il y a toutefois quelques limites. D’abord, une interruption est générée pour tout changement de broche, on ne peut pas limiter le matériel aux fronts montants ou descendants seulement, même si on pourrait l’implémenter dans votre ISR. Ensuite, comme toutes les broches d’un port partagent un vecteur d’interruption, si vous utilisez plus d’une broche dans un port, vous devrez vérifier à la main quelle broche a généré l’interruption. Notez que l’entrée dans l’ISR prend plusieurs cycles d’horloge, donc votre ISR ne s’exécutera pas instantanément, et il peut donc être difficile de « vérifier » quelle broche a généré l’interruption. Enfin, comme il n’existe pas de bibliothèque pour cela, il faut écrire un peu plus de code.

Notez qu’Arduino a pour ses broches des noms arbitraires, sans rapport avec les noms de l’AVR : il faudra utiliser la fiche technique de l’ATMEGA168, plus le schéma du brochage d’Arduino, pour s’y retrouver dans les valeurs des registres. C’est assurément un sujet avancé, mais c’est un excellent moyen d’apprendre quelques détails de plus de l’architecture AVR.

Code :

// Quick example of using pin change interrupts
// This shows how to use Digital Pin 4 (PCINT18/PD2) as an interrupt

#include 

// we need to remember that the Arduino environment uses different pin numbers
// than the ATMEGA168 itself. 

void setup(){
    // Make digital 4 (PCINT18/PD2) an input
    pinMode(4, INPUT);
    
    // this is ATMEGA168 specific, see page 70 of datasheet

    // Pin change interrupt control register - enables interrupt vectors
    // Bit 2 = enable PC vector 2 (PCINT23..16)
    // Bit 1 = enable PC vector 1 (PCINT14..8)
    // Bit 0 = enable PC vector 0 (PCINT7..0)
    PCICR |= (1 << PCIE2);
    
    // Pin change mask registers decide which pins are enabled as triggers
    PCMSK2 |= (1 << PCINT18);

    // enable interrupts
    interrupts();
}

void loop(){
    // do nothing...
}

// we have to write our own interrupt vector handler..
ISR(PCINT2_vect){
    // this code will be called anytime that PCINT18 switches 
    //    (hi to lo, or lo to hi)
}

Quelques avertissements pour les utilisateurs d’Arduino
N’utilisez pas les fonctions delay() ou millis() à l’intérieur d’une ISR sur Arduino. La raison est qu’elles dépendent de l’horloge système, qui est elle-même générée par une interruption. Sur l’architecture AVR, quand une interruption commence à traiter son ISR, toutes les autres interruptions sont désactivées temporairement. Pour cette même raison, il faut garder votre ISR aussi courte que possible (pour ne pas perturber l’horloge système elle-même).

Notes finales
Voilà qui couvre les bases des interruptions, avec quelques exemples utilisant Arduino. Jetez un œil à mon tutoriel sur la boucle de rétroaction fermée pour plus d’informations sur l’utilisation des codeurs.

S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x