Pages: [1] 2   Go Down
Author Topic: [conseil] soucis de programme (trop long ?) pour detection d'obstacle (sur 360°)  (Read 1540 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 38
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Coucou

je reviens vous demander conseil, car j'ai un petit soucis. J'avais comme projet de faire un detecteur d'obstacle (avec un sonar, une LED) et il fonctionnait tres bien. J'ai voulu passer a l’étape supérieur en essayant avec 6 LEDs et 6 sonars (les mêmes bien sûr) pour faire une détection sur 360°.
J'ai confectionné un programme :

Il est long mais tres simple a comprendre, j'ai essayé de faire des sortes de sous programme

Code:
long previousMillis = 0;
boolean beep_state;

int interval0 = 200;
int interval1 = 200;
int interval2 = 200;
int interval3 = 200;
int interval4 = 200;
int interval5 = 200;

int analogPin0 = 0;
int analogPin1 = 1;
int analogPin2 = 2;
int analogPin3 = 3;
int analogPin4 = 4;
int analogPin5 = 5;

int val0 = 0;
int val1 = 0;
int val2 = 0;
int val3 = 0;
int val4 = 0;
int val5 = 0;

void setup()
{
 Serial.begin (9600);  
 pinMode(12, OUTPUT); // Le signal est envoyé sur le buzzer qui est branché sur la sortie 12
 pinMode(3, OUTPUT); // Le signal est envoyé sur les LED qui sont branchées sur les sortie 3,5,6,9,10,11
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(9, OUTPUT);
 pinMode(10, OUTPUT);
 pinMode(11, OUTPUT);
 
}

void loop()
{
  Serial.println(val4);
  lecture_val0();
  lecture_val1();
  lecture_val2();
  lecture_val3();
  lecture_val4();
  lecture_val5();
  beep0();
  beep1();
  beep2();
  beep3();
  beep4();
  beep5();

}

void lecture_val0()
{
val0 = analogRead(analogPin0);
interval0 = val0 * 2;

}
void lecture_val1()
{
val1 = analogRead(analogPin1);
interval1 = val1 * 2;

}
void lecture_val2()
{
val2 = analogRead(analogPin2);
interval2 = val2 * 2;

}
void lecture_val3()
{
val3 = analogRead(analogPin3);
interval3 = val3 * 2;

}
void lecture_val4()
{
val4 = analogRead(analogPin4);
interval4 = val4 * 2;

}
void lecture_val5()
{
val5 = analogRead(analogPin5);
interval5 = val5 * 2;

}

// ----------------------------------------------------------------------------------

void beep0()
{
unsigned long currentMillis = millis();

if ( val0 < 100)
{
    beep_state = 1;
    digitalWrite(3, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val0 < 300)
{
    if ( currentMillis - previousMillis > interval0 )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;  
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(3, HIGH);  // active la LED (ON)
            
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(3, LOW );  // active la LED (Off)
            
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(3, LOW );  // active la LED (Off)
    
    noTone(16);
    previousMillis = currentMillis;
}
}
//-------------------------------------------------------------------------------------------------------
void beep1()
{
unsigned long currentMillis = millis();

if ( val1 < 100)
{
    beep_state = 1;
    digitalWrite(5, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val1 < 300)
{
    if ( currentMillis - previousMillis > interval1 )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;  
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(11, HIGH);  // active la LED (ON)
            
            tone(5, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(5, LOW );  // active la LED (Off)
            
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(5, LOW );  // active la LED (Off)
    
    noTone(16);
    previousMillis = currentMillis;
}
}
//---------------------------------------------------------------------------------------------------------------------
void beep2()
{
unsigned long currentMillis = millis();

if ( val2 < 100)
{
    beep_state = 1;
    digitalWrite(6, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val2 < 300)
{
    if ( currentMillis - previousMillis > interval2)
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;  
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(6, HIGH);  // active la LED (ON)
            
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(6, LOW );  // active la LED (Off)
            
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(6, LOW );  // active la LED (Off)
    
    noTone(16);
    previousMillis = currentMillis;
}
}
//-----------------------------------------------------------------------------------------------------

void beep3()
{
unsigned long currentMillis = millis();

if ( val3 < 100)
{
    beep_state = 1;
    digitalWrite(9, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val3 < 300)
{
    if ( currentMillis - previousMillis > interval3 )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;  
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(9, HIGH);  // active la LED (ON)
            
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(9, LOW );  // active la LED (Off)
            
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(9, LOW );  // active la LED (Off)
    
    noTone(16);
    previousMillis = currentMillis;
}
}
//-----------------------------------------------------------------------------------------------------------

void beep4()
{
unsigned long currentMillis = millis();

if ( val4 < 100)
{
    beep_state = 1;
    digitalWrite(11, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val4 < 300)
{
    if ( currentMillis - previousMillis > interval4 )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;  
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(11, HIGH);  // active la LED (ON)
            
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(11, LOW );  // active la LED (Off)
            
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(11, LOW );  // active la LED (Off)
    
    noTone(16);
    previousMillis = currentMillis;
}
}
//-----------------------------------------------------------------------------------------------
void beep5()
{
unsigned long currentMillis = millis();

if ( val5 < 100)
{
    beep_state = 1;
    digitalWrite(10, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val5 < 300)
{
    if ( currentMillis - previousMillis > interval5 )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;  
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(10, HIGH);  // active la LED (ON)
            
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(10, LOW );  // active la LED (Off)
            
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(10, LOW );  // active la LED (Off)
    
    noTone(16);
    previousMillis = currentMillis;
}
}

Pour voir si il fonctionne j'ai effectué un test sonar par sonar . Mon test actuel est avec le sonar branché pour la partie "beep4".
Si je mets ma main a moins d 1m la LED est censé resté allumée, si je suis à plus d 1m ca clignote. Or dans mon cas, que je sois a + ou - de 1m la LED s allume et ne s'eteind longtemps apres.
J'ai essayé d'isolé uniquement la partie "beep4" en mettant toutes les autres parties en commentaire et là ca marche.
J'ai donc essayé de mettre une a une chaque partie avec "beep4" mais a chaque fois, ca le fais le meme coup, la led reste allumé.

Je pense que le logiciel se perd dans mon programme car il y a trop de chose ou alors le temps qu il execute tout mon programme il lui faut un moment ..

Si qq'un pouvait m'aider smiley

Merci

Benoit 1121
Logged

Made in Belgium
Offline Offline
God Member
*****
Karma: 1
Posts: 756
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Je ne vois pas où ce situe ton problème à part quelque différence entre pin pour une même fonctions (c'est peut être le but ?), par contre je vois que tu fais des appel successifs de fonctions similaire en tout points ce qui est un comble vu que les fonctions son justement prévu pour pallier à du code répétitifs ...
Donc vu qu'elles sont similaires, on peux les différencier via arguments non ?

Code:
byte tabVal[5] = {0};
int tabInterval[5] = {0}
byte tabPin[5] = {3,5,6,9,11}
byte i = 0;

void loop()
{
  if(i < 5)
  {
    lecture_val(i);
    beep(tabPin[i]);
    i++;
  }
  else
  {
     i = 0;
  }

}

void lecture_val(byte pinVal)
{
  tabVal[pinVal] = analogRead(pinVal);
  tabInterval = tabVal[pinVal] * 2;
}

void beep(byte pin)
{
unsigned long currentMillis = millis();

if ( val3 < 100)
{
    beep_state = 1;
    digitalWrite(pin, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val3 < 300)
{
    if ( currentMillis - previousMillis > interval3 )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;  
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(pin, HIGH);  // active la LED (ON)
            
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(pin, LOW );  // active la LED (Off)
            
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(pin, LOW );  // active la LED (Off)
    
    noTone(16);
    previousMillis = currentMillis;
}
}

Sans doute pas exactement ça, mais c'est le principe.
« Last Edit: June 07, 2012, 10:06:20 am by osaka » Logged


Offline Offline
Newbie
*
Karma: 0
Posts: 38
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Salut Osaka,

En fait mes 5 sonars m'envois 5 valeur differente appelé Val0 à Val5

Chaque LED sera lié a une sortie (3, 5, 6, 9, 10, 11)

la LED sortie 3 avec Val0
   LED sortir 5 avec Val1
  ...
  LED sortie 11 avec Val5

Donc je voulais avoir pour chacune des valeurs de mes sonar, un petit programme faisant clignoter la LED associé au sonar.

Mais je pense que mon programme fait une succession de petit programme qui fait que ca marche pas comme je veux.



 
Logged

0
Offline Offline
God Member
*****
Karma: 2
Posts: 802
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Je pense qu'il est normal d'avoir un décalage entre la réalité et la mesure de la sonde ultrason, sur une seule sonde, la latence est quasi invisible.

Quelques pistes :

1- Action/réaction : Tu fais d'abord toutes tes mesures et ensuite les leds réagissent. L'autre option est de faire une mesure et d'appeler immédiatement la routine de la led correspondante. En effet, si la variable est nulle, on passe à la prochaine sonde, si la variable est complétée, il y a détection et donc réaction immédiate.

Code:
lecture_val0();
beep0();
lecture_val1();
beep1();
etc...

2- L'arduino mega dispose de 5 timers, cela permettrait de rendre la réaction quasi indépendant des mesures.

3- As-tu essayé de commenter les appels à tone() ??? Je ne l'utilise pas donc mon conseil est peut être faux, mais à y regarder de plus prés, tu devrais gérer cette fonction comme les leds en y appliquant un troisième paramètres tone(pin, frequency, duration)

4- Le conseil d'Osaka est bon.

@+

Zoroastre.
« Last Edit: June 07, 2012, 11:01:26 am by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

Made in Belgium
Offline Offline
God Member
*****
Karma: 1
Posts: 756
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

En fait mes 5 sonars m'envois 5 valeur differente appelé Val0 à Val5

Chaque LED sera lié a une sortie (3, 5, 6, 9, 10, 11)

la LED sortie 3 avec Val0
   LED sortir 5 avec Val1
  ...
  LED sortie 11 avec Val5

C'est pour celà que dans mon exemple j'ai utilisé divers tableau, la correspondance entrée(lecture)/sortie(led) est positionnel dans leur tableau respectif.

Donc je voulais avoir pour chacune des valeurs de mes sonar, un petit programme faisant clignoter la LED associé au sonar.

Mais je pense que mon programme fait une succession de petit programme qui fait que ca marche pas comme je veux.

En fait tu peux voire une fonction comme étant un sous programme, mais même un sous programme est prévu dans le cas d'actions différentes et non pour une même action sur des objet différent mais similaire par leurs propriétés.
C'est un peux comme si tu développais une application de gestion d'images pour chaque images différentes alors qu'au final ce sont toutes des images sur lesquels on peux faire la même action ...

Pour ton problème je pense que zoro te donne la bonne direction et effectivement même si je ne l'ai jamais utilisé tone() pourais être un facteur bloquant, enfin ça me dit quelque chose ...
« Last Edit: June 07, 2012, 11:51:05 am by osaka » Logged


Offline Offline
Newbie
*
Karma: 0
Posts: 38
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour, Merci à vous deux pour vos réponse smiley

En fait je me servais de tone() lorsque j'utilisais mon buzzer, or dans mon exemple je l'ai mis de coté pour déjà y arriver avec les LED.
Je vais suivre vos conseil en essayant de les introduire dans mon programme. je vous tiendrais au courant si cela marche ou pas.

Merci !

Ps: je possède la carte DUEMILANOVE

Benoit
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 38
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

@Osaka

Je n'arrive pas à comprendre le principe de ton programme ...
 
Code:
void loop()
{
  if(i < 5)
  {
    lecture_val(i);
    beep(tabPin[i]);
    i++;
  }
  else
  {
     i = 0;
  }

}

il faut écrire le code pour  lecture_val(i);
                                     beep(tabPin);

les codes que tu as écrit apres :

Code:
void lecture_val(byte pinVal)
{
  tabVal[pinVal] = analogRead(pinVal);
  tabInterval = tabVal[pinVal] * 2;
}

void beep(byte pin)
{
unsigned long currentMillis = millis();

if ( val3 < 100)
{
    beep_state = 1;
    digitalWrite(pin, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (val3 < 300)
{
    if ( currentMillis - previousMillis > interval3 )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(pin, HIGH);  // active la LED (ON)
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(pin, LOW );  // active la LED (Off)
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(pin, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
}

c'est pour le "i" ou je dois reécrire mes "void lecture_val" et "void beep" comme je les ai mis au début ?
je suis perdu ... et je ne trouve tjrs pas de solution a mon soucis ...

Merci

Benoit
Logged

83 - var
Offline Offline
God Member
*****
Karma: 9
Posts: 863
ARDUINO Powa !
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bon je pense que c'est partie un peux dans tout les sens la il va falloir recadré ton sujet, pour ça je pense qu'il serais bien que tu poste la dernière version de ton code à toi avec tes erreurs etc et qu'on t'oriente à partir de la, pense à ré exprimer ton problème car je crois qu'on est passé au travers la..

Skizo
Logged

Un tien vaux mieux que deux tu l'auras !

83 - var
Offline Offline
God Member
*****
Karma: 9
Posts: 863
ARDUINO Powa !
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

pour ce qui est du code d'osaka il est simple regarde:


Code:
void loop()   // boucle infini jusque la cava..
{
  if(i < 5) // i < 5 => 5 sonnar même si chez moi de 0 a 5 ca fait 6.. bref ^^
  {
    lecture_val(i);   // la une fonction qui réalise la lecture
    beep(tabPin[i]);   // la une fonction qui réalise la réaction en fonction du résultat de la lecture
    i++;                         // passage au sonar suivant
  }
  else                     // fin de tour tous les sonnar on été fait
  {
     i = 0;                    // remise a 0 retour au premier sonnar
  }

}

voila ça déja c'est l'utilisation de tes fonction tu mets juste ça dans le loop de ton programme et c'est mar ça roule, après les fonction:

Code:
void lecture_val(byte pinVal)                      // nom d'appel: lecture_val(5); pour la pin 5
{
  tabVal[pinVal] = analogRead(pinVal);               // lecture analogique
  tabInterval = tabVal[pinVal] * 2;                 // calcule x2.. si il le dit ^^
}                                                        // fin de la première fonction


Je voulais faire la deuxième puis.. bas j'ai pas du tout compris ce qu'il voulais faire dedans :s désolé bref après tu mets la définition de ces fonction dans ton programme, pas dans le setup, pas dans le loop en dehors de tout ! saute des ligne en fin de programme et tu colle.

Donc on récapitule:

En dehors de tout tu mets tes déclaration de fonction:
void lecture_val(byte pinVal)                   
{
  ...
}     

Et dans le loop ou autre quand tu les utilise juste tu les appel par leurs nom ces fonctions:
lecture_val(2); par exemple...


Skizo !
Logged

Un tien vaux mieux que deux tu l'auras !

Offline Offline
Newbie
*
Karma: 0
Posts: 38
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Salut Skizoh !

Merci d'avoir pris le temps d'avoir marqué des commentaires sur les étapes.

Je vais mettre mon dernier code que j'ai modifier avec vos commentaires :

Code:
long previousMillis = 0;
boolean beep_state;


int tabVal[5] = {0};
int tabInterval[5] = {0};
int tabPin[5] = {3,5,6,9,11};
int i = 0 ;


int analogPin0 = 0;
int analogPin1 = 1;
int analogPin2 = 2;
int analogPin3 = 3;
int analogPin4 = 4;
int analogPin5 = 5;


void setup()
{
 Serial.begin (9600); 
 pinMode(12, OUTPUT); // Pas utilisé pour le moment
 pinMode(3, OUTPUT); // Le signal est envoyé sur les LED qui sont branchées sur les sorties 3,5,6,9,10,11
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(9, OUTPUT);
 pinMode(10, OUTPUT);
 pinMode(11, OUTPUT);
 
}

void loop()
{
    if(i < 5)
  {
    lecture_tabVal(i);
    beep(tabPin[i]);
    i++;
  }
  else
  {
     i = 0;
  }

 
}

void lecture_tabVal(0)
{
tabVal[0] = analogRead(analogPin0);
tabInterval[0] = tabVal[0] ;

}
void lecture_tabVal(1)
{
tabVal[1] = analogRead(analogPin1);
tabInterval[1] = tabVal[1] ;

}
void lecture_tabVal(2)
{
tabVal[2] = analogRead(analogPin2);
tabInterval[2] = tabVal[2] ;

}
void lecture_tabVal(3)
{
tabVal[3] = analogRead(analogPin3);
tabInterval[3] = tabVal[3] ;

}
void lecture_tabVal(4)
{
tabVal[4] = analogRead(analogPin4);
tabInterval[4] = tabVal[4] ;

}
void lecture_tabVal(5)
{
tabVal[5] = analogRead(analogPin5);
tabInterval[5] = tabVal[5] ;

}

// ----------------------------------------------------------------------------------

void beep(3) //0   Void pour le sonar 1 et clignotement LED sortie 3
{
unsigned long currentMillis = millis();

if ( tabVal[0] < 100)
{
    beep_state = 1;
    digitalWrite(3, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[0]  < 300)
{
    if ( currentMillis - previousMillis > tabInterval[4] )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(3, HIGH);  // active la LED (ON)
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(3, LOW );  // active la LED (Off)
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(3, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
}
//-------------------------------------------------------------------------------------------------------
void beep(5) //1   Void pour le sonar 2 et clignotement LED sortie 5
{
unsigned long currentMillis = millis();

if ( tabVal[1] < 100)
{
    beep_state = 1;
    digitalWrite(5, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[1]  < 300)
{
    if ( currentMillis - previousMillis > tabInterval[4] )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(5, HIGH);  // active la LED (ON)
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(9, LOW );  // active la LED (Off)
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(9, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
}
//---------------------------------------------------------------------------------------------------------------------
void beep(6) //2   Void pour le sonar 3 et clignotement LED sortie 6
{
unsigned long currentMillis = millis();

if ( tabVal[2] < 100)
{
    beep_state = 1;
    digitalWrite(6, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[2]  < 300)
{
    if ( currentMillis - previousMillis > tabInterval[4] )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(6, HIGH);  // active la LED (ON)
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(6, LOW );  // active la LED (Off)
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(6, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
}
//-----------------------------------------------------------------------------------------------------

 void beep(9) //3   Void pour le sonar 4 et clignotement LED sortie 9
{
unsigned long currentMillis = millis();

if ( tabVal[3] < 100)
{
    beep_state = 1;
    digitalWrite(9, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[3]  < 300)
{
    if ( currentMillis - previousMillis > tabInterval[4] )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(9, HIGH);  // active la LED (ON)
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(9, LOW );  // active la LED (Off)
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(9, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
}
//-----------------------------------------------------------------------------------------------------------

void beep(10) //4     Void pour le sonar 5 et clignotement LED sortie 10
{
unsigned long currentMillis = millis();

if ( tabVal[4] < 100)
{
    beep_state = 1;
    digitalWrite(11, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[4]  < 300)
{
    if ( currentMillis - previousMillis > tabInterval[4] )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(11, HIGH);  // active la LED (ON)
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(11, LOW );  // active la LED (Off)
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(11, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
}
//-----------------------------------------------------------------------------------------------
 void beep(11) //5   Void pour le radar 6 et clignotement LED sortie 11
{
unsigned long currentMillis = millis();

if ( tabVal[5] < 100)
{
    beep_state = 1;
    digitalWrite(10, HIGH);  // active la LED (ON)
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[5]  < 300)
{
    if ( currentMillis - previousMillis > tabInterval[4] )
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(10, HIGH);  // active la LED (ON)
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(10, LOW );  // active la LED (Off)
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(11, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
}

Quand je veux faire un "verify" ce message d'erreur apparait et je ne vois pas ce que c'est : "variable or field 'lecture_tabVal' declared void"
tout me semble être déclaré pourtant ..

Merci
Benoit
Logged

Made in Belgium
Offline Offline
God Member
*****
Karma: 1
Posts: 756
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Yop Yop,

@Osaka

Je n'arrive pas à comprendre le principe de ton programme ...

c'est pour le "i" ou je dois reécrire mes "void lecture_val" et "void beep" comme je les ai mis au début ?
je suis perdu ... et je ne trouve tjrs pas de solution a mon soucis ...

L'exemple était plus pour le principe, pas vraiment exact.
Ai corrigé (il peux subsister des erreurs) et commenté pour mieux comprendre, c'est surtout le principe que je voulais démontré.
entre () les numéros de pin analogique étant successif (0,1,2,3,4,5) ça correspond exactement à l'incrémentation de 'i' donc pratique, maintenant s'ils avaient été en désordre ou autre il aurait fallu faire autrement en ajoutant également un tableau de correspondance pin analog par exemple.

Code:
byte tabPin[5] = {3,5,6,9,11} //tableau de correspondance pin digitale en sortie
byte tabVal[5] = {0}; //tableau des valeurs correspondant au pin analogie 0,1,2,3,4,5
int tabInterval[5] = {0} //tableau des intervalle correspondant au pin analogie 0,1,2,3,4,5

byte i = 0;

void loop()
{
  if(i < 5) //si i < 5
  {
    lecture_val(i); //appelle de la fonction de lecture des entrée analogique i=0,prochain tour i=1 ensuite i=2 ... jusque 5
    beep(i); //appel de la fonction beep avec en paramètre la correspondance tableaux
    i++; // on incrémente de 1 pour l'entrée suivante
  }
  else // sinon on recommence ...
  {
     i = 0;
  }

}

void lecture_val(byte pinVal) //lecture entrée analogique avec en paramètre le numéro de la pin analogique
{
  tabVal[pinVal] = analogRead(pinVal); // on enregistre dans le tableau de correspondance les valeurs
  tabInterval[pinVal] = tabVal[pinVal] * 2; //on calcule l'intervalle que l'on enregistre dans le tableau de correspondance
}

void beep(byte val) // fonction beep avec en paramètre la correspondance tableaux
{
unsigned long currentMillis = millis();

if ( tabVal[val] < 100) comparaison selon la valeur enregistré précédemment dans la fonction lecture_val
{
    beep_state = 1;
    digitalWrite(tabPin[val], HIGH);  // active la LED (ON) selon la correspondance dans le tableau
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[val] < 300) comparaison selon la valeur enregistré précédemment dans la fonction lecture_val
{
    if ( currentMillis - previousMillis > tabInterval[val] ) // delay selon intervalle enregistré précédemment dans la fonction lecture_val
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(tabPin[val], HIGH);  // active la LED (ON) selon la correspondance dans le tableau
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(tabPin[val], LOW );  // active la LED (Off) selon la correspondance dans le tableau
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(pin, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}
Logged


Offline Offline
Newbie
*
Karma: 0
Posts: 38
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Merci Osaka pour ces commentaires !

J'ai encore une question qui me turlupine ^^
Code:
void lecture_val(byte pinVal) //lecture entrée analogique avec en paramètre le numéro de la pin analogique
{
  tabVal[pinVal] = analogRead(pinVal); // on enregistre dans le tableau de correspondance les valeurs
  tabInterval[pinVal] = tabVal[pinVal] * 2; //on calcule l'intervalle que l'on enregistre dans le tableau de correspondance
}

J'ai besoin de faire ce void une seul fois ? et ça le prendra en compte pour toutes les valeurs du tableau ?
ou bien je dois le reécrire pour chaque valeur ? c'est ce que j'ai fait en fait (sur le dernier code que j'ai posté)

Ma question est la meme pour cette partie :
Code:
void beep(byte val) // fonction beep avec en paramètre la correspondance tableaux
{
unsigned long currentMillis = millis();

if ( tabVal[val] < 100) comparaison selon la valeur enregistré précédemment dans la fonction lecture_val
{
    beep_state = 1;
    digitalWrite(tabPin[val], HIGH);  // active la LED (ON) selon la correspondance dans le tableau
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[val] < 300) comparaison selon la valeur enregistré précédemment dans la fonction lecture_val
{
    if ( currentMillis - previousMillis > tabInterval[val] ) // delay selon intervalle enregistré précédemment dans la fonction lecture_val
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(tabPin[val], HIGH);  // active la LED (ON) selon la correspondance dans le tableau
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(tabPin[val], LOW );  // active la LED (Off) selon la correspondance dans le tableau
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(pin, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}

Encore merci à tout le monde de m'aider ! smiley

Benoit
Logged

Made in Belgium
Offline Offline
God Member
*****
Karma: 1
Posts: 756
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

J'ai besoin de faire ce void une seul fois ? et ça le prendra en compte pour toutes les valeurs du tableau ?
ou bien je dois le reécrire pour chaque valeur ? c'est ce que j'ai fait en fait (sur le dernier code que j'ai posté)

Ma question est la meme pour cette partie :


Je comprend pas très la question ou alors il y a une petite confusion sur les fonctions ?  smiley-confuse
Ce qui se trouve devant le nom de la fonction indique le type de retour éventuel de la fonction, donc ici void signifie que la fonction ne retourne rien puisqu'on en a pas besoin dans ton cas. (! une fonction ne peut retourner qu'une seule valeur)

La signature d'une fonction se décompose ainsi.
typeDeRetourDeLaFonction nomDeLafonction(typeDuOuDesParamètresEventuels nomDuOuDesParamètresEventuels)

Code:
void maFonction(byte unParametre)
{
}

byte maFonction(byte unParametre)
{
    return uneVariableDeTypeByte;
}


Edit: Une petite incompréhension peut être également du au fait que loop est une fonction appelé en boucle indéfiniment, cette boucle est masquée par l'ide arduino mais existe bien une fois compilé.

Pour mieux comprendre c'est comme si ton programme ressemblait à ceci

Code:

byte i = 0;

while(1)//boucle infinie
{
    loop(); //appel constant de loop à chaque tour de la boucle while(1)
}

void loop()
{
  if(i < 5) //si i < 5
  {
    lecture_val(i);
    beep(i);
    i++;
  }
  else
  {
     i = 0;
  }

}
« Last Edit: June 11, 2012, 09:55:57 am by osaka » Logged


Offline Offline
Newbie
*
Karma: 0
Posts: 38
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

@Osaka

Ma question est : Est ce que je dois écrire ceci pour chaque pin (pour la lecture de la pin3, la lecture de la pin 5 ... la lecture de la pin11) ? ou cette partie me permet de venir lire toutes mes pin en meme temps ?

Code:
void lecture_val(byte pinVal) //lecture entrée analogique avec en paramètre le numéro de la pin analogique
{
  tabVal[pinVal] = analogRead(pinVal); // on enregistre dans le tableau de correspondance les valeurs
  tabInterval[pinVal] = tabVal[pinVal] * 2; //on calcule l'intervalle que l'on enregistre dans le tableau de correspondance
}


et ma question est la meme pour cette partie :
Code:
void beep(byte val) // fonction beep avec en paramètre la correspondance tableaux
{
unsigned long currentMillis = millis();

if ( tabVal[val] < 100) comparaison selon la valeur enregistré précédemment dans la fonction lecture_val
{
    beep_state = 1;
    digitalWrite(tabPin[val], HIGH);  // active la LED (ON) selon la correspondance dans le tableau
    tone(16, 1319);
    previousMillis = currentMillis;
}
else if (tabVal[val] < 300) comparaison selon la valeur enregistré précédemment dans la fonction lecture_val
{
    if ( currentMillis - previousMillis > tabInterval[val] ) // delay selon intervalle enregistré précédemment dans la fonction lecture_val
    {
        // save the last time you blinked the LED
        previousMillis = currentMillis;   
        if (beep_state == 0)
        {
            beep_state = 1;
            digitalWrite(tabPin[val], HIGH);  // active la LED (ON) selon la correspondance dans le tableau
             
            tone(16, 1319);
        }
        else
       {
            beep_state = 0;
            digitalWrite(tabPin[val], LOW );  // active la LED (Off) selon la correspondance dans le tableau
           
            noTone(16);
        }
    }
}
else
{
    beep_state = 0;
    digitalWrite(pin, LOW );  // active la LED (Off)
   
    noTone(16);
    previousMillis = currentMillis;
}

C'est à dire si ce programme permettant le clignotement de chaque LED doit être écrit pour chacune des LED ou non

Benoit
Logged

Made in Belgium
Offline Offline
God Member
*****
Karma: 1
Posts: 756
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

@Osaka

Ma question est : Est ce que je dois écrire ceci pour chaque pin (pour la lecture de la pin3, la lecture de la pin 5 ... la lecture de la pin11) ? ou cette partie me permet de venir lire toutes mes pin en meme temps ?

C'est à dire si ce programme permettant le clignotement de chaque LED doit être écrit pour chacune des LED ou non

Benoit

Je vois qu'il y a une grosse confusion avec les fonctions, pourquoi réécrire la fonction pour chaque pin différente alors qu'un paramètre est prévu pour.
Les paramètres sont prévu pour recevoir des valeurs donc pour ta fonction nous lui transmettrons la valeur de 'i' qui correspond à l'entrée analogique et au différentes valeurs correspondantes dans les tableaux, c'est la même fonction qui est appelé à chaque fois avec une valeurs en paramètre différent à chaque appel.
Les fonctions n'auraient pas grand intérêt si on doit les réécrire autemps de fois que le nombre de pin l'arduino.

Code:
lecture_val(i); //j'appel la fonction en lui donnant la valeur de 'i' en paramètre


Code:
void lecture_val(byte pinVal) //la fonction appelée prendra en paramètre la valeur transmise lors de l'appel donc 'i'

Un petit teste pour comprendre ce qui ce passe avec affichage dans le serial monitor.

Code:
byte i = 0;
byte tabPin[6] = {3,5,6,9,10,11}; //tableau de correspondance pin digitale en sortie
byte tabVal[6] = {0}; //tableau des valeurs correspondant au pin analogie 0,1,2,3,4,5,6
int tabInterval[6] = {0}; //tableau des intervalle correspondant au pin analogie 0,1,2,3,4,5,6
void setup()
{
    Serial.begin(9600);
    delay(1000);
}

void loop()
{
  if(i < 6) //si i < 6
  {
    Serial.print("i = ");
    Serial.println(i, DEC);
    lecture_val(i); //appel de la fonction avec en paramètre la valeur de i
    i++;
  }
  else
  {
     i = 0;
     delay(5000); //une petite pause pour laisser le temps de lire sur le monitor
  }
  Serial.println();
}

void lecture_val(byte pinVal) //fonction avec en paramètre le numéro de la pin analogique transmise via 'i' lors de l'appel de la fonction
{
  Serial.println("debut fonction lecture_val");
  Serial.print("pinVal : ");
  Serial.println(pinVal, DEC); //On affiche la valeur de pinVal pour chaque appel de la fonction

  tabVal[pinVal] = analogRead(pinVal);
  Serial.print("Valeur relevee : ");
  Serial.println(tabVal[pinVal], DEC); // on affiche la valeur relevée
  tabInterval[pinVal] = tabVal[pinVal] * 2;
  Serial.print("interval : ");
  Serial.println(tabInterval[pinVal] ,DEC); // on affiche l'intervalle calculé
  Serial.println("fin fonction lecture_val");
}


Entre () il y a une petite correction à faire dans mon prog, il y 6 entrées analogique et non 5  smiley-sweat
« Last Edit: June 11, 2012, 11:06:42 am by osaka » Logged


Pages: [1] 2   Go Up
Jump to: