next topic »

[on:]

Bonjour,

Je souhaite faire des lectures analogRead sur les 6pins, a suivre.

Plutot que de faire

v0 = analogRead(pin0);
v1 = analogRead(pin1);
v2 = analogRead(pin2);
v3 = analogRead(pin3);
v4 = analogRead(pin4);
v5 = analogRead(pin5);

j'aimerai passer par une boucle ou autre pour eviter les ecritures redondantes.

Du style :
for(int i=0;i<=4;i++){
v'i'=analogRead(pin'i');
}

voyez vous ce que je veux dire ? Mais biensur le code ci dessus ne marche pas. Voyez vous comment je pourrais my prendre ?

Merci !

[Reply #1 on:]

Salut
as-tu essayé ça

int pinArray[] = {0, 1, 2, 3, 4, 5};
int count = 0;


void setup(){
  for (count=0;count<6;count++) {
    analogRead(pinArray[count]);
  }
}
je ne garanti pas le resultat,mais je pense que ça fonctionne
@+
William

[Reply #2 on:]

Bonjour Zener57 !

Jai du mal a saisir ton ecriture. C'est comme écrire :


int count = 0;


void setup(){
 for (count=0;count<6;count++) {
   analogRead(count);

Non ?

[Reply #3 on:]

Si on prend son exemple, oui.
Mais le but est d'avoir un tableau regroupant la liste des ports physiques de l'arduino.

Notamment ton :
-pin1 peut etre le port 12,
-pin2 peut etre le port 13,
-pin3 peut etre le port 6, ......

soit le tableau du début :
int pinArray[] = {12, 13, 6, 3, 4, 5};


Donc pour appeler "pin1", tu appelles la case 1 de ton tableau :
pinArray[0] (qui est égal à 12 ici)

[Reply #4 on:]

Ne pas oublier le tableau pour récupérer les résultats

Code:

int pinArray[] = {12, 13, 6, 3, 4, 5};
int count = 0;
int v[6];


void setup(){
 for (count=0;count<6;count++) {
   v[count]= analogRead(pinArray[count]);
 }
}

[Reply #5 on:]

bonjour à tous ,et merci

je viens d'apprendre quelque chose ,il est vrai que j'avais oublié v[count] ,mais ça n'aurai rien changé,il ne faut pas m'en vouloir car je débute sur ce type de programmation et sur l'arduino,je m'etais basé sur le guide reference (array). désolé KiliYaBB pour l'erreur j'ai cru bien faire.
@+
William

[Reply #6 on:]

T'inquiètre zener57 on est tous la pour apprendre, et tu avais pensé a l'array, chose que je n'avais pas faite donc la piste etait bonne !

[Reply #7 on:]

merci,sympa

Surtout que je suis ravi d'etre sur ce forum ,car étant inscrit sur 6 forums differents (electronique) ,je n'ai jamais eu autant d'infos que celui-ci    

@+

[Reply #8 on:]

Bon.. c'est vrai que c'est juste d'un point de vue programmation, mais je vous déconseille de faire une boucle pour ceci.

Même si l'Arduino utilise un microcontrôleur avec pas mal de ressources, faire une boucle en consomme beaucoup (à la fois de la mémoire mais aussi du temps de calcul), ce qui peut poser problème à terme quand votre programme deviendra plus important.

J'avais commencé un article sur l'optimisation de code pour microcontrôleur concernant les appels de fonction. Je pense qu'il va falloir en faire un pour les utilisations de boucles.

http://www.pobot.org/Optimisation-de-code.html

[Reply #9 on:]

Ah bon ?

Je pensais au contraire que faire une boucle serait mieux, plus propre que d'écrire 5 fois la même ligne...

[Reply #10 on:]

Le plus propre n'est pas toujours l'optimum.
Mais en même temps l'optimum des fois on s'en fout. Pour allumer des LED on est pas à quelques µs près. Et si l'écriture du source est plus simple et plus claire on risque moins d'erreur et donc de temps de mise au point.
Le style d'écriture du code dépend aussi de l'application.
En ce qui concerne l'utilisation de la mémoire, il faut faire la guerre aux variables globales qui restent en mémoire pendant toute l'exécution. Il faut privilégier les variable locales aux fonctions car l'espace est rendu dès que l'on quitte la fonction.
Par exemple il est stupide de définir, comme on le voit souvent dans les exemple, les pin d'entrée/sorties avec des variables. En général les numéros de broche ne change pas au cours du programme. Il est préférable de définir ces numéros de broches avec des #define.

[Reply #11 on:]

"""""""""
il faut faire la guerre aux variables globales qui restent en mémoire pendant toute l'exécution. Il faut privilégier les variable locales aux fonctions car l'espace est rendu dès que l'on quitte la fonction.
Par exemple il est stupide de définir, comme on le voit souvent dans les exemple, les pin d'entrée/sorties avec des variables. En général les numéros de broche ne change pas au cours du programme. Il est préférable de définir ces numéros de broches avec des #define
"""""""""""

sur ce point pourrait tu donner un exemple de code stp ?

plutot que :

Code:

int toto=1;

setup{
...
}

void loop {
fonction();
...
}

void fonction(){
while (i<3){
...
}
}

il faudrait ecrire :

Code:

setup{
...
}

void loop {
fonction()
...
}

void fonction(){
int toto=1;
while (i<3){
...
}
}

cest ca ?

[Reply #12 on:]

C'est exactement ça.
Et c'est encore plus vrai lorsqu'on utilise des tableaux.

[Reply #13 on:]

Ok fdufnews mais comment on fait si on veut garder la valeur prise par toto a la fin de la fonction ?

Supposons que fonction() soit dans loop et que dans les boucles on se sert de la dernière valeur de toto dans fonction() ? Par ce que avec cette declaration de toto "toto=1" dans dans fonction() on reinitiliase toto a chaque debut de fonction()

Suis je clair ?

Code:

int toto=1;

void loop{

fonction();

}

fonction{
toto=toto+1;
Serial.print(toto);
}

renverrai 2,3,4...

mais si on écrit

Code:

void loop{

fonction();

}

fonction{
int toto=1;
toto=toto+1;
Serial.print(toto);
}

ca va renvoyer 2,2,2,2...

Comment faire dans ce cas ? Pour déclarer toto dans fonction() mais que l'on conserve sa valeur ?

[Reply #14 on:]

ca va renvoyer 2,2,2,2...

Comment faire dans ce cas ? Pour déclarer toto dans fonction() mais que l'on conserve sa valeur ?

il n'y a pas de miracle, il y a deux façon distincte pour faire ça...
tu peux soit utiliser une variable globale

Code:

int toto=1;

void loop{

  fonction();

}

fonction{
  toto=toto+1;
  Serial.print(toto);
}

ou soit une paramètre dans ta fonction (note que vu la nature de l'appelant (loop) tu va rencontrer le même problème pour déclarer ta variable...)

Code:

void loop{
  int toto=1;
  for(;;){
    fonction(toto);
  }

}

fonction(param){
  param=param+1;
  Serial.print(param);
}

les variables globales, ne sont pas à bannir, il faut just éviter de les utiliser lorsqu'on peut l'éviter (pour toutes les variables locales par exemple)... et généralement préférer la solution des paramètres (pour les variable d'état)...