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
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
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.
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.
"""""""""
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 :
int toto=1;
setup{
...
}
void loop {
fonction();
...
}
void fonction(){
while (i<3){
...
}
}
il faudrait ecrire :
setup{
...
}
void loop {
fonction()
...
}
void fonction(){
int toto=1;
while (i<3){
...
}
}
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 ?
int toto=1;
void loop{
fonction();
}
fonction{
toto=toto+1;
Serial.print(toto);
}
renverrai 2,3,4...
mais si on écrit
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 ?
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)...
Cette écriture ne permet pas à l'appelant de récupérer toto et donc d'incrémenter toto à chaque itération.
Il faut que fonction() retourne un entier
void loop{
int toto=1;
for(;;){
toto=fonction(toto);
}
}
int fonction (int param){
int temp=param+1;
Serial.print(temp);
return(temp);
}
ou alors il faut passer par des pointeurs. Là c'est un peu lourd pour manipuler une pauvre variable. Par contre c'est efficace pour les tableaux et les structures.
void loop{
int toto=1;
for(;;){
fonction(&toto);
}
}
fonction (int* param){
*param=*param+1;
Serial.print(*param);
}
[edit]Oups j'ai fait une boulette dans la version avec pointeur, à l'intérieur de la fonction ce n'est pas toto qui doit apparaitre mais param bien sur. Correction effectuée[/edit]
