Home
Arduino Mega

Arduino - Bouton - Pression longue Pression courte

Prêt à débloquer le potentiel caché d'un simple bouton ? Vous êtes au bon endroit ! Ce tutoriel Arduino Mega sur les boutons vous guidera à travers tout ce que vous devez savoir pour détecter les événements de pression longue et de pression courte - une compétence qui va considérablement étendre les possibilités de vos projets Arduino.

Pensez à votre smartphone ou à n'importe quel appareil moderne - un seul bouton peut effectuer plusieurs fonctions selon la façon dont vous l'appuyez. Pression courte pour une action, pression longue pour une autre. Aujourd'hui, nous apportons cette même fonctionnalité intelligente à vos projets Arduino Mega ! Que vous débutiez avec la programmation Arduino ou que vous cherchiez à ajouter des interactions utilisateur plus sophistiquées à vos projets existants, ce guide complet vous accompagne.

Dans ce tutoriel, vous maîtriserez quatre techniques essentielles : détecter les pressions courtes de bouton, reconnaître les pressions longues, combiner les deux méthodes de détection, et implémenter un debouncing approprié pour une fiabilité en conditions réelles. Ne vous inquiétez pas si vous débutez en programmation - nous allons tout parcourir étape par étape, expliquant non seulement le "comment" mais aussi le "pourquoi" derrière chaque concept. À la fin, vous comprendrez comment créer des interfaces de boutons réactives et de qualité professionnelle qui peuvent distinguer entre des tapotements rapides et des pressions longues délibérées.

Les applications pratiques sont infinies ! Vous pourriez construire un contrôleur domotique où les pressions courtes font défiler les modes et les pressions longues allument/éteignent les appareils, créer une horloge numérique où les pressions courtes changent l'affichage et les pressions longues règlent l'heure, ou concevoir un système de sécurité où seule une pression longue (évitant les déclenchements accidentels) active l'alarme. Quel projet incroyable allez-vous créer en premier ?

Nous allons apprendre :

Dans les trois premières sections, nous explorerons les principes fondamentaux derrière la détection de pression de bouton, construisant votre compréhension étape par étape. Dans la section finale, nous implémenterons des solutions pratiques, réelles en utilisant des techniques de debouncing. C'est crucial car sans debouncing approprié, vous pourriez obtenir de fausses lectures - voir pourquoi avons-nous besoin de debounce pour les boutons pour une explication détaillée. Pensez au debouncing comme un réglage fin de "l'oreille" de votre Arduino pour qu'il puisse clairement distinguer entre les pressions de bouton intentionnelles et le bruit électrique.

Matériel requis

1×Arduino Mega
1×Câble USB 2.0 type A/B
1×Bouton à monter sur breadboard avec capuchon
1×Kit de boutons à monter sur breadboard
1×Bouton poussoir à monter sur panneau
1×Module bouton poussoir
1×Breadboard (plaque d'essai)
1×Fils de liaison
1×Recommandé: Screw Terminal Block Shield for Arduino Uno/Mega
1×Recommandé: Breadboard Shield for Arduino Mega
1×Recommandé: Enclosure for Arduino Mega

Ou vous pouvez acheter les kits suivants:

1×Kit de Capteurs DIYables (30 capteurs/écrans)
1×Kit de Capteurs DIYables (18 capteurs/écrans)
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

À propos du bouton

Un bouton est un dispositif d'entrée simple mais incroyablement polyvalent qui permet aux utilisateurs d'envoyer des signaux numériques à votre Arduino Mega en l'appuyant et le relâchant physiquement. Pensez-y comme un pont que vous pouvez ouvrir et fermer pour contrôler le flux d'électricité dans votre circuit. Quand il est appuyé, il crée une connexion ; quand il est relâché, il rompt cette connexion.

Comprendre le comportement des boutons est fondamental pour créer des projets Arduino interactifs. Les boutons peuvent détecter divers types d'interactions utilisateur - des simples états on/off aux motifs de pression complexes comme les pressions longues et courtes que nous explorons aujourd'hui. La clé pour maîtriser le contrôle des boutons réside dans la compréhension du timing, des changements d'état, et comment interpréter ces changements dans votre code.

Ce qui rend les boutons particulièrement puissants dans la programmation Arduino, c'est leur capacité à déclencher des événements basés sur l'intention de l'utilisateur. Une pression courte peut indiquer une sélection rapide ou un changement de mode, tandis qu'une pression longue pourrait signaler une action plus délibérée comme éteindre un appareil ou confirmer une opération critique. Cette polyvalence rend un seul bouton capable de contrôler plusieurs fonctions, économisant à la fois les coûts matériels et l'espace physique dans vos projets.

Si vous ne connaissez pas les fondamentaux des boutons (brochage, fonctionnement, programmation des fonctions de base), nous recommandons vivement de commencer par notre guide complet des bases des boutons. Ces connaissances de base rendront tout dans ce tutoriel beaucoup plus clair et significatif :

Schéma de câblage

Jetons un coup d'œil au montage de câblage - ne vous inquiétez pas, c'est plus simple qu'il n'y paraît ! Comprendre ces connexions est essentiel pour faire fonctionner correctement votre détection de pression de bouton.

Schéma de câblage Arduino Bouton

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Dans ce tutoriel, nous utiliserons la résistance de pull-up interne de l'Arduino Mega, qui est une fonctionnalité intégrée pratique qui vous évite d'avoir besoin de composants externes. Cela signifie que la broche du bouton lira HIGH (5V) quand le bouton est dans son état normal, non appuyé, et LOW (0V) quand vous l'appuyez. Pensez à la résistance de pull-up interne comme "tirant" doucement la broche vers un état HIGH quand rien d'autre n'est connecté - c'est comme avoir un réglage par défaut qui empêche la broche de flotter dans un état indéfini.

Broche du bouton Broche Arduino Mega
Une borne Broche numérique 2
Autre borne GND (Masse)

Note importante : Utiliser la résistance de pull-up interne signifie que votre logique de bouton sera inversée par rapport à ce que vous pourriez initialement attendre. Appuyé = LOW, Relâché = HIGH. C'est parfaitement normal et en fait la méthode préférée pour les connexions de bouton dans la plupart des projets Arduino car c'est plus fiable et nécessite moins de composants.

Comment détecter une pression courte

Maintenant la partie passionnante - donnons vie à votre bouton avec une détection intelligente de pression ! Ne vous inquiétez pas si vous débutez avec la programmation basée sur le timing ; nous allons parcourir ce concept étape par étape, et je promets que c'est plus facile que vous ne le pensez.

Le principe clé derrière la détection de pression courte est la mesure de la durée. Nous créons essentiellement un chronomètre qui démarre quand le bouton est appuyé et s'arrête quand il est relâché. Si cette durée tombe en dessous de notre seuil défini (disons 500 millisecondes), nous savons que l'utilisateur voulait une pression rapide et courte plutôt qu'un appui long délibéré.

Décomposons le processus de détection en étapes gérables :

Nous mesurons la durée entre les événements d'appui et de relâchement en utilisant la fonction intégrée millis() d'Arduino, qui compte les millisecondes depuis le début du programme. Si la durée est plus courte que notre seuil de temps prédéfini, nous avons détecté avec succès un événement de pression courte. Pensez-y comme mesurer combien de temps quelqu'un maintient une poignée de main - une secousse rapide versus une prise qui s'éternise vous dit des choses différentes sur leur intention !

Voyons l'implémentation étape par étape :

  • Définir le seuil de durée de pression courte - Ceci définit le temps maximum qui qualifie une pression "courte" :
const int SHORT_PRESS_TIME = 500; // 500 millisecondes
  • Détecter quand le bouton est d'abord appuyé et capturer ce moment :
if(lastState == HIGH && currentState == LOW) pressedTime = millis();
  • Détecter quand le bouton est relâché et enregistrer l'heure de relâchement :
if(lastState == LOW && currentState == HIGH) releasedTime = millis();
  • Calculer la durée totale d'appui en trouvant la différence :
long pressDuration = releasedTime - pressedTime;
  • Déterminer si c'est une pression courte en comparant la durée avec notre seuil :
if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected");

Code Arduino pour détecter la pression courte

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int SHORT_PRESS_TIME = 500; // 500 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) // button is pressed pressedTime = millis(); else if(lastState == LOW && currentState == HIGH) { // button is released releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); } // save the the last state lastState = currentState; }

Étapes rapides

Nouveau sur Arduino ? Commencez par notre guide Arduino Getting Started pour apprendre d'abord les bases.

  • Téléverser le code : Copiez le code ci-dessus dans votre IDE Arduino et téléversez-le sur votre Arduino Mega. Prenez votre temps avec le processus de téléversement - il n'y a pas d'urgence !
  • Tester les pressions courtes : Appuyez rapidement sur le bouton plusieurs fois (moins d'une demi-seconde chaque fois). Essayez différentes vitesses pour avoir une idée de ce qui qualifie comme "court".
  • Surveiller les résultats : Ouvrez votre Moniteur série (Outils → Moniteur série) et observez les messages de détection. Vous devriez voir des confirmations à chaque fois qu'une pression courte est détectée.

Conseil de pro : Essayez d'expérimenter avec différentes valeurs de SHORT_PRESS_TIME pour trouver ce qui semble le plus naturel pour votre projet spécifique. Certaines applications peuvent nécessiter des réponses plus rapides (200ms), tandis que d'autres peuvent préférer des seuils légèrement plus longs (800ms).

COM6
Send
A short press is detected A short press is detected A short press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

※ Note:

Le Moniteur série peut afficher plusieurs détections de pression courte pour un seul appui. C'est le comportement normal des boutons dû à quelque chose appelé le "phénomène de rebond" - de minuscules rebonds électriques qui se produisent quand les contacts métalliques font et rompent la connexion. Ne vous inquiétez pas pour l'instant ; nous résoudrons complètement ce problème dans la section debouncing à la fin de ce tutoriel. Pensez-y comme un réglage fin que nous aborderons une fois que vous comprendrez les concepts de base !

Comment détecter une pression longue

La détection de pression longue ouvre un tout nouveau monde de possibilités d'interface utilisateur ! Il y a en fait deux approches distinctes que nous pouvons adopter, chacune servant des objectifs différents selon les besoins de votre projet. Laissez-moi vous guider à travers les deux méthodes pour que vous puissiez choisir celle qui correspond le mieux à votre vision créative.

Comprendre la différence entre ces approches est crucial pour créer des interfaces utilisateur réactives. La première méthode attend patiemment jusqu'à ce que l'utilisateur termine complètement son interaction (relâche le bouton) avant de prendre des décisions. La seconde méthode est plus proactive, détectant la pression longue pendant qu'elle se produit et répondant immédiatement. Les deux ont leur place dans différents types d'applications !

Il y a deux cas d'usage pratiques pour détecter les événements de pression longue :

  • Détection après relâchement : L'événement de pression longue est détecté juste après que le bouton soit relâché - parfait pour les confirmations et actions finales
  • Détection pendant l'appui : L'événement de pression longue est détecté pendant que le bouton est encore maintenu enfoncé - idéal pour le feedback en temps réel et les actions continues

Dans le premier cas d'usage, nous mesurons la durée totale entre les événements d'appui et de relâchement, similaire à notre méthode de pression courte mais avec un seuil plus long. Si la durée totale dépasse notre limite de temps définie, nous savons que l'utilisateur voulait une action de pression longue.

Dans le second cas d'usage, nous adoptons une approche plus dynamique. Après que le bouton soit initialement appuyé, nous surveillons continuellement la durée d'appui en temps réel, vérifiant la condition de pression longue de façon répétée jusqu'à ce que le bouton soit relâché. Cela nous permet de répondre immédiatement quand le seuil de pression longue est atteint, même pendant que l'utilisateur maintient encore le bouton enfoncé. Pensez-y comme une barre de progression qui déclenche une action dès qu'elle se remplit, plutôt que d'attendre que l'utilisateur lâche prise.

Code Arduino pour détecter la pression longue au relâchement

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) // button is pressed pressedTime = millis(); else if(lastState == LOW && currentState == HIGH) { // button is released releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration > LONG_PRESS_TIME ) Serial.println("A long press is detected"); } // save the the last state lastState = currentState; }

Étapes rapides

Vous n'avez jamais utilisé Arduino avant ? Jetez un coup d'œil rapide à notre guide Arduino Getting Started pour construire vos fondations.

  • Téléverser et tester : Téléversez le code ci-dessus sur votre Arduino Mega via l'IDE Arduino. Cette méthode nécessite de la patience - vous devez maintenir le bouton pendant toute la durée !
  • Pratiquer les pressions longues : Appuyez et maintenez le bouton pendant plus d'une seconde, puis relâchez-le. Remarquez comment la détection ne se produit qu'après que vous ayez lâché.
  • Observer le timing : Vérifiez les résultats du Moniteur série. Vous verrez que l'événement de pression longue n'est détecté qu'immédiatement après que le bouton soit relâché, pas pendant l'appui.

Conseil de pro : Cette méthode est parfaite pour les actions qui nécessitent une confirmation, comme les scénarios "Êtes-vous sûr de vouloir supprimer ceci ?". L'utilisateur doit compléter tout le geste de pression longue avant que quelque chose ne se produise.

COM6
Send
A long press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

L'événement de pression longue n'est détecté qu'immédiatement après que le bouton soit relâché

Code Arduino pour détecter la pression longue pendant l'appui

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; bool isPressing = false; bool isLongDetected = false; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) { // button is pressed pressedTime = millis(); isPressing = true; isLongDetected = false; } else if(lastState == LOW && currentState == HIGH) { // button is released isPressing = false; } if(isPressing == true && isLongDetected == false) { long pressDuration = millis() - pressedTime; if( pressDuration > LONG_PRESS_TIME ) { Serial.println("A long press is detected"); isLongDetected = true; } } // save the the last state lastState = currentState; }

Étapes rapides

Première fois avec Arduino ? Nous recommandons de consulter notre guide Arduino Getting Started - cela aidera tout à avoir du sens !

  • Téléverser et expérimenter : Téléversez ce code et remarquez immédiatement la différence en réactivité. La détection se produit pendant que vous maintenez encore le bouton enfoncé !
  • Tester la détection temps réel : Appuyez et maintenez le bouton pendant plusieurs secondes sans le relâcher. Vous devriez voir le message de détection apparaître pendant que votre doigt est encore sur le bouton.
  • Ressentir la différence : Cette approche fournit un feedback instantané, rendant vos projets plus réactifs et professionnels.

Conseil de pro : Cette méthode est excellente pour les actions comme "maintenir pour éteindre" ou "appuyer et maintenir pour entrer en mode configuration" où un feedback immédiat rassure l'utilisateur que quelque chose se passe.

COM6
Send
A long press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

L'événement de pression longue est détecté immédiatement quand le seuil est atteint, même pendant que le bouton est encore appuyé

Comment détecter à la fois pression longue et pression courte

Maintenant nous arrivons aux choses vraiment passionnantes ! Combiner la détection de pression longue et courte transforme un simple bouton en un élément d'interface utilisateur sophistiqué. C'est là que vos projets commencent à ressembler à des appareils professionnels avec des contrôles intuitifs et multifonctionnels.

La beauté de la détection duale réside dans la maximisation de la fonctionnalité tout en minimisant le matériel. Au lieu d'avoir besoin de plusieurs boutons pour différentes actions, un seul bouton peut gérer deux fonctions distinctes basées sur l'intention de l'utilisateur. Pression courte pour les actions rapides, pression longue pour les fonctions plus délibérées ou critiques - tout comme le bouton d'alimentation de votre smartphone ou les contrôles des appareils modernes !

Pression courte et pression longue après relâchement

Cette approche attend que l'interaction avec le bouton soit complètement terminée avant de prendre des décisions. C'est comme laisser quelqu'un finir sa phrase avant de répondre - très poli et délibéré !

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) // button is pressed pressedTime = millis(); else if(lastState == LOW && currentState == HIGH) { // button is released releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); if( pressDuration > LONG_PRESS_TIME ) Serial.println("A long press is detected"); } // save the the last state lastState = currentState; }

Étapes rapides

  • Téléverser et expérimenter : Téléversez le code ci-dessus sur votre Arduino Mega et commencez à expérimenter avec différentes durées d'appui. Essayez des tapotements rapides et des appuis plus longs pour voir comment le système distingue entre eux.
  • Tester les deux types : Pratiquez les pressions longues et courtes pour avoir une idée du timing. Remarquez comment le système attend que vous relâchiez le bouton avant de décider quel type de pression c'était.
  • Surveiller la détection duale : Regardez le Moniteur série pour voir comment votre Arduino Mega catégorise intelligemment chaque interaction de bouton.

Conseil de pro : Cette méthode est parfaite pour les applications où vous voulez éviter les déclenchements accidentels. Puisque rien ne se passe jusqu'à ce que le bouton soit relâché, les utilisateurs peuvent changer d'avis en cours d'appui !

COM6
Send
A short press is detected A long press is detected A short press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

※ Note:

Le Moniteur série peut afficher plusieurs détections de pression courte pendant les tentatives de pression longue. C'est le comportement normal des boutons dû au "phénomène de rebond" - de minuscules rebonds électriques qui se produisent dans les contacts mécaniques du bouton. Ne vous inquiétez pas ! C'est complètement normal et attendu. Nous résoudrons complètement ce problème dans la section debouncing qui arrive ensuite, où nous implémenterons une gestion de bouton de qualité professionnelle.

Pression courte et pression longue pendant l'appui

Cette approche dynamique fournit un feedback instantané dès qu'un seuil de pression longue est atteint, tout en détectant les pressions courtes quand le bouton est relâché rapidement. C'est comme avoir le meilleur des deux mondes !

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; bool isPressing = false; bool isLongDetected = false; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) { // button is pressed pressedTime = millis(); isPressing = true; isLongDetected = false; } else if(lastState == LOW && currentState == HIGH) { // button is released isPressing = false; releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); } if(isPressing == true && isLongDetected == false) { long pressDuration = millis() - pressedTime; if( pressDuration > LONG_PRESS_TIME ) { Serial.println("A long press is detected"); isLongDetected = true; } } // save the the last state lastState = currentState; }

Étapes rapides

  • Expérimenter la réponse temps réel : Téléversez ce code et ressentez la différence en réactivité. Les pressions longues sont détectées immédiatement tandis que les pressions courtes sont capturées au relâchement.
  • Pratiquer le timing : Essayez diverses durées d'appui pour comprendre comment le système répond. Vous remarquerez que le feedback de pression longue se produit instantanément, tandis que le feedback de pression courte attend le relâchement.
  • Apprécier la sophistication : Cette approche crée une expérience utilisateur très professionnelle avec un feedback visuel ou audio immédiat pour les pressions longues.

Conseil de pro : Cette méthode est excellente pour les projets où les actions de pression longue nécessitent une confirmation ou un feedback immédiat, comme les scénarios "maintenir pour activer" où les utilisateurs ont besoin de savoir que leur commande est en cours de traitement.

COM6
Send
A long press is detected A short press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

※ Note:

Vous pourriez remarquer quelques détections de pression courte supplémentaires pendant les opérations de pression longue. C'est un comportement de bouton complètement normal appelé le "phénomène de rebond". Pensez-y comme les contacts mécaniques du bouton qui rebondissent légèrement quand ils font ou rompent la connexion. La bonne nouvelle ? Nous allons réparer ceci complètement avec des techniques de debouncing professionnelles dans la section suivante !

Pression longue et pression courte avec debouncing

C'est ici que nous transformons votre gestion de boutons d'exemples éducatifs en code professionnel, prêt pour la production ! Le debouncing est absolument crucial pour les applications du monde réel - c'est la différence entre un projet d'amateur et un appareil fiable, de qualité commerciale.

Le debouncing de bouton peut sembler compliqué, mais pensez-y comme apprendre à votre Arduino à "écouter attentivement" au lieu de réagir à chaque petit bruit électrique. Quand vous appuyez sur un bouton physique, les contacts métalliques ne font pas une connexion parfaite et propre immédiatement. Au lieu de cela, ils "rebondissent" - faisant et rompant le contact rapidement pendant quelques millisecondes. Sans debouncing, votre Arduino pourrait interpréter une pression de bouton comme plusieurs pressions, menant à un comportement frustrant et imprévisible.

La bonne nouvelle est que le debouncing ne doit pas être accablant, surtout quand on utilise plusieurs boutons ou des scénarios de timing complexes. Pour rendre ceci beaucoup plus facile pour les débutants (et les développeurs expérimentés aussi !), nous utiliserons une fantastique bibliothèque appelée ezButton. Cette bibliothèque gère tous les timings compliqués et la gestion d'état en arrière-plan, vous permettant de vous concentrer sur la construction de projets incroyables plutôt que de lutter avec la mécanique de boutons de bas niveau.

Pensez à la bibliothèque ezButton comme votre assistant qualifié qui interprète parfaitement chaque pression de bouton, filtrant le bruit électrique et ne délivrant que les interactions utilisateur propres et intentionnelles auxquelles vous voulez vraiment répondre. C'est comme avoir un traducteur professionnel qui s'assure que rien ne se perd dans la communication !

Pression courte et pression longue avec debouncing après relâchement

Cette implémentation fournit une fiabilité inébranlable en attendant l'interaction utilisateur complète avant de prendre des décisions, combinée avec un debouncing de qualité professionnelle pour une précision parfaite à chaque fois.

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-button-long-press-short-press */ #include <ezButton.h> const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds ezButton button(7); // create ezButton object that attach to pin 7; unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); button.setDebounceTime(50); // set debounce time to 50 milliseconds } void loop() { button.loop(); // MUST call the loop() function first if(button.isPressed()) pressedTime = millis(); if(button.isReleased()) { releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); if( pressDuration > LONG_PRESS_TIME ) Serial.println("A long press is detected"); } }

Étapes rapides

  • Installer la bibliothèque ezButton : D'abord, installez la bibliothèque ezButton dans votre IDE Arduino. Consultez le Guide d'installation détaillé si vous avez besoin d'aide avec l'installation de bibliothèques - ne vous inquiétez pas, c'est simple !
  • Téléverser et tester la fiabilité : Téléversez le code ci-dessus et remarquez immédiatement la différence ! Plus de fausses détections ou de comportement erratique - chaque pression de bouton est interprétée exactement comme vous l'avez voulu.
  • Expérimenter la qualité professionnelle : Essayez des pressions rapides, des touches douces, et des appuis fermes. La version avec debouncing gère tout de façon fluide et prévisible.

Conseil de pro : Une fois que vous expérimentez la gestion de bouton avec debouncing, vous ne voudrez jamais revenir aux méthodes de détection de base. C'est la fondation du développement de projets Arduino professionnels !

COM6
Send
A short press is detected A long press is detected A short press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Pression courte et pression longue avec debouncing pendant l'appui

Cette implémentation avancée combine la détection de pression longue temps réel avec un debouncing à toute épreuve, créant l'interface de bouton la plus réactive et fiable possible.

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-button-long-press-short-press */ #include <ezButton.h> const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds ezButton button(7); // create ezButton object that attach to pin 7; unsigned long pressedTime = 0; unsigned long releasedTime = 0; bool isPressing = false; bool isLongDetected = false; void setup() { Serial.begin(9600); button.setDebounceTime(50); // set debounce time to 50 milliseconds } void loop() { button.loop(); // MUST call the loop() function first if(button.isPressed()){ pressedTime = millis(); isPressing = true; isLongDetected = false; } if(button.isReleased()) { isPressing = false; releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); } if(isPressing == true && isLongDetected == false) { long pressDuration = millis() - pressedTime; if( pressDuration > LONG_PRESS_TIME ) { Serial.println("A long press is detected"); isLongDetected = true; } } }

Étapes rapides

  • S'assurer de l'installation de la bibliothèque : Assurez-vous d'avoir la bibliothèque ezButton installée. Consultez le guide d'installation si nécessaire - vous pouvez le faire !
  • Téléverser et ressentir la différence : Téléversez ce code et expérimentez l'ultime en réactivité de bouton. Les pressions longues fournissent un feedback immédiat tout en maintenant une précision parfaite.
  • Tester extensivement : Essayez toutes sortes d'interactions de boutons - tapotements rapides, appuis longs, pression variable. Tout fonctionne parfaitement maintenant !

Conseil de pro : C'est la référence absolue pour les projets Arduino interactifs. Utilisez cette approche quand vous voulez une réactivité maximale combinée avec une fiabilité professionnelle. Vos utilisateurs remarqueront la différence !

COM6
Send
A long press is detected A short press is detected A long press is detected A short press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Pourquoi avoir besoin de pression longue et pression courte

Comprendre les applications pratiques de la détection de pression duale vous inspirera à incorporer cette technique puissante dans vos propres projets créatifs ! La capacité à distinguer entre les pressions courtes et longues n'est pas juste une astuce de programmation cool - c'est un principe d'interface utilisateur fondamental qui rend les appareils plus intuitifs, efficaces et sûrs à utiliser.

Maximiser la fonctionnalité avec un matériel minimal : Un des plus grands avantages est la conservation des ressources et de l'espace. Un seul bouton peut élégamment gérer deux fonctions complètement différentes ou plus, réduisant à la fois les coûts des composants et l'espace physique requis pour votre projet. C'est particulièrement précieux dans les projets compacts où chaque millimètre compte, ou quand vous voulez garder votre interface utilisateur propre et dégagée. Au lieu d'avoir plusieurs boutons qui encombrent votre boîtier de projet, un bouton bien programmé peut faire le travail de plusieurs.

Prévenir les actions accidentelles : La détection de pression longue est incroyablement précieuse pour implémenter des mécanismes de sécurité et prévenir les opérations non intentionnelles. Les fonctions critiques comme les remises à zéro usine, la suppression de données, ou les arrêts système peuvent être protégées derrière des exigences de pression longue (typiquement 3-5 secondes ou plus). Cela prévient le scénario frustrant et potentiellement dommageable où quelqu'un effleure accidentellement un bouton et déclenche un changement système majeur. Pensez à combien d'appareils utilisent la pression longue pour la fonctionnalité d'extinction - c'est un motif de sécurité prouvé et convivial.

Créer des expériences utilisateur intuitives : Les utilisateurs comprennent instinctivement le concept d'interactions "tapotement rapide" versus "appui délibéré". Ce mapping de comportement naturel rend vos projets immédiatement intuitifs à utiliser sans nécessiter de manuels d'instruction ou de formation. Les pressions courtes semblent naturelles pour faire défiler des options, changer de modes, ou effectuer des actions rapides, tandis que les pressions longues semblent appropriées pour des actions plus significatives ou finales.

Tutoriels connexes

※ NOS MESSAGES

  • N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !
DIVULGATION
Newbiely.fr participe au Programme Partenaires d'Amazon Services LLC, un programme de publicité d'affiliation conçu pour permettre aux sites de percevoir une rémunération grâce à la création de liens vers Amazon.com, Amazon.it, Amazon.fr, Amazon.co.uk, Amazon.ca, Amazon.de, Amazon.es, Amazon.nl, Amazon.pl et Amazon.se
Copyright © 2026 Newbiely.fr. Tous droits réservés.
Conditions d'utilisation | Politique de confidentialité
Email: newbiely.com@gmail.com