ISR Vs attach to interrupt

Bonjour, j'ai un projet dans lequel je déclenche une interruption à chaque front descendant pour un compteur de vitesse avec aimants et capteur à effet Hall.

Et je voudrais aussi gérer un timer pour effectuer le rafraîchissement des diverses informations collectées.

Or, il y a un petit souci avec les interruptions;

je déclare :

attachInterrupt(digitalPinToInterrupt(pinInterrupt), function, FALLING);

pour associer la pin à la routine d'interruption mais ceci fait quoi exactement ?

Il fait l'association mais il active aussi implicitement toutes les interruptions pour pouvoir activer, au moins, la sienne.

Je préfère de loin utiliser cli() et sei() pour gérer les interruptions quand je veux

Des fois on peut avoir besoin de désactiver toutes les interruptions

Comment peut-on faire pour associer une pin à une interruption timer et ne la mettre en service que lorsque la fonction sei() apparaît ?

#include "define.h"

//storage variables
boolean toggle1 = 0;

void setup(){
  
  //set pins as outputs
  pinMode(LED, OUTPUT);

//  ????????????????????
    attachInterrupt(digitalPinToInterrupt(pinInterrupt), function, FALLING);
    pinMode(pinInterrupt, INPUT);

cli();//stop interrupts

//set timer1 interrupt at 1Hz
  TCCR1A = 0;// set entire TCCR1A register to 0
  TCCR1B = 0;// same for TCCR1B
  TCNT1  = 0;//initialize counter value to 0
  // set compare match register for 1hz increments
  //OCR1A = 15624;// = (16*10^6) / (1*1024) - 1 (must be <65536)
  // maximum de registre compare, soit 0.28 Hz soit 4.19 secondes
  OCR1A = 65535;// = (16*10^6) / (1*1024) - 1 (must be <65536)
  
  // turn on CTC mode
  TCCR1B |= (1 << WGM12);
  // Set CS12 and CS10 bits for 1024 prescaler
  TCCR1B |= (1 << CS12) | (1 << CS10);  
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);

sei();//allow interrupts

}//end setup

//////////////////////////////////////////////////////////////////
//                                                              //
//  routines d'interruptions                                    //
//                                                              //
//////////////////////////////////////////////////////////////////

ISR(TIMER1_COMPA_vect){//timer1 interrupt 1Hz toggles pin 13 (LED)
//generates pulse wave of frequency 1Hz/2 = 0.5Hz (takes two cycles for full wave- toggle high then toggle low)
  if (toggle1){
    digitalWrite(LED,HIGH);
    toggle1 = 0;
  }
  else{
    digitalWrite(LED,LOW);
    toggle1 = 1;
  }
}

// fonction appelée à chaque front descendant sur la pin 2
void function() {
  compteur += 1;
  tempfunc = millis();
}
  



void loop(){
  //do other things here
}

J'aimerais en savoir plus. Rafraîchir les données qui vont être affichées par quel moyen?

Qu'est ce qui te bloque?

Si tu utilises une carte équipée de micro Atmel le mieux est de lire le chapitre de la datasheet concernant les interruptions et la macro ISR.

La fonction Wiring/arduino attachinterupt() n'est qu'un habillage, pas forcément complet, de cette macro.

Dans la datasheet tu pourra aussi lire qu'il existe d'autres interruptions, les PCINT, qui concernent beaucoup plus de pins que les interruptions directes.
Pour l'atmega328 toutes les pins sont concernées y compris celles faussement appelées analogiques par Arduino, pour le micro de la carte Mega seuls certains ports sont concernés mais le nombre de pins disponibles est nettement plus grand..
Tu peux éventuellement consulter mes notes de travail sur le 328p que j'avais mis au propre pour les publier : Interruptions ATMega 328p - Tutoriels et cours - Arduino Forum

PS : Quand on entre dans une interruption on désactive les interruptions, on ne les réactive qu'à la sortie de l'interruption.
J'ai lu que ce n'est pas une obligation mais gérer une interruption dans une interruption demande une réelle maîtrise qui n'est pas à la portée de tout le monde.

Et si vous lisez l’anglais Nick a un bon article sur le sujet

Ok, merci pour le pdf et le lien de gammon que j'avais oublié; il m'avait déjà aider à l'époque pour le bootloader...

Donc je peux écrire maintenant:

//interruption INT0 sur front descendant
//donc sur pin D2
pinMode(2, INPUT);  // pin correspondante en entrée
digitalWrite(2, HIGH);  // pull-up sur pin activé

EIFR = bit(INT0); // efface le flag INT0
EICRA = 0b00000010; // interruption sur front descendant
EIMSK = 0b00000001; // activation de l'interruption INT0

à la place de :

//    attachInterrupt(digitalPinToInterrupt(pinInterrupt), function, FALLING);
//    pinMode(pinInterrupt, INPUT);

et alors l'activer ou non individuellement.

Par contre c'est au niveau de la syntaxe d'écriture dans les registres que j'ai un peu de mal:
Moi je préfère faire à l'ancienne style:

EIMSK = 0b00000001; // activation de l'interruption INT0

plutôt que:

  // Set CS12 and CS10 bits for 1024 prescaler
  TCCR1B |= (1 << CS12) | (1 << CS10);

qui se devine mais qui est un peu difficile à comprendre pour moi qui était plus habitué à faire ça en assembleur avec les PICs

Y aurait-il un autre pdf sur le sujet parce que j'ai déjà été et c'est un peu juste...