Aller au contenu principal

Utiliser des boutons-poussoirs

InformatiqueTechnologieSteaMiMicroPython
ProjetDuréeDifficultéÂgeLogiciel STeaMi testé
I-Novmicro #225 minIntermédiaire11-99 ans0.23.1

Matériel et Montage​

  • 1 carte STeaMi
  • 1 câble USB de données (micro-USB pour la STeaMi V1, USB-C pour la STeaMi V2).
  • 1 ordinateur sous Windows, macOS ou Linux
  • Un IDE compatible MicroPython : Thonny (voir la fiche Thonny : Prise en main de MicroPython) ou tout autre éditeur compatible (Mu, VS Code, Vittascience, mpremote...).
Boutons-poussoirs de la STeaMi

De quoi parle-t-on ?​

Le bouton-poussoir est un composant simple pour faire le lien entre une action physique (un doigt qui appuie dessus) et une action numérique (un programme qui réagit). On en trouve partout : clavier d'ordinateur, interrupteur de chevet, manette de console, bouton d'arrêt d'urgence... Tous fonctionnent sur le même principe : un appui ferme un circuit (laisse le courant électrique passer), un relâchement le rouvre (empêche le courant de passer).

La STeaMi intègre trois boutons-poussoirs simples directement utilisables sans câblage : les boutons A, B et Menu. La carte possède aussi un bouton multidirectionnel que nous n'utiliserons pas pour le moment.

Dans cette fiche, on apprend à lire leur état en MicroPython et à déclencher des actions selon qu'ils sont appuyés ou relâchés. C'est la brique de base pour construire de l'interaction utilisateur sur des objets électroniques : sonnette, jeux, télécommandes... Concrètement, nous allons construire un mini-jeu de réflexes pour deux joueurs : chacun choisit un bouton (A ou B), un arbitre donne le signal de départ, et le premier qui appuie sur son bouton allume sa LED.

Objectifs d'apprentissage​

  • Lire l'état d'un bouton intégré à la STeaMi en MicroPython
  • Comprendre la logique inverse des boutons (1 au repos, 0 quand on appuie) et le principe de la résistance de tirage
  • Détecter une transition d'état (relâché → appuyé) plutôt qu'un simple état, pour ne déclencher qu'une fois par appui
  • Combiner lecture de bouton et pilotage de LED
  • Découvrir ce qu'est une « machine à états » avec un mini-jeu à deux joueurs

Étape 1 : Construire​

Ici, « construire » est rapide : les trois boutons-poussoirs sont déjà soudés sur la face avant de la STeaMi. Pas de breadboard, pas de câblage.

1. Localiser les boutons​

Sur la STeaMi, trois boutons-poussoirs sont accessibles dans le code via des noms parlants :

Emplacement des boutons A, B et Menu sur la STeaMi

Les trois boutons-poussoirs de la face avant : A, B et Menu.

BoutonNom de broche
Bouton AA_BUTTON
Bouton BB_BUTTON
Bouton MenuMENU_BUTTON
Logique inverse : value() renvoie 0 quand on APPUIE

Spontanément, on pourrait penser que « bouton appuyé = 1 » et « bouton relâché = 0 ». Sur la STeaMi (comme sur la plupart des cartes microcontrôleurs), c'est l'inverse :

État du boutonTension sur la brocheCe que renvoie value()
Relâché (repos)3,3 V1
Appuyé0 V0

Pourquoi cette inversion ? Un bouton-poussoir, ce n'est rien d'autre qu'un interrupteur qui ferme un fil quand on appuie. Sans précaution, quand le bouton est relâché, la broche du microcontrôleur n'est connectée à rien : elle « flotte » et lit n'importe quoi (du bruit électrique). Pour éviter ça, il faut forcer une valeur par défaut, et c'est précisément le rôle d'une résistance de tirage.

Sur la STeaMi, cette résistance (4,7 kΩ) relie chaque broche de bouton à l'alimentation (3,3 V). Tant que personne n'appuie, elle « tire » doucement la broche vers le haut : on lit 1. Appuyer sur le bouton crée un chemin direct vers la masse (0 V), beaucoup plus « fort » que la résistance : la broche tombe à 0. Ce câblage « tirage vers le haut » (pull-up en anglais) est la convention la plus courante en électronique embarquée. C'est pour cela que la quasi-totalité des cartes éducatives (STeaMi, micro:bit, Arduino, Raspberry Pi Pico...) renvoient 0 quand on appuie.

Conséquence pratique : dans le code, on teste btn_a.value() == 0 pour savoir si A est appuyé, pas == 1.

2. Connecter la carte à l'ordinateur​

Brancher la STeaMi à l'ordinateur via le câble USB. Si l'IDE est déjà configuré (voir la fiche Thonny : Prise en main de MicroPython si vous démarrez), la console MicroPython doit afficher >>>. C'est l'invite (parfois appelée « prompt » en anglais) : un signe qui apparaît en début de ligne pour vous dire que la console est prête à recevoir une commande.

3. Lancer le programme​

Notre premier programme va proposer un mini-jeu à deux joueurs : la première personne qui appuie sur son bouton allume sa LED. Bouton A allume la LED rouge, bouton B allume la LED bleue. Tant qu'un bouton est maintenu enfoncé, l'autre joueur ne peut plus gagner. Le code complet est donné à l'Étape 2 : Programmer ci-dessous. Copiez-le dans votre IDE.

Une fois le code en place, deux manières de le lancer :

  • Test rapide : lancer le programme depuis l'IDE (typiquement bouton Run ▶ ou F5).
  • Programme persistant : enregistrer le fichier sous le nom main.py sur la carte. Il sera relancé à chaque démarrage.

4. Jouer​

Une fois le programme lancé :

  • Appuyer sur A : la LED rouge s'allume.
  • Appuyer sur B : la LED bleue s'allume.
  • Chaque joueur choisit son bouton et l'objectif est de savoir qui sera le plus rapide.
  • Le premier joueur qui fait éclairer sa LED a gagné le tour. C'est l'arbitre qui donnera le signal au joueur pour réagir.
  • Tant qu'un bouton reste enfoncé, l'autre n'a plus aucun effet.
  • Relâcher les deux boutons : les LED s'éteignent, le tour suivant peut commencer.

À deux personnes, c'est un mini-jeu de réflexes. Seul, c'est l'occasion d'observer en temps réel comment chaque appui modifie l'état du programme.

Étape 2 : Programmer​

Le code​

# Testée avec firmware STeaMi 0.23.1
from machine import Pin
from time import sleep_ms

# LED RGB de la STeaMi (sortie push-pull)
led_r = Pin('LED_RED', Pin.OUT)
led_b = Pin('LED_BLUE', Pin.OUT)

# Boutons A et B (résistance de tirage externe : 1 au repos, 0 quand on appuie)
btn_a = Pin('A_BUTTON', Pin.IN)
btn_b = Pin('B_BUTTON', Pin.IN)

# Drapeau : un appui est-il possible pour le tour en cours ?
# Tant que `tour_libre` est False, plus aucune LED ne réagit
# avant que les deux boutons soient relâchés.
tour_libre = True

while True:
    a_actif = btn_a.value() == 0
    b_actif = btn_b.value() == 0

    if not a_actif and not b_actif:
        # Les deux boutons sont relâchés : on éteint les LED et
        # on rouvre le tour suivant.
        led_r.off()
        led_b.off()
        tour_libre = True
    elif tour_libre and a_actif:
        # Premier appui du tour, sur A : LED rouge.
        led_r.on()
        tour_libre = False
    elif tour_libre and b_actif:
        # Premier appui du tour, sur B : LED bleue.
        led_b.on()
        tour_libre = False

    # Petite pause pour ne pas saturer le processeur et atténuer
    # les rebonds mécaniques du bouton (cf. la fiche concept
    # "Anti-rebond" en Aller plus loin).
    sleep_ms(20)

Comment cela fonctionne ?​

Le programme s'organise en quatre parties :

  • Initialisation : on déclare les deux LED (Pin.OUT) et les deux boutons (Pin.IN). Le firmware STeaMi expose les composants sous des noms parlants ('LED_RED', 'A_BUTTON'...). Pas besoin de mémoriser un numéro de broche.
  • Lecture des boutons : btn_a.value() renvoie 1 ou 0. À cause de la logique inverse, on compare à 0 pour savoir si le bouton est appuyé. On stocke le résultat dans a_actif (booléen) pour rendre la suite plus lisible.
  • Détection de transition : la variable tour_libre joue le rôle de drapeau. Elle prend la valeur False dès qu'on allume une LED, ce qui empêche l'autre bouton de prendre la main. Elle ne reprend la valeur True que quand les deux boutons sont relâchés : c'est ce qui marque la fin du tour.
  • Boucle principale : à chaque tour de boucle, on lit les deux boutons et on choisit la branche if/elif/elif appropriée. Les LED restent allumées tant qu'un bouton est appuyé. Le sleep_ms(20) final laisse souffler le processeur (sans pause, la boucle tournerait à 100 % CPU) et atténue les rebonds mécaniques du contact (le bouton se ferme plusieurs fois en quelques millisecondes au moment de l'appui).
Machine à états

Le drapeau tour_libre transforme cette boucle en une machine à états : on est soit dans l'état « tour libre » (aucune LED allumée, on attend un appui), soit dans l'état « tour gagné » (une LED allumée, on attend que les deux boutons se relâchent). Ce principe revient partout en programmation interactive (distributeurs, menus, jeux vidéo).

Étape 3 : Améliorer​

1. Compter les points​

Ajouter deux compteurs score_a et score_b qui s'incrémentent à chaque tour gagné, puis afficher le score dans la console avec print(). Variante : remettre les compteurs à zéro avec le bouton Menu.

2. Faire clignoter la LED du gagnant​

Plutôt que d'allumer la LED en continu, la faire clignoter quelques fois pour bien marquer la victoire. La technique est dans la fiche Faire clignoter une LED.

3. Afficher le résultat sur l'écran​

Combiner cette fiche avec la fiche Afficher du texte sur l'écran OLED pour afficher le nom du gagnant en grand sur l'écran intégré. Beaucoup plus parlant qu'une simple LED.

4. Jeu de réaction (bonus)​

Au lieu de lancer la partie immédiatement, attendre un délai aléatoire (random.uniform(1, 5) secondes), puis allumer brièvement les deux LED simultanément comme signal de départ. Le premier qui appuie après le signal gagne ; celui qui appuie avant a un faux départ. Idée centrale : mesurer le temps de réaction, lié à la fiche transverse Temps de réaction.

Aller plus loin​

Pour comprendre​

  • Bouton-poussoir (Wikipedia) : histoire, types (à fermeture, à ouverture, à accrochage), applications. Le composant le plus simple, mais le pilier de presque toutes les interfaces.
  • Anti-rebond (Wikipedia) : un bouton qui se ferme rebondit pendant quelques millisecondes, ce qui peut faire enregistrer plusieurs appuis pour un seul clic. Le pattern de détection de transition utilisé ici résout en partie ce problème ; les solutions plus poussées sont logicielles (temporisation) ou matérielles (condensateur).
  • Automate fini (Wikipedia) : le drapeau tour_libre est une mini machine à états à deux états. Les automates finis sont une des formalisations les plus utiles en informatique : compilateurs, ascenseurs, distributeurs, expressions régulières...

Pour s'inspirer​

  • Le buzzer de jeu télévisé : exactement le même principe que notre mini-jeu, mais à l'échelle d'un plateau de télévision (Questions pour un champion, Slam, Burger Quiz...). Premier appuyé, premier servi.
  • Borne d'arcade (projet JediTrack) : fiche du wiki sur la fabrication d'une borne d'arcade complète. Les boutons d'arcade fonctionnent exactement comme ceux de la STeaMi, en plus gros et en plus colorés.
  • Bouton STOP des bus : un bouton-poussoir qui change la trajectoire d'un véhicule à quelques tonnes. Présent partout dans les transports en commun depuis les années 1950.
  • Manette NES (Nintendo) : 8 boutons-poussoirs sur un PCB, et toute l'histoire du jeu vidéo des années 80. Une bonne occasion de regarder ce qu'il y a à l'intérieur d'un objet familier.

Cette fiche fait partie du projet I-Novmicro #2 : Action EXAO. Adaptée du projet Let's STEAM (fiche r1as03-boutons) sous licence CC BY-SA 4.0.