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 :
// --- 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
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
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
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);
}
}
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.