Voila cela fait un tout petit moment que je me suis mis à l'arduino est là pour un projet plus complexe je seche
Sa va vous paraître c** mais par comment remplacer sa!?
maFonction(TrucA, BiduleA, MachinA);
maFonction(TrucB, BiduleB, MachinB);
maFonction(TrucC, BiduleC, MachinC);
....
Pour le moment il y à 18 ligne prévu......
Bonsoir,
Que veux-tu dire part "Comment remplacer çà!?"
Remplacer par quoi ?
Pour info (ou cas où tu ne le saurais pas),
maFonction(TrucA, BiduleA, MachinA);
équivaut à :
maFonction(int A, int B , int C);
Genre Non de la fonction( type ....)
Ta fonction "maFonction" reçoit ou doit recevoir 3 paramètres (dont le type est défini en fonction des donnés à recevoir) afin de pouvoir exécuter les instructions qui lui sont assignées. En gros il lui faut ces trois paramètres pour pouvoir faire le travail qu'il faut.
La question est un peu vague mais je pense comprendre ce que tu cherches. Tu devrais creuser de ce cote là : http://arduino.cc/en/Reference/Array
Un tableau permet de stocker un ensemble de données et de les ressortir ensuite. L'accès se faisant par un index cela permet de coder une boucle pour extraire les données au lieu de répéter plusieurs fois la même ligne.
Ainsi le code suivant
maFonction(TrucA, BiduleA, MachinA);
maFonction(TrucB, BiduleB, MachinB);
maFonction(TrucC, BiduleC, MachinC);
maFonction(TrucD, BiduleD, MachinD);
devient
const byte la_taille_de_mon_tableau=4;
type de la variable monTableau[la_taille_de_mon_tableau][3]={{TrucA, BiduleA, MachinA},
{TrucB, BiduleB, MachinB},
{TrucC, BiduleC, MachinC)},
{TrucD, BiduleD, MachinD)}
};
for(byte i=0;i<la_taille_de_mon_tableau;i++){
maFonction(monTableau[i][0],monTableau[i][1],monTableau[i][2]);
}
Éventuellement maFonction pourrait être re-écrite pour lui passer en argument monTableau plutôt que les 3 valeurs. Mais c'est une autre histoire .....
Désolé c'est vraiment quand me relisant ce matin...... :~ je vais essayé d'être plus clair
j'ai 3x18 variable qui se ressemble
TrucA, TrucB, TrucC . . . . . TrucR
BiduleA, BiduleB, BiduleC . . . . . BiduleR
MachinA, MachinB, MachinC . . . . MachinR
Je voudrais simplement faire une boucle qui change automatiquement :A par B puis C puis D . . . . R
sa me permettrai d'écrire qu'un seul fois ma fonction plutot que toutes ses ligne!
PS: En écrivant ceci je me demande finalement si c'est utile 
car quoi qu'il arrive il faut les écrires quelque part, sauf si je met la liste sur une SD, Sa éviterai surtout les erreur de frappe, et l'ajout et la suppression rapide d'une nouvelle "lettre".....
Bin fdufnews t'as donné la solution
fdufnews:
La question est un peu vague mais je pense comprendre ce que tu cherches. Tu devrais creuser de ce cote là : http://arduino.cc/en/Reference/Array
Un tableau permet de stocker un ensemble de données et de les ressortir ensuite. L'accès se faisant par un index cela permet de coder une boucle pour extraire les données au lieu de répéter plusieurs fois la même ligne.
c'est presque ça :), dans l'idéal je voudrai appeler directement la ligne A qui me resortirai donc TrucA , BiduleA, MachinA que je fais passer à ma fonction
Je vais me pencher sur les tableau du coup sa peut peut etre résoudre mon soucis
merci....
PS: Vous écrivez trop vite j'ai pas le temps de répondre moi!!!!! MDR
fdufnews
En faite c'est sa!!!!! :* :* :* :*
Juste une autre question du coup est il possible d'avoir des variables:
trucA
trucB
trucC
est de les appeler à la demande c'est à dire:
Taper une lettre
lettre = "lettre taper"
Afficher truc(lettre)
bonjour,
ca serait tripounettement bien d'être plus clarinette, car j'ai l'impression de lire la bd "sisters" (sympa au passage).
mais tres trucs, machin bidulechose, c'est quoi?
des float, int?
on recatapulte donc ce que tu veux trucmachinchosefaire 
via le serail tu veux rentrer une lettre, puis afficher le résultat en retour de ta fonction si j'ai bien compris
je ferai un truc comme ca
utilise les switch case dans ce cas avec ta fonction
if serial ...........
switch (test){
case A :
mafonction( test,test,test);
break;
case B:
mafonction( test,test,test);
break;
case C:
mafonction( test,test,test);
break;
.....
....
void mafonction(byte x,byte y,byte z)
{
le travail de ta fonction
return;
}
par la même occasion, change le titre de ton topic pour être plus explicite 
par ce que "je sèche", on va dire, bois un coup et mets toi à l'ombre
Hello.
En fait, son 1er souci a une solution en PHP (mais pas du tout recommandé selon moi): des variables-variables.
Je sais pas si ça existe en C (mais c'est déjà pas propre en PHP alors en C ...)...
Il faudrait d'abord que tu expimes clairement ce que tu veux avant de commencer à imaginer les solutions techniques, sinon tu vas nous pondre une usine à gaz
Ninnin:
Hello.En fait, son 1er souci a une solution en PHP (mais pas du tout recommandé selon moi): des variables-variables.
Je sais pas si ça existe en C (mais c'est déjà pas propre en PHP alors en C ...)...
il est ou le php?
parce que rien n'indique comment il veut si prendre
donc on en revient au même point de départ
ca serait tripounettement bien d'être plus clarinette, car j'ai l'impression de lire la bd "sisters" (sympa au passage).
mais tres trucs, machin bidulechose, c'est quoi?
des float, int?
Il faudrait d'abord que tu expimes clairement ce que tu veux avant de commencer à imaginer les solutions techniques, sinon tu vas nous pondre une usine à gaz smiley-wink
Désolé de ne pas être assez claire :*
Voici mon code (j'ai juste gardé ce que je voudrai amélioré)
const byte BoutonA = 0, SortieA = 13; boolean AncienEtatA = 0;
const byte BoutonB = 1, SortieB = 12; boolean AncienEtatB = 0;
const byte BoutonC = 2, SortieC = 11; boolean AncienEtatC = 0;
maFonction(BoutonA, AncienEtatA, SortieA); //La partie que je voudrait remplacer
maFonction(BoutonB, AncienEtatB, SortieB); //La partie que je voudrait remplacer
maFonction(BoutonC, AncienEtatC, SortieC); //La partie que je voudrait remplacer
int maFonction(byte param1, byte param2, byte param3)
{ actuel = digitalRead(param1); //Lecture du bouton
if (actuel != param2) //Si actuel différent de ancien
{ if (actuel == LOW) //Si bouton est appuyé
{ if (digitalRead(param3) == LOW) //Si LED est éteinte
{ digitalWrite(param3, HIGH); //Allume la LED
}
else
{ digitalWrite(param3, LOW); //Eteind la LED
}
}
param2 = actuel;
}
}
L'appelle de la fonction à lieu (pour l'intant) 18x c'est pour celà que j'aimerais la remplacer, la solution de fdufnews me convient pour l'instant.
mais je me demander si l'on ne pouver pas simplement lancé la fonction en indiquant juste A,B ou C
c'est à dire:
je lance une fonction avec "A","B" ou "C"
et elle me ressort "BoutonA, AncienEtatA, SortieA"
que je renvoie dans "maFonction(BoutonA, AncienEtatA, SortieA);"
J'éspère que j'ai réussi à me faire comprendre! XD
Soit, mais que veux-tu faire au juste (le "business" de ton programme) ? on ne voit qu'une facette de ton problème, et ce n'est pas clair du tout.
Ta demande correspond dans l'idée à ce que je proposais à la fin de ma réponse.
Re-écrire la fonction pour qu'elle accepte en argument une ligne du tableau plutôt que trois valeurs.
Là tu voudrais passer l'index en argument à la fonction et c'est dans la fonction que tu interrogerais le tableau.
Maintenant, c'est vrai que la demande n'est pas claire. Par exemple dans ta dernière réponse ont a constaté que ton besoin mélanges les types et donc ce n'est plus un tableau à 2 dimensions qu'il faudrait utiliser mais un tableau de structures.
Un simple switch / case ne va-t-il pas résoudre le problème?
Une solution "bazooka" serait d'utiliser des "design patterns" mais je pense que le problème est plus simple qu'il n'est présenté.
j'i pas l'impression que tout le monde comprenne ce que tu veux faire, mais j'ai mon idée.
et tu ne lis pas toutes les réponses et XavierMiller a la même idée que moi
relis ma réponse
http://forum.arduino.cc/index.php?topic=243116.msg1741884#msg1741884
bon je vais m'occupé des tableau dés que je peux!
voila mon "vrai" code! par contre j'ai un soucis à la fin de la fonction?
////////////////////////////////////////////////////////////// Les Broches //////////////////////////////////////////////////////////////
//Entrée (digital)
const int InterCuisine = 0;
//const byte InterSalleManger = 1;
//const byte InterSalon = 2;
//const byte InterHall = 4;
//const byte InterWcBas = 7;
//const byte InterAtelier = 8;
//const byte InterGarage = 12;
//sortie (digitale)
const int LumiereCuisine = 13;
//const byte LumiereSalleManger = 13;
//const byte LumiereSalon = 13;
//const byte LumiereHall = 13;
//const byte LumiereWcBas = 13;
//const byte LumiereAtelier = 13;
//const byte LumiereGarage = 13;
////////////////////////////////////////////////////////////// Les variables //////////////////////////////////////////////////////////////
int actuel = 0;
int AncienInterCuisine = 0;
//boolean AncienInterSalleManger = 0;
//boolean AncienInterSalon = 0;
//boolean AncienInterHall = 0;
//boolean AncienInterWcBas = 0;
//boolean AncienInterAtelier = 0;
//boolean AncienInterGarage = 0;
////////////////////////////////////////////////////////////// Initialisation //////////////////////////////////////////////////////////////
void setup()
{
pinMode(InterCuisine, INPUT);
//pinMode(InterSalleManger, INPUT);
//pinMode(InterSalon, INPUT);
//pinMode(InterHall, INPUT);
//pinMode(InterWcBas, INPUT);
//pinMode(InterAtelier, INPUT);
//pinMode(InterGarage, INPUT);
pinMode(LumiereCuisine, OUTPUT);
//pinMode(LumiereSalleManger, OUTPUT);
//pinMode(LumiereSalon, OUTPUT);
//pinMode(LumiereHall, OUTPUT);
//pinMode(LumiereWcBas, OUTPUT);
//pinMode(LumiereAtelier, OUTPUT);
//pinMode(LumiereGarage, OUTPUT);
}
////////////////////////////////////////////////////////////// Le Programme //////////////////////////////////////////////////////////////
void loop()
{
VaEtVient(InterCuisine, AncienInterCuisine, LumiereCuisine);
//VaEtVient(InterSalleManger, AncienInterSalleManger, LumiereSalleManger);
//VaEtVient(InterSalon, AncienInterSalon, LumiereSalon);
//VaEtVient(InterHall, AncienInterHall, LumiereHall);
//VaEtVient(InterWcBas, AncienInterWcBas, LumiereWcBas);
//VaEtVient(InterAtelier, AncienInterAtelier, LumiereAtelier);
//VaEtVient(LumiereGarage, AncienInterGarage, LumiereGarage);
}
////////////////////////////////////////////////////////////// Les Fonctions //////////////////////////////////////////////////////////////
int VaEtVient(int param1, int param2, int param3)
{
actuel = digitalRead(param1);
if (actuel != param2) //Si l'actuel est différent de ancien
{
if (actuel == LOW) //Si le bouton est appuyé
{
if (digitalRead(param3) == LOW) //Si la lumière est éteinte
{
digitalWrite(param3, HIGH); //Allume la lumière
}
else
{
digitalWrite(param3, LOW); //Eteind la lumière
}
}
AncienInterCuisine = actuel; // PB je ne pas utilisé param2 car sinon reste dans la boucle
}
}
Voilà
Dans la partie "le programme" c'est ce que je veux évité, j'essairai avec un tableau en 2 dimension est une boucle!
whouaou, tout ca pour ca?
cherche du coté de boolean, ca va te simplifier la vie