Go Down

Topic: Projet Led haute puissance avec recepteur de modelisme (Read 5302 times) previous topic - next topic

bypbop

Merci bien cela fonctionne parfaitement ! ok pour l 'explication !!

Cordialement,
bypbop

bypbop

Voila j'ai testé l'interruption sur le post de b@tto et je n'ai aucun resultat dans result

j'ai fait volontairement un Serial.println(result); pour voir si il y avait des varations de result mais aucun ...
J'utilise sur ma nano la pin D2 qui correspond à l interruption avec le timer1.

En fait j'aimerais avoir la variation du signal de mon recepteur RC pour enclencher le changement de programme par la suite

Code: [Select]

int ledWhite = 5;
int ledGreen = 11;
int ledRed = 10;
int ledBlue= 9;

int tache=0;  // tache en cours
boolean tacheDone=false;  // indique si la tache a été executé ou pas encore

unsigned long top,delai;

volatile byte flag=0;
volatile unsigned long time,result;

int prog=0;


//int Sequence[][5] = {
//{255, 0  , 0 , 0  , 50},
//{0, 0  , 0 , 0  , 300},
//{255, 0  , 0 , 0  , 50},
//{0, 0  , 0 , 0  , 300},
//{255, 0  , 0 , 0  , 50},
//{0, 0  , 0 , 0  , 300},
//{0, 128  , 0 , 0 , 1000},
//{0, 0  , 255 , 0 , 1000},
//{0, 0  , 0 , 255 , 1000},
//{0, 0  , 255 , 255 , 1000},
//{0, 128  , 255 , 0 , 1000},
//{0, 128  , 0 , 255 , 1000},
//{0, 128  , 255 , 255 , 1000},
//};


int Sequence[][5] = {
{255, 0  , 0 , 0  , 50},
{0, 0  , 0 , 0  , 200},
{255, 0  , 0 , 0  , 50},
{0, 0  , 0 , 0  , 200},
{255, 0  , 0 , 0  , 50},
{0, 0  , 0 , 0  , 200},
{0, 128  , 0 , 0 , 50},
{0, 0 , 0 , 0 , 500},
};

//int Sequence[][5] = {
//
//{0, 128  , 0 , 0 , 100},
//{0, 0  , 255 , 0 , 100},
//{0, 0  , 0 , 255 , 100},
//{0, 0  , 255 , 255 , 100},
//{0, 128  , 255 , 0 , 100},
//{0, 128  , 0 , 255 , 100},
//{0, 128  , 255 , 255 , 100},
//
//};




void setup() {
   Serial.begin(9600);
   pinMode(ledRed, OUTPUT);
   pinMode(ledGreen, OUTPUT);  
   pinMode(ledWhite,OUTPUT);

   top = millis(); // Enregistrement de mon point de départ
  attachInterrupt(4,pulse,RISING);

}

void Prog() {
prog++;
Serial.println(result);  
}


void pulse() {

detachInterrupt(4);

if(flag) {

result=micros()-time;
Prog();
attachInterrupt(4,pulse,RISING);

}else {

time=micros();
attachInterrupt(4,pulse,FALLING);
}

flag=!flag;

}


void loop() {

// gestionnaire du sequenceur de taches
 if((top+delai)<=millis()) {
   tache +=1;
   if (tache > (sizeof(Sequence)/10)-1){tache=0;}
   // a chaque chagement du sequenceur, on met reinit tacheDone et le temps de la tache
   // c'est dans la tache qu'on defini son timing (bof, c'est ce que tu veux, donc ca ira)
   tacheDone = false;
   top=millis();
 }
 
// sequenceur de taches
 if (tacheDone == false){
     analogWrite(ledWhite,Sequence[tache][0]);
     analogWrite(ledRed,Sequence[tache][1]);
     analogWrite(ledGreen,Sequence[tache][2]);
     analogWrite(ledBlue,Sequence[tache][3]);
     delai=Sequence[tache][4];
     tacheDone =true;

}

pulse();
}





Cordialement,
bypbop

jean-I

je n'ai pas de nano pour essais.
c'est la version 2 (168) ou 3 (328) du nano que tu as?
t'as deja joué avec les interruptions seules?

puls() va etre executé a chaque tour de loop() ET puls peut etre interrompue par l'interruption elle meme malgré ton detachInterrupt.

tu t'y prend mal:
admettons que tu veut calculer la duré d'appuy sur la broche:

unsigned long dureeAppuiStart = 0;
unsigned long dureeAppui = 0;

dans setup:
attachInterrupt(4,pulse,CHANGE);

dans puls():
puls() {  //cette IT a lieu a chaque changement LOW/HIGH
  if (digitalRead(D2)==HIGH) {  // front montant, on memorise l'instant
    dureeAppuiStart = millis();
  }
  if (digitalRead(D2)==LOW) {  // front descendant, on calcule la durée
    dureeAppui = millis() - dureeAppuiStart;
  }
}
(et c'est tout)

dans loop:
vire puls()
rajoute:
if (dureeAppui>0) {
  dureeAppui=0;
  prog++;
  Serial.println(result);
}

voila, j'ai pas testé mais ca dervai marcher, au moins avec un fil sud D2, et le code est non bloquant.
tu devrai pouvoir adapter de la meme maniere un delai entre 2 appuy consécutif.

bypbop

Bonjour Jean-l,

Alors je suis debutant et les interruptions je comprends le principe mais je ne maitrise pas encore trés bien cette notion ca vient ...
alors j'ai fait les petites modifs mais le code ne fonctionne pas j'ai fais un petit test pour voir si on rentre bien dans l int !! mais apparement non ...

Code: [Select]

int ledWhite = 5;
int ledGreen = 11;
int ledRed = 10;
int ledBlue= 9;

int tache=0;  // tache en cours
boolean tacheDone=false;  // indique si la tache a été executé ou pas encore

unsigned long top,delai;

unsigned long dureeAppuiStart = 0;
unsigned long dureeAppui = 0;

int prog=0;


//int Sequence[][5] = {
//{255, 0  , 0 , 0  , 50},
//{0, 0  , 0 , 0  , 300},
//{255, 0  , 0 , 0  , 50},
//{0, 0  , 0 , 0  , 300},
//{255, 0  , 0 , 0  , 50},
//{0, 0  , 0 , 0  , 300},
//{0, 128  , 0 , 0 , 1000},
//{0, 0  , 255 , 0 , 1000},
//{0, 0  , 0 , 255 , 1000},
//{0, 0  , 255 , 255 , 1000},
//{0, 128  , 255 , 0 , 1000},
//{0, 128  , 0 , 255 , 1000},
//{0, 128  , 255 , 255 , 1000},
//};


int Sequence[][5] = {
{255, 0  , 0 , 0  , 50},
{0, 0  , 0 , 0  , 200},
{255, 0  , 0 , 0  , 50},
{0, 0  , 0 , 0  , 200},
{255, 0  , 0 , 0  , 50},
{0, 0  , 0 , 0  , 200},
{0, 128  , 0 , 0 , 50},
{0, 0 , 0 , 0 , 500},
};

//int Sequence[][5] = {
//
//{0, 128  , 0 , 0 , 100},
//{0, 0  , 255 , 0 , 100},
//{0, 0  , 0 , 255 , 100},
//{0, 0  , 255 , 255 , 100},
//{0, 128  , 255 , 0 , 100},
//{0, 128  , 0 , 255 , 100},
//{0, 128  , 255 , 255 , 100},
//
//};

void pulse() {

if (digitalRead(2)==HIGH) {  // front montant, on memorise l'instant
    dureeAppuiStart = millis();
  }
  if (digitalRead(2)==LOW) {  // front descendant, on calcule la durée
    dureeAppui = millis() - dureeAppuiStart;
  }


Serial.println("Int");
}


void setup() {
    Serial.begin(9600);
    pinMode(ledRed, OUTPUT);
    pinMode(ledGreen, OUTPUT); 
    pinMode(ledWhite,OUTPUT);

    pinMode(2,INPUT);
   
   
    top = millis(); // Enregistrement de mon point de départ
   attachInterrupt(4,pulse,RISING);

}

void Prog() {
prog++;

}


void loop() {

// gestionnaire du sequenceur de taches
  if((top+delai)<=millis()) {
    tache +=1;
    if (tache > (sizeof(Sequence)/10)-1){tache=0;}
    // a chaque chagement du sequenceur, on met reinit tacheDone et le temps de la tache
    // c'est dans la tache qu'on defini son timing (bof, c'est ce que tu veux, donc ca ira)
    tacheDone = false;
    top=millis();
  }
 
// sequenceur de taches
  if (tacheDone == false){
      analogWrite(ledWhite,Sequence[tache][0]);
      analogWrite(ledRed,Sequence[tache][1]);
      analogWrite(ledGreen,Sequence[tache][2]);
      analogWrite(ledBlue,Sequence[tache][3]);
      delai=Sequence[tache][4];
      tacheDone =true;

}

if (dureeAppui>0) {
 
  Serial.println(dureeAppui);
  dureeAppui=0;
  prog++;
}
}




Cordialement,
bypbop

jean-I

si tu veux comprendre le IT, alors concentre toi sur les IT, pas sur le fait de jouer une sequence, ni de comuniquer en IR.
tu peut entre autre tester un exemple simple:
http://arduino.cc/en/Reference/AttachInterrupt

je n'ai pas de nano, tu ne m'a pas dit lequel tu avais.
j'ai supposé que l'IT 4 correspondai a la pin D2 du nano, puisque tu l'avais ecrit. j'ai pas été vérifier.
d'ou
attachInterrupt(4,pulse,CHANGE);
et
if (digitalRead(D2)==LOW ... ou HIGH

d'apres http://arduino.cc/en/Reference/AttachInterrupt
la nano se comporte comme sur UNO (au moins le model en 328), les interruptions de pins (celles du genre que l'on souhaite) ne sont possible que les pin 2 et 3, et sont respectivement les interruption 0 et 1.
il aurai donc fallu ecrire
attachInterrupt(0,pulse,CHANGE);
et
if (digitalRead(2)==LOW ... ou HIGH




bypbop

dslé j'avais oublié oui c'est une 328 ... oui j'ai deja fait l'interruption sur cette exemple...

exact !! c t bien 0 ...

Je me fais la main sur cette interruption et je reviens sur le forum !!!
Encore merci pour ton aide.


Cordialement,
bypbop

bypbop

Bonjour à tous,

Voila je ressors du placard mon projet !! j'ai bien avancé depuis j'ai réalisé uné interruption à partir du pwm de mon recepteur radio qui marche plutot bien !!

Voila j'ai ajouté cette interruption au sequenceur qui gère les 2 leds ... mais je n'arrive pas à charger un nouveau tableau ....

J'ai ajouté une sequence en début de code pour voir si le sequenceur tourne bien et c'est le cas !


Pourquoi cela ?

Code: [Select]


volatile unsigned long timer_start;
volatile int pulse_time;

volatile int last_time;

int ledGreen = 11;
int ledBlue = 9;
int ledRed = 10;
int ledWhite = 5;
int rcPin = 2;

int Sequence[][5] = {
    {255, 0  , 0 , 0  , 50},
    {0, 0  , 0 , 0  , 200},
    {255, 0  , 0 , 0  , 50},
    {0, 0  , 0 , 0  , 200},
    {255, 0  , 0 , 0  , 50},
    {0, 0  , 0 , 0  , 200},
    {0, 255  , 0 , 0 , 50},
    {0, 0  , 0 , 0  , 50},
    {0, 255  , 0 , 0 , 50},
    {0, 0 , 0 , 0 , 500},
    };

unsigned long top,delai;
int tache=0;  // tache en cours
boolean tacheDone=false;  // indique si la tache a été executé ou pas encore


int prog;
void chargement()
{
Serial.print("Programme :");
Serial.println(prog);

    if (prog==0){
    Serial.println("PRG 00000"); // je rentre bien dans le chargement
    int Sequence[][5] = {
    {0, 0  , 0 , 0 , 1000},
    {0, 0 , 0 , 0 , 1000},
    };
   
    }
    if (prog==1){
    int Sequence[][5] = {
    {255, 0  , 0 , 0  , 50},
    {0, 0  , 0 , 0  , 200},
    {255, 0  , 0 , 0  , 50},
    {0, 0  , 0 , 0  , 200},
    };
    }
    if (prog==2){
    int Sequence[][5] = {
    {0, 255  , 0 , 0 , 1000},
    {0, 0 , 0 , 0 , 1000},
    };
    }

}


void calcSignal()
{
      if(digitalRead(rcPin) == HIGH)
          {
              timer_start = micros();
          }

          else
          {
           
            if(timer_start > 0)
            {
               
                pulse_time = ((volatile int)micros() - timer_start);
                timer_start = 0;
           
            }
          }
   
  if(pulse_time >1850 && last_time <=1100){
    prog++;
    if (prog>2){prog=0;}
    tacheDone = false;
    chargement();
    last_time = pulse_time;
  }
  else
  {
    last_time = pulse_time;
  }
}

void setup()
{
    timer_start = 0;
    prog = 0;
    pinMode(ledGreen, OUTPUT);     
    pinMode(ledBlue, OUTPUT);
    pinMode(ledRed, OUTPUT);
    pinMode(ledWhite, OUTPUT);
    pinMode(rcPin, INPUT);
   
    top = millis();
   
    attachInterrupt(0, calcSignal, CHANGE);
    Serial.begin(9600);


}

void loop()
{
// gestionnaire du sequenceur de taches
  if((top+delai)<=millis()) {
    tache +=1;
    if (tache > (sizeof(Sequence)/10)-1){tache=0;}
    tacheDone = false;
    top=millis();
  }
 
// sequenceur de taches
  if (tacheDone == false){
      analogWrite(ledWhite,Sequence[tache][0]);
      analogWrite(ledRed,Sequence[tache][1]);
      analogWrite(ledGreen,Sequence[tache][2]);
      analogWrite(ledBlue,Sequence[tache][3]);
      delai=Sequence[tache][4];
      tacheDone =true;

}

}




Le principe : dans le loop le sequenceur lis le tableau en boucle et j'ai une interruption qui calcule le signal pwm du recepteur rc ....


Je rentre bien dans les programmes mais la nouvelle sequence ne se charge pas ....

Cordialement,
bypbop

Go Up