Utiliser les entrées / sorties numériques d'une carte Arduino / Genuino

Un voyant et un bouton, c'est déjà un bon début !

Image d'entête

par skywodd | | Licence (voir pied de page)

Catégories : Tutoriels Arduino | Mots clefs : Arduino Genuino LED DEL Bouton

Cet article n'a pas été mis à jour depuis un certain temps, son contenu n'est peut être plus d'actualité.


Dans ce tutoriel, nous allons apprendre ensemble à utiliser les entrées / sorties numériques d'une carte Arduino / Genuino. Nous verrons comment allumer un voyant et lire l'état d'un bouton. En bonus, nous verrons quelques petites astuces et fonctionnalités avancées qui vous simplifieront la vie par la suite ;)

Sommaire

Bonjour à toutes et à tous !

Dans un précédent article, nous avons vu ensemble comment installer et prendre en main l'environnement de développement Arduino. Nous allons à présent voir comment utiliser les entrées / sorties numériques d'une carte Arduino pour faire s'allumer un voyant en fonction de l'appui sur un bouton.

Qu'est-ce qu’une entrée / sortie numérique ?

Avant de commencer, voyons ensemble quelques bases d'électronique numérique ;)

Photo carte Arduino UNO avec pinmap

Carte Arduino UNO

Tout d'abord, une entrée / sortie est une connexion physique, une "broche", sur laquelle vous pouvez venir câbler quelque chose, comme un voyant, un bouton, un capteur, etc.

Une entrée / sortie numérique est une entrée / sortie qui peut prendre un des trois états physiques suivant : "haut" (HIGH), "bas" (LOW) ou "haute impédance" (INPUT).

L'état "haut" (HIGH) signifie que la broche génère un signal. Cet état se traduit généralement par une tension de 5 volts en sortie de la broche avec une carte Arduino classique.

L'état "bas" (LOW) signifie que la broche ne génère pas de signal. Cet état se traduit généralement par une tension de 0 volt en sortie de la broche.

L'état "haute impédance" (INPUT) est un état un peu particulier. Dans cet état, la broche ne génère aucun signal. L'état "haute impédance" signifie que la broche est "en lecture" (en entrée). C'est cet état qui permet de "lire" un bouton par exemple.

Ne pas confondre états physiques et états logiques

Vous remarquerez que j'emploie le terme d'état physique et non le terme d'état logique. C'est volontaire. Il y a une subtile différence entre ces deux termes, pourtant semblables, mais complètement différents.

Un état physique est par définition physique (sans blague !). Si vous prenez un multimètre (un outil qui permet de mesurer une tension) et que vous le placez entre une broche et la masse, vous pouvez mesurer la tension de cette broche et donc en déduire son état physique.

Un état logique (état binaire 0 / 1, vrai / faux, éteint / allumé, etc.) ne correspond à aucun état physique particulier. C'est la personne qui fait le programme qui décide de dire "allumé = haut", "éteint = bas", ou l'inverse par exemple. Vous verrez dans la suite de l'article que dans certains cas la correspondance entre état logique et état physique est inversée.

Configurer une broche en sortie et allumer une LED

Maintenant que nous savons ce qu'est une broche d'entrée / sortie et quels sont les différents états que peut prendre celle-ci, passons à la pratique.

Nous allons faire un montage relativement simple. Nous allons allumer et éteindre une LED.

Ce n'est pas le montage le plus palpitant qui soit, j'en conviens. Mais comme vous pourrez le voir dans les chapitres suivants, allumer une simple LED demande pas mal de réflexion ;)

Wooo du calme ! C'est quoi une LED !?

Une LED (ou DEL pour la version francophone que personne n'utilise) est un voyant, une sorte de petite lampe. LED signifie "Light Emitting Diode" en anglais, ou "Diode électroluminescente" en français.

Différent type de LED

Quelques exemples de LED

Une LED peut avoir différentes couleurs : rouge, verte, jaune, orange, bleu, blanc, différentes tailles : 10mm, 5mm, 3mm, différentes formes : carrées, rondes et différentes puissances. Il y a des LED pour tous les gouts et tous les projets ;)

La couleur, la forme et la taille ne changent pas grand-chose dans le cadre de ce tutoriel. Une LED rouge ronde 5mm standard fera très bien l'affaire.

Symbole LED

Symbole d'une diode électroluminescente

Vous pouvez repérer une LED sur un schéma électronique grâce à son symbole ci-dessus. Il s'agit du symbole d'une diode avec deux petites flèches en plus pour montrer qu'il s'agit d'une diode électroluminescente (qui produit de la lumière).

Une LED est un composant polarisé. Cela signifie qu'il faut la câbler dans un certain sens pour qu'elle marche. Si vous câblez une LED à l'envers, elle ne s'allumera pas.

Schéma de principe du câblage LED

Schéma de principe du câblage LED

Pour qu'une LED s'allume et illumine votre journée, il faut que le courant passe de l'anode à la cathode. Cela revient à dire que la tension doit être supérieure côté anode par rapport au côté cathode.

Instant "étale ta science" : quand une tension est supérieure à une autre au sein d'un même circuit, on parle de "différence de potentiel".

Pour repérer la cathode et l'anode, c'est assez simple quand on connait le truc. La cathode se trouve du côté de "barre verticale" et l'anode du côté "triangle".

Astuce mnémotechnique LED

Astuce mnémotechnique

Pour vous rappeler facilement de quel côté est quoi, il existe un moyen mnémotechnique assez simple.

La cathode est du côté de la barre qui forme un K et l'anode du côté de la barre qui forme un A.

LED en gros plan

Le méplat indique le côté cathode

Physiquement, la cathode d'une LED est repérable grâce au méplat sur le côté du plastique de la LED.

Schéma de principe du câblage LED (à l'envers)

Schéma de principe du câblage LED (à l'envers)

Si vous câblez une LED à l'envers, elle ne s'allumera pas. Et pas de panique, si cela arrive, la LED ne sera pas endommagée.

N.B. Les schémas ci-dessus sont des schémas de principe. N'essayez pas de câbler une LED directement à la sortie d'une pile sans savoir ce que vous faites, sinon vous allez griller votre LED ;)

Le montage

Matériel pour exemple Blink

Matériel nécessaire

Pour réaliser ce premier montage, il va nous falloir :

  • Une carte Arduino UNO (et son câble USB),

  • Une LED, j'utilise une LED rouge standard 5mm,

  • Une résistance de 330 ohms (on va voir tout de suite pourquoi cette résistance et cette valeur en particulier) – code couleur orange / orange / marron,

  • Une plaque d'essai et des fils pour câbler notre montage.

Je n’ai pas de LED et/ou de résistance de 330 ohms ! Je fais quoi !

Pas de panique, toutes les cartes Arduino classiques disposent d'une LED de test sur la broche n°13. Donc même si vous n'avez pas les composants nécessaires, simplement avec votre carte Arduino, il est possible de tester le code de ce tutoriel.

La carte Arduino UNO va nous permettre de contrôler la LED. OK. La LED va nous permettre d'ajouter un peu de joie et de bonne humeur à notre journée. OK. La plaque d'essai et les fils vont nous permettre de câbler le montage. OK. Mais à quoi va bien pouvoir nous servir cette "résistance" !?

En fait, je vous ai caché un gros secret, pour faire s'allumer une LED correctement, il faut limiter le courant qui la traverse. C'est le même principe qu'avec n'importe quel appareil électrique. Si vous branchez un grille-pain sur une ligne haute tension, il se transformera instantanément en super grille-pain cracheur de feu (n'essayez pas ça chez vous). C'est pareil avec les LED.

Si vous câblez une LED directement sur une broche de sortie, sans limiter le courant, la LED va griller. Ce n'est pas plus compliqué que cela. D'où l'utilité de la résistance, qui va faire résistance au courant et limiter celui-ci à un niveau adéquat pour que notre LED s'illumine sans griller.

Pourquoi une résistance de 330 ohms ?

Je n'ai pas sorti la valeur de 330 ohms de nulle part. Cette valeur est le résultat d'un calcul simple et cependant fondamental en électronique : la loi d'Ohm. S’il n'y a qu'une seule formule que vous devez impérativement connaitre en électronique, c'est bien celle-là.

La loi d'Ohm dit que : U (tension en volts) = R (résistance en ohms) x I (courant en ampère).

Pour qu'une LED s'illumine sans griller, il faut qu'un courant d'environ 12mA (soit 0,012A) la traverse. On connait donc I dans notre formule. Reste maintenant à déterminer U pour calculer R.

Une LED standard induit à ses broches une chute de tension d'environ 1,2 volt. Notre carte Arduino fonctionne elle en 5 volts.

Pour calculer la valeur de la résistance de limitation de courant, il faut déterminer la tension U que cette même résistance va devoir dissiper (en chauffant). Dans le cas de notre LED : U = 5 – 1,2 = 3,8 volt.

U = R x I soit R = U / I, avec U = 5 et I = 0,012 (12mA en ampère).

On obtient donc, R = 3,8 / 0,012 = 316 ohms.

Tableau résistance E12

Valeurs standards de résistances

La valeur supérieure la plus proche que l'on peut trouver dans le commerce est 330 ohms.

Important : on choisit toujours une résistance de valeur supérieure pour éviter de dépasser la limite en courant de la LED.

N.B. Certains tutoriels disponibles sur Internet partent du principe qu'une LED a besoin de 20mA pour s'allumer et utilisent donc en conséquence des résistances de 200 ohms (la valeur supérieure la plus proche de 190 ohms). Le but ici n'est pas d'éclairer une pièce, mais bien de servir d'indicateur. Un courant de 12mA est largement suffisant pour voir la LED en plein jour.

Vue prototypage du montage de l'exemple Arduino Blink

Vue prototypage du montage

Vue schématique du montage de l'exemple Arduino Blink

Vue schématique du montage

Pour commencer notre montage, nous allons câbler la résistance de 330 ohms en reliant une de ses extrémités (les résistances n'ont pas de sens à respecter) à la broche D13 de la carte Arduino au moyen d'un fil. L'autre extrémité de la résistance est reliée à la plaque d'essai sur une des lignes de celle-ci.

Une fois la résistance en place, on câble la LED en plaçant l'anode de celle-ci sur la même ligne de la plaque d'essai que la résistance. On place ensuite la cathode (le côté avec le méplat) sur une autre ligne de la plaque d'essai.

Montage de l'exemple Arduino Blink

Le montage fini

On achève ensuite le circuit en reliant la masse de la carte Arduino (broche GND) à la cathode de la LED avec un fil.

Parenthèse : Utilisation d'une plaque d'essai et conventions de couleurs

Illustration des connexions d'une plaque d'essai

Illustration des connexions d'une plaque d'essai

Une plaque d'essai, aussi appelée "Protoboard" ou "Breadboard" en anglais, se compose de points de connexion groupés sous forme de lignes et de colonnes.

Tous les points d'une même ligne sont reliés entre eux. Les points de deux lignes adjacentes ne sont pas reliés entre eux. Les points des lignes à droite et à gauche de la séparation verticale au centre de la plaque d'essai ne sont pas reliés entre eux.

Tous les points des colonnes aux extrémités droites et gauches de la plaque d'essai sont reliés entre eux. Ces colonnes servent généralement à l'alimentation du circuit (masse + alimentation) et sont la plupart du temps annotées avec deux traits verticaux, un rouge et un noir.

Par convention, on utilise un fil rouge pour les alimentations et un fil noir pour les masses. Libre à vous ensuite de choisir une couleur de fil pour que le reste du circuit reste "lisible".

Il n'y a rien de pire que d'avoir un circuit avec des couleurs de fils non conventionnelles. Si un électronicien voit un fil noir dans un circuit, c'est une masse et un fil rouge, une alimentation. Respectez les conventions, elles vous sauveront la vie plus tard en cas d'erreur ;)

Le code

Capture d'écran Arduino, exemple Blink

Capture d'écran du logiciel Arduino

Maintenant que nous avons notre montage, passons au code !

Le but de notre code va être :

  1. De mettre la broche avec notre LED en sortie.

  2. D'allumer la LED.

  3. D'attendre une seconde (on verra dans un prochain article plus en détail cet aspect du code).

  4. D'éteindre la LED.

  5. D'attendre une seconde et de recommencer au point 2.

Pour réaliser ce morceau code, communément appelé "Blink" par la communauté Arduino, nous allons utiliser deux fonctions propres au logiciel Arduino : pinMode() et digitalWrite().

Détails de la fonction pinMode()

La fonction pinMode() permet de configurer une broche en sortie ou en entrée (haute impédance).

1
pinMode(broche, mode);

La fonction pinMode() accepte deux paramètres obligatoires : le numéro de broche à configurer en premier paramètre et le mode de fonctionnement de la broche en second paramètre.

Le mode de fonctionnement de la broche peut prendre les valeurs suivantes : OUTPUT (sortie), INPUT (entrée) ou INPUT_PULLUP (entrée avec résistance de tirage) depuis la version 1.0.1 du logiciel Arduino (plus de détails sur ce mode dans les chapitres suivants).

Remarque : les broches A0, A1, A2, etc, peuvent être utilisées comme des broches numériques.

Détails de la fonction digitalWrite()

La fonction digitalWrite() permet de choisir l'état d'une broche.

1
digitalWrite(broche, etat);

La fonction digitalWrite() accepte deux paramètres obligatoires : le numéro de broche à configurer en premier paramètre et l'état de la broche en second paramètre.

L'état de la broche peut prendre les valeurs suivantes : HIGH (état haut) ou LOW (état bas).

Remarque : mettre une broche configurée en entrée (INPUT) à l'état haut (HIGH) ou bas (LOW) est possible et communément utilisé. Cela a pour effet d'activer / désactiver les résistances de tirage internes dont nous verrons l'utilité dans la seconde partie de ce tutoriel.

1
const int BROCHE_LED = 13;

Nous allons commencer notre programme en déclarant une constante (mot clef const) de type "nombre entier" (mot clef int). Cette constante sera initialisée avec la valeur 13, qui correspond à la broche sur laquelle est reliée notre LED.

Par convention, on nomme toujours les constantes en majuscule, avec un sous tiret entre chaque mot, si cela est nécessaire. De plus, pour faciliter la lecture du code, on utilise généralement un préfixe commun pour toutes les constantes d'un même usage. Dans ce tutoriel, j'utilise le préfixe BROCHE_ pour désigner les constantes représentant une broche. Libre à vous de choisir le préfixe qui vous semble le plus pertinent dans vos codes ;)

1
2
3
void setup() {
    pinMode(BROCHE_LED, OUTPUT);
}

Nous allons ensuite configurer en sortie la broche sur laquelle est reliée notre LED. Cette étape n'a besoin d'être réalisée qu'une seule fois au démarrage de la carte Arduino.

Faire quelque chose une seule fois au démarrage de la carte Arduino ? C'est le but même de la fonction setup() que nous allons donc utiliser sans hésiter ;)

1
2
3
4
5
6
void loop() {
    digitalWrite(BROCHE_LED, HIGH);
    delay(1000);
    digitalWrite(BROCHE_LED, LOW);
    delay(1000);
}

Nous allons ensuite faire le gros du travail : allumer et éteindre le LED, en boucle.

Pour ce faire, nous utilisons la fonction digitalWrite(), une fois avec l'état HIGH pour allumer la LED et une autre fois avec l'état LOW pour éteindre la LED. De plus, afin de pouvoir voir la LED s'allumer et s'éteindre, nous ajoutons un délai d'une seconde (1000 millisecondes) après chaque digitalWrite().

Comme cela doit être fait continuellement, en boucle, nous allons placer ce morceau de code dans la fonction loop() qui s'exécute continuellement tant que la carte Arduino est alimentée.

N.B. Je ne vous parle volontairement pas de la fonction delay() pour le moment, ce n'est pas le sujet de ce tutoriel. Pour faire simple, cette fonction permet de faire une temporisation de N millisecondes.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*
 * Code d'exemple Blink.
 *
 * Fais clignoter une LED câblée sur la broche D13.
 */

// Déclare la broche sur laquelle est câblée la LED
const int BROCHE_LED = 13;

// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {

    // Configure la broche de la LED en sortie
    pinMode(BROCHE_LED, OUTPUT);
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {
    
    // Allume la LED
    digitalWrite(BROCHE_LED, HIGH);

    // Attend 1 seconde
    delay(1000);

    // Eteint la LED
    digitalWrite(BROCHE_LED, LOW);

    // Attend 1 seconde
    delay(1000);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Téléversez et sortez le champagne !

Connectez votre carte Arduino à votre PC, téléversez le code dans la carte depuis l'environnement de développement Arduino et sortez le champagne !

Vous venez de faire clignoter une LED. Félicitation !

Configurer une broche en entrée et allumer une LED en fonction de l'état du bouton

Maintenant que nous avons une LED qui s'allume et qui s'éteint, nous allons passer à la vitesse supérieure. Nous allons allumer la LED en fonction de l'état d'un bouton.

Quand le bouton sera appuyé, la LED sera éteinte et quand le bouton sera laissé au repos, la LED sera allumé.

Le matériel

Matériel pour exemple Button

Matériel nécessaire

Pour réaliser ce second montage, il va nous falloir :

  • Une carte Arduino UNO (et son câble USB),

  • Une LED,

  • Une résistance de 330 ohms – code couleur orange / orange / marron,

  • Un bouton poussoir normalement ouvert,

  • Une résistance de 10K ohms – code couleur marron / noir / orange,

  • Une plaque d'essai et des fils pour câbler notre montage.

Avant de commencer : Les deux types de boutons poussoirs

Je ne pense pas avoir à vous expliquer ce qu'est un bouton poussoir. Dans le doute, faisons quand même un petit rappel.

Un bouton poussoir est un bouton sur lequel vous pouvez appuyer et qui revient dans sa position initiale quand on cesse d'appuyer sur celui-ci. Électriquement parlant, un bouton poussoir se comporte comme un fil qui peut être connecté ou non au reste du circuit.

Dans la vie, il existe deux types de boutons poussoirs : les boutons poussoirs normalement ouverts et les boutons poussoirs normalement fermés.

Symbole bouton poussoir NO

Symbole d'un bouton poussoir normalement ouvert (NO)

Les boutons poussoirs normalement ouverts (NO) sont par défaut ouverts (pas de contact entre les deux broches du bouton). Quand on appuie sur un bouton poussoir normalement ouvert, celui-ci se ferme et fait contact entre les deux broches du bouton.

Symbole bouton poussoir NC

Symbole d'un bouton poussoir normalement fermé (NC)

Les boutons poussoirs normalement fermés (NC) font l'exact opposé. Par défaut, il y a contact entre les deux broches du bouton. Quand on appuie sur un bouton poussoir normalement fermé, celui-ci s'ouvre et arrête de faire contact entre les deux broches du bouton.

Le choix du type de bouton est crucial pour le bon fonctionnement du montage. Dans le cadre de ce tutoriel, nous utiliserons des boutons poussoirs miniatures, normalement ouverts (NO).

Minute "étale ta science" : un bouton poussoir n'a qu'un état stable (NO ou NC), c'est ce que l'on appelle un composant monostable. Un interrupteur au contraire a deux états stables, c'est un composant dit bistable. Il existe aussi des composants dits astables (sans état stable), comme les oscillateurs par exemple.

Carte Arduino, LED, résistance de 330 ohms, plaque d'essai et fils, OK. Bouton poussoir, pourquoi pas. Mais la résistance de 10K ohms, c'est pour faire joli ?

Décidément, je vous cache plein de choses aujourd'hui ;)

Exemple de parasites RF

Exemple de parasites

Quand une broche est configurée en entrée (haute impédance), elle se comporte comme une antenne.

Une broche configurée en entrée doit toujours être tirée (forcée) à un état connu (haut ou bas). Si vous laissez une entrée flottante (non connectée), elle va capter une montagne de parasites en provenance du réseau électrique, des systèmes de communication, des appareils à proximité, etc. Bref, ça va être un massacre et vous n'arriverez jamais à lire correctement l'état de votre bouton.

Dans certaines conditions cette caractéristique peut s'avérer très pratique et utile. Je vous laisse chercher "détecteurs EMF" sur Google. Mais dans notre cas, il faut impérativement éviter les entrées flottantes. Notre but n'est pas de détecter les fantômes, mais bien de lire un bouton de manière fiable.

Les résistances de tirage à la rescousse

Les résistances de tirage permettent de forcer une broche configurée en entrée à un niveau connu par défaut. Ce sont en générales des résistances de valeur assez élevée, entre 1K et 10K ohms, voir plus selon le montage.

En forçant, la broche a un état connu par défaut, on évite les parasites. On obtient alors une lecture d'état propre et fiable. C'est l'idéal pour lire un bouton ;)

Le principe d'une résistance de tirage est simple : on connecte une extrémité de la résistance au niveau de la broche d'entrée et l'autre extrémité à la masse ou à l'alimentation.

Montage d'un bouton en "pull-down"

Montage d'un bouton en "pull-down"

Quand la résistance est reliée à la masse, on appelle cela une résistance de tirage à la masse ("pulldown" en anglais).

Montage d'un bouton en "pull-up"

Montage d'un bouton en "pull-up"

Quand la résistance est reliée à l'alimentation, on appelle cela une résistance de tirage à l'état haut ("pullup" en anglais).

La configuration en "pullup" est extrêmement classique en électronique. L'avantage de cette configuration est qu'il y a un courant qui traverse constamment le fil reliant le bouton et 'entrée. Cela permet d'avoir des boutons au bout d'un long fil, sans risquer de capter des parasites.

N.B. Dans l'idéal, on place la résistance de tirage à proximité du bouton poussoir pour que le courant soit obligé de traverser toute la longueur du fil dans un sens puis dans l'autre.

Et INPUT_PULLUP dans tout ça ?

Certains lecteurs auront remarqué qu'en début d'article, il était fait référence à un mode nommé INPUT_PULLUP pour la fonction pinMode(). Or, dans INPUT_PULLUP, il y a "pullup".

Ce n'est pas une simple coïncidence ;)

Les montages avec des résistances de tirage à l'état haut sont extrêmement classiques. Les fabricants de microcontrôleurs intègrent donc en général une résistance de tirage à l'état haut activable par logiciel sur chaque broche.

Avec le mode INPUT_PULLUP de la fonction pinMode(), il est possible d'activer cette résistance de tirage intégrée et ainsi de se passer d'une résistance de tirage externe. Cela est pratique quand on fait un montage avec des longueurs de câbles courtes, mais dans la plupart des cas, rien ne vaut une résistance de tirage externe ;)

Avant Arduino 1.0.1, l'activation des résistances de tirage internes se faisait en deux étapes avec pinMode() et digitalWrite().

1
2
pinMode(broche, INPUT);
digitalWrite(broche, HIGH);

Si vous rencontrez ce genre de code par la suite, il s'agit tout simplement d'un pinMode(INPUT_PULLUP) à l'ancienne. Cette ancienne façon de faire est encore couramment utilisée aujourd'hui, il est donc important de la connaitre.

N.B. Avec les microcontrôleurs AVR du fabricant ATMEL, utilisaient dans les cartes Arduino classiques, les résistances de tirage à l'état haut interne ont une valeur nominale entre 20K et 50K ohms.

Vue prototypage du montage de l'exemple Arduino Button

Vue prototypage du montage

Vue schématique du montage de l'exemple Arduino Button

Vue schématique du montage

Pour faire notre second montage, nous allons reprendre notre premier montage et lui ajouter un bouton poussoir, avec une résistance de tirage à l'état haut pour éviter les parasites.

Pour ce faire, on va d'abord tirer un fil de la broche D8 (j'ai choisi cette broche de manière totalement arbitraire) à une des lignes de la plaque d'essai. On va ensuite placer notre bouton poussoir de manière à ce qu'une de ses broches soit sur cette même ligne.

Astuce : les boutons poussoirs à 4 broches ont deux broches reliées de chaque côté. Il est en général assez compliqué de savoir quelle broche est reliée à quelle autre broche.

L'astuce consiste à câbler une broche du bouton, puis la broche du côté opposé, en diagonale. En faisant cela, vous êtes sûr de tomber sur les deux broches non reliées du bouton.

Montage d'exemple Arduino Button

Le montage fini

Une fois le bouton en place, on tire un fil du bouton vers la masse de la carte Arduino (broche GND). On achève ensuite le circuit en plaçant la résistance d'un côté sur la ligne de la plaque d'essai allant vers la broche D8 et de l'autre sur une autre ligne, que l'on câblera sur le +5V de la carte Arduino avec un dernier fil.

Le code

Capture d'écran Arduino, exemple Button

Capture d'écran du logiciel Arduino

Maintenant que nous avons notre montage, passons au code !

Le but de notre second code va être :

  1. De mettre la broche avec notre LED en sortie.

  2. De mettre la broche avec notre bouton en entrée.

  3. De lire l'état du bouton.

  4. D'éteindre la LED si le bouton est appuyé, ou de l'allumer dans le cas contraire.

  5. De recommencer au point 3.

Pour réaliser ce morceau code, nous allons réutiliser les fonctions pinMode() et digitalWrite() vues précédemment, avec en plus une troisième fonction : digitalRead().

Détails de la fonction digitalRead()

La fonction digitalRead() permet de "lire" l'état d'une broche.

1
digitalRead(broche);

La fonction digitalRead() accepte un paramètre obligatoire : le numéro de la broche à lire.

La fonction digitalRead() retourne une valeur pouvant être : HIGH (état haut) ou LOW (état bas), en fonction de l'état physique de la broche.

1
2
const int BROCHE_LED = 13;
const int BROCHE_BOUTON = 8;

Nous allons commencer notre programme en déclarant deux constantes (mot clef const) de type "nombre entier" (mot clef int). La constante BROCHE_LED sera initialisée avec la valeur 13, qui correspond à la broche sur laquelle est reliée notre LED. La constante BROCHE_BOUTON sera initialisée avec la valeur 8, qui correspond à la broche sur laquelle est reliée notre bouton

1
2
3
4
5
void setup() {
    pinMode(BROCHE_LED, OUTPUT);
    pinMode(BROCHE_BOUTON, INPUT);
    // digitalWrite(BROCHE_BOUTON, HIGH); // Si vous n'avez pas de résistance de 10K
}

Nous allons ensuite configurer en sortie la broche sur laquelle est reliée notre LED et en entrée la broche sur laquelle est reliée notre bouton. Cette étape n'a besoin d'être réalisée qu'une seule fois au démarrage de la carte Arduino.

N.B. Si vous n'avez pas de résistance de 10K pour faire office de résistance de tirage, vous pouvez utiliser la résistance de tirage intégrée en décommentant la ligne avec le digitalWrite().[/]

1
2
3
4
void loop() {
    byte etat_bouton = digitalRead(BROCHE_BOUTON);
    digitalWrite(BROCHE_LED, etat_bouton);
}

Nous allons ensuite faire le gros du travail : allumer et éteindre le LED en fonction de l'état du bouton.

Pour ce faire, nous utilisons la fonction digitalRead() pour lire l'état du bouton. Le résultat sera stocké dans une variable de type byte (un octet, pouvant stocker des valeurs comprises en 0 et 255), nommée etat_bouton dans mon exemple de code.

On utilise ensuite la fonction digitalWrite() pour affecter l'état du bouton à la broche de sortie avec notre LED.

N.B. Comme on utilise un montage avec une résistance de tirage à l'état haut, par défaut (au repos) le bouton est à l'état HIGH et passe à l'état LOW quand on appuie sur celui-ci. C'est un exemple typique d'inversion d'état logique / état physique. Ici il paraitrait beaucoup plus logique d'avoir HIGH = bouton appuyé et LOW = bouton au repos, pourtant dans la pratique on utilise quasi systématiquement l'inverse ;)

Ce morceau de code est placé dans la fonction loop() pour que l'assignation de l'état du bouton se fasse continuellement.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
 * Code d'exemple Bouton.
 *
 * Allume ou éteint une LED câblée sur la broche D13 en fonction de l'état d'un bouton poussoir sur la broche D8.
 */

// Déclare la broche sur laquelle est câblée la LED et le bouton
const int BROCHE_LED = 13;
const int BROCHE_BOUTON = 8;

// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {

    // Configure la broche de la LED en sortie
    pinMode(BROCHE_LED, OUTPUT);

    // Configure la broche du bouton en entrée
    pinMode(BROCHE_BOUTON, INPUT);

    // Si vous n'avez pas de résistance de tirage à l'état haut dans votre circuit, 
    // vous pouvez décommenter la ligne ci-dessous pour activer la résistance de tirage interne.
    // digitalWrite( BROCHE_BOUTON, HIGH);
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {
    
    // Lit l'état du bouton
    byte etat_bouton = digitalRead(BROCHE_BOUTON);

    // Allume la LED en fonction de l'état du bouton
    digitalWrite(BROCHE_LED, etat_bouton);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Téléversez et (re)sortez le champagne !

Connectez votre carte Arduino à votre PC, téléversez le nouveau code dans la carte depuis l'environnement de développement Arduino et ressortez le champagne pour une seconde tournée !

Vous venez de faire s'allumer une LED en fonction de l'appui sur un bouton poussoir. Félicitation !

Bonus : Je voudrais que la LED s'allume quand j'appuie sur le bouton

Actuellement, la LED s'allume quand on relâche le bouton. Cela est dû à la résistance de tirage qui force le bouton à l'état haut par défaut.

Ce n'est pas très logique comme exemple, on va donc faire l'exemple inverse. On va allumer la LED quand on appuie sur le bouton et éteindre la LED quand on relâche le bouton.

Une solution physique sera de câbler le bouton avec une résistance de tirage à l'état bas. Le problème c'est que cela n'est pas très pratique et est assez peu commun en électronique. On préfère de loin les résistances de tirage à l'état haut, car celles-ci permettent une bien meilleure protection contre les parasites.

En logiciel, cette petite modification de comportement est possible de deux façons différentes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
void loop() {
    
    // Lit l'état du bouton
    byte etat_bouton = digitalRead(BROCHE_BOUTON);

    // Allume la LED en fonction de l'état du bouton
    if (etat_bouton == HIGH) {
        digitalWrite(BROCHE_LED, LOW);
   } else {
        digitalWrite(BROCHE_LED, HIGH);   
   }
}

La première façon de faire implique l'utilisation d'un test avec la syntaxe if (condition) { code si vrai } else { code si faux}.

1
2
3
4
5
6
7
8
void loop() {
    
    // Lit l'état du bouton
    byte etat_bouton = digitalRead(BROCHE_BOUTON);

    // Allume la LED en fonction de l'état du bouton
    digitalWrite(BROCHE_LED, !etat_bouton);
}

La seconde solution est la plus simple, elle utilise un opérateur très commun en informatique : la négation booléenne.

En interne, HIGH et LOW sont deux valeurs booléennes (vrai / faux, 0 / 1), HIGH = 1 et LOW = 0.

L'opérateur de négation booléenne ! permet d'inverser la valeur booléenne d'une valeur numérique. Normalement, toute valeur autre que zéro est "vraie" et la valeur zéro est "fausse".

En utilisant !etat_bouton on inverse la valeur booléenne de etat_bouton. Comme HIGH et LOW sont en réalité des valeurs booléennes, HIGH devient LOW et LOW devient HIGH.

Cette petite astuce est couramment utilisée en programmation, gardez là dans un coin de votre tête pour plus tard ;)

Bonus : Améliorer le montage avec un anti-rebond

Le code de notre montage fonctionne, notre LED s'allume et s'éteint en fonction de l'appui sur le bouton. Mais il y a un "mais".

En réalité, si vous pouviez voir la LED s'allumer et s'éteindre à la vitesse de la lumière, vous remarqueriez qu'elle ne s'allume pas d'un coup, mais qu'elle clignote avant de s'allumer ou de s'éteindre.

Exemple de rebonds d'un bouton poussoir

Exemple de rebonds d'un bouton poussoir

Cela n'est pas dû à la LED, mais bien au bouton poussoir.

Un bouton est un composant mécanique. Il est constitué de lames en métal qui viennent faire contact entre elles quand on appuie sur le bouton. Or, comme partout en mécanique, il y a des vibrations.

Ces vibrations sont appelées des "rebonds" en électronique. Ce sont de toutes petites vibrations qui se produisent quand le métal du contact du bouton se plie ou se déplie. Cela ne dure que quelques millisecondes et est imperceptible à l'oeil nu, mais pour l'électronique cela est parfaitement visible.

Il existe deux façons de résoudre le problème des rebonds.

Vue prototypage d'un anti-rebond matériel

Vue prototypage

Vue schématique d'un anti-rebond matériel

Vue schématique

La première solution consiste à câbler un condensateur de 100nF en parallèle du bouton pour amortir les rebonds.

C'est une solution physique très appréciée des électroniciens, car facile à mettre en oeuvre et indépendante de tout code ;)

1
2
3
4
5
6
7
8
9
void loop() {
    
    // Lit l'état du bouton
    byte etat_bouton = digitalRead(BROCHE_BOUTON);
    delay(25); // Anti rebonds

    // Allume la LED en fonction de l'état du bouton
    digitalWrite(BROCHE_LED, !etat_bouton);
}

La seconde solution consiste à attendre entre 20 et 150 millisecondes quand on lie l'état d'un bouton. Cela permet d'ignorer la période pendant laquelle le bouton est dans un état intermittent.

C'est une solution logicielle qui ne coute rien et qui évite d'avoir à refaire un montage en cas de problème.

Conclusion

Ce tutoriel est désormais terminé.

Si ce tutoriel vous a plu, n'hésitez pas à le commenter sur le forum, à le diffuser sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.