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 !

par skywodd | Feb. 6, 2016 | 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

• Qu'est-ce qu’une entrée / sortie numérique ?
• Configurer une broche en sortie et allumer une LED
  • Le montage
  • Le code
• Configurer une broche en entrée et allumer une LED en fonction de l'état du bouton
  • Le matériel
  • Le code
• Bonus : Je voudrais que la LED s'allume quand j'appuie sur le bouton
• Bonus : Améliorer le montage avec un anti-rebond
• Conclusion

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

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.

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

Le montage

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.

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.

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.

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

Le code

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().

1

pinMode(broche, mode);

1

digitalWrite(broche, etat);

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).

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

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.

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

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.

1
2

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

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.

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

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().

1

digitalRead(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).

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.

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.

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.

Cliquez ici pour accéder aux commentaires de l'article.