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

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

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

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.

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.

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.

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

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

@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

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.

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

derien mec, bon courage !!
Skizo !