[conseil] soucis de programme (trop long ?) pour detection d'obstacle (sur 360°)

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

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 :slight_smile:

Merci

Benoit 1121

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 ?

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.

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.

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.

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.

Benoit1121:
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.

Benoit1121:
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 ...

Bonjour, Merci à vous deux pour vos réponse :slight_smile:

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

@Osaka

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

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 :
```
*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

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

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

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:

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 !

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 :

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

Yop Yop,

Benoit1121:
@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.

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;
}

Merci Osaka pour ces commentaires !

J'ai encore une question qui me turlupine ^^

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 :

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 ! :slight_smile:

Benoit

Benoit1121:
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 ? :~
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)

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

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;
  }

}

@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 ?

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 :

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

Benoit1121:
@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.

lecture_val(i); //j'appel la fonction en lui donnant la valeur de 'i' en paramètre
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.

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 :sweat_smile:

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):wink: elle ce lance fait sont petit bou de programme puis rend la main au programme pour qu'il continue.

c'est mieux la???

Skizo !

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

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

Skizo !

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.. :frowning:

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

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? )

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:

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 !