LOCODUINO

Les interruptions (1)

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

Principe de fonctionnement des interruptions On a vu dans « La programmation, qu’est ce que c’est » que l’Arduino exécutait son programme en séquence, instruction par instruction, dans l’ordre. Certaines instructions permettent de rompre cet ordre : les instructions conditionnelles comme le if ... else ou les instructions de boucle comme le for(...). (...)

Retourner à l'article

Vous répondez à :

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

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

Aide : Enrichissement typographiques dans les commentaires

50 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 2018 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 2018 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>
        
        #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

Les interruptions (1) 28 janvier 14:42, par ndiaye

Bonjour,

je voulais faire une interruption sur un front montant et j’en suis pas sur de mon programme :

int monBouton = 2; // bouton en broche 2
int compteur = 0;  // un compteur
int etatBouton; // L'état du bouton
 
void setup() {
  // le bouton en entrée
  pinMode(monBouton, INPUT); 
}
 
void loop() {
  // si on appuie sur le bouton
  etatBouton = digitalRead(monBouton);
  if(etatBouton == HIGH) {
    // alors on incrémente le compteur
    compteur = compteur+1;
  }
}

Répondre

Les interruptions (1) 2 avril 22:35, par hicheri

static unsigned long dateDernierChangement = 0 ;
cette ligne remet à zero à chaque fois qu’il ya interruption, ya un probleme non ?

Répondre
- Les interruptions (1) 2 avril 22:48, par Jean-Luc
  
  Bonsoir,
  effectivement il y a un problème dans votre remarque. Je vous invite à lire ceci.
  cordialement.
  
  Répondre
  - Les interruptions (1) 2 avril 22:55, par hicheri
    
    c clair, merci
    
    Répondre

Les interruptions (1)

Vous répondez à :

50 Messages

Rubrique Programmation

Les derniers articles

La compilation d’un projet Arduino

TCOs en Processing (2)

Comment concevoir rationnellement votre système

Comment réussir son projet Arduino

Piloter son Arduino avec son navigateur web et Node.js (4)

TCOs en Processing

Ces tableaux qui peuvent nous simplifier le développement Arduino

Processing pour nos trains

Piloter son Arduino avec son navigateur web et Node.js (3)

Piloter son Arduino avec son navigateur web et Node.js (2)

Les articles les plus lus