LOCODUINO

Les interruptions (1)

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

Retourner à l'article

Vous répondez à :

46 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) 8 mars 21:28, par Mat13

        super article ! merci

        pour ne pas se mélanger les pinceaux entre numéro d’interruption et numéro de pin, la bonne pratique est d’utiliser digitalPinToInterrupt()
        attachInterrupt (digitalPinToInterrupt(n° pin), fonction_ISR, FALLING ) ;

        Répondre

        • Les interruptions (1) 9 mars 16:34, par Jean-Luc

          Merci :-)

          Oui, il faudrait que je mette à jour avec ces informations ; l’article étant antérieur à l’apparition de digitalPinToInterrupt :)

          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 2017 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 2017 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 2017 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 2017 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 2017 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> html  >

          #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

• Les interruptions (1) 11 août 2017 20:43, par Guyon

  Bonjour

  Je voudrais utiliser la fonction interruption d’Arduino (micro) pour :

  * sur un front montant "faire 1"

  * sur une front descendant "faire 2"

  le programme (partiel) :

  attachInterrupt(0,front_montant,RISING))
   
  attachInterupt(0,front_descendant,FALLING)

  puis plus loin :

  void front_montant () {
    faire1
  }
   
  void front descendant () {
    faire2
  }

  Cela ne fonctionne pas : une seule interruption est prise en compte (la seconde)

  Une idée ???

  Merci d’avance

  Gilles

  Répondre

  • Les interruptions (1) 11 août 2017 21:02, par guyon

    il manque bien sûr les { et } avant et après les faire…
    Gilles

    Répondre

• Les interruptions (1) 11 août 2017 21:06, par Jean-Luc

  Bonsoir,

  c’est normal. En effet, on ne peut associer qu’une seule routine d’interruption a une broches. Votre second attachInterrupt remplace le premier.

  Pour faire cela, il faut que la sensibilité soit CHANGE et que vous testiez via un digitalRead l’état de la broche.

  Répondre

• Les interruptions (1) 1er décembre 2017 23:12, par Loco28

  Bonsoir,

  J’ai posé ma question dans une autre rubrique mais je pense qu’elle est mieux ici.
  La récupération des données DCC   se fait à l’aide d’une interruption.
  On obtient ADDRESS et DATA.
  Le problème c’est que quand on traite ces deux données pour générer une action, on peut louper les données qui suivent.
  Il faudrait pouvoir stocker ces données dans une pile, puis les dépiler pour les traiter, sachant qu’à chaque interruption une nouvelle donnée serait entrée dans la pile.
  Problème : je n’ai aucune idée comment faire et je voudrais un peu d’aide.

  Répondre

  • Les interruptions (1) 2 décembre 2017 09:54, par bobyAndCo

    Bonjour,

     

    Dans une pile ou plus probablement dans une file d’ailleurs car il est vraisemblable que dans le cas que vous évoquez il vaille mieux un First In / First Out. C’est une question de programmation en C que vous trouverez traité sur de nombreux sites dont en particulier en français sur "OpenClassRoom". Ici, ça me semble très bien expliqué : https://openclassrooms.com/courses/...

     

    Les structures ne sont pas des notions bien compliquées. Quant aux pointeurs, je vous assure que ce n’est pas non plus bien compliqué mais il faut bien essayer de comprendre les mécanismes. Une fois fait, ça simplifie considérablement l’écriture offre de plus grandes possibilités.

     

    Reportez vous aux articles de Thierry : http://www.locoduino.org/spip.php?a...

     

    Commencez au moins à écrire le code et si vous rencontrez des difficultés, nous pourrons vous aider.

     

    Bien amicalement

    Répondre

    • Les interruptions (1) 2 décembre 2017 10:22, par Jean-Luc

      Perso, je n’irais pas vers le type de structure présenté sur OpenClassroom qui consomme pas mal de mémoire pour stocker 2 malheureux octets et suppose une allocation dynamique des éléments du tampon. Et on ne fait pas d’allocation dynamique dans une application temps réelle. Un tableau de struct (couples adresse / donnée) géré en tampon circulaire est mieux.

      Répondre

      • Les interruptions (1) 2 décembre 2017 11:59, par Loco28

        Bon, j’ai du travail, mais j’aime ça.

        Par contre : "Un tableau de struct (couples adresse / donnée) géré en tampon circulaire est mieux", cela se traduit comment en "français-arduino" ?

        Répondre

        • Les interruptions (1) 2 décembre 2017 13:16

          Ça se traduit par l’utilisation d’une bibliothèque qui va bien. Par exemple https://github.com/rlogiacco/CircularBuffer

          Puis par la définition d’un type de donnée :

          typedef struct {
            byte adresse;
            byte commande;
          } PaquetDCC;

          Ce qui permet ensuite d’instancier un buffer de disons 10 éléments :

          CircularBuffer<PaquetDCC,10> buffer;

          Répondre

          • Les interruptions (1) 2 décembre 2017 22:19, par Loco28

            OK, je commence à comprendre le principe en ayant, entre autre, regardé la bibliothèque CircularBuffer.
            Par contre, c’est le point d’entrée que je n’arrive pas à situer.
            Ci-après mon programme de récupération des données DCC   :

            #include <DCC_Decoder.h>
            #define kDCC_INTERRUPT    0    // pin 2 for UNO
             
            //Handler DCC
            void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data){
              // Conversion de l'adresse NMRA en adresse decodeur d'accessoire
              address -= 1;
              address *= 4;
              address += 1;
              address += (data & 0x06) >> 1;
              int action = (data & 0x01);
             //
             //
             // ici se situe le programme pour activer les sorties
             // en fonction des données reçues
             //
             //
              } 
            void setup() {      
              DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true); 
              DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );  
            }
            void loop() {
              DCC.loop();
            }

            Il faut que je récupère ADDRESS et ACTION pendant l’exécution de la routine d’interruption.
            Où dois-je placer mes instructions d’écriture dans le buffer ?

            Répondre

            • Les interruptions (1) 3 décembre 2017 08:29, par Jean-Luc

              Je dirais dans BasicAccDecoderPacket_Handler. Elle est curieuse cette fonction. On y calcule des choses qui finalement sont écrites dans data mais data étant une variable locale, la valeur est oubliée.

              Répondre

              • Les interruptions (1) 3 décembre 2017 13:44, par Loco28

                Je ne pourrais pas répondre concernant la particularité de la fonction BasicAccDecoder_Handler, je me suis contenté de l’utiliser telle quelle.
                Si je comprend bien ta réponse, tout ce qui est dans le "Void BasicAccDecoderPacket_Handler" est fait dans le cadre de la routine d’interruption ? Ce qui voudrait dire qu’actuellement je traite les données lors de l’interruption. Si c’est le cas, je comprend que je loupe des instructions.
                Est-ce que cela veut dire que je dois mettre le "dépilage" et le traitement des données dans la partie "Void loop" ?

                Répondre

                • Les interruptions (1) 4 décembre 2017 20:17, par Loco28

                  Finalement, avec l’aide tous, j’ai réussi, je pense, à résoudre mon problème.
                  Ci-dessous mon code provisoire :

                  ---

                  #include <DCC_Decoder.h>
                  #define kDCC_INTERRUPT    0    // pin 2 for UNO
                  #include <CircularBuffer.h>
                   
                  CircularBuffer <int, 100> storadresse;
                  CircularBuffer <byte, 100> storaction;
                   
                  int add = 0;
                  int act = 0;
                  int old_add = 0;
                  int old_act = 0;
                  int action = 0;
                   
                  //Handler DCC
                  void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data){
                    //Serial.print(address);
                    //Serial.print("    ");
                    //Serial.println(data);
                   storadresse.push (address);
                   storaction.push (data); 
                    } 
                  void setup() {      
                    DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true); 
                    DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
                    Serial.begin (115200);  
                    Serial.println("Debut test");
                  }
                  void loop() {
                    DCC.loop();
                   
                    while(!storadresse.isEmpty()) {
                     add = storadresse.shift();
                     act = storaction.shift();
                   
                   if ((add != old_add) || (act != old_act)){
                      old_add = add;
                      old_act = act;
                  // Conversion de l'adresse NMRA en adresse decodeur d'accessoire 
                     add -= 1;
                     add *= 4;
                     add += 1;
                     add += (act & 0x06) >> 1;
                     action =(act & 0x01);
                     Serial.print(add);
                     Serial.print("   ");
                     Serial.println(action);
                   
                     } //fin nouvelle donnée
                    } //fin while   
                  } //fin loop 

                  ---

                  Le traitement des données pour détermination des ordres à envoyer vers les aiguillages et les signaux se fera à l’emplacement des "Serial.print", dans la "loop".
                  Seul inquiétude : je travaille avec 2 fichiers que je remplis et vide en même temps mais je préférerais une solution plus synchrone.

                  Répondre

• Les interruptions (1) 3 décembre 2017 20:12, par Dominique

  La fonction BasicAccDecoderPacket_handler est tronquée. Il manque ce qui permet de récupérer le resultat :

  for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
   {
       if( address == gAddresses[i].address )
       {
           Serial.print("Basic addr: ");
           Serial.print(address,DEC);
           Serial.print("   activate: ");
           Serial.println(enable,DEC);
           
           if( enable )
           {
               gAddresses[i].output = 1;
               gAddresses[i].onMilli = millis();
               gAddresses[i].offMilli = 0;
           }else{
               gAddresses[i].output = 0;
               gAddresses[i].onMilli = 0;
               gAddresses[i].offMilli = millis();
           }
       }
   }

  Répondre

  • Les interruptions (1) 6 décembre 2017 20:47, par Loco28

    J’avoue ne pas tout comprendre.
    Je pense que c’est à mettre juste après la "void" BasicAcc…..
    L’adresse que l’on récupère n’est pas directement exploitable et, pour avoir la bonne adresse, il y a une formule avec DATA, que je ne vois pas.
    A quoi servent les lignes qui sont après le test de l’Enable ?

    Répondre

    • Les interruptions (1) 6 décembre 2017 22:43, par dominique

      Pourrais-tu transporter tes questions dans le forum (débuter ou vos projets) : ce n’est pas pratique ici, l’article n’est pas fait pour cela

      merci

      Répondre