Comment câbler et programmer plusieurs boutons-poussoirs avec un Arduino

Les boutons-poussoirs sont incroyablement courants dans l'espace DIY Arduino, avec d'innombrables projets sur le Web s'appuyant sur ces petits commutateurs pour activer leur code. Mais comment pouvez-vous exactement câbler et programmer plus d'un bouton-poussoir pour qu'il fonctionne avec votre Arduino? Découvrons-le.

Que faisons-nous ?

Il s'agit d'un projet simple conçu pour vous permettre de démarrer avec des versions Arduino plus complexes à l'avenir. Nous n'allons pas donner de travail à nos boutons, mais cela signifie que vous pouvez choisir ce que vous aimeriez qu'ils fassent pour vous-même en utilisant l'un de nos autres guides DIY Arduino pratiques.

De quoi avez-vous besoin?

Vous n'avez besoin que d'une poignée de pièces pour réaliser ce projet, dont beaucoup que vous aurez déjà dans votre collection de pièces de bricolage.

• 4 x interrupteurs à bouton-poussoir
• 4 résistances 10kΩ
• 1 fois type de carte Arduino (nous utilisons un Leonardo)
• Fil recouvert de PVC/silicone

Câblage de plusieurs boutons-poussoirs avec un Arduino

Le câblage de ce projet est simple, mais vous devez faire attention à ne pas emmêler vos fils lors de chaque connexion, car chaque bouton nécessite deux fils différents.

Commencer simplement, il est logique de câbler un bouton-poussoir avec sa branche positive connectée à la broche 5V sur notre Arduino, et la jambe de terre du bouton connectée à la fois à GND et à la broche numérique 2 sur notre Arduino planche. Une résistance doit être connectée entre la patte de masse du bouton et la broche GND de l'Arduino.

Avec un bouton câblé, il est temps d'ajouter les autres. Chaque bouton a besoin de sa propre broche numérique; nous avons choisi 2, 3, 4 et 5 pour les quatre boutons que nous utilisons, mais n'importe laquelle des broches numériques fonctionnera. Maintenant que votre Arduino est câblé, il est temps de commencer à travailler sur le code.

Programmation de plusieurs boutons-poussoirs avec un Arduino

Le code du projet est agréable et simple, sans avoir besoin de bibliothèques de classes ou d'autres programmations compliquées.

Attribuer des boutons aux broches

Pour la première étape, nous devons attribuer nos boutons aux différentes broches de notre carte Arduino. Étant donné que nous avons utilisé les broches numériques 2, 3, 4 et 5, ce sont les broches que nous déclarerons avec notre code. Cela devrait être placé en haut de votre projet Arduino, avant l'une des fonctions.

int input4Pin = 5 ;
int input3Pin = 4 ;
int input2Pin = 3 ;
int input1Pin = 2 ;

Configuration des boutons

Comme pour la plupart des projets Arduino, nous utiliserons une fonction qui s'exécutera une fois au début du programme, appelée void setup(). Tout d'abord, nous allons démarrer notre connexion série avec un débit en bauds de 57600, suivi de l'initialisation de nos boutons. C'est tout ce dont nous avons besoin dans notre void setup() une fonction.

void setup()
{
 Série.begin (57600); // cela commence la connexion série avec un débit en bauds de 57600
 pinMode (entrée4Pin, ENTRÉE);
 pinMode (entrée3Pin, ENTRÉE);
 pinMode (entrée2Pin, ENTRÉE);
 pinMode (entrée1Pin, ENTRÉE); // ces lignes déclarent chacun des boutons comme une entrée
}

Détection des appuis sur les boutons

Cette prochaine étape est plus complexe que les autres, car nous allons créer notre propre fonction qui traitera une variable de la fonction de boucle principale. Pour commencer, nous devons déclarer notre fonction avec une variable entière comme le code ci-dessous.

void checkPush (int pinNumber)

Ensuite, nous devons affecter la variable que nous utilisons et créer un si déclaration pour détecter quand chaque bouton est pressé. Cette fonction ne peut vérifier que le bouton à la fois, en utilisant la variable qu'elle obtient de la fonction de boucle principale afin qu'elle sache quel bouton vérifier. Notre si vérifie l'état du bouton à l'aide de la fonction intégrée numériqueLire une fonction.

void checkPush (int pinNumber) 
{
 int buttonPushed = digitalRead (pinNumber); 
 si (boutonPushed == ÉLEVÉ) {
 // ajouter le code ici pour quand un bouton est pressé
 }
 autre {
 // ajouter le code ici pour quand un bouton n'est pas pressé
 }
}

Code ajouté au si s'exécute lorsqu'un bouton est enfoncé, tandis que le code dans autre L'instruction ne s'exécutera que lorsqu'un bouton n'est pas enfoncé.

Construction de la boucle principale

Enfin, en tant que dernier morceau de code que vous devez ajouter à votre programme, il est temps de construire le boucle vide () une fonction. Nous avons juste besoin de quatre lignes de code: une pour chacun des boutons que nous avons attachés à notre Arduino. Ces lignes appellent la fonction que nous avons créée à l'étape précédente avec le numéro de broche de chaque bouton.

boucle vide ()
{
 cocherPousser (5);
 checkPush (4);
 checkPush (3);
 checkPush (2);
}

Le code fini

Une fois que vous avez tout ce code en place, votre programme fini devrait ressembler au code ci-dessous. Nous avons ajouté des commentaires à chaque ligne pour faciliter la compréhension, mais nous vous encourageons à rechercher et à lire tout ce que vous ne reconnaissez pas. Cela peut être un excellent moyen d'élargir vos connaissances en matière de codage.

int input4Pin = 5 ;
int input3Pin = 4 ;
int input2Pin = 3 ;
int input1Pin = 2; 
// ceci déclare chacun de nos boutons et leurs épingles
// assurez-vous que vous utilisez les broches auxquelles vos boutons sont câblés
void setup()
{
 Série.begin (57600); // cela commence la connexion série avec un débit en bauds de 57600
 pinMode (entrée4Pin, ENTRÉE);
 pinMode (entrée3Pin, ENTRÉE);
 pinMode (entrée2Pin, ENTRÉE);
 pinMode (entrée1Pin, ENTRÉE); // ces lignes déclarent chacun des boutons comme une entrée
}
boucle vide ()
{
 cocherPousser (5);
 checkPush (4);
 checkPush (3);
 checkPush (2); // chacune de ces lignes appelle notre fonction checkPush avec un numéro de pin différent
}
void checkPush (int pinNumber) // cette fonction attend une valeur entière lorsqu'elle est appelée
{
 int buttonPushed = digitalRead (pinNumber); // cela lit l'état d'un bouton en fonction de son numéro de broche
 if (buttonPushed == HIGH) { // ceci vérifie l'état du bouton
 // ajouter le code ici pour quand un bouton est pressé
 }
 autre {
 // ajouter le code ici pour quand un bouton n'est pas pressé
 }
}

Succès: Câblage et programmation de plusieurs boutons-poussoirs avec un Arduino

Il s'agit d'un projet facile à démarrer lorsque vous souhaitez en savoir plus sur le matériel et les logiciels pour Arduinos. Vous pouvez facilement développer ce que vous avez fait avec des composants supplémentaires, ce qui vous donne la possibilité d'explorer une multitude d'idées passionnantes et de créer des choses qui vous rendent fier.

Programmation Arduino pour les débutants: Tutoriel du projet de contrôleur de feux de signalisation

Lire la suite

A propos de l'auteur