Go Down

Topic: [conseil] soucis de programme (trop long ?) pour detection d'obstacle (sur 360°) (Read 1 time) previous topic - next topic

skizoh

Ton probleme c'est que les fonctions c'est pas tes potes en faite ^^

Regarde:

Tu prépare la fonction void lecture (int x ) { ...; ...; ...; }

ça c'est fait tu l'écrit une seul fois en bas de ton programme sortie du loop du setup, donc au milieu d'aucun crochet parenthèse ou quoi.

apres tes que tu a besoin de faire l'action tu l'appel:

lecture(8);
lecture(4);
lecture(6);

et la le 6 4 8 c'est le numéro de pin que tu indique à la fonction en paramètre pour quel fonctionne, ça tu peu le placer dans le programme !
donc tu n'a besoin que d'une fonction défini comme ça pour faire toute tes pin !
quand tu l'appel ("lecture (2);) elle ce lance fait sont petit bou de programme puis rend la main au programme pour qu'il continue.

c'est mieux la???

Skizo !
Un tien vaux mieux que deux tu l'auras !

Benoit1121

Bonjour Zkizoh et Osaka

J'ai compris le fonctionnement global maintenant. merci à vous.
Me reste plus qu'a voir si réellement j'ai compris en le mettant en œuvre en correspondance avec mon programme.

je mettrais mon programme une fois correctement fini...
Merci

Benoit

skizoh

ok ok bas bon courage et n'hésite pas à pausé tes questions ! :)

Skizo !
Un tien vaux mieux que deux tu l'auras !

Benoit1121

Rah, vous allez peut être me prendre pour un idiot mais je pense qu'on s'éloigne de ma problématique ^^
Je n'arrive pas à visualiser votre fonction dans ce que je veux faire.. :(

Je pense vraiment avoir compris le principe de fonctionnement de votre fonction.

Je me répète mais j'ai 6 sonars, je veux lire les valeurs de mes 6 sonars et il faut que ces 6 valeurs soient differenciées.  En effet car en fonction de ces valeurs je veux allumer une LED (j'ai 6 LED, chaque LED correspond à son sonar.

On va appeler les sonars de Sonar0 à Sonar5 et les LED de LED0 à LED5 :

Sonar0 sur l'entrée analogique 0 (la valeur lue sera appelé par une variable)
Sonar1 sur l'entrée analogique 1 (la valeur lue sera appelé par une variable)
........
Sonar5 sur l'entrée analogique 5 (la valeur lue sera appelé par une variable)

LED0 sur la sortie numerique 3
LED1 sur la sortie numerique 5
LED2 sur la sortie numerique 6
LED3 sur la sortie numerique 9
LED4 sur la sortie numerique 10
LED5 sur la sortie numerique 11

dans une boucle if :

ex : (je présente la chose de façons grossière..)

SI (valeur du sonar1 < 100)

LED1 allumée //

else

 If (valeur sonar1 <300)

LED1 clignote

(voila pour le Sonar1)
..........................................................................

SI (valeur du sonar2 < 100)

LED2 allumée //

else

 If (valeur sonar2 <300)

LED2 clignote

(voila pour le Sonar2)
.
.
.
.
.
.
Pareil jusqu'au sonar 5

D'où l'importance que les valeurs de mes 6 sonars soit différencié.

Bon, En fait ce qui me tracasse c'est qu'avec votre fonction, je ne vois pas comment ça peut associer tel valeur d'un sonar avec telle LED

(pour cela que dans mon tout premier post, j'ai linké le programme avec des fonctions qui se répètent mais c'est pour bien différencier que par exemple la valeur du sonar 1 fera varier la LED1 etc)

Il faudrait que je trouve un moyen de faire lire de facons parallèle chaque programme permettant l'acquisition de la valeur d'un sonar et d'enchainer sur le programme du contrôle de la LED associée. Car dans mon premier programme que j'ai link, ca ne fonctionne pas car la carte execute chaque focntion les unes apres les autres donc je pense que c'est a cause de ca que ca ne fontionne pas ..

Je crois en fait que j'arrive pas à vous faire comprendre mon projet ou alors je ne suis pas fait pour de la programmation ... ^^

Benoit


skizoh

il y à des deux ^^ on c'est écarté a vouloir te faire gobé ce qu'était les fonction et toi tu n'est pas le roi de la prog ^^

bon je te fait un petit truc pour te structuré :
(tes fonction son déjà déclaré elle s'appel lecture(int) et led(int,int) et ton tableau qui récupère tes valeur (bien distincte !)s'appel état ok? )
Code: [Select]

int etat[7];
boolean led_stat[7];

loop()
{

lecture(0);  //lecture sonar 1  valeur stocker dans etat[0]   en suposant que le sonar 1 est a l'adresse 0 le 2 a la 1 etc..
lecture(1);  //lecture sonar 2  valeur stocker dans etat[1]
lecture(2);  //lecture sonar 3  valeur stocker dans etat[2]
lecture(3);  //lecture sonar 4  valeur stocker dans etat[3]
lecture(4);  //lecture sonar 5  valeur stocker dans etat[4]
lecture(5);  //lecture sonar 6  valeur stocker dans etat[5]

led_stat[0]=led(0,etat[0]);    // vérification de l'allumage de la led 1 ( sortie 0 ) en fonction de la valeur sonnar 1 donc etat[0] + stockage etat led dans led_stat
led_stat[1]=led(1,etat[1]);    // vérification de l'allumage de la led 2 ( sortie 1 ) en fonction de la valeur sonnar 2 donc etat[1] + stockage etat led dans led_stat
led_stat[2]=led(2,etat[2]);    // vérification de l'allumage de la led 3 ( sortie 2 ) en fonction de la valeur sonnar 3 donc etat[2] + stockage etat led dans led_stat
led_stat[3]=led(3,etat[3]);    // vérification de l'allumage de la led 4 ( sortie 3 ) en fonction de la valeur sonnar 4 donc etat[3] + stockage etat led dans led_stat
led_stat[4]=led(4,etat[4]);    // vérification de l'allumage de la led 5 ( sortie 4 ) en fonction de la valeur sonnar 5 donc etat[4] + stockage etat led dans led_stat
led_stat[5]=led(5,etat[5]);    // vérification de l'allumage de la led 6 ( sortie 5 ) en fonction de la valeur sonnar 6 donc etat[5] + stockage etat led dans led_stat

}


voila donc la on vois en premier la lecture de tout tes sonar puis le traitement après.

pour obtenir sa on aurais des fonction comme sa:

Code: [Select]

void lecture(int sonar);
{
etat  //tableau  [sonar] //numero de la case du tableau     =   analogRead // lecture     (sonar);   //pin sur la quel lire !   // ( c'est claire la ^^')   
}

boolean led(int led_pin,int etat_sonar) // donc boolean pck on retourne l'état de la led  // led_pin le numéro de pin led associé // état sonar la valeur à tester
{
  if (etat_sonar<100) // test de ton 100 sur l'état sonar correspondant a la led
  {

       digitalWrite(led_pin,HIGH);    //etat haut si positif
       return 1;
   }
  else if(etat_sonar < 300 )          // sinon si < 300 on la fait clignoter
  {
   if(led_stat[led_pin]==1)    // pour clignoter d'abord tester l'état de la led stocker précéda-ment
   {
         digitalWrite(led_pin,LOW);      // éteindre si allumer
          return 0;                                // retourner 0 pour éteinte


    }else
    {
        digitalWrite(led_pin,HIGH);     // si éteinte allumé la led
        return 1;                                 //retourner 1 l'état allumer
    }
  }
}





voila !!! mis a par la ligne avec des commentaire en plein millieu j'ai tester le programme passe la compile déja ^^

Skizo !
Un tien vaux mieux que deux tu l'auras !

osaka

Je pense qu'il y a deux trois notions et logique propre aux développement qui t'échappe, ce qui est normale quand on débute.
a tu bien fais le test que je t'ai proposé sur la page précédent avec les sortie sur le serial monitor parce que tout est là et bien affiché ?

Quote

Bon, En fait ce qui me tracasse c'est qu'avec votre fonction, je ne vois pas comment ça peut associer tel valeur d'un sonar avec telle LED


L'association entrées Analogique (sonar), valeurs et sorties numérique (led) ce situe dans tes tableaux.

Code: [Select]

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;


Dans mes exemples, tout ceci est supprimé et remplacé par les tableaux.

Code: [Select]

byte i = 0;
byte tabPin[6] = {3,5,6,9,10,11}; // soit 3 si i = 0, 5 si i = 1, 6 si i = 2, ...
byte tabVal[6] = {0, 0, 0, 0, 0, 0}; // index de chaque valeur correspondra à i (0->5 dans loop)
int tabInterval[6] = {200, 200, 200, 200, 200, 200}; // index de chaque valeur correspondra à i (0->5 dans loop)


J'aurais pus faire un tableau "entreeAnalog[6] = {0,1,2,3,4,5,6}" mais comme 'i' sera incrémenté dans loop de 0 à 5 ce qui correspond en tout point à tes numéros d'entrée analogique donc pas besoin de variables spécifiques supplémentaires ou tableau, au fur et à mesure que i est incrémenté de 1 nous appelons les fonctions en transmettant ça valeur actuelle en paramètre.


Pour la correspondance, led, valeur et interval, comme les tableaux sont indexé (a partir de 0), si tu veux retrouver une valeur contenue dans l'un de tes tableaux tu lui spécifie l'index voulu entre [], donc si je veux retrouver la deuxième valeur de tabVal je fais "tabVal[1]" et ce 1 la variable i est totalement capable de ta la fournie puisque qu'elle ira de 0 à 5 dans loop.

Lorsque tu transmets i en paramètre à pinVal pour chaque appel de la fonction c'est comme si tu fessais à chaque fois tabVal[0] puisque pinVal vaut 0, tabVal[1]  puisque pinVal vaut 1, tabVal[2] puisque pinVal vaut 2, ...


Regarde bien quand i vaut 3 par exemple, ce qui correspond à ton sonar 3 (entré analogique 3) tu appels la fonction et i est transmis en paramètre de la fonction à pinVal donc pinVal à la valeur 3 à ce moment là, puis dans ta fonction lorque tu lis ta valeur "analogRead(pinVal);" c'est comme si tu fessais analogRead(3) puisque pinVal vaut 3, ensuite tu enregistre la valeur dans le tableau tabVal[pinVal] c'est comme si tu fessais pinVal[3] pousque pinVal vaut 3.
Maintenant lorsque tu appelleras la fonction suivante tu lui transmet également la valeur de i donc il suffira d'aller chercher la ou les valeur enregistré précédemment dans les tableaux correspondant, tabVal[3] puisque i vaut 3 à ce moment là, idem pour les led tabPin[3] vaut 6 donc nous avons bien la sortie digital 6 pour notre sonar 3.

tu peux aller voire mon tuto sur les pointeurs et tableaux peut être que tu y verras plus claire avec mes schémas comme je reprend quelque notions de base dedans.
http://arduino.cc/forum/index.php/topic,101780.0.html

PS: si ton programme ne fais pas ce que tu désires, celà doit venir de ta fonction beep, incohérence d'intervale ou interval de valeurs incorrecte mais le principe que je te fournis depuis la page précédente est le bon :
Tu lis la valeurs d'une entrée analogique dans la fonction lecture et ensuite tu effectues l'action correspondant à la valeur relevé précédement dans la fonction beep, chaque lecture ce fera successivement dans loop selon l'entrée analogique correspondant à 'i' donc de l'entrée 0 à 5.

osaka


SI (valeur du sonar1 < 100)

LED1 allumée //

else

 If (valeur sonar1 <300)

LED1 clignote

(voila pour le Sonar1)
..........................................................................

SI (valeur du sonar2 < 100)

LED2 allumée //

else

 If (valeur sonar2 <300)

LED2 clignote

(voila pour le Sonar2)
.
.
.
.
.
.




Hormis le problème avec la façon de gérer lecture-> action, j'avais pas encore bien regardé cette fonction beep mais je pense que tu dois sortir le code de clignotement de cette fonction, celle-ci ne servirait qu'a indiqué si la led doit clignoté, allumé ou éteinte.
Il y aurait donc une troisième fonction qui ne s'occuperait que de l'action a effectuer sur les led.

Edit : ou supprimer cette fonction beep et attribuer directement  l'action a effectué dans la fonction lecture suivant la valeur relevée dans celle ci ....

Benoit1121

Merci encore une fois à vous deux, c'est plus claire pour moi maintenant.

@skizoh : je vais essayer cette méthode ! merci d'avoir pris le temps ! :)

@osaka : Maintenant je peux dire que j'ai compris , merci à toi aussi d'avoir pris le temps de m'expliquer plus en details et clairement. Je vais également essayer de faire cette méthode afin de mieux comprendre le principe de fonctionnement.

MERCI !

Benoit

osaka

Yop Yop,

Un peux de code pour montrer comment j'aurais fais pour moi.
On lis les valeurs pour chaque entrée analogique successivement (loop), à chaque lecture selon la distance enregistrée on attribue une action numérotée, ensuite on effectue l'action correspondante.

Code: [Select]


byte i = 0; //i sera incrémenté de 1 dans loop, on utilisera sa valeur pour faire correspondre les différente valeur des tableau suivant leur index

const byte tabPinLed[6] = {3,5,6,9,10,11}; //tableau de correspondance numero pin digitale en sortie
byte tabVal[6] = {0, 0, 0, 0 ,0, 0}; //tableau des valeurs relevees
byte tabActions[6] = {0, 0, 0, 0 ,0, 0}; //tableau des actions
int tabInterval[6] = {0, 0, 0, 0 ,0, 0}; //tableau des intervalles

byte beep_state = 0;
unsigned long previousMillis = 0;

void setup()
{
}

void loop() //on peux considéré loop comme une boucle infinie while(1)
{
 if(i < 5) //si i < 5
 {
   lecture_val(i); //appelle de la fonction de lecture des entrée analogique (sonar) correspondant à 'i'
   beep(i); //appel de la fonction beep pour l'action correspondant au sonar 'i' enregistré via tableau dans la fonction lecture_val
   i++; // on incrémente de 1 pour l'entrée (sonar) suivante
 }
 else // sinon on recommence c'est qu'on a fais le tour de toute nos entree analogique ...
 {
    i = 0;
 }
}

void lecture_val(byte sonarNumero) //lecture entrée analogique (sonar), sonarNumero aura pour valeur celle transmise via 'i' dans loop au moment de l'appel
{
 tabVal[sonarNumero] = analogRead(sonarNumero); // on enregistre dans le tableau de correspondance les valeurs

 //selon la valeur mesurée on enregistrera l'action choisie dans un tableau , 0 extinction led+bip, 1 allumage+bip contsant, 2 clignotement+bip alterné
 if (tabVal[sonarNumero] < 100)
 {
   tabActions[sonarNumero] = 1; //si distance inferieure à 100, action 1 correspond à une led allumé constament
 }
 else if (tabVal[sonarNumero] < 300) //si distance supérieur à 100 et inférieure à 300, action 1 correspond à une led allumé constament
 {
   tabActions[sonarNumero] = 2; //action 2 correspondant à un clignotement
   tabInterval[sonarNumero] = tabVal[sonarNumero] * 2; //on calcule un intervalle uniquement pour l'action de clignotement
 }
 else
 {
   tabActions[sonarNumero] = 0; // pour une distance supérieure à 300, action=0 pour extinction de la led
 }
}

void beep(byte sonarNumero) // fonction beep , sonarNumero aura pour valeur celle transmise via 'i' dans loop au moment de l'appel
{
 switch(tabActions[sonarNumero]) //selon le numero d'action enregistré précédemment
 {
   case 1: //si l'action est 1, allumage led constant + beep
   {
    digitalWrite(tabPinLed[sonarNumero], HIGH);
    tone(16, 1319);  
   }
   break;
   
   case 2: //si l'action est 2, clignotement led + beep
   {
     unsigned long currentMillis = millis();
     if ( currentMillis - previousMillis > tabInterval[sonarNumero] ) // delay selon intervalle enregistré précédemment dans la fonction lecture_val
     {      
         if (beep_state == 0)
         {
             beep_state = 1;
             digitalWrite(tabPinLed[sonarNumero], HIGH);  // active la LED (ON) selon la correspondance dans le tableau
             
             tone(16, 1319);
         }
         else
        {
             beep_state = 0;
             digitalWrite(tabPinLed[sonarNumero], LOW );  // active la LED (Off) selon la correspondance dans le tableau
             
             noTone(16);
         }
         previousMillis = currentMillis;
     }
   }
   break;
   
   default : //si l'action est 0 ou autre valeur par defaut, on eteint tout
   {
     digitalWrite(tabPinLed[sonarNumero], LOW);    
     noTone(16);
   }
 }
}


Entre () je remarque que dans mes exemples précédents je n'ai peut être pas utilisé des noms de variables appropriés, d'où une petite confusion possible.  :smiley-sweat:

skizoh

Un tien vaux mieux que deux tu l'auras !

Go Up