Comment créer un bouton poussoir et l’utiliser comme interrupteur sur Arduino à partir de zéro? Guide étape par étape

Un élément essentiel que tout créateur et développeur devrait avoir est Arduino . Une plate-forme utile pour créer des appareils électroniques matériels et logiciels gratuits . Si vous souhaitez savoir comment créer un bouton-poussoir et l’utiliser comme interrupteur , continuez à lire ce guide étape par étape .

Avec Arduino, vous pouvez développer différents modèles de micro-ordinateurs à carte unique. En tant que logiciel et matériel gratuits , il offre les bases nécessaires à chacun pour développer, modifier et fournir ses propres utilitaires.

Les cartes Arduino offrent une énorme liberté de travail , vous pouvez donc les utiliser pour toutes sortes de choses. Apprenez à créer un bouton poussoir à utiliser comme interrupteur! .

Quelle est la différence entre un bouton poussoir et un interrupteur?

Un bouton est compris comme un composant présent dans presque tous les appareils électroniques aujourd’hui . Ils sont également appelés touches ou boutons. Un bon exemple pour illustrer un bouton-poussoir serait une sonnette. Lorsque vous appuyez sur le bouton, un signal est activé, qui s’éteint au moment où vous appuyez sur. Cependant, quelle est la différence entre un bouton poussoir et un interrupteur? .

De son côté, l’interrupteur est un composant qui est responsable de l’ouverture ou de la fermeture d’un circuit . Lorsqu’il est activé, il reste dans cet état jusqu’à ce qu’il soit à nouveau exécuté par l’utilisateur. Un exemple clair serait l’interrupteur d’éclairage. Là réside alors la principale différence entre un bouton poussoir et un interrupteur . Pendant que l’un ouvre ou ferme le circuit pendant qu’il est enfoncé, revenant à son état initial lorsqu’il est relâché, l’autre maintient son état (ouvert ou fermé) après chaque actionnement.

Apprenez étape par étape à créer un bouton poussoir et à le programmer comme interrupteur avec Arduino

Tout d’abord, pour comprendre étape par étape comment créer un bouton poussoir et le programmer comme interrupteur, il est nécessaire de connaître la bonne façon de connecter un bouton dans Arduino.

Voici quelques points essentiels dont vous devez tenir compte.

• Le bouton poussoir peut être connecté à n’importe laquelle des broches Arduino , qu’elle soit numérique ou analogique.
• Vous devez configurer la broche sélectionnée comme entrée numérique.
• Il est essentiel de considérer la présence de bruit et de rebond dans le logiciel.
• Vous pouvez faire deux types de configurations: avec résistance Pull-Down ou Pull-Up résistance. Concernant la fonction des résistances, on peut dire qu’il s’agit de maintenir un certain état pour le moment où le bouton poussoir n’est pas actionné. Ils sont nécessaires soit internes soit externes.
• Lorsque le bouton-poussoir n’est pas actionné , la résistance Pull-Up maintient un état haut. Lorsqu’il est enfoncé, l’état actif devient bas.
• Lorsque le bouton-poussoir n’est pas actionné , la résistance Pull-Down maintient un état bas. Lorsqu’il est enfoncé, l’état actif devient élevé.

La programmation d’un interrupteur en bouton poussoir est une pratique assez simple. Tout ce que vous avez à faire est de créer une variable dont la valeur changera à chaque pression sur le bouton. Selon l’état dans lequel il se trouve, il passera de 1 à 0 ou vice versa lorsque vous appuyez sur. Enfin, vous pourrez allumer la LED en fonction de l’état de la variable et non du bouton.

Pour le réaliser, les matériaux de fabrication suivants sont nécessaires:

• 1 Arduino.
• 1 LED.
• 1 planche à pain.
• Câbles.
• Câble de données
• 1 Résistance pour le bouton.
• 1 Résistance pour la LED.

Le schéma de montage peut varier en fonction de la configuration des résistances. Qu’ils soient Pull-Up ou Pull-Down , internes ou externes.

Dans le cas d’une résistance Pull-Down interne, le code à saisir serait le suivant:

#define Push 2 // On donne l'alias à notre pin 2.
#define LED 3 // On donne l'alias à notre pin 3.
int Push_lee = 0;
int LEDState = 0;
int oldState = 0;
void setup ()
{
pinMode (LED, SORTIE); // Nous définissons la broche LED comme une sortie.
pinMode (Push, INPUT); // Nous définissons le Push pin comme entrée.
}
void loop () // Nous définissons notre séquence.
{
Push_lee = digitalRead (Push); // Nous stockons la lecture du bouton dans la variable.
si ((Push_lee == 1) && (oldState == 0))
{
stateLed = 1 - stateLed;
retard (10);
}
oldState = Push_lee;

if (estadoLed == 1) // Condition que si nous avons la valeur 1, il l'entrera.
{
digitalWrite (LED, HAUT); // Un STOP est envoyé à la LED.
}
else // Condition remplie si le if n'est pas satisfait.
{
digitalWrite (LED, LOW);
}
}

Une fois le schéma d’assemblage et le code de programmation complétés , vous devez le transférer sur la carte Arduino via le câble réseau .

Les meilleurs projets Arduino avec des commutateurs et des boutons poussoirs pour mettre en pratique vos compétences

Comme mentionné ci-dessus, le matériel et les logiciels gratuits d’Arduino se prêtent à toutes sortes de créations et d’utilitaires . Pour cette raison, nous vous laissons certains des meilleurs projets Arduino avec des commutateurs et des boutons pour mettre en pratique vos compétences .

Voyons voir ensuite:

Feu de signalisation simple

Le sémaphore simple est l’un des projets Arduino les plus basiques. En termes simples, vous devez programmer un code qui vous permet de simuler un feu de signalisation . Beaucoup de gens décident de faire un changement et de le convertir pour le rendre «intelligent».

Les deux projets sont relativement faciles et se composent presque des mêmes matériaux:

• Arduino UNO .
• Planche à pain.
• 3 ou 6 résistances de 220 Ω.
• 2 résistances 10 K Ω.
• 2 boutons poussoirs.
• LED rouges, jaunes et vertes.

Le code à saisir est le suivant:

/ **
* Feu de signalisation simple
* /

void setup () {
pinMode (13, SORTIE);
pinMode (12, SORTIE);
pinMode (11, SORTIE);
digitalWrite (13, FAIBLE);
digitalWrite (12, FAIBLE);
digitalWrite (11, FAIBLE);
}

boucle void () {
digitalWrite (13, FAIBLE);
digitalWrite (11, HIGH);
retard (5000);
digitalWrite (11, FAIBLE);
digitalWrite (12, HIGH);
retard (1000);
digitalWrite (12, FAIBLE);
digitalWrite (13, HAUT);
retard (5000);
}

Circuit LED

Le but de cette pratique est de pouvoir allumer plusieurs LED les unes après les autres. C’est un dispositif qui peut être réalisé en suivant les mêmes séquences et instructions connues .

Vos matériaux seraient:

• Arduino Uno.
• Câbles.
• Résistances.
• Plusieurs LED.
• Planche à pain.

Si vous connectez différentes LED à différentes broches numériques dans Arduino, vous devez le déclarer dans la fonction setup () qui peut être comme suit:

void setup ()
{
// initialise les broches numériques en sortie
pinMode (13, SORTIE);
pinMode (12, SORTIE);
pinMode (11, SORTIE);
…………………………
pinMode (6, SORTIE);
}

À son tour, la boucle () doit être répétée autant de fois qu’il y a de LED . Cependant, c’est une meilleure solution C ++ , car c’est un moyen pratique d’indiquer que vous devez répéter un certain nombre de fois. Pour ce faire , la fonction For est appliquée en combinaison avec une variable . Ainsi, pour démarrer les broches 13 à 6 en tant que sorties dans setup (), vous pouvez utiliser l’instruction for.

Sur cette base, ce serait comme suit dans le code:

void setup ()
{
int i = 0; // On initialise la variable i comme un entier
pour (i = 6; i <14; i ++)
pinMode (i, OUTPUT);
}

Sous les mêmes critères, la fonction loop () pourrait également s’écrire comme suit:

boucle vide ()
{
int i = 0; // On initialise la variable i comme un entier
pour (i = 6; i <14; i ++)
{
digitalWrite (i, HIGH);
retard (500);
digitalWrite (i, LOW);
retard (500);
}
}

Prise électrique

Il consiste à simuler un dé à six faces , et à pouvoir choisir un nombre aléatoire entre 1 et 6 en appuyant sur un bouton. C’est un projet simple, mais dans lequel il faut être très prudent avec les résultats aléatoires lors de la programmation, car il pourrait toujours renvoyer la même séquence.

Les matériaux sont:

• 1 bouton poussoir
• 1 affichage à 7 segments
• 1 résistance 10 k (pull down)
• 1 résistance 220 Ω

Le code complet à utiliser serait le suivant:

// Broches constantes
#define PUSHBUTTON 10 // Tableau multidimensionnel pour afficher les nombres
numéro d'octet [10] [8] =
{
{1, 1, 1, 1, 1, 1, 0, 0}, // 0
{0, 1, 1, 0, 0, 0, 0, 0}, // 1
{1, 1, 0, 1, 1, 0, 1, 0}, // 2
{1, 1, 1, 1, 0, 0, 1, 0}, // 3
{0, 1, 1, 0, 0, 1, 1, 0}, // 4
{1, 0, 1, 1, 0, 1, 1, 0}, // 5
{1, 0, 1, 1, 1, 1, 1, 0}, // 6
{1, 1, 1, 0, 0, 0, 0, 0}, // 7
{1, 1, 1, 1, 1, 1, 1, 0}, // 8
{1, 1, 1, 0, 0, 1, 1, 0} // 9
}; void setup () {
// On démarre le moniteur série
Serial.begin (9600); // Nous mettons les broches de segment en mode OUTPUT (sortie)
pour (int i = 2; i <10; i ++)
{
pinMode (i, OUTPUT);
}

// On met la broche du bouton poussoir en mode INPUT (entrée)
pinMode (BOUTON POUSSOIR, ENTRÉE);

// Nous définissons la graine fixe
randomSeed (analogRead (A0));
}

boucle void () {
// On lit la valeur du bouton
valeur int = digitalRead (BOUTON POUSSOIR);

// Si c'est pressé
if (valeur == HIGH)
{

// Génère un nombre aléatoire entre 1 et 6
int randomNumber = aléatoire (1, 7);

// Nous mettons les broches dans le bon état pour afficher le nombre randomNumber
pour (int e = 0; e <8; e ++)
{
digitalWrite (e + 3, nombre [randomNumber] [e]);
}

retard (500);
}
}

Si vous avez des questions, laissez-les dans les commentaires, nous vous répondrons dans les plus brefs délais, et cela sera également d’une grande aide pour plus de membres de la communauté. Je vous remercie!