Un bouton "multifonction"

Bonjour. Je debute. Je viens de lire

Je debute une expérimentation:
Je voudrais incrémenter/decrementer une variable avec un bouton poussoir.
Quelle est selon vous le meilleur moyen sachant que je débute.

  • un appuie long veut dire que je veut diminuer, ensuite chaque appuie decremente la variable et un nouvel appuis long me sort du mode.
  • un appuie court veut dire que je veut augmenter, puis chaque appuie incremente la variable et appuie long pour sortir

Ou deux boutons ou un menu ?

Je n'ai pas trouvé de tuto accessible au débutant.
Auriez vous des liens ou une idée de comment organiser tout ça " simplement"
Merci

c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

en complément de la réponse de J-M-L sur la structuration en 'machine à états' voir la librairie simplebouton de bricoleau etles exemples fournis (dont les appuis longs)

La bibliothèque JC_Button se prête bien à ce genre de besoin, elle propose la détection d’appuik long ou court. L’exemple LongPress est écrit sous forme d’une machine à états.

A simple state machine where a short press of the button turns the Arduino pin 13 LED on or off, and a long press causes the LED to blink rapidly. Once in rapid blink mode, another long press goes back to on/off mode.

C’est très proche de ce que tu présentes.

Je le recopie ci-dessous :

#include <JC_Button.h>          // https://github.com/JChristensen/JC_Button

// pin assignments
const byte
    BUTTON_PIN(7),              // connect a button switch from this pin to ground
    LED_PIN(13);                // the standard Arduino "pin 13" LED

Button myBtn(BUTTON_PIN);       // define the button
const unsigned long
    LONG_PRESS(1000),           // we define a "long press" to be 1000 milliseconds.
    BLINK_INTERVAL(100);        // in the BLINK state, switch the LED every 100 milliseconds.

void setup()
{
    myBtn.begin();              // initialize the button object
    pinMode(LED_PIN, OUTPUT);   // set the LED pin as an output
}

// the list of possible states for the state machine. This state machine has a fixed
// sequence of states, i.e. ONOFF --> TO_BLINK --> BLINK --> TO_ONOFF --> ONOFF
// note that while the user perceives two "modes", i.e. ON/OFF mode and rapid blink mode,
// two extra states are needed in the state machine to transition between these modes.
enum states_t {ONOFF, TO_BLINK, BLINK, TO_ONOFF};

bool ledState;                  // current LED status
unsigned long ms;               // current time from millis()
unsigned long msLast;           // last time the LED was switched

void loop()
{
    static states_t STATE;      // current state machine state
    ms = millis();              // record the current time
    myBtn.read();               // read the button

    switch (STATE)
    {
        // this state watches for short and long presses, switches the LED for
        // short presses, and moves to the TO_BLINK state for long presses.
        case ONOFF:
            if (myBtn.wasReleased())
                switchLED();
            else if (myBtn.pressedFor(LONG_PRESS))
                STATE = TO_BLINK;
            break;

        // this is a transition state where we start the fast blink as feedback to the user,
        // but we also need to wait for the user to release the button, i.e. end the
        // long press, before moving to the BLINK state.
        case TO_BLINK:
            if (myBtn.wasReleased())
                STATE = BLINK;
            else
                fastBlink();
            break;

        // the fast-blink state. Watch for another long press which will cause us to
        // turn the LED off (as feedback to the user) and move to the TO_ONOFF state.
        case BLINK:
            if (myBtn.pressedFor(LONG_PRESS))
            {
                STATE = TO_ONOFF;
                digitalWrite(LED_PIN, LOW);
                ledState = false;
            }
            else
                fastBlink();
            break;

        // this is a transition state where we just wait for the user to release the button
        // before moving back to the ONOFF state.
        case TO_ONOFF:
            if (myBtn.wasReleased())
                STATE = ONOFF;
            break;
    }
}

// reverse the current LED state. if it's on, turn it off. if it's off, turn it on.
void switchLED()
{
    msLast = ms;                // record the last switch time
    ledState = !ledState;
    digitalWrite(LED_PIN, ledState);
}

// switch the LED on and off every BLINK_INTERVAL milliseconds.
void fastBlink()
{
    if (ms - msLast >= BLINK_INTERVAL)
        switchLED();
}

Bonjour,

Si tu as le choix entre un bouton et la procédure que tu decris et deux boutons, il n'y a pas photo.
Choisis deux boutons: un pour incrémenter, un pour décrémenter.

bonsoir
Merci pour vos réponses.
J'ai bien noté pour les librairies.
Je viens de faire l'essaie comme dit par (Kamil) pour commencer ça me parait plus simple, après pour mon plaisir je vais essayer de traiter les appuis long et court.
la version (Kamil) a l'air de marcher
mais maintenant si par exemple j'ai un code qui tourne je veut donc décider si je rentre ou pas dans le menu configuration.
mais la je voit pas bien comment faire.
-je pense qu'il faut que je connaisse l'état des boutons (par défaut relâché)

  • ensuite mettre dans une condition si l'état est différent donc appuyé, alors je rentre dans ma configuration
  • mais comment savoir a quel moment sortir du mode configuration
  • a moins de mettre un troisième bouton qui indiquerais si le programme doit se derouler ou si je doit rester en mode configuration.
    J'ai du mal a cerner comment faire simplement pour commencer
    Merci
    ps j'ai rien inventé, me suis inspiré de différents post du forum.
int pinBouton1 = 8; // Bouton  1 branché sur le pin 8
int pinBouton2 = 9; // Bouton  2 branché sur le pin 9
float decremente = 1.11;
float incremente = 2.22;

void setup() {
  //définition des modes
  pinMode(pinBouton1, INPUT_PULLUP);
  pinMode(pinBouton2, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  //lecture de l'état des boutons et stockage dans etatBouton
  boolean etatBouton1 = digitalRead(pinBouton1);
  boolean etatBouton2 = digitalRead(pinBouton2);
  //test des conditions
  if (etatBouton1 == LOW) //test si bouton 1 appuyé
  {
    while (!digitalRead(pinBouton1)) { //attend que BP1 soit relaché
    decremente = decremente + 0.20;
    Serial.print("variable decremente : ");
      Serial.println(decremente, 2);
      delay(500);
    }
  }
  if (etatBouton2 == LOW) //test si bouton 2 appuyé
  {
    while (!digitalRead(pinBouton2)) { //attend que BP2 soit relaché
    incremente = incremente - 0.50;
    Serial.print("variable incremente : ");
      Serial.println(incremente, 2);
      delay(500);
    }
  }
}

Tu pourrais par exemple appuyer sur les deux boutons à la fois pour sortir de la configuration.

Je viens de faire l'essaie comme dit par (Kamil) pour commencer ça me parait plus simple, après pour mon plaisir je vais essayer de traiter les appuis long et court.

Il faut toujours choisir la solution la plus pratique et la plus intuitive pour l'utilisateur.
Que les développeurs se fassent plaisir à élaborer des usines à gaz est une autre histoire, qui finit souvent par ne pas plaire aux utilisateur, et termine à la poubelle.

@+

Bonjour.
Merci pour l'idée des appuies sur les deux boutons.
Hyper simple, mais faut y penser.
Je vais essayer et ensuite je reviens vers vous.
Par contre comment faites-vous pour trouver les bonnes idées.
Il doit y avoir des façons de faire.
Après j'imagine que l'expérience contribue.
Je découvre l'arduino après avoir bricolé du basic il y a une trentaine d'années.
C'est très plaisant.

Bonjour

kamill:
Si tu as le choix entre un bouton et la procédure que tu decris et deux boutons, il n’y a pas photo.
Choisis deux boutons: un pour incrémenter, un pour décrémenter.

Avec un bouton, pour le fun!

Je n’ai pas fait de tuto mais je me suis prêté à l’exercice, comme on dit.
Comme indiqué par @lesept, j’ai utilisé la bibliothèque JC_Button.

L’incrémentation et la décrémentation de la valeur traitée se fait au relâchement du bouton.
Une longue pression, ici 1 sec., fait passer l’incrément de +1 à -1 alternativement.
Quand l’incrément est à +1 la LED est allumée.
Ca donne ça

#include <JC_Button.h>          // https://github.com/JChristensen/JC_Button

#define ledPin 13                                                    // Pin de connection de la LED, allumée quand le bouton incrémente
#define boutonPin 7                                                  // Pin de connection du bouton, le bouton "envoie" un GND (0V.)
int longuePressionTemps = 1000;                                      // Définition du temps de longue pression 1000 = 1 sec.

Button monBouton(boutonPin);                                         // On défini l'objet monBouton raccordé à boutonPin

int valeurIncrement;                                                 // Valeur d'incrément du mode 
int valeurTraitee = 0;                                               // Valeur traitée par le programme

void setup()
{
	Serial.begin(9600);                                              // Initialisation du port série du moniteur
	
	pinMode(ledPin, OUTPUT);                                         // Initialisation de la sortie qui commande la LED
	pinMode(boutonPin, INPUT_PULLUP);                                // Initialisation de l'entrée du bouton avec résistance interne de polarisation

	valeurIncrement = 1;                                             // Addition
	digitalWrite(ledPin, HIGH);                                      // Allumage de la LED
	
	Serial.println("Alain-alph  projet.");
}

void loop()
{
	monBouton.read();
	if (monBouton.wasReleased())                                     // Si le bouton est relaché
	{
		valeurTraitee += valeurIncrement;
		Serial.println("Valeur en cours = " + String(valeurTraitee));
	}
	else if (monBouton.pressedFor(longuePressionTemps))
	{
		if (valeurIncrement == 1)                                    // Si addition
		{
			valeurIncrement = -1;                                    // Soustraction
			digitalWrite(ledPin, LOW);                               // Extinction de la LED
		}
		else
		{
			valeurIncrement = 1;                                     // Addition
			digitalWrite(ledPin, HIGH);                              // Allumage de la LED
		}

		Serial.println("Increment = " + String(valeurIncrement));

		while(monBouton.isPressed())                                 // Attente du relachement du bouton
		{
		monBouton.read();                                        
		}
	}
}

A ta disposition pour toutes informations complémentaires

Cordialement
jpbbricole

bonjour
merci a tous.
Bien le code a un bouton.
Mais pour l'instant je ne sais pas entrer/sortir de la condition de configuration.

J'ai essayé de faire un loop qui compte juste pour savoir si je suis dans le loop ou dans la partie configuration.
L'idée:

  • je tourne dans le loop.
  • quand 2 boutons sont pressées je rentre dans la configuration.
  • dans la configuration je passe une balise a 1.
  • tant que cette balise est a 1 je reste dans la configuration ou je peux modifier ma variable a l'aide d'UN bouton.
  • quand j'ai finit ma configuration j'appuie a nouveau sur deux bouton ce qui repasse ma balise a 0 et je sort de tout ça comme je peux (pour l'instant un goto!)

Alors ça marche avec des prints
mais quand au lieux des prints je place le code d'incrémentation j'incrémente/décrémente mais ne sort plus de la configuration
bizarre!
je veux bien une piste!

code avec les prints qui marche:

int balise = 0 ;
int cpt_tour = 0 ;
int pinBouton1 = 8; // Bouton  1 branché sur le pin 8
int pinBouton2 = 9; // Bouton  2 branché sur le pin 9
float decremente = 1.00;
float incremente = 2.00;

void setup() {
  //définition des modes
  pinMode(pinBouton1, INPUT_PULLUP);
  pinMode(pinBouton2, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
sortir: ;
  //lecture de l'état des boutons et stockage dans etatBouton
  boolean etatBouton1 = digitalRead(pinBouton1); // pin 8
  boolean etatBouton2 = digitalRead(pinBouton2); // pin 9


  //************************************************
  //        entree dans la configuration           *
  //        si bouton 1 et 2 appuyé simultanément  *
  //************************************************

  if (etatBouton1 == LOW && etatBouton2 == LOW ) // test si bouton 1 et 2 sont appuyé simultanément
  {
    while (!digitalRead(pinBouton2) && !digitalRead(pinBouton1) ) { //attend que BP1 et BP2 soient relachés
      Serial.println("entrée config.");
      Serial.println("je passe ma balise a 1.");
      balise = 1 ;
      delay(500);
    }
    // j'ai mis ma balise a 1 et je ne sortirais que lorsque la balise sera a 0
    // je remet la balise a 0 pour sortir de la config en appuyant simultanement
    // a nouveau sur le bouton 1 et le bouton 2
    while (balise = 1 ) {
      Serial.println("entrée reglage.");
      Serial.print("la balise est a: ");
      Serial.println(balise);
      Serial.print("je suis dans reglage et nb tours que le prg a fait: ");
      Serial.println (cpt_tour) ;
      delay(500);

      // test pour sortie de config
      if (etatBouton1 == LOW && etatBouton2 == LOW  ) // test si bouton 1 et 2 sont appuyé simultanément
      {
        while (!digitalRead(pinBouton2) && !digitalRead(pinBouton1) ) { //attend que BP1 et BP2 soient relachés
          balise = 0 ;
          Serial.println("sortie config.");
          Serial.println("je passe ma balise a 0.");
          Serial.println("la balise est a: ");
          Serial.println(balise);
          delay(500);
          goto sortir;
        }
      }

    }
  }// fin du IF config

  Serial.print("nb tours que le prg a fait: ");
  Serial.println (cpt_tour) ;
  cpt_tour = cpt_tour + 1 ;
  delay(500);
}// fin du loop

et avec l'incrémentation de variable a la place du print mais qui ne marche pas!

int balise = 0 ;
int cpt_tour = 0 ;
int pinBouton1 = 8; // Bouton  1 branché sur le pin 8
int pinBouton2 = 9; // Bouton  2 branché sur le pin 9
float decremente = 1.00;
float incremente = 2.00;

void setup() {
  //définition des modes
  pinMode(pinBouton1, INPUT_PULLUP);
  pinMode(pinBouton2, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
sortir: ;
  //lecture de l'état des boutons et stockage dans etatBouton
  boolean etatBouton1 = digitalRead(pinBouton1); // pin 8
  boolean etatBouton2 = digitalRead(pinBouton2); // pin 9


  //************************************************
  //        entree dans la configuration           *
  //        si bouton 1 et 2 appuyé simultanément  *
  //************************************************

  if (etatBouton1 == LOW && etatBouton2 == LOW ) // test si bouton 1 et 2 sont appuyé simultanément
  {
    while (!digitalRead(pinBouton2) && !digitalRead(pinBouton1) ) { //attend que BP1 et BP2 soient relachés
      Serial.println("entrée config.");
      Serial.println("je passe ma balise a 1.");
      balise = 1 ;
      delay(500);
    }
    // j'ai mis ma balise a 1 et je ne sortirais que lorsque la balise sera a 0
    // je remet la balise a 0 pour sortir de la config en appuyant simultanement
    // a nouveau sur le bouton 1 et le bouton 2
    while (balise = 1 ) {
      Serial.println("entrée reglage.");
      Serial.print("la balise est a: ");
      Serial.println(balise);
      Serial.print("je suis dans reglage et nb tours que le prg a fait: ");
      Serial.println (cpt_tour) ;
      delay(500);

      //**debut code modification variable
      if (etatBouton1 == LOW) //test si bouton 1 appuyé
      {
        while (!digitalRead(pinBouton1)) { //attend que BP1 soit relaché
          decremente = decremente + 0.20;
          Serial.print("variable decremente : ");
          Serial.println(decremente, 2);
          delay(500);
        }
      }
      if (etatBouton2 == LOW) //test si bouton 2 appuyé
      {
        while (!digitalRead(pinBouton2)) { //attend que BP2 soit relaché
          incremente = incremente - 0.50;
          Serial.print("variable incremente : ");
          Serial.println(incremente, 2);
          delay(500);
        }
      }
      //**fin code modification variable


      // test pour sortie de config
      if (etatBouton1 == LOW && etatBouton2 == LOW  ) // test si bouton 1 et 2 sont appuyé simultanément
      {
        while (!digitalRead(pinBouton2) && !digitalRead(pinBouton1) ) { //attend que BP1 et BP2 soient relachés
          balise = 0 ;
          Serial.println("sortie config.");
          Serial.println("je passe ma balise a 0.");
          Serial.println("la balise est a: ");
          Serial.println(balise);
          delay(500);
          goto sortir;
        }
      }

    }
  }// fin du IF config

  Serial.print("nb tours que le prg a fait: ");
  Serial.println (cpt_tour) ;
  cpt_tour = cpt_tour + 1 ;
  delay(500);
}// fin du loop

suis un peu perdu quand a la façon de faire.
quand j'enlève l'attente du relâchement alors je sort bien de la configuration mais incrémentation/décrémentation se fait en permanence!

En attendant je vais regarder le code a un bouton
merci
ps je devrais peut être modifier le titre du post?

bonsoir
par politesse et pour ceux qui l’on lue je n’efface pas mon post au dessus.
Mais je recommence autrement demain " a force je vais bien y arriver"
la bibliothèque de Bricoleau est super.

En fait ce que j’essaie de faire c’est d’essayer de ne pas ralentir le code par des tests successifs.
Donc j’essaie de n’avoir qu’un test afin de savoir si je doit rentrer ou non dans tous les conditions pour incrémenter/décrémenter.

Je voudrais arriver a:

-au passage dans chaque tour du loop juste une condition afin de savoir si je continue le loop ou si je rentre dans les “configurations”.
-Si je rentre dans “configuration” alors je dois pouvoir:
– augmenter la variable.
– diminuer la variable.
– lancer la fonction d’affichage de certaines valeurs sur mon écran lcd.
bien entendu sortir et reprendre le cours du code.

le code tourne
l’affiche LCD tourne
je n’ai pas besoin de sauvegarder ma configuration. La valeur de ma variable permet un fonctionnement par défaut.
Je débute… c’est pas gagné.

Un test ne va pas ralentir votre code de manière perceptible à l’échelle d’un click bouton... allez y tranquille et virez le goto...

—> c’est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

Un enum est toujours sympa pour définir des petits noms

enum : uint8_t {MODE_NORMAL, ATTENTE_VALIDE_PARAM, MODE_PARAM, ATTENTE_VALIDE_NORMAL} etat;

Dans le setup() vous rajoutez alors unetat=MODE_NORMAL;

Si vous utilisez un booleen,respectez le type et mettez une valeur de vérité dedans et donnez leur un nom parlant

boolean  appuiBouton1 = (digitalRead(pinBouton1) == LOW); // vrai si appui
boolean appuiBouton2 = (digitalRead(pinBouton2) == LOW); // vrai si appui

Les boutons rebondissent donc si vous voulez attendre que les deux soient stabilisés sans avoir à traiter les rebonds, un petit délai sera utile (15ms généralement suffisantes)

Dans la loop() vous pouvez alors tester dans quel mode vous êtes et faire ce qu’il faut en appelant une fonction pour chaque mode: unTourDeModeNormal() et unTourDeModeParam() en non bloquant.

Vous aurez sans doute besoin de la même technique de mémorisation d’un l’état au sein de ces fonctions pour gérer l’appui et relâchement d’un bouton sans être bloquant donc un petit enum de plus pour l’état des boutons individuellement serait pas mal

enum : uint8_t {REPOS, APPUI} etatPrecedentBouton1, etatPrecedentBouton2 ;

ça donnerait un truc du genre:

enum : uint8_t {MODE_NORMAL, ATTENTE_VALIDE_PARAM, MODE_PARAM, ATTENTE_VALIDE_NORMAL} etat;

enum : uint8_t {REPOS, APPUI} etatPrecedentBouton1, etatPrecedentBouton2 ;

const uint8_t pinBouton1 = 8;
const uint8_t pinBouton2 = 9;

boolean appuiBouton1;
boolean appuiBouton2;

long compteur;

void setup()
{
   //définition des modes
   pinMode(pinBouton1, INPUT_PULLUP);
   pinMode(pinBouton2, INPUT_PULLUP);
   Serial.begin(115200);
   compteur = 0;
   etat=MODE_NORMAL;
}

void unTourDeModeNormal()
{
   // on sait que cette fonction n’est appelée que si les 2 boutons ne sont pas enfoncés en même temps
   if (appuiBouton1) {
      ...
   } else
   if (appuiBouton2) {
      ...
   }
   else {
      ...
   }
}

void unTourDeModeParam() 
{
   // on sait que cette fonction n’est appelée que si les 2 boutons ne sont pas enfoncés en même temps
   if (appuiBouton1) {
      ...
   } else
   if (appuiBouton2) {
      ...
   }
   else {
      ...
   }
}

void loop()
{
   appuiBouton1 = (digitalRead(pinBouton1) == LOW); // vrai si appui
   appuiBouton2 = (digitalRead(pinBouton2) == LOW); // vrai si appui

   switch(etat) {
      case MODE_NORMAL:
      if (appuiBouton1 && appuiBouton2) { // est-ce qu’on passe en mode param
         etat = ATTENTE_VALIDE_PARAM;
         delay(15); // anti rebond
       } else {
          // sinon traiter le mode normal
          unTourDeModeNormal(); // à écrire en non bloquant
       }
      break;

      case ATTENTE_VALIDE_PARAM: // on attend juste la relâche des 2 boutons pour confirmer le passage en mode param
      if (!appuiBouton1 && !appuiBouton2) { // on passe en mode param
         etat = MODE_PARAM;
         delay(15); // anti rebond
         etatPrecedentBouton1 = REPOS;
         etatPrecedentBouton2 = REPOS;
       }
      break;

      case MODE_PARAM:
      if (appuiBouton1 && appuiBouton2) { // est-ce qu’on sort de ce mode ?
         etat = ATTENTE_VALIDE_NORMAL;
         delay(15); // anti rebond
       } else {
          // on traite un tour de mode param  
          unTourDeModeParam(); // à écrire en non bloquant
       }
      break;

      case ATTENTE_VALIDE_NORMAL: // on attend la relâche des 2 boutons
      if (!appuiBouton1 && !appuiBouton2) { // on passe en mode normal
         etat = MODE_NORMAL;
         delay(15); // anti rebond
         etatPrecedentBouton1 = REPOS;
         etatPrecedentBouton2 = REPOS;
       }
      break;
   }
}

—> vous voyez que c’est un peu laborieux cependant car il vous faudra sans doute imbriquer une machine à état au sein d’une autre (et mettre à jour etatPrecedentBouton1 et etatPrecedentBouton2) et bien traiter tous les cas mais en séparant les modes ça aide à penser plus clairement

(Nb: tout tapé ici donc il se peut qu’il y ait des fautes)

bonjour

vous voyez que c'est un peu laborieux

c'est rien de le dire, surtout pour débuter.
Merci pour toutes ces explications.
Ce que je retiens en priorité:

Un test ne va pas ralentir votre code de manière perceptible à l'échelle d'un click bouton... allez y tranquille et virez le goto...

J'avais peur que tous ces tests successifs ralentissent énormément.

Je vais donc simplifier au maximum afin de terminer ce que je fait.
Par contre je vais revenir des que j'aurais un peu de temps sur ce bout de "code" afin d'essayer de comprendre un peu comment faire "simple".
La bibliothèque de Bricoleau est franchement simple mais je n'ai pas vue d'exemple gérant les deux boutons, mais vue que je débute je suis peut être passé a coté.
Le code de jpbbricole marche mais bon pareil pour débuter tout ne me semble pas évident.
Pourtant c'est une bonne base proche de ce que je cherche faire
Merci d'avoir pris sur votre temps afin de me renseigner

Alain-alph:
Le code de jpbbricole marche mais bon pareil pour débuter tout ne me semble pas évident.

C'est bien sûre! Mais je suis à ta disposition pour toute question ou explication.

Cordialement
jpbbricole

bonjour
merci pour la proposition d'aide. Mais je suis vraiment trop débutant j'ai peur que cela devienne pénible pour vous. Je vais essayer de "travailler" un peu.
Par contre si l'idée vous prend d'élaborer un tuto dans la rubrique tuto et cours, alors le je suis (et d'autres) preneur
Merci

Je pense que tu devrai relire le tuto d'Eskimon, une seule lecture ne suffit pas.

Conseil personnel : teste ton apprentissage sur des choses très simples et ne fait qu'un test unitaire à la fois.
N'assemble que des codes qui ont déjà été testé en code unitaire.
Cela parait plus long que de tout faire en même temps mais au final tu gagne un temps énorme.

Quant au temps de réaction du micro, une période de son horloge fait 62,5 ns, la nanoseconde est égale à un milliardième de seconde. Même si une ligne de code peut représenter plusieurs centaines de période horloge il y a de la marge avant que tu vois un ralentissement.
Le temps qu'il te faut pour enfoncer un bouton est gigantesque devant la temps de calcul du micro.

bonsoir
merci encore pour tous ces précieux conseil.
Effectivement a force de parler de gigas de mémoire et de processeur de PC, Tablettes ou téléphone qui tournent a des vitesses folles. J'ai finit par penser que les malheureux 16 Mghz de l'arduino étaient une misère.
Certainement une confusion entre processeur et micro contrôleur.