next topic »

[on:]

Bonjour tout le monde

Je me lance un peu dans les interruption pour une gestion de pwm. L'interruption fonctionne mais mon programme ne parcourt jamais le Loop() ... Et je ne sais pas du tout pourquoi

Coincé depuis un moment je viens demander votre aide ...

Voici mon code :

Code:

// --- constantes des broches ---
int rxPin = 12;

const int ledVerte=9;
const int ledRouge=10;
const int ledJaune=11;

// Variables globales Burk !
int pwmVerte;
int pwmRouge;
int pwmJaune;
 
void setup(){
  // Configuration de la broche de reception
  pinMode(rxPin, INPUT);
 
  // Configuration des broches LED
  pinMode(ledVerte, OUTPUT);
  pinMode(ledRouge, OUTPUT);
  pinMode(ledJaune, OUTPUT);
 
  Serial.begin(9600); // Configuration de la liaison série
  attachInterrupt(0, reception, CHANGE); // Interruption sur la broche 2
}

void loop(){
 
 Serial.println("On passe dans le loop");
 // analogWrite(ledVerte,pwmVerte);
 // analogWrite(ledRouge,pwmRouge);
 // analogWrite(ledJaune,pwmJaune);
}

La fonction reception se trouve dans un autre .pde dans le même dossier

Amicalement,

[Reply #1 on:]

Après plusieurs recherches, je viens le petit coupable de tout ça ^^

j'utilise le code Home Easy récupéré sur le site d'Arduino et il semble de celui ci ne soit pas très content d'être attaché à une interruption ...

Mes compétences étant très limitées voila le code entier :S

Code:

void analyseTrame(unsigned long sender, bool group, bool on, unsigned int recipient){

int pwmV;
int pwmR;
int pwmJ;
 
  // on test pour voir si c'est bien notre télécommande
  if(sender==5041182){
   
    Serial.println("Sender ok");

    switch (recipient) { // on test la valeur de recipient pour choisir la LED
    case 0: // cas 0 -> led verte
       if(on){
         pwmVerte = pwmVerte + 10;
         Serial.println("Vert ++");
        }
        else{     
         pwmVerte = pwmVerte - 10;
         Serial.println("Vert --");
        }
      break; 
    case 1: // cas 1 -> led rouge
        if(on){
         pwmRouge = pwmRouge + 10;
        }
        else{     
         pwmRouge = pwmRouge - 10;
        }
      break;
    case 2: // cas 2 -> led jaune
        if(on){
         pwmJaune = pwmJaune + 10;
        }
        else{     
         pwmJaune = pwmJaune - 10;
        }
      break;
    default: // cas par défaut
   
      break;
      }

  }
}// fin void

Code:

void reception()
{
        int i = 0;
        unsigned long t = 0;
 
        byte prevBit = 0;
        byte bit = 0;
 
        unsigned long sender = 0;
        bool group = false;
        bool on = false;
        unsigned int recipient = 0;
 
        // latch 1
        while((t < 9480 || t > 10350))
        {       t = pulseIn(rxPin, LOW, 1000000);
        }
 
        // latch 2
        while(t < 2550 || t > 2700)
        {       t = pulseIn(rxPin, LOW, 1000000);
        }
 
        // data
        while(i < 64)
        {
                t = pulseIn(rxPin, LOW, 1000000);
 
                if(t > 200 && t < 365)
                {       bit = 0;
                }
                else if(t > 1000 && t < 1360)
                {       bit = 1;
                }
                else
                {       i = 0;
                        break;
                }
 
                if(i % 2 == 1)
                {
                        if((prevBit ^ bit) == 0)
                        {       // must be either 01 or 10, cannot be 00 or 11
                                i = 0;
                                break;
                        }
 
                        if(i < 53)
                        {       // first 26 data bits
                                sender <<= 1;
                                sender |= prevBit;
                        }     
                        else if(i == 53)
                        {       // 26th data bit
                                group = prevBit;
                        }
                        else if(i == 55)
                        {       // 27th data bit
                                on = prevBit;
                        }
                        else
                        {       // last 4 data bits
                                recipient <<= 1;
                                recipient |= prevBit;
                        }
                }
 
                prevBit = bit;
                ++i;
        }
 
        // interpret message
        if(i > 0)
        {       printResult(sender, group, on, recipient);
                analyseTrame(sender, group, on, recipient);
        }
}

Code:

void printResult(unsigned long sender, bool group, bool on, unsigned int recipient)
{
        Serial.print("sender ");
        Serial.println(sender);
 
        if(group)
        {       Serial.println("group command");
        }
        else
        {       Serial.println("no group");
        }
 
        if(on)
        {       Serial.println("on");
        }
        else
        {       Serial.println("off");
        }
 
        Serial.print("recipient ");
        Serial.println(recipient);
 
        Serial.println();
}

Si quelqu'un à une idée ou un conseil

Amicalement,

[Reply #2 on:]

Il ne faut pas appeler Serial.print sous interruption car la fonction utilise elle même les interruptions.

Le code gagnerait à être découpé de tel sorte que tu ne fasses sous interruption que la réception de ta trame. L'impression et l'analyse se déroulant à l'extérieur (comprendre dans loop).
A la sortie de reception(), si une trame valide a été reçue, positionner un drapeau pour l'indiquer.
A l'intérieur de loop, si le drapeau est levé, analyser la trame, efface le drapeau et agir en conséquence.
Il faut passer le minimum de temps sous interruption pour ne pas bloquer d'autres tâches qui les utilises aussi.

[Reply #3 on:]

Merci beaucoup pour toutes ces réponses

Je vais me pencher sur les flags

Amicalement,