Un buzzer et un bouton sur une même entrée / sortie, c'est possible

Nom de Zeus !

par skywodd | June 22, 2016 | Licence (voir pied de page)

Catégories : Tutoriels Arduino Projets | Mots clefs : Arduino Genuino Bouton Buzzer Astuce

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

Dans ce projet, nous allons voir comment câbler un bouton et un buzzer piézo sur une seule et même broche au lieu de deux. Pas d'inquiétude, il ne s'agit pas d'un bug de la matrice, mais bien d'un montage électronique astucieux. En bonus, nous jouerons un petit air de Tetris en appuyant sur un bouton.

Sommaire

• Le problème de base
• La solution
• Études des cas possibles
  • Cas 1 – Sortie HIGH et bouton OFF
  • Cas 2 – Sortie HIGH et bouton ON
  • Cas 3 – Sortie LOW et bouton OFF
  • Cas 4 – Sortie LOW et bouton ON
  • Cas 5 – Entrée et bouton OFF
  • Cas 6 – Entrée et bouton ON
• Le montage de démonstration
• Le code
• Bonus : Tetris version DJ Bouton
• Conclusion

Bonjour à toutes et à tous !

Dans le cadre d'un projet sur lequel je travaille depuis quelque temps, j'ai dût réaliser un schéma de câblage pour un prototype électronique disposant d'une interface utilisateur. Écran LCD, LEDs, boutons, interfaces diverses, j'ai dû intégrer un certain nombre de composants pour cette interface.

Seulement voilà, une fois le schéma terminé, j'ai relu mon cahier des charges et j'ai réalisé que j'avais oublié un buzzer piézoélectrique (un petit buzzer plat en métal). DOH ! J'ai donc repris mon schéma et là, c'est le drame, plus aucune broche disponible sur mon microcontrôleur. Impossible donc de câbler le buzzer sans faire de modifications.

Les solutions envisageables étaient nombreuses : ajouter un circuit d'extension d'entrées / sorties, multiplexer plusieurs broches ensemble, utiliser un afficheur LCD série, etc. Toutes ces solutions avaient cependant un gros défaut : elles me demandaient une remise en question complète du montage et du code pour celui-ci.

Je me suis donc posé une question bête et méchante : n'y a-t-il pas une broche sur ma carte que je pouvais utiliser pour faire deux choses à la fois ? Après quelques minutes de réflexion, j'ai trouvé le candidat idéal pour cela : le bouton ON / OFF du montage. Il s'agit d'un bouton d'allumage électronique, il n'est donc utilisé que deux fois à chaque utilisation et ne sert à rien le reste du temps.

Est-il possible de câbler un bouton et un buzzer sur une seule et même broche d'entrée / sortie ? Eh bien oui, c'est possible et c'est le sujet de cet article !

Le problème de base

Le problème de base est relativement simple : un bouton, un buzzer, une broche d'entrée / sortie et un but : faire fonctionner ces trois éléments ensemble sans qu'il y ait d'interférences dans leurs fonctionnements. C'est tout.

Pour être un peu plus précis, le but finalement est de pouvoir lire l'état du bouton, sans que le buzzer ne gêne la lecture, mais aussi de pouvoir contrôler le buzzer, sans que le bouton ne gêne d'une quelconque façon le buzzer. Ces deux actions doivent pouvoir être réalisées autant de fois que nécessaire, mais jamais en même temps.

Pour faciliter le montage et la réflexion, j'ai décidé de tolérer un "clic" du buzzer à chaque appui sur le bouton. Les buzzers piézoélectriques font des "clics" quand la tension change soudainement à leurs bornes. Un simple "clic" au moment d'appuyer sur le bouton ou de le relâcher est parfaitement tolérable.

J'ai longuement cherché sur internet une solution "simple" à ce problème, sans succès. J'ai donc sortir mon cahier de dessin, un crayon et je me suis gratté la tête pendant une grosse demi-heure pour aboutir à la solution ci-après. Celle-ci n'étant manifestement pas documentée sur internet, j'ai décidé d'en faire un article dédié

La solution

Étudions d'abord un montage très naïf (et dangereux) :

Le montage ci-dessus fonctionne sans problème si la sortie du microcontrôleur est de type "collecteur ouvert". Par contre, dans le cas d'une sortie TTL CMOS standard, il y a un problème, un gros problème.

Tant que l'on n’appuie pas sur le bouton, tout va bien. Il s'agit dans ce cas d'un montage classique avec un transistor bipolaire et une résistance de tirage sur sa base.

Quand on appuie sur le bouton, on contrôle le transistor et on peut lire l'état du bouton sans problème grâce à la résistance de tirage, jusque là rien d'anormal. Seulement, que ce passe-t-il quand le bouton est appuyé et que le code fait biper le buzzer ? Et bien la broche de sortie à HIGH (VCC) va directement à la masse. C'est un court-circuit. Si ce montage était utilisé dans la vraie vie, ce serait une vraie bombe à retardement n'attendant qu'un appui sur le bouton poussoir pour détruire le microcontrôleur.

Un circuit qui s'autodétruit en appuyant sur un bouton, c'est parfait pour un film de Jame Bond ou de Mission Impossible, mais pas pour un montage électronique.

Comment résoudre ce petit défaut ? Certains seraient tentés de dire "ajoutons un transistor avant la broche d'entrée / sortie pour en faire une sortie à collecteur ouvert !". Effectivement, cela résoudrait le problème. Une sortie à collecteur ouvert ne génère pas de tension. Ce type de sortie se contente de se comporter comme des interrupteurs reliés à la masse. Cela reviendrait donc à avoir deux interrupteurs en parallèle : un électronique, l'autre mécanique.

Seulement … Ça ne marcherait pas. Les vraies entrées / sorties à collecteur ouvert sont constituées en interne d'une entrée et d'une sortie, d'où le terme "entrées / sorties". Il n'y a pas de connexion entre les parties entrée et sortie avant la broche physique sur laquelle on peut venir se câbler. Ajouter un transistor avant la broche sur le schéma ci-dessus ne servirait donc à rien, car l'entrée serait au final quand même connectée à la sortie et déclencherait un court circuit de la même façon que le montage précédent.

On en revient donc à la question qui tue : comment éviter le court-circuit ?

Ma solution est simple, économique et particulièrement astucieuse : deux résistances. Une résistance en série avec la base du transistor et une autre en série avec le bouton poussoir.

Dans cette configuration, aucun court-circuit n'est possible. Qu'importe le cas d'usage, il y a toujours une limitation de courant avant ou après le noeud de courant.

De plus, avec ce schéma, on voit bien qu'ajouter un buzzer sur une broche existante revient simplement à greffer une résistance entre le bouton et la masse, puis de relier le reste du montage (ultra classique) pour le buzzer sans se poser de question.

Études des cas possibles

Balancer un schéma sans explication n'est pas très instructif, je vous propose donc de faire une étude des différents cas d'utilisation possibles.

Comme vous pourrez le voir dans les chapitres ci-dessous, qu'importe l'état du bouton, on garde toujours le contrôle du buzzer et inversement.

Cas 1 – Sortie HIGH et bouton OFF

Dans ce premier cas, la sortie est à VCC (HIGH) et le bouton relâché. La résistance de tirage à VCC peut être retirée de l'équation, car la même tension se trouve à ses deux bornes.

On obtient donc un montage ultra classique avec une résistance de limitation de courant sur la base d'un transistor bipolaire. Le courant va directement dans la base du transistor, le transistor est donc passant.

Cas 2 – Sortie HIGH et bouton ON

Dans ce second cas, la sortie est à VCC (HIGH) et le bouton appuyé. Comme précédemment, on peut retirer la résistance de tirage à VCC de l'équation. On considère aussi que l'interrupteur est un simple fil dans ce cas.

On obtient un noeud de courant, la moitié du courant va à la masse via la résistance en série avec le bouton et l'autre moitié va dans la base du transistor. Le transistor est ici passant.

PS La consommation de ce circuit est de 10mA (2 x 5mA). On pourrait réduire cette consommation en choisissant une valeur de résistance plus élevée, mais strictement inférieure à 10K ohms (voir cas n°6).

Cas 3 – Sortie LOW et bouton OFF

Dans ce troisième cas, la sortie est à 0 volt (LOW) et le bouton relâché. Un courant minime passe au travers de la résistance de tirage à VCC (environ 0,5mA). Cette résistance peut cependant être retirée de l'équation une fois de plus, car elle n'apporte rien au reste du circuit.

Dans ce cas, la base du transistor est reliée à la masse via la résistance en série. Le transistor est bloquant.

Cas 4 – Sortie LOW et bouton ON

Dans ce quatrième cas, la sortie est à 0 volt (LOW) et le bouton appuyé. Comme précédemment, on peut retirer la résistance de tirage à VCC de l'équation. On considère aussi que l'interrupteur est un simple fil dans ce cas. Au passage, on peut aussi retirer la résistance en série avec le bouton de l'équation, car celle-ci est reliée à la masse GND à ses deux bornes.

Comme dans le cas précédent, la base du transistor est reliée à la masse via la résistance en série. Le transistor est bloquant.

Cas 5 – Entrée et bouton OFF

Dans ce cinquième cas, la broche est en entrée et le bouton relâché.

Ici la résistance tirage à l'état haut permet de lire un état haut (HIGH), car le bouton ne force pas le courant vers la masse GND.

N.B. Une petite partie du courant part dans la base du transistor, générant un "clic" lors de l'appui sur le bouton. En calculant précisément la valeur de la résistance de base en fonction du gain du transistor, on pourrait empêcher ce "clic", mais je ne voulais pas alourdir cet article avec des calculs.

Cas 6 – Entrée et bouton ON

Dans ce sixième et dernier cas, la broche est en entrée et le bouton appuyé.

On observe dans ce cas la création d'un point diviseur de tension formé par la résistance de tirage à VCC et la résistance en série avec le bouton. Ce pont diviseur de tensions a un rapport de 1 / 10, cela signifie qu'au niveau de l'entrée on obtient une tension de 1 / 10 * VCC, soit 0.5 volt pour VCC = 5 volts.

Avec les circuits logiques de technologie CMOS (le standard depuis de nombreuses années), toute tension de moins de 1 / 2 de VCC est interprétée comme un LOW et toute tension supérieure à 1 / 2 de VCC comme un HIGH.

On liera donc dans ce cas un état bas (LOW) au niveau de l'entrée.

Le montage de démonstration

La théorie a assez duré, passons à la pratique

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

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

• Un bouton poussoir,

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

• Un buzzer piézo,

• Deux résistances de 1K ohms – code couleur marron / noir / rouge,

• Un transistor NPN, j'utilise un simple BC547 pour ce montage,

• Une diode 1N4148 ou 1N4007 (cela importe peu),

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

N.B. Le schéma est le même que celui du chapitre précédent. La broche PIN est reliée à la broche D2 de la carte Arduino pour ce montage d'exemple, cela est bien évidemment totalement modifiable en fonction des besoins.

Pour faire ce montage, il faudra commencer par tirer un fil de la broche D2 de la carte Arduino vers une ligne de la plaque d'essai. De même, il faudra tirer un câble de la broche 5V et GND de la carte Arduino vers respectivement les colonnes + (rouge) et – (bleu) de la plaque d'essai. Cela facilitera le câblage par la suite.

Une fois cela fait, il faudra relier la résistance de 10K ohms entre la colonne + de la plaque d'essai et la broche D2 de la carte Arduino. Il faudra ensuite placer et relier le bouton poussoir entre la broche D2 de la carte Arduino et une extrémité d'une des résistances de 1K ohms. On terminera ensuite la partie bouton avec la connexion de l'autre extrémité de la résistance de 1K ohms avec la masse GND (colonne - de la plaque d'essai).

Astuce : Cablez le bouton poussoir en diagonal pour être sûr de bien câbler les deux contacts du bouton.

Dans un coin de la plaque d'essai, on viendra placer le transistor NPN. Attention à l'ordre des broches ! Je vous laisse regarder sur internet le câblage du transistor que vous souhaitez utiliser. Dans le cas du BC547, l'ordre est : C.B.E. (collecteur, base, émetteur) quand on regarde le transistor broches vers le bas et méplat face à soi.

PS Dans le doute, l'image Fritzing ci-dessus utilise un BC547, vous pouvez donc vous y référer pour le câblage

Une fois le transistor en place, il faudra câbler la seconde résistance de 1K ohms entre la broche D2 et la base du transistor. Il faudra ensuite ajouter un câbler entre l'alimentation (5V / colonne + de la plaque d'essai) et le collecteur du transistor.

Pour finir, il faudra câbler le buzzer entre l'émetteur du transistor et la masse GND / colonne - de la plaque d'essai. La diode viendra ensuite conclure le montage en se câblant en parallèle du buzzer, avec la cathode (côté avec le trait plat, repéré physiquement sur la diode par un trait blanc) du côté de l'émetteur du transistor.

Le code

Le code pour utiliser cette broche à double usage est si bête que je ne sais pas quoi expliquer.

Faire biper le buzzer revient à utiliser le code de mon précédent article sur le sujet. Il en va de même pour la lecture de l'état du bouton.

La seule remarque que j'aurais à faire est qu'il est nécessaire de passer la broche en entrée avant toute lecture du bouton, car la fonction tone() passe la broche en sortie avant de générer un son.

Le code d'exemple avec ses 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47

/**
 * Code d'exemple d'utilisation d'un bouton et d'un buzzer sur une même broche.
 * N.B. Ce code nécessite un montage spécial pour fonctionner.
 */

/** La broche pour le bouton et le buzzer */
const byte PIN_BUZZING_BUTTON = 2;

/** Fonction setup() */
void setup() {
  
  // Met la LED broche 13 en sortie pour visualiser l'état du bouton
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
}

/** Fonction loop() */
void loop() {

  // Fait biper le buzzer
  beep(500);

  // Lit l'état du bouton et assigne cet état à la LED broche 13
  digitalWrite(LED_BUILTIN, readButtonState());
  delay(500);
}

/** Fonction permettant de lire l'état du bouton */
byte readButtonState() {
  
  // Met le broche en entrée (sans pullup)
  pinMode(PIN_BUZZING_BUTTON, INPUT);
  
  // Lit l'état du bouton
  return digitalRead(PIN_BUZZING_BUTTON);
}

/** Fonction permettant de faire biper le buzzer */
void beep(unsigned long duration) {
  
  // Génére un bip sur la broche du buzzer
  // N.B. La broche est automatiquement configurée en sortie.
  tone(PIN_BUZZING_BUTTON, 440, duration);
  
  // Attend la fin du bip
  delay(duration);
}

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 : Tetris version DJ Bouton

Vous vous rappelez le code bonus permettant de jouer l'air de Tetris avec un buzzer et une carte Arduino ?

Je vous propose aujourd'hui la version "DJ Bouton", tant que vous pressez le bouton, la musique tourne :

 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

/**
 * Code d'exemple d'utilisation d'un bouton et d'un buzzer sur une même broche.
 * Joue le thème musical de Tetris en Arduino avec tone() tant que le bouton est appuyé.
 * N.B. Ce code nécessite un montage spécial pour fonctionner.
 */

/** La broche pour le bouton et le buzzer */
const byte PIN_BUZZING_BUTTON = 2;

/** Fonction setup() */
void setup() {
  // Rien à faire ici
}

/** Fonction permettant de faire biper le buzzer tant que le bouton apppuyé */
void beepMelody(unsigned int frequency, unsigned long duration, unsigned long delay_duration) {
  
  // Met le broche en entrée (sans pullup)
  pinMode(PIN_BUZZING_BUTTON, INPUT);
  
  // Attend que le bouton soit apppuyé
  while (digitalRead(PIN_BUZZING_BUTTON) == HIGH);
  
  // Génére un bip sur la broche du buzzer
  // N.B. La broche est automatiquement configurée en sortie.
  tone(PIN_BUZZING_BUTTON, frequency, duration);
  
  // Attend la fin du bip
  delay(delay_duration);
}

/** Fonction loop() */
void loop() {
  beepMelody(2637, 200, 400);
  beepMelody(1975, 200, 200);
  beepMelody(2093, 200, 200);
  beepMelody(2349, 200, 400);
  beepMelody(2093, 200, 200);
  beepMelody(1975, 200, 200);
  beepMelody(1760, 200, 400);
  beepMelody(1760, 200, 200);
  beepMelody(2093, 200, 200);
  beepMelody(2637, 200, 400);
  beepMelody(2349, 200, 200);
  beepMelody(2093, 200, 200);
  beepMelody(1975, 200, 400);
  beepMelody(1975, 200, 200);
  beepMelody(2093, 200, 200);
  beepMelody(2349, 200, 400);
  beepMelody(2637, 200, 400);
  beepMelody(2093, 200, 400);
  beepMelody(1760, 200, 400);
  beepMelody(1760, 200, 800);
  beepMelody(1760, 200, 400);
  beepMelody(2349, 200, 200);
  beepMelody(2794, 200, 200);
  beepMelody(3520, 200, 400);
  beepMelody(3136, 200, 200);
  beepMelody(2794, 200, 200);
  beepMelody(2637, 200, 600);
  beepMelody(2093, 200, 200);
  beepMelody(2637, 200, 400);
  beepMelody(2349, 200, 200);
  beepMelody(2093, 200, 200);
  beepMelody(1975, 200, 400);
  beepMelody(1975, 200, 200);
  beepMelody(2093, 200, 200);
  beepMelody(2349, 200, 400);
  beepMelody(2637, 200, 400);
  beepMelody(2093, 200, 400);
  beepMelody(1760, 200, 400);
  beepMelody(1760, 200, 800);
}

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

Conclusion

Ce projet est désormais terminé.

Si ce projet 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.