LOCODUINO

Les interruptions (1)

Le 21 décembre 2014. Par : Jean-Luc

Retourner à l'article

Vous répondez à :

29 Messages

• Les interruptions (1) 27 décembre 2014 17:50, par Vauban38

  Bonsoir,

  Deux incompréhensions de ma part, après lecture de cet article :
   Dans le détail des arguments d’attachInterrupt il est indiqué "numéro est le numéro de la broche d’interruption concernée. Il s’agira de 0 ou 1.." ne s’agit-il pas simplement du numéro d’interruption, au même titre que dans detachInterrupt ?
   Les broches 2 & 3 sont indiquées correspondre à INT0 et INT1, et plus loin il est indiqué que PCINT3 correspond aux broches 0 à 7. Quid alors des 2 & 3 ?

  Désolé pour ces questions peut-être saugrenues, mais j’essaye de comprendre ! ;-)
  En tout cas bravo pour vos articles.

  Répondre

  • Les interruptions (1) 28 décembre 2014 10:32, par Jean-Luc

    Ce ne sont pas des questions saugrenues et les commentaires attachés aux articles sont là pour les poser et améliorer les articles :). Effectivement la façon dont le numéro de broche est présenté n’est pas clair. Je corrige.

    PCINT3 et INT0/INT1 se chevauchent. C’est à dire que les broches 2 et 3 de l’Arduino peuvent être soit utilisées en INT0 et INT1 soient utilisée avec PCINT3. À noter que la bibliothèque PinChangeInt permet de masquer la cuisine du matériel sous-jacent et je m’aperçois donc que j’ai dit une bêtise. Je complète et améliore l’article en ce sens.

    Répondre

    • Les interruptions (1) 28 décembre 2014 12:19, par Vauban38

      Merci pour ces précisions qui répondent totalement à mes interrogations.

      Répondre

• Les interruptions (1) 2 janvier 2015 22:43, par RailyRabbit

  Hello,

  La déclaration suivante à l’entrée des fonctions Void me laisse perplexe :

  static unsigned long dateDernierChangement = 0 ;

  La valeur est systématiquement à 0 dès qu’on entre dans la fonction ? Je comprends l’utilisation de millis(), mais pas l’organisation du code :(

  Répondre

  • Les interruptions (1) 2 janvier 2015 23:31, par Jean-Luc

    Bonsoir,

    static utilisé pour préfixer une déclaration de variable à l’intérieur d’une fonction signifie que cette variable n’est connue que de la fonction mais se comporte comme une variable globale. C’est à dire que son initialisation n’est faite qu’une seule fois avant le commencement de l’exécution du programme et que la variable retient sa valeur d’une exécution à l’autre de la fonction.

    Répondre

    • Les interruptions (1) 5 janvier 2015 17:20, par RailyRabbit

      Merci pour cette précision ! ;)

      Répondre

    • Les interruptions (1) 13 janvier 2015 19:26, par Gwadavel

      Normalement ce n’est pas "volatile" qu’on utilise quand une variable peut être changé par une interruption ?

      Répondre

      • Les interruptions (1) 13 janvier 2015 20:44, par Jean-Luc

        Bonsoir,

        Effectivement, volatile est généralement utilisé pour les variables partagées entre une interruption et le programme principal. volatile force le compilateur à aller chercher la variable en mémoire à chaque fois qu’elle est utilisée. De cette manière la variable en mémoire est toujours à jour. En l’absence de volatile, le compilateur pourrait produire un code où une variable partagée est copiée dans un registre et la variable en mémoire n’est jamais mise à jour dans une partie du programme. Et, par exemple, des modifications faites dans le programme principal ne serait pas vues par la routine d’interruption.

        Mais, une variable globale non volatile est toujours lue de la mémoire au début d’une fonction et écrite dans la mémoire à la fin. Donc, dans le programme présenté, les ISR mettent à jour leur variable comptageILSx à la fin de la routine et loop() relit systématiquement les variables comptageILSx au début. volatile n’est donc pas nécessaire ici. Si par contre, dans loop(), on encadrait les affichages dans un while(1){}, l’exécution du programme principal resterait entièrement contenu dans loop() et, très probablement, les variables comptageILSx ne seraient pas relues et le LCD n’afficherait pas les bonnes valeurs.

        volatile fera l’objet d’un prochain article.

        Répondre

• Les interruptions (1) 13 janvier 2015 20:54, par Gwadavel

  Merci pour votre réponse

  Répondre

• Les interruptions (1) 6 mars 2016 21:06, par ekiki

  Super.
  C’est un vieil article mais j’ai bien aimé la présentation et les explications.
  Sympa également de laisser les commentaires et les réponses associées.
  Je me penche sur les interruptions, et, pour une fois, j’ai l’impression d’avoir compris.
  Y’a plus qu’a….

  Répondre

• Les interruptions (1) question ILS anémometre 25 mars 2016 15:51, par Clement

  Bonjour, ce sujet date un peu mais j’espère que vous trouverez mon message.
  Je suis en terminale sti2d et j’étudie un anémomètre (je précise que je débute en programmation).
  Je suis actuellement bloqué pour une histoire de timer.
  Lorsque l’anemometre va tourner il va activer l’ILS, le programme va alors entrer dans la boucle compteur.
  Cependant je cherche un moyen de compter le nombre de fois que l’ILS va s’activer pendant une seconde. Pour cela il me faut enclencher un timer lorsque le programme entre dans la boucle compteur et incrémenter jusqu’a ce que le timer atteigne une seconde. Le problème étant que a chaque interruption la boucle recommence donc le timer se reset a chaque fois. Merci d’avance.
  voici la datasheet   de l’anémomètre ainsi que le code que j’ai réaliser pour le moment. J’ai besoin d’aide merci.
  datasheet   : https://www.sparkfun.com/datasheets...

  int anemometre = 3;           //pin pour compter le nombre d'impulsion 
  int compt = 0;                    //fonction pour compter le nombre d'impulsio
  float vitesse = 0;                //vitesse du vent
  float valeur = 2.4;              //2,4 km/h par activation de l'ILS par seconde
   
  void setup()
  {
    Serial.begin(9600);
    attachInterrupt(digitalPinToInterrupt(3),compteur,RISING); //fonction pour compter le nombre d'interruption
  }
   
   
  void loop()
  {
    Serial.println("ca tourne pas");  
  }  
   
  void compteur()
  {
   static unsigned long temps_dernier = 0;
   unsigned long temps = millis();
   
      while ((temps - temps_dernier) <= 1000);
      {
      compt++;
      temps_dernier = temps;
      }    
    affichage();
  }
   
  void affichage()
  {
    vitesse = valeur*compt; //calcul de la vitesse du vent
    Serial.print("vitesse du vent :");
    Serial.println(vitesse);
    compt = 0;
  }

  Répondre

• Les interruptions (1) 25 mars 2016 16:26, par Jean-Luc

  Bonjour,

  Ah oui, c’est la période des projets sti2d :-)

  votre problème est assez éloigné du modélisme ferroviaire mais je vais quand même vous répondre. Votre programme ne va pas fonctionner car :
   dans votre routine d’interruption vous faites une attente active sur le passage du temps via millis(). Or la variable que vous récupérez via millis() est incrémentée via une autre routine d’interruption, celle du TIMER0. Elle ne peut pas s’exécuter car on ne peut pas interrompre une routine d’interruption. Donc le temps ne passe plus et votre while boucle à l’infini.
   votre affichage à l’intérieur de la routine d’interruption peut également engendrer des problèmes. En effet, les caractères vont dans un tampon et, si le tampon est plein, il est vidé via la routine d’interruption associée à l’interruption registre d’envoi vide. Routine qui ne s’exécute pas pour le même raison que précédemment.

  Bref, c’est tout faux.

  Il ne faut pas faire d’attente active, il faut lire l’instant à laquelle se produit l’interruption via millis(), la mémoriser dans une variable. La prochaine fois que la routine est exécutée, on lit l’instant de nouveau, on calcule l’intervalle de temps entre interruption et on le stocke. Tout le reste du traitement doit être fait dans loop : calcul de la vitesse instantanée en prenant l’inverse de l’intervalle de temps, filtrage éventuel, etc. Si vous avez d’autre question contactez moi à l’aide du formulaire « Jean-Luc »

  Répondre

  • Les interruptions (1) re : question ILS anémometre 30 mars 2016 21:06, par Clement

    Merci pour votre réponse cela m’a beaucoup apris, j’ai retravaillé mon programme avec l’aide de votre commentaire et j’aimerais savoir si celui ci est plus juste

    int anemometre = 3; // broche de l'anémometre   
    float vitesse = 0;  //vitesse du vent
    float valeur = 2.4; //2,4 km/h par interruption
    unsigned long temps;
    unsigned long temps_maintenant;
    int interrupt=0;  //fonction pour compter le nombre d'impulsion
     
     
     
    void setup()
    {
      pinMode(anemometre, INPUT);
      Serial.begin(9600);
      temps=millis();
      attachInterrupt(digitalPinToInterrupt(3),compteur,RISING); //fonction pour compter le nombre d'interruption
    }
     
     
    void loop()
    { 
        if (interrupt != 0)
          {
            temps_maintenant = millis();
            while (temps - temps_maintenant <= 1000)
            {
              vitesse = valeur*interrupt; //calcul de la vitesse du vent
              Serial.print("vitesse du vent :");
              Serial.println(vitesse);         
            }
            interrupt = 0;
          }
       Serial.print("Pas de vent");    
    }  
     
     
    void compteur()
    {
     
      interrupt++; // on incrémente interrupt
     
    }

    Répondre

  • Les interruptions (1) 31 mars 2016 10:05, par Jean-Luc

    Contactez moi via http://modelleisenbahn.triskell.org/spip.php?auteur1
    Cordialement

    Répondre

• Les interruptions (1) 21 mai 2016 10:42, par Cyril

  Une question concernant les fonctions ISR, pourquoi n’est il pas possible d’envoyer une variable à cette fonction ? Est ce protocolaire ou pour optimiser le temps d’exécution ? Cela éviterait d’écrire plusieurs fois la même fonction. D’avance merci :)

  Répondre

  • Les interruptions (1) 21 mai 2016 11:03, par Jean-Luc

    Bonjour,

    je suppose que vous parlez d’un argument à la fonction ? Quel argument ? Qui le passerait ?

    Répondre

    • Les interruptions (1) 21 mai 2016 11:10, par Cyril

      Oui, un identifiant qui serai passé en argument lors de l’initialisation mais je viens de lire sur le site arduino qu’effectivement on ne peut passer d’argument à ce type de fonction. Ce qui est dommage car cela oblige a réécrire la même fonction X fois.
      Si on se base sur votre exemple avec les ILS on pourrait ne l’écrire qu’une seule fois passer en argument le numéro d’ILS qui correspondrait à une case du tableau de comptage.

      Répondre

      • Les interruptions (1) 21 mai 2016 19:40, par Dominique

        Si vous voulez autant d’interruptions que d’ILS, il faut donc leur affecter une pin chacune et chaque interruption est relative à un seul ILS.

        Il me semble que c’est déjà un argument : chaque interruption connaît son ILS.

        Il suffit d’activer une variable globale (true dans un booléen par exemple) dans chaque routine d’interruption (c’est un tout petit code qui peut être répété dans chaque interruption), et laisser la LOOP traiter ces événements dans une routine unique.

        En règle générale, on en fait le moins possible dans les interruptions pour ne pas en perdre !

        Répondre

• Les interruptions (1) 25 mai 2016 18:40, par Maxime

  Bonjour,
  Voila je suis sur un projet de train modélisme. Je voudrais calculer la vitesse de mon train j’ai un capteur à effet hall dessous un wagon et un aimant qui est sur l’essieu.
  Je calcule le temps entre deux interruptions pour ensuite calculer la vitesse avec le temps.

  voici mon code :

  int pin = 4;
  const byte interruptPin = 2;
  volatile byte compteur;
  float Temps;
  unsigned long timeold;
  float DP = 3.5;
   
  void setup()
  {
    pinMode(interruptPin, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(interruptPin), compte, LOW);
    pinMode(pin, INPUT);
    Serial.begin(9600);
    timeold = 0;
  }
   
  void loop()
  {
    Temps = (millis() - timeold)*compteur;
    Serial.println(Temps);
  }
   
  void compte ( ) {
   compteur = compteur+1; 
  }

  Répondre

• Les interruptions (1) 25 mai 2016 19:30, par Jean-Luc

  Bonjour,

  compteur compte les tours de roue, c’est donc une distance qui correspond à PI x D, D étant le diamètre de la roue.

  Par conséquent millis() x compteur (j’oublie timeold qui vaut tout le temps 0) est un temps multiplié par une distance. Ce n’est donc pas un temps et ce n’est pas non plus une vitesse. Ça ne correspond à aucune grandeur physique en fait.

  Si vous voulez calculer la vitesse, il faut calculer quelque chose qui ait la dimension d’une vitesse : une distance divisée par un temps.

  Ensuite il faut multiplier par les constantes qui vont bien pour avoir une vitesse dans une unité qui va bien pour le train miniature. Si vous voulez le résultat en millimètres par seconde, il faut, puisqu’on divise par des millisecondes, multiplier compteur par 1000 et multiplier par PI x D (D étant exprimé en millimètres).

  Répondre

• Les interruptions (1) 25 mai 2016 21:19, par Maxime

  D’accord mais du coup que doit-je mettre dans mon interruptions pour récupérer le temps ?

  Répondre

  • Les interruptions (1) 25 mai 2016 23:05, par Dominique

    Vous ne changez rien dans l’interruption qui continue à incrémenter un compteur à chaque tour de roue.
    C’est le calcul dans la loop qu’il faut changer.

    Par exemple, vous pouvez compter le nombre de tour de roues NB par seconde, c’est à dire la distance PI x D x NB par seconde et ce sera donc la vitesse que vous cherchez à obtenir !

    int pin = 4;
    const byte interruptPin = 2;
    volatile int compteur;
    int compteurold;
    float vitesse;
    unsigned long time, timeold;
    float DP = 3.5;
     
    void setup()
    {
      pinMode(interruptPin, INPUT_PULLUP);
      attachInterrupt(digitalPinToInterrupt(interruptPin), compte, LOW);
      pinMode(pin, INPUT);
      Serial.begin(9600);
      timeold = millis();
      compteurold = 0;
    }
     
    void loop()
    {
      if ( (millis() - timeold) > 1000) { // une seconde s'est écoulée 
        timeold = millis();
        vitesse = (compteur - compteurold)*PI*DP;
        compteurold = compteur;
        Serial.println(vitesse);
      }
    }
     
    void compte ( ) {
     compteur = compteur+1; 
    }

    Répondre

• Les interruptions (1) 26 décembre 2016 08:55

  Bonjour,

  J’ai un problème à la compilation de programme utilisant des interruptions. Le compilateur m’indique qu’a l’intérieur de attachInterrupt(numéro, ISR, mode) ;
  l’ISR n’est pas déclaré. Auriez vous une solution ?

  Merci par avance.

  Répondre

  • Les interruptions (1) 26 décembre 2016 09:20, par Jean-Luc

    Bonjour,

    Avec aussi peu d’informations, non. Quel Arduino, quel ISR, quel message d’erreur exactement ?

    Répondre

• Les interruptions (1) 2 mars 22:50, par jf

  Bonjour,

  Une incompréhension qui vous paraîtra peut être bête…..
  dans cette ligne de code :

  const unsigned long dureeAntiRebond = 1 ;

  le 1 signifie t-il 1 ms ? si oui cette valeur devrait être égal à 0.001

  merci pour votre réponse

  Répondre

  • Les interruptions (1) 3 mars 08:04, par Jean-Luc

    Bonjour,

    oui, il s’agit d’une milliseconde. Et non ça ne devrait pas être 0,001 car la fonction millis() retourne la date comptée en millisecondes.

    Répondre

    • Les interruptions (1) 3 mars 12:07, par jf

      Bjr,
       Merci pour votre réponse, je viens de comprendre que (date - dateDernierChangement)donnait un chiffre proche de 1.

       Une question qui n’est pas en rapport avec les locos……
      Sur un anémomètre comportant un ILS et quatre aimants (quatre déclenchement par tour)et tournant à une vitesse élevée n’y a t-il pas un risque que le rebond du premier déclenchement de l’ILS ne chevauche le deuxième déclenchement et du coup n’altère ou fausse la précision de cette vitesse ?
      1ms est elle une durée acceptable dans la plupart des cas ou doit-on tâtonner pour en trouver une acceptable ?
      cordialement merci

      Répondre

      • Les interruptions (1) 3 mars 13:31, par Jean-Luc

        Si l’anémomètre tourne à plus de 250 tours/s, oui il y aura un problème. Ça fait quand même 15000 tours/minute. Ça tourne si vite un anémomètre ? Par ailleurs pourquoi mettre 4 aimants ? un seul ne suffit pas ? Enfin à une telle vitesse, il vaut mieux mettre un capteur à effet Hall qui ne nécessite pas d’antirebond

        Répondre

        • Les interruptions (1) 4 mars 20:01, par fj

           En fait il n’y a que deux aimants mais qui déclenchent 4 fois l’ILS par tour.
          Après calculs je trouve une période de déclenchement de l’ILS de 5ms pour une vitesse du vent de 40km/h (distance du centre d’une tasse à l’axe de rotation de 40mm)
          donc 1ms cela devrait suffire pour gommer le rebond mais j’en ai toujours….même en remplaçant mon anémomètre par un simple interrupteur.

          voici mon programme au cas ou

          #include <TimerOne.h>

          #define duree_mesure 10 //l’étiquette duree_mesure vaut 10
          unsigned int nombre_imp ;
          unsigned int seconde ;
          const unsigned long dureeAntiRebond = 1 ; //(1 ms)

          void setup()
          

          pinMode(2,INPUT_PULLUP) ; //active la résistance pull-up interne et déclaration du pin 2 comme entrée
          Serial.begin(9600) ;
          Serial.println("C’est parti !") ;
          attachInterrupt(0,compte_imp,FALLING) ;
          Timer1.initialize(1000000) ;
          Timer1.attachInterrupt(fin_comptage) ;
          nombre_imp=0 ;
          seconde=0 ;

          void loop()
          

          void compte_imp()
          
          static unsigned long dateDernierChangement = 0 ;

          unsigned long date = millis() ;
          if ((date - dateDernierChangement) > dureeAntiRebond)
          
          nombre_imp=nombre_imp+1 ; //équivalent à nombre_imp++ ;
          dateDernierChangement = date ;
          

          
          void fin_comptage()
          
          seconde++ ; //équivalent à seconde = seconde+1 ;
          if(seconde>=duree_mesure)
          
          Serial.println(nombre_imp) ;

          nombre_imp=0 ;
          seconde=0 ;
          
          

          Répondre