Bouton poussoir Arduino – Tutoriel complet

Dans ce tutoriel complet, vous apprendrez à utiliser un bouton poussoir avec Arduino, avec différentes configurations de circuits. Vous verrez également comment utiliser le bouton poussoir pour diverses applications et tirer parti de certaines des capacités de l'Arduino, par exemple les interruptions.

Je vais utiliser une carte Arduino Uno, mais ce tutoriel fonctionne également pour toute autre carte Arduino que vous pouvez trouver.

C'est parti !

Table des matières

[on]

Circuit à bouton-poussoir

Pour le circuit vous aurez besoin de :

  • Carte Arduino
  • Planche à pain
  • Quelques fils
  • Bouton poussoir

Voici le circuit que nous allons réaliser.

Bouton poussoir Arduino avec INPUT_PULLUP

Vous apprenez à utiliser Arduino pour construire vos propres projets ?

Découvrez Arduino pour débutants et apprenez étape par étape.

Étapes pour construire le circuit :

  • Assurez-vous d'éteindre l'Arduino.
  • Branchez le bouton poussoir au milieu de la breadboard, comme sur la photo.
  • Sur la patte d'un bouton, branchez un fil (noir si possible) à une broche GND de la carte Arduino.
  • Les pattes supérieure gauche et inférieure gauche du bouton sont connectées ensemble, et les pattes supérieure droite et inférieure droite sont connectées ensemble. Si vous avez branché le fil GND sur le côté gauche, branchez un autre fil sur le côté droit, afin qu'ils ne soient pas connectés ensemble. Cet autre fil va à une broche numérique, par exemple 4.

Pour l'instant, il n'y a pas de résistance impliquée dans le circuit. Dans la suite de cet article, nous en parlerons plus en détail. De plus, si vous souhaitez en savoir plus sur les broches de l'Arduino, consultez ce guide de brochage de l'Arduino Uno .

Code Arduino pour lire l'état du bouton poussoir

Ce que nous essayons de faire ici est simplement de lire l'état du bouton et de l'imprimer 10 fois par seconde.

>> Regardez cette vidéo comme ressource supplémentaire à cette section du didacticiel :

Après avoir regardé la vidéo, abonnez-vous à la chaîne Youtube Robotics Back-End pour ne pas manquer les prochains tutoriels !

Imprimer l'état du bouton poussoir

Voici le code pour imprimer l'état du bouton 10 fois par seconde.

#define BUTTON_PIN 4

configuration vide ()

{

Série. début ( 9600 ) ;

pinMode ( BROCHE_BOUTON, ENTRÉE_PULLUP ) ;

}

boucle vide ( )

{

Série. println ( digitalRead ( BUTTON_PIN )) ;

retard ( 100 ) ;

}

Décomposons ce code ligne par ligne.

Code pour configurer le bouton poussoir

#define BUTTON_PIN 4

Nous créons d'abord un #define pour la broche du bouton, afin de ne pas avoir à écrire « 4 » à chaque fois que nous voulons utiliser cette broche dans notre code. Cela vous facilitera la vie, surtout si vous souhaitez connecter le bouton à une autre broche plus tard. De cette façon, vous n'avez besoin de modifier qu'une seule ligne de code, qui se trouve en haut du programme et donc facile à trouver.

configuration vide ()

{

Série. début ( 9600 ) ;

La fonction void setup() sera appelée en premier, une seule fois. Ce que nous faisons ici est d'initialiser la communication série, afin que nous puissions utiliser le moniteur série pour imprimer les données que nous avons obtenues à partir du bouton.

pinMode ( BROCHE_BOUTON, ENTRÉE_PULLUP ) ;

}

Voici comment initialiser le bouton poussoir dans votre code. Dans le void setup(), vous utilisez la fonction pinMode() avec 2 arguments : d'abord le pin du bouton – ici BUTTON_PIN sera remplacé par « 4 » – puis le mode que nous voulons pour le pin.

Comme nous allons lire les données du bouton – et non les écrire – nous choisissons un mode d'entrée. Et puis nous avons encore 2 options : INPUT ou INPUT_PULLUP. Comme nous n'avons pas de résistance dans notre circuit, nous utiliserons INPUT_PULLUP pour utiliser la résistance de rappel interne de la carte Arduino. Notez que dans ce tutoriel, je ne vais pas plonger dans l'explication de INPUT_PULLUP, mais si vous voulez en savoir plus, consultez ce tutoriel Arduino INPUT_PULLUP .

Code pour lire l'état du bouton poussoir

boucle vide ( )

{

Série. println ( digitalRead ( BUTTON_PIN )) ;

Maintenant, la broche du bouton est initialisée en entrée, et nous entrons dans la boucle void(), qui sera appelée encore et encore un nombre infini de fois.

Pour lire l'état du bouton, nous utilisons la fonction digitalRead(), avec un argument : le pin du bouton. Le résultat de cette fonction sera soit HIGH, soit LOW. Ici, comme nous sommes dans une configuration pull up (avec INPUT_PULLUP), lorsque le bouton n'est pas enfoncé, vous lirez HIGH. Lorsque le bouton est enfoncé, vous lirez LOW.

Ensuite, nous mettons le résultat de digitalRead() dans la fonction Serial.println(), qui imprimera simplement les données sur le Serial Monitor.

retard ( 100 ) ;

}

Juste après avoir lu l'état du bouton et l'avoir imprimé, nous ajoutons un delay() de 100 millisecondes, ce qui signifie que nous allons effectuer cette action environ 10 fois par seconde. Après avoir quitté la boucle void(), elle est à nouveau appelée, etc.

Vous pouvez maintenant tester le code en le compilant et en le téléchargeant sur votre Arduino.

Ouvrez le moniteur série et appuyez/relâchez le bouton-poussoir plusieurs fois.

Vous verrez quelque chose comme ceci :

1

1

1

1

0

0

0

0

1

1

1

1

Toutes les 100 millisecondes, vous aurez une nouvelle ligne, avec soit 0 soit 1.

Comme je l'ai écrit précédemment, la valeur que vous obtenez de digitalRead() est HIGH ou LOW, mais lorsque vous l'envoyez via Serial, elle sera convertie en 1 (HIGH) ou 0 (LOW).

Ainsi, lorsque le bouton n’est pas enfoncé, vous verrez « 1 » imprimé, et lorsque le bouton est enfoncé, vous verrez « 0 ».

Amélioration : Imprimer un message plus explicite

Ce premier code est un excellent exemple minimal pour voir les données provenant du bouton poussoir. Mais dans une application réelle, vous souhaiterez peut-être faire des choses plus intéressantes que simplement imprimer l'état du bouton. Par exemple, vous pouvez lire l'état du bouton, le conserver dans une variable, puis, en fonction de la valeur, effectuer une action spécifique.

Utilisons le code Arduino suivant.

#define BUTTON_PIN 4

configuration vide ()

{

Série. début ( 9600 ) ;

pinMode ( BROCHE_BOUTON, ENTRÉE_PULLUP ) ;

}

boucle vide ( )

{

octet buttonState = digitalRead ( BUTTON_PIN ) ;

si ( buttonState == BAS ) { 

Serial. println ( "Le bouton est enfoncé" ) ;

}

autre {

Serial. println ( "Le bouton n'est pas enfoncé" ) ;

}

retard ( 100 ) ;

}

La phase de configuration est la même. Et comme vous pouvez le voir dans la boucle (), nous stockons maintenant la valeur que nous avons obtenue à partir de digitalRead () dans une variable que nous nommons buttonState. Le type de données de cette variable est octet, ce qui est ce dont vous avez besoin pour les valeurs HIGH et LOW.

Ensuite, avec une structure if simple, nous vérifions si l'état est LOW, ce qui signifie que, dans notre configuration avec la résistance de rappel interne de l'Arduino, le bouton est enfoncé. Lorsque nous détectons cela, nous pouvons décider de faire l'action que nous voulons. Et si la condition est fausse, ce qui signifie que l'état est HIGH (car il n'y a que 2 états possibles), nous savons que le bouton n'est pas enfoncé.

Vous pouvez maintenant exécuter ce code et voir « Le bouton n’est pas enfoncé » imprimé toutes les 100 millisecondes, et lorsque vous appuyez sur le bouton-poussoir, « Le bouton est enfoncé ».

Le bouton n'est pas enfoncé

Le bouton n'est pas enfoncé

Le bouton n'est pas enfoncé

Le bouton n'est pas enfoncé

Le bouton est appuyé

Le bouton est appuyé

Le bouton est appuyé

Le bouton n'est pas enfoncé

Le bouton n'est pas enfoncé

Il s’agit d’une belle amélioration par rapport au code précédent, qui nous donne plus de contexte et permet au code de grandir avec plus de fonctionnalités.

Utilisation de résistances pull up/down

Pour l'instant, nous n'avons utilisé aucune résistance dans notre circuit – en fait, nous l'avons fait, mais il s'agit de la résistance interne de l'Arduino.

En gros, lorsque vous branchez un bouton-poussoir sur une broche numérique, la valeur lue par l'Arduino est comprise entre 0 V et 5 V. Si la valeur est proche de 0 V, vous obtiendrez LOW dans votre code, et si elle est proche de 5 V, vous obtiendrez la valeur HIGH.

Si vous ne mettez pas de résistance, la valeur peut « flotter » entre 0 V et 5 V, ce qui donne des résultats aléatoires et étranges. En ajoutant une résistance, vous pouvez forcer l'état par défaut à être soit BAS, soit HAUT. Et lorsque vous appuyez sur le bouton, l'état devient l'inverse.

Nous avons donc 3 options ici :

  1. Aucune résistance, mais utilisez le mode INPUT_PULLUP pour activer la résistance de rappel interne (forcera la tension de lecture par défaut à 5 V – HAUT).
  2. Ajoutez une résistance pull-up (valeur par défaut : HIGH).
  3. Ajoutez une résistance pull-down (valeur par défaut : LOW).

Pour plus de détails sur les résistances pull up/down, lisez ce tutoriel INPUT_PULLUP .

Nous avons donc déjà utilisé l'option 1, voyons maintenant comment travailler avec les options 2 et 3.

Et pourquoi devrions-nous considérer les options 2 et 3, si nous pouvons simplement construire le circuit sans aucune résistance ? Eh bien, parce que la résistance de rappel interne est assez faible par rapport à ce que nous allons ajouter manuellement dans le circuit. Cela peut conduire à des résultats peu fiables, si vous avez des fils plus longs par exemple.

Bouton poussoir Arduino avec résistance de rappel externe

Pour ce circuit, vous aurez besoin d'une résistance de 10 k Ohm et de tous les autres composants que nous avons utilisés précédemment.

Bouton poussoir Arduino avec résistance de rappel externe

  • Avant de modifier le circuit, assurez-vous d'éteindre l'Arduino, pour éviter tout risque pour votre matériel.
  • Pour le fil de terre (noir) et le fil de données (bleu), c'est la même chose qu'avant. Assurez-vous qu'ils se trouvent sur des côtés différents du bouton, par exemple GND sur le côté gauche et la broche numérique sur le côté droit.
  • Vous allez ajouter la résistance de 10 kOhm du même côté que la connexion de la broche numérique, dans cet exemple, du côté droit. L'autre branche de la résistance va à une ligne différente sur la plaque d'essai, et à partir de cette branche, vous ajoutez un fil (rouge) à la broche 5 V de l'Arduino. Il s'agit de la résistance de rappel, qui garantira que la tension par défaut que vous lisez est de 5 V, donc HIGH dans le code.

Maintenant, voici le code.

#define BUTTON_PIN 4

configuration vide ()

{

Série. début ( 9600 ) ;

pinMode ( BUTTON_PIN, ENTRÉE ) ;

}

boucle vide ( )

{

octet buttonState = digitalRead ( BUTTON_PIN ) ;

si ( buttonState == BAS ) { 

Serial. println ( "Le bouton est enfoncé" ) ;

}

autre {

Serial. println ( "Le bouton n'est pas enfoncé" ) ;

}

retard ( 100 ) ;

}

Comme vous pouvez le voir, le code est le même, nous avons simplement modifié le mode dans la fonction pinMode(). Au lieu d'utiliser INPUT_PULLUP, qui définira la broche comme INPUT + activera la résistance de rappel interne, nous utilisons simplement INPUT.

Bouton poussoir Arduino avec résistance de rappel externe

Pour ce circuit, nous utiliserons également une résistance de 10k Ohm.

Bouton poussoir Arduino avec résistance de rappel externe

Le principe est le même, mais notez que les choses sont un peu différentes ici :

  • Encore une fois, assurez-vous d’éteindre l’Arduino avant de faire quoi que ce soit.
  • Vous allez ajouter la résistance de 10k Ohm du côté connecté à la masse. Donc, en partant d'une patte du bouton, vous avez la résistance, puis un fil (noir) connecté à GND.
  • Le fil connecté à la broche numérique doit maintenant être du même côté que la résistance – dans cet exemple, les connexions GND et de la broche numérique sont sur le côté gauche (et non sur des côtés opposés).
  • Vous ajoutez un fil (rouge) entre une patte du bouton – du côté opposé de GND, donc ici sur le côté droit – et 5V.

Et voici le code.

#define BUTTON_PIN 4

configuration vide ()

{

Série. début ( 9600 ) ;

pinMode ( BUTTON_PIN, ENTRÉE ) ;

}

boucle vide ( )

{

octet buttonState = digitalRead ( BUTTON_PIN ) ;

si ( buttonState == HAUT ) { 

Serial. println ( "Le bouton est enfoncé" ) ;

}

autre {

Serial. println ( "Le bouton n'est pas enfoncé" ) ;

}

retard ( 100 ) ;

}

Comme vous pouvez le voir, nous utilisons également le mode INPUT dans la fonction pinMode().

Mais maintenant, lorsque nous lisons l'état du bouton-poussoir, LOW signifie que le bouton n'est pas enfoncé. Nous devons donc modifier la façon dont nous analysons les données dans notre code. C'est ce que vous pouvez voir à la ligne 13 : si l'état est HIGH, cela signifie maintenant que le bouton a été enfoncé.

Détecter un changement d'état

Super, vous pouvez maintenant lire l'état du bouton et faire quelque chose de différent dans votre code, si le bouton est enfoncé ou non.

Mais que faire si vous souhaitez détecter non pas l'état lui-même, mais un changement d'état ? Par exemple, lorsque l'état du bouton passe de « non enfoncé » à « enfoncé » (appuyer), ou l'inverse (relâcher). En fonction de votre application, cela peut s'avérer très utile.

Et pour cela nous pouvons utiliser 2 méthodes : les interruptions et le polling.

Pour ces 2 méthodes, je vais vous donner ici une bonne introduction – un code qui vous permettra de démarrer avec une compréhension de base – mais si vous voulez en savoir plus, j'ai mis quelques liens vers d'autres tutoriels approfondis dans la section conclusion de ce tutoriel.

Utiliser les interruptions avec le bouton poussoir

Avec les interruptions, vous pouvez créer une fonction qui sera appelée lorsqu'un certain changement se produit sur une broche numérique. L'appel de cette fonction « interrompra » le déroulement normal du programme.

Seules certaines broches numériques peuvent être utilisées pour les interruptions. Sur Arduino Uno, vous pouvez utiliser les broches 2 et 3. Comme le bouton est actuellement connecté à la broche 4, nous devons modifier le circuit.

Voici le circuit avec la résistance pull-down externe, mais cette fois le fil de données est connecté à la broche numérique 3.

Circuit à bouton-poussoir Arduino avec broche d'interruption

Maintenant, le code pour détecter quand le bouton est relâché :

#define BUTTON_PIN 3

bouton d'octet volatileReleased = false ;

bouton voidReleasedInterrupt () { 

boutonReleased = vrai ;

}

configuration vide () { 

Série. début ( 9600 ) ;

pinMode ( BUTTON_PIN, ENTRÉE ) ;

attachInterrupt ( digitalPinToInterrupt ( BUTTON_PIN ) ,

boutonReleasedInterrupt,

CHUTE ) ;

}

boucle vide () { 

si ( boutonRelâché ) { 

boutonLibéré = faux ;

// faire quelque chose ici, par exemple imprimer sur Serial

Serial. println ( "Bouton relâché" ) ;

}

}

La manière d’initialiser le bouton est la même que précédemment.

Nous créons ensuite une nouvelle fonction appelée buttonReleasedInterrupt(). Cette fonction sera appelée lorsque l'interruption sera déclenchée – avec le mode FALLING, ce qui signifie que l'état du bouton passera de HIGH à LOW.

Ainsi, lorsque le bouton est relâché (l'état passe de HIGH à LOW), la fonction est appelée. Nous définissons une valeur booléenne (marquée comme « volatile », car nous la modifions à l'intérieur d'une interruption) sur true, et dans la boucle void loop(), nous vérifions ce booléen. Si c'est vrai, alors nous savons que le bouton a été relâché. Nous remettons le booléen à false et effectuons l'action que nous voulons, par exemple nous pouvons imprimer « Button released » sur le Serial Monitor.

Remarque importante : n'utilisez pas Serial directement dans une fonction d'interruption.

Si vous souhaitez une explication plus détaillée, j'ai également écrit un tutoriel complet sur les interruptions Arduino , qui vous donnera également toutes les choses à faire et à ne pas faire pour utiliser correctement les interruptions.

Détecter le changement d'état avec l'interrogation

Essayons une autre façon de vérifier si le bouton a été relâché, en interrogeant continuellement l'état.

#define BUTTON_PIN 3

octet lastButtonState = BAS;

configuration vide () { 

Série. début ( 9600 ) ;

pinMode ( BUTTON_PIN, ENTRÉE ) ;

}

boucle vide () { 

octet buttonState = digitalRead ( BUTTON_PIN ) ;

si ( buttonState != lastButtonState ) { 

lastButtonState = état du bouton;

si ( buttonState == BAS ) { 

// effectuer une action, par exemple imprimer sur Serial

Serial. println ( "Bouton relâché" ) ;

}

}

}

Encore une fois, nous initialisons le bouton de la même manière que nous l’avons fait précédemment.

Nous conservons également une variable globale nommée lastButtonState, afin de pouvoir comparer l'état du bouton actuel que nous lisons avec le précédent.

Dans la boucle void(), nous vérifions en permanence l'état du bouton. Si l'état est différent du précédent, cela signifie qu'il s'est passé quelque chose : soit nous venons d'appuyer sur le bouton, soit nous venons de le relâcher. Dans les deux cas, nous sauvegardons l'état actuel comme dernier état.

Ensuite, nous vérifions si l'état est BAS. Si oui, dans notre configuration de résistance de rappel, cela signifie que nous avons relâché le bouton. Si vous utilisiez la configuration de rappel, vous devriez faire l'inverse : vérifier si l'état est HAUT.

Débloquer le bouton

Le problème avec le code ci-dessus est que lorsque vous l'exécutez, vous pouvez parfois voir plusieurs « Bouton relâché » lorsque vous relâchez simplement le bouton une fois.

C'est parce que le bouton « rebondit » physiquement lorsque vous le touchez (passant de BAS à HAUT et de HAUT à BAS plusieurs fois dans un court intervalle), tout comme lorsque vous laissez tomber une balle sur le sol. La balle n'atteint pas simplement le sol et y reste, elle rebondit plusieurs fois avant de se stabiliser. C'est similaire pour le bouton poussoir.

Heureusement, nous pouvons résoudre ce problème dans notre code.

#define BUTTON_PIN 3

octet lastButtonState = BAS;

unsigned long debounceDuration = 50; // millis

unsigned long lastTimeButtonStateChanged = 0;

configuration vide () { 

Série. début ( 9600 ) ;

pinMode ( BUTTON_PIN, ENTRÉE ) ;

}

boucle vide () { 

si ( millis () - lastTimeButtonStateChanged > debounceDuration ) { 

octet buttonState = digitalRead ( BUTTON_PIN ) ;

si ( buttonState != lastButtonState ) { 

lastTimeButtonStateChanged = millisecondes () ;

lastButtonState = état du bouton;

si ( buttonState == BAS ) { 

// effectuer une action, par exemple imprimer sur Serial

Serial. println ( "Bouton relâché" ) ;

}

}

}

}

Ce que nous faisons ici consiste essentiellement à ignorer tout résultat du bouton-poussoir pendant une durée donnée après que l'état a changé. De cette façon, nous pouvons éviter de lire l'état lorsque le bouton rebondit physiquement.

Pour ce faire, avant de lire l'état du bouton, nous vérifions si la durée depuis la dernière fois que l'état a changé est supérieure à la debounceDuration que nous avons définie – ici 50 millisecondes. Si oui, nous lisons l'état du bouton. Et puis si nous constatons que l'état est différent du dernier, nous réinitialisons la variable lastTimeButtonStateChanged à l'heure actuelle avec millis(). En faisant cela, nous devrons attendre à nouveau la prochaine fois – au moins 50 millisecondes.

Pour une explication plus détaillée du mécanisme anti-rebond, regardez cette vidéo :

Conclusion – Bouton poussoir Arduino

Dans ce didacticiel sur les boutons-poussoirs Arduino, vous avez appris à :

  • Créez correctement un circuit avec un bouton poussoir connecté à votre carte Arduino,
  • Lire l'état du bouton,
  • Utilisez cet état ou ce changement d’état pour divers cas d’utilisation.

Pour aller plus loin, je vous invite à consulter ce tutoriel sur comment allumer et éteindre une LED avec un bouton poussoir . Dans ce tutoriel, vous verrez comment inclure le bouton poussoir dans diverses applications simples utilisant des LED. Vous obtiendrez également une explication beaucoup plus complète sur le mécanisme anti-rebond.

Créé avec HelpNDoc Personal Edition: Créer facilement des fichiers Qt Help