Exemple avec les capteur PIR

Cette exemple est valable avec une carte Arduino.

Par exemple, on souhaite réagir prioritairement à un capteur PIR quel que soit l'état du programme.
Les capteurs PIR détectent les rayonnements infrarouges émis par un objet.
Puisque tout objet émet un rayonnement infrarouge, le capteur PIR est muni de deux cellules sensibles aux infrarouges qui vont détecter ces rayons infrarouges réfléchit ou émit par l'objet.

Utilisation

Nous allons présenter un code réalisé sans interruption et un autre qui utilise les interruptions.

Code PIR sans interruption

Voici un code d'exemple pour réagir dès qu'une présence est détectée.

#define LED 13    //Broche de la LED
#define OUT 2     //Broche du capteur PIR
    
void setup() 

      
  pinMode(LED, OUTPUT); //LED en sortie
  pinMode(OUT, INPUT);  //Broche du capteur en entrée
  Serial.begin(9600);   //Vitesse de communication à 9600 bauds
//End setup
    
void loop(){
    
  outValue = digitalRead(OUT);          //Lire létat du capteur
        
    if (outValue == HIGH)                 //Détection d'un mouvement
    
        Serial.println("Detection");
    //End else
}//End loop

Maintenant, supposons que la carte exécute un programme qui prend plusieurs secondes. Comment faire ?

On peut utiliser une interruption externe.

Code PIR avec interruption

#define LED 13    //Broche de la LED
    #define OUT 2     //Broche du capteur PIR
       
    void setup() 
      
      Serial.begin(9600);//Vitesse de communication à 9600 bit/s
      
      pinMode(LED, OUTPUT); //LED en sortie
      pinMode(OUT, INPUT);  //Broche du capteur en entrée
      
      attachInterrupt(digitalPinToInterrupt(OUT), presence, RISING);  //Appel de la fonction presence à chaque changement de front du bouton
      Serial.println("Init");
    
    
    void loop() 
      
     delay(5000); //Pause du programme principal
      
    
    
    void presence() 
      
      Serial.println("Presence !");
    

Mise en pratique avec la carte CREPP.io

En dernier exemple, prenons le cas d'un bouton qui doit changer l'état d'une LED à n'importe quel moment du programme :

Branchements

Il ne faut pas oublier de mettre les jumpers sur la carte (D5, D6 et D7)

Les variables volatiles

Avant d'examiner le code, il est essentiel de comprendre l'utilité du mot-clé volatile. Dans notre exemple de contrôle d'une LED, une variable partagée sera modifiée à la fois par le programme principal et par une interruption (ISR).

Sans indication explicite, le compilateur pourrait optimiser l'accès à cette variable en la mettant en cache dans un registre, supposant que sa valeur ne change qu'au sein du flux d'exécution actuel. Or, une ISR peut modifier cette variable de manière imprévisible pour le programme principal. Pour empêcher cette optimisation et garantir que chaque accès lit toujours la valeur actuelle en mémoire, nous utilisons le mot-clé volatile.

Ainsi, le compilateur sera contraint de lire systématiquement la valeur en mémoire à chaque utilisation, assurant la cohérence des données entre le programme principal et l'interruption.

volatile int state = LOW;

Code pour les interruptions

Mise en pratique avec une carte ESP12 hors CREPP.io

Nous souhaitons réagir de manière prioritaire à l'appui d'un bouton poussoir. Cet appui inversera l'état actuel de la LED interne (broche ).

Schéma de l'exemple

• entre la résistance de $10~k\Omega$ et le bouton-poussoir

• sur l'autre coté du bouton-poussoir

• relié à la résistance La broche D2 est utilisée en tant que broche d'interruption.

Code C++ basique

const uint8_t buttonPin = D2;
  const uint8_t ledPin = D4;
  
  volatile bool stateLed = false; //State of LED
  
  //ISR = Interrupt Service Routine
  void IRAM_ATTR blinkLed()
  
    stateLed =! stateLed;         //Swap led state 
    digitalWrite(ledPin, stateLed);  //Update state
    Serial.println("Changing led state");
  
  
  
  void setup() 
  
  
    pinMode(ledPin, OUTPUT);      //Set led on OUTPUT
    attachInterrupt(digitalPinToInterrupt(buttonPin), blinkLed, RISING); //Start interrupt service
  
    Serial.begin(9600);
    
  
  
  
  void loop() 
  
    //Nothing in this loop...
  
  

Code C++ avancé

Dans l'exemple suivant, l'anti-rebond est fait de manière logicielle. ^[1]

Nous allons définir une durée pendant laquelle nous allons ignorer les fronts. Il s'agit de la période d'anti-rebond appelée DEBOUNCE\_TIME dans notre programme.

#define DEBOUNCE_TIME 200

le principe réside dans la lecture de la variable exprimant le temps passée depuis le démarrage de la carte.

La fonction millis() renvoie le temps écoulé en milliseconde depuis le démarrage.

Ainsi, au bout d'une seconde, milli() renvoie la valeur 10000...

A chaque appel de l'ISR, on va regarder si le temps depuis le dernier évènement est supérieur à notre délai. Si c'est le cas, cela veut dire que nous pouvons mettre à jour l'état de la LED.

//Update
  previousTime = currentTime;
  currentTime = millis();
if(currentTime > (previousTime + DEBOUNCE_TIME) )
  
    stateLed =! stateLed;         //Swap led state 
    digitalWrite(ledPin, stateLed);  //Update state
    Serial.println("Changing led state");
  

Le code complet est le suivant :

#define DEBOUNCE_TIME 200      //'Anti-rebond'
const uint8_t buttonPin = D2;
  const uint8_t ledPin = D4;
  
  volatile bool stateLed = false; //State of LED
  
  uint16_t currentTime = 0; //Current time
  uint16_t previousTime = 0;
  
  //ISR = Interrupt Service Routine
  void IRAM_ATTR blinkLed()
  {
    //Update
    previousTime = currentTime;
    currentTime = millis();
  
    if(currentTime > (previousTime + DEBOUNCE_TIME) )
    
      stateLed =! stateLed;         //Swap led state 
      digitalWrite(ledPin, stateLed);  //Update state
      Serial.println("Changing led state");
    
  
  }
  
  
  void setup() 
  
  
    pinMode(ledPin, OUTPUT);      //Set led on OUTPUT
    attachInterrupt(digitalPinToInterrupt(buttonPin), blinkLed, RISING); //Start interrupt service
  
    Serial.begin(9600);
    
  
  
  
  void loop() 
  
    //Nothing in this loop...