[Résolu]Quelques questions de "C".

Bonjour à tous,
Préambule: Je sais, qu'il y a le site du zéro, et plein de tutos. Mais les "Hello ]:)world"; y'en a raz l'bol. Donc, les questions:

  • Si j'ai 10 variables: a1, a2, a3....a10; y'a t-il moyen de les déclarer dans une boucle, ou aura t-on toujours 10 lignes de déclaration ?
  • j'ai un doute sur la syntaxe des strings, la doc de ref dit: string constant (ends with °\0°) "abc: : : de"
    mais: "abc...z°\0°" ?; ou: "abc...z"°\0° ?; ou: "abc...z" tout sec ?; qui ne serait pas plus mal. (°\0°<--wtf?-->0°C? Lol!)
  • Peut-on stocker les états des digitalPin dans une string ?
  • Est-ce que: "atoi(s)"; c'est le val(string) du basic ?
  • Si oui, que me renverra à-moi: atoi(00101...) ?
  • Si rien; y'a t-il quelque chose de prévu pour avoir l'état des digitalPin en décimal ? :stuck_out_tongue:
  • Si non.... Snif...Où sont rangés les mouchoirs ?
    Merci d'avance; ce sera tout pour aujourd'huis. Mais....Il en resteuuuu.

bonjour,
un peu de lecture pour tes variables :wink:
http://arduino.amt69.fr/Arduino-lecon2.html

Carolyne:

  • Si j'ai 10 variables: a1, a2, a3....a10; y'a t-il moyen de les déclarer dans une boucle, ou aura t-on toujours 10 lignes de déclaration ?
byte a0, a1, a2, (...), a9;  // déclare 10 variables de type byte (en informatique, on aime bien commencer par 0)
byte b[10];    // déclare un tableau de 10 variables de type byte, accessibles par b[0], b[1], b[2], (...), b[3] (d'où l'idée de commencer par 0)

Carolyne:

  • j'ai un doute sur la syntaxe des strings, la doc de ref dit: string constant (ends with °\0°) "abc: : : de"
    mais: "abc...z°\0°" ?; ou: "abc...z"°\0° ?; ou: "abc...z" tout sec ?; qui ne serait pas plus mal. (°\0°<--wtf?-->0°C? Lol!)

je ne suis pas un champion du string, mais pas un mou du slip non plus. en fait, la chaine de caractère se termine par le caractère nul (code 00 ). donc :

string s = "abcd"; // occupe 5 octets car on rajoute implicitement le caractère nul à la fin
byte b[5] = {97, 98, 99, 100, 0};  // b = s. ces deux déclas sont équivalentes, mais ne seront pas traités pareil...

char c = s[2];   // on met dans c le caractère à la position 2 dans s : c = 'c'
char c1 = b[2];  // étonnament, on a le droit de faire ça
if (c == c1) youpi();  // et la fonction youpi() sera appelée, car l'égalité est vérifiée!

arrêtez-moi si je me trompe.

Carolyne:

  • Peut-on stocker les états des digitalPin dans une string ?

oui, mais c'est dommage, car ça va en bouffer de la mémoire!

Carolyne:

  • Est-ce que: "atoi(s)"; c'est le val(string) du basic ?

jamais utilisé, désolé... http://www.cplusplus.com/reference/cstdlib/atoi/ cela semble être la même chose que val()

Carolyne:

  • Si oui, que me renverra à-moi: atoi(00101...) ?

ben je dirais que ça va rien renvoyer du tout, car atoi() attend un string en paramèrte, là, tu lui donnes une valeur numérique...

int i = atoi("00101");  // i = 101 en décimal

Carolyne:

  • Si rien; y'a t-il quelque chose de prévu pour avoir l'état des digitalPin en décimal ? :stuck_out_tongue:

digitalRead() renvoie une valeur décimale : 0 ou 1 (false ou true, LOW ou HIGH). le mieux, est d'utiliser le type booléen, car c'est fait pour :

boolean b5 = digitalRead(5);  // b5 contient maintenant l'état de la pin 5 (donc true ou false).

si tu veux faire encore plus fort, stocke l'état de 8 pins dans un seul octet!!! (un boolean occupe aussi un octet en mémoire)

byte pins[8] = {0, 1, 3, 6, 12, 4, A3, 13};  // déclare les 8 pins à lire
byte etatPins;  // contient l'état des 8 pins
boolean b5 = digitalRead(5);  // b5 contient maintenant l'état de la pin 5 (donc true ou false).

void setup(){
  for(byte i=0; i<8; i++) pinMode(pins[i], INPUT);  // met les 8 pins en entrée
}

void loop(){
  etatPins = 0;   // initialise la variable
  for(byte i=0; i<8; i++) etatPins |= digitalRead(pins[i]) << i;  // lit les 8 pins et les range dans la variable
// ayé, on a sauvegardé l'état des 8 pins dans etatPins.

  if (etatPins & (1 << 3)) {  // on teste la valeur sauvegardée de la 3ième pin du tableau pins[], soit la 6
    // faire ce qu'on a à faire si la pin 6 était à HIGH
  } else {
    // sinon, faire ce qu'on a à faire si elle était à LOW.
  }
}

J'avoue que je tappe très haut sur ce coup là, à l'occasion, regarde ce qu'il se passe là-dedans, ça nous fera des vacances XD ]:smiley: :grin:

Carolyne:

  • Si non.... Snif...Où sont rangés les mouchoirs ?

tu as utilisé le dernier hier soir.

Super_Cinci:

Carolyne:

  • j'ai un doute sur la syntaxe des strings, la doc de ref dit: string constant (ends with °\0°) "abc: : : de"
    mais: "abc...z°\0°" ?; ou: "abc...z"°\0° ?; ou: "abc...z" tout sec ?; qui ne serait pas plus mal. (°\0°<--wtf?-->0°C? Lol!)

je ne suis pas un champion du string, mais pas un mou du slip non plus. en fait, la chaine de caractère se termine par le caractère nul (code 00 ). donc :

string s = "abcd"; // occupe 5 octets car on rajoute implicitement le caractère nul à la fin

byte b[5] = {97, 98, 99, 100, 0};  // b = s. ces deux déclas sont équivalentes, mais ne seront pas traités pareil...

char c = s[2];   // on met dans c le caractère à la position 2 dans s : c = 'c'
char c1 = b[2];  // étonnament, on a le droit de faire ça
if (c == c1) youpi();  // et la fonction youpi() sera appelée, car l'égalité est vérifiée!



arrêtez-moi si je me trompe.

Attention, le caractère NULL n'est pas zéro, c'est NULL, ou bien '\0'. Et bien faire la nuance entre String et string : String est une classe intégrée depuis l'IDE 1.0, alors que string est le terme pour désigner une chaîne de caractères du genre :

char MaChaine[]= "Coucou"; // prendra 7 octet, 6 pour Coucou + 1 pour le NULL

Donc attention char MaChaine[6]= "Coucou" ==> Erreur, il faut 7 emplacement

Super_Cinci:
char c1 = b[2]; // étonnamment, on a le droit de faire ça

Pourquoi étonnamment ? Tu viens justement de montrer qu'une string c'est une chaine de byte :wink: d'ailleurs sur Code Composer (IDE pour launchpad) le byte n'existe pas, on déclare des char

ça nous fera des vacances

Tu l'a dit !!.. ça va m'occuper un moment. Mais tes explic's m'ont l'air bien claires en première lecture.
à part un truc qui me parait louche (et que je vais donc potasser "à part".)
Je m'en vais raconter tout ça à mon ami le débuggeur. Gros gros MERCI !.
Pour: 'S'tring and 's'tring, on verra plus tard. (faut y aller mollo.)
Tu viens de sauver infobarque que j'allais enguirlander pour m'avoir refilé un lien de "Pré-Newbee".

Carolyne:
un lien de "Pré-Newbee".

tout est bon à lire, ça repose des fois de relire un truc de gros nul, et en plus, dedans, il y a sûrement des nuances qui ne pourront que te confirmer des doutes. Ne vas pas reprocher ça au roi des coincs!

B@tto:
Attention, le caractère NULL n'est pas zéro, c'est NULL, ou bien '\0'. Et bien faire la nuance entre String et string : String est une classe intégrée depuis l'IDE 1.0, alors que string est le terme pour désigner une chaîne de caractères du genre :

char MaChaine[]= "Coucou"; // prendra 7 octet, 6 pour Coucou + 1 pour le NULL

Donc attention char MaChaine[6]= "Coucou" ==> Erreur, il faut 7 emplacement

le code ascii du caractère inconnu n'est pas 0? on l'écrit pourtant '\0' (c'est bien les informaticiens, inventer des matériélisations pour des choses qui n'existent pas XD ).

Justement, faut-il faire la différence entre un char[] et un char[3] par exempe? le second est bien un tableau de 3 caractères, le premier serait alors une chaine de caractères (terminée par '\0') et non pas un simple tableau? Je reconnais qu'en travaillant avec des chaines sur nono, je fais toujours attention à ne pas définir des trucs chelous, uniquement des tableaux de char bornés et bien définis...

Carolyne:

ça nous fera des vacances

Tu l'a dit !!.. ça va m'occuper un moment. Mais tes explic's m'ont l'air bien claires en première lecture.
à part un truc qui me parait louche (et que je vais donc potasser "à part".)
Je m'en vais raconter tout ça à mon ami le débuggeur. Gros gros MERCI !.
Pour: 'S'tring and 's'tring, on verra plus tard. (faut y aller mollo.)
Tu viens de sauver infobarque que j'allais enguirlander pour m'avoir refilé un lien de "Pré-Newbee".

ben voilà, on essaye d'aider et on se fait détendre le string :slight_smile:
tu voulais une réponse, s'en était une, simpliste, mais une approche à ta 1ere question.
après chacun à sa méthode plus ou moins optimisée niveau code et mémoire pour le nono.
si tu veux des réponses que seul un expert peut décoder, pas de soucis, ca sera fait la prochaine fois.

Edit :
merci SC :wink: coincoinc

Super_Cinci:
Justement, faut-il faire la différence entre un char[] et un char[3] par exemple? le second est bien un tableau de 3 caractères, le premier serait alors une chaine de caractères (terminée par '\0') et non pas un simple tableau? Je reconnais qu'en travaillant avec des chaines sur nono, je fais toujours attention à ne pas définir des trucs chelous, uniquement des tableaux de char bornés et bien définis...

Entre char MaChaine[3] = "12" et char MaChaine[]="12" il n'y aura aucune différence, l'avantage de d'utiliser [] c'est d'être sûr de ne pas se viander dans le dimensionnement du tableau tout en économisant au maxi la RAM. On évite les erreurs et les prises de tête, tout bénef :slight_smile: bien sûr si la chaines est manipulée ensuite il faut veiller à ne pas dépasser l'index maxi. D'ailleurs je ne sais ce qui se passe si on touche au NULL en fin de chaîne ...

Bah, infobarque, tu va pas aller te vexer ? C'était pour de rire.
Bon, j'ai compris qu'il allait falloir se taper la conversion à la pogne.
Alors, à partir de ton code Super_5, j'ai fait ce qui suit:
Mais ce coquin de débug me refuse ça: byte tabpin[8] = ( 0, 0, 0, 0, 0, 0, 0);
Qui est pourtant le même que le tiens: byte pins[8] = {0, 1, 3, 6, 12, 4, A3, 13};
Aux N° près.
Il va falloir aussi que j'éclaicisse le confusionnaaage entre: chaîne et tableau.

byte pins[8] = { 1, 2, 3, 4, 5, 6, 7};  // déclare les 8 pins à lire
byte etatPins;  // contient l'état des 8 pins (d'une pin)
boolean b5 = digitalRead(5);  // b5 contient maintenant l'état de la pin 5 (donc true ou false).
int incr = 0;
byte tabpin[8] = ( 0, 0, 0, 0, 0, 0, 0, 0);
byte bi[8] = ( 0, 0, 0, 0, 0, 0, 0), 0;
int energtot = 0;

void setup(){
  for(byte i=0; i<8; i++) pinMode(pins[i], INPUT);  // met les 8 pins en entrée
}

void loop(){
  etatPins = 0;   // initialise la variable
  for(byte i=0; i<8; i++){
    etatPins |= digitalRead(pins[i]) << i;   // lit les 8 pins et les range dans la variable
  }
  for(incr = 7; incr != 0; incr--){
    if (etatPins & (1 << incr)) {  // on teste les valeurs du tableau pins[]
      // faire ce qu'on a à faire si la pin 6 était à HIGH
      bi[incr]=2^incr; // on mets dans bi[] la ^ de 2 correspondante
    }
  }
  for(incr = 7; incr != 0; incr--){
    energtot=energtot + bi[incr]; //on additionne, et normalement on a le résultat
  }
}
[code]
Ouille ! AÏe ! On avait dit: Pas la tête !!!!

[/code]
Edit: j'ai ajouté les zéros qui manquaient dan tabpin[] et bi[]
Le débug en veut toujours pas.... sale bête !

quelques corrections...

Carolyne:
Bah, infobarque, tu va pas aller te vexer ? C'était pour de rire.
Bon, j'ai compris qu'il allait falloir se taper la conversion à la pogne.
Alors, à partir de ton code Super_5, j'ai fait ce qui suit:
Mais ce coquin de débug me refuse ça: byte tabpin[8] = ( 0, 0, 0, 0, 0, 0, 0);
Qui est pourtant le même que le tiens: byte pins[8] = {0, 1, 3, 6, 12, 4, A3, 13};
Aux N° près.

en rouge : tu mets des parenthèses... ce sont des acollades qu'il faut!

Carolyne:
Il va falloir aussi que j'éclaicisse le confusionnaaage entre: chaîne et tableau.
quelques erreurs :

byte pins[8] = { 1, 2, 3, 4, 5, 6, 7};  // déclare les 8 pins à lire     /!\ Tu n'en a mis que 7

byte etatPins;  // contient l'état des 8 pins (d'une pin)
boolean b5 = digitalRead(5);  // b5 contient maintenant l'état de la pin 5 (donc true ou false).  /!\ tu ne peux pas initialiser en appelant une fonction avant le setup()
int incr = 0;
byte tabpin[8] = ( 0, 0, 0, 0, 0, 0, 0);  //  /!\ des acollades! et y'en a que 7...
byte bi[8] = ( 0, 0, 0, 0, 0, 0, 0);          //  /!\ idem et idem
int energtot = 0;

void setup(){
  for(byte i=0; i<8; i++) pinMode(pins[i], INPUT);  // met les 8 pins en entrée
}

void loop(){
  etatPins = 0;  // initialise la variable
  for(byte i=0; i<8; i++){
    etatPins |= digitalRead(pins[i]) << i;  // lit les 8 pins et les range dans la variable
  }
  for(incr = 7; incr != 0; incr--){
    if (etatPins & (1 << incr)) {  // on teste les valeurs du tableau pins[]
      // faire ce qu'on a à faire si la pin incr était à HIGH
      bi[incr]=2^incr; // on mets dans bi[] la ^ de 2 correspondante  /!\  je ne vois pas ce que tu cherches à faire là...
    }
  }
  for(incr = 7; incr != 0; incr--){
    energtot=energtot + bi[incr]; //on additionne, et normalement on a le résultat
  }
}

[code]
Ouille ! AÏe ! On avait dit: Pas la tête !!!!


[/code]

Et c'est sencé faire quoi au juste? car exploîter les données de bi[], ça va pas être facile... si tu veux une chaîne de caractères contenant des 1 et des 0, il y a plus simple à partir de etatPins :

string s;  // déclarer une chaîne
// et dans loop :
  s = "";
  for(incr = 7; incr != 0; incr--){
    if (etatPins & (1 << incr)) {  // on teste les valeurs du tableau pins[]
      s += '1';
    } else {
      s += '0';
    }
  }

J'ai pas tappé ailleurs que sur mon clavier, le pauvre, il a tout pris...

Argh! Les parenthèses ! Le piège ! Pourtant je n'ai pas un petit écran.
Les chaines, je crains de ne pas m'en sortir, il me semble que la gestion des tableaux est plus facile.
Donc, je comptais tester les états dans une "for" avec "incr" comme "moteur".
Si état = 1 mettre dans bi[ ] la puissance de 2 correspondant au rang du bit, en me servant de: "incr" pour indicer le tableau et aussi comme exposant.(puisque c'est aussi le rang.)
Je me suis apperçue entre temps que le "^" n'était pas de mise.
bi[ ] est un tableau; pourquoi ce n'est pas simple de l'exploiter.
J'ai un peu de mal avec les déclarations de "types". Mais patience, ça viendra. Il faut que je potasse le truc.

Carolyne:
bi[ ] est un tableau; pourquoi ce n'est pas simple de l'exploiter.

disons que les valeurs possibles de bi[ x ] seraient (selon l'état de la pin correspondante) :

xbi[ x ] (0)bi[ x ] (1)etatPins & (1 << x) (0)etatPins & (1 << x) (1)
00101
10202
20404
30808
4016016
5032032
6064064
701280128

en restant sur etatPins, tu n'utilises qu'une seule variable (un seul octet), alors que bi demande 8 octets (et le temps de le remplir), pour un même résultat. pour les tests, if (bi[ x ])... équivaut à if (etatPins & (1 << x))... par exemple, si tu veux tester l'état 1 de deux pins en même temps, alors if (etatPins & 0x14) est plus rapide que if ( bi[4] && bi[2] )

oups, si je commence à mettre de l'hexa... XD ==> []

désolé, le tableau est pas très lisible...

Tu est en train de dire que l'on peut lire une chaine comme un tableau (sans passer par des "left$", "right$" et consorts.) C'est super ça !
Ce qui me fait peur c'est la syntaxe qui n'est pas du tout "parlante" (etatPin &(1 << x))
Tes valeurs du tableau vont très bien, avec ça on peut convertir binaire-->décimal.
Je vais tester ton truc de ouf: "& ta Pin et machin-chouette."
Y'a des chances que je revienne pour l'élévation (comme à l'église Amen!)
Because: Y'a une entourloupe à base de "base" (je vais mettre base 10, on verra bien ce qui sort...)
p....n, avec cette syntaxe; je suis en apnée. :stuck_out_tongue: . Et avec la loupe...Pour les "paren-ccolades". :astonished:
Encore merci, tu me fait bien avancer. Sur mon basar, et sur ce langage si bizarre.

Pour l'élévation, j'ai mis: bi[incr]=pow(2, incr) ]:); j'espère que c'est ça pour faire: 2^incr. :stuck_out_tongue:
En tous cas il me l'a pris sans broncher.
Me confirme tu qu'il faut mettre une R dans les 15 à 70K en série avec les poussoirs sur les digitalPins ?
Sur le petit schéma de la leçon 1 on dirait que la R est incluse dans la carte. Mais sur le montage, il y a une R de: 1,2k ou 12K ?
Comme je vais mettre des straps permanents pour les essais, je ne mets pas de condos.
J'attendrai ta réponse pour les R des poussoirs avant d'envoyer les électrons.

oui il faut une résitance pour éviter les rebonds.
10k suffit en général
certains rajoutent un condo, mais c'est pas indispensable.
réponse de "pré-newbie" ? :slight_smile:

Carolyne:
J'attendrai ta réponse pour les R des poussoirs avant d'envoyer les électrons.

Tu fais bien, car tu risques d'avoir un souci, voir plus loin ou plus bas.

Carolyne:
Pour l'élévation, j'ai mis: bi[incr]=pow(2, incr) ]:); j'espère que c'est ça pour faire: 2^incr. :stuck_out_tongue:
En tous cas il me l'a pris sans broncher.

en effet, mais les puissances, c'est du bouffe mémoire-temps à mort. ci-dessous un petit truc très utile :

i = 1 << x;  // donne le même résultat que i = pow(2, x);

Pourquoi?
1 : i = 1 << x dit que dans i, on met 1 décalé de x bits. en binaire :

byte b1 = b00000001 << 1;  // = b00000010     // on a décalé le tout vers la gauche (le sens des flèches) de 1 bit.
byte b2 = b00000001 << 6; // = b01000000     // on a décalé le tout vers la gauche (le sens des flèches) de 6 bit.

Résultat :
b1 = 2 en décimal, soit 2^1 (en réalité, l'opération est b1 = 1 x 2^1)
b2 = 64 en décimal, soit 2^6 (en réalité, l'opération est b1 = 1 x 2^6)
l'est pas belle la vie?
2 : l'opérateur "<<" est intégré dans le code machine (assembleur, éxécution directe dans le processeur) et ne prend que 62,5ns. la fonction pow() doit bien prendre quelques dizaines de ms...
généralisation de l'opérateur : A << B = A x 2^B
par analogie, l'opérateur ">>" fait l'inverse : décallage à droite, donc A >> B = A / 2^B
t'es toujours là?
Pour multiplier ou diviser un nombre par une puissance de 2 (2, 4, 8, 16, 32.....), on utilise de préférence les opérateurs << et >> 1000 fois plus rapide que les multiplications ou divisions arythmétiques. Seule limitation : ça ne marche que sur des entiers non signés, sinon, le résultat peut être... comment dire... inattendu?
http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.Decalage

Carolyne:
Me confirme tu qu'il faut mettre une R dans les 15 à 70K en série avec les poussoirs sur les digitalPins ?
Sur le petit schéma de la leçon 1 on dirait que la R est incluse dans la carte. Mais sur le montage, il y a une R de: 1,2k ou 12K ?
Comme je vais mettre des straps permanents pour les essais, je ne mets pas de condos.

non, je ne confirme pas. il faut mettre le bouton poussoir entre la pin d'entrée et la masse (le 0V). ensuite, dans le setup(), faire pinMode(pin, INPUT_PULLUP);. Ensuite, à la lecture, si tu as 1, c'est que le bouton est relâché (la résistance interne du circuit rappelle la pin à +5V), si tu as 0, c'est qu'il est appuyé. pas besoin de rajouter une résistance, elle est déjà dans le biniou, suffit de l'activer!

COIIIIIIIIIIINC??? une résistance n'évite pas les rebonds... ça n'a pas de réponse temporelle, une résistance... seule une capa en parrallèle avec le contact fait un bon antirebond! tu n'as pas inversé tes mots?

j'oublie toujours cette #### de pull_up qu'on peut déclarer dans le setup, honte à moi.

COIIIIIIIIIIINC??? une résistance n'évite pas les rebonds... ça n'a pas de réponse temporelle, une résistance... seule une capa en parrallèle avec le contact fait un bon antirebond! tu n'as pas inversé tes mots?

si on se réfère à ceci http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ExempleDebounce
non, c'est bien une résistance qui est utilisée.
par contre, je sais pas si ceci est encore valable

attachInterrupt(bouton, traite_int, FALLING);

infobarquee:

COIIIIIIIIIIINC??? une résistance n'évite pas les rebonds... ça n'a pas de réponse temporelle, une résistance... seule une capa en parrallèle avec le contact fait un bon antirebond! tu n'as pas inversé tes mots?

si on se réfère à ceci http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ExempleDebounce
non, c'est bien une résistance qui est utilisée.

Mais si on regarde bien, il relie le BP entre le +5 et la pin et se sert de la résistance comme pull-down. Il gère ensuite le debounce en soft. Nous, on préfère mettre une capa sur le BP, ça évite bon nombre de lignes de code et surtout d'oublis...

infobarquee:
par contre, je sais pas si ceci est encore valable

attachInterrupt(bouton, traite_int, FALLING);

si, sûrement, mais avec un I majuscule à Interrupt avais mal lu. :wink:

exact :wink:

oui avec un i majuscule, tu m'as mIs le doute à un moment

Oh ! ! ! Trop fort le coup du décalage. ça marche que pour les puissances de 2, mais c'est bien pratique pour gérer le binaire cette magouille. Mais bon, faut quand même bien maîtriser le sujet.

t'es toujours là?

Oui...mais le: A >> B = A / 2^B; je vais le réserver pour les grandes occasions. Une fausse manip avec ce truc, ça doit pas être facile à débusquer.
Je suis même allée voir ton lien; où c'est trop expliqué; ça noie le pêcheur.

  • Le INPUT_PULLUP, vu que c'est: "pinMode ça doit mettre les R sur toutes les pins; normalement.
  • Par contre, j'ai vu quelque part qu'il ne fallait pas laisser les digitalPin en l'air. (laisser les pin en l'air Looool!! Ces anglais avec leur pin, ils nous font écrire de ces choses) Mais si je ne les lis pas, je peux les laisser en l'air ? ou non ? Ces pines. A mon avis: Oui.

Pour les condos de poussoirs, on dira : A la louche: 100 nF. J'ai bon ? (m'en fout je vais mettre des dips, en attendant de faire une belle usine à gaz d'encodage en TTL. Faudra pas en mettre trop non plus. C'est que ça bouffe ces bestioles.)

infobarquouiiiinc say:

réponse de "pré-newbie" ? smiley

I reply: couiiiiinc ? Pouuuett XD !
Edit: Rectif je remplace le INPUT par: INPUT_PULLUP dans la "for"; et voili voilou.