Raspberry Pi bouton poussoir : tutoriel Python pour débutant

Un simple bouton poussoir transforme un Raspberry Pi en interface interactive. Allumage, arrêt sécurisé, déclenchement d’actions en chaîne, contrôle d’une LED ou d’un capteur : le geste le plus basique devient un point d’entrée vers des projets étonnamment complets.

Avec Python, quelques résistances bien choisies et une poignée de lignes de code, un débutant met rapidement en place un circuit fiable. Les détails les plus subtils se cachent pourtant dans le câblage, la protection des broches GPIO et la gestion logicielle des appuis. La suite du tutoriel rentre dans ces nuances pas à pas.

Élément clé	Synthèse
Objectif 🎯	Apprendre à utiliser un bouton poussoir avec un Raspberry Pi via un script Python simple.
Matériel requis 🔧	Raspberry Pi, bouton poussoir, résistances, câbles Dupont.
Principe ⚙️	Le GPIO lit l’état du bouton : pression = changement d’état logique.
Code Python 🐍	Quelques lignes pour configurer un GPIO en entrée et détecter les pressions via une boucle.
Usage typique 🚀	Déclencher une action : allumer une LED, lancer un script, interagir avec un projet domotique.

📌

Télécharger l’image

Présentation du projet : un bouton poussoir pour piloter le Raspberry Pi en Python

Un bouton poussoir connecté aux GPIO du Raspberry Pi offre une interaction simple et efficace : une pression déclenche une action Python. Ce tutoriel s’adresse à un débutant qui veut monter un montage électronique fiable, comprendre le schéma, puis programmer le comportement du bouton.

L’objectif est double : apprendre à câbler correctement un bouton NO (normalement ouvert) sans risquer d’endommager la carte, puis écrire un script Python propre avec les bibliothèques RPi.GPIO et gpiozero. Le tout en gardant la porte ouverte à des extensions comme le contrôle d’une LED, d’un capteur de température ou d’un script système avancé.

Fonctionnement d’un bouton poussoir sur Raspberry Pi

Le bouton poussoir utilisé ici est de type NO (Normally Open / normalement ouvert). Sans pression, le circuit reste ouvert, aucun courant ne circule. Lorsqu’on appuie, le contact se ferme et relie la broche GPIO choisie à la masse (GND) ou à la tension 3,3 V selon la configuration.

Le Raspberry Pi ne lit pas une tension analogique. Chaque GPIO fonctionne en binaire : niveau haut (3,3 V logiques) ou niveau bas (0 V, relié à GND). Le rôle du bouton consiste simplement à faire basculer cet état logiques d’un côté ou de l’autre de façon nette.

Composants et caractéristiques électriques à respecter

Les broches GPIO du Raspberry Pi fonctionnent en 3,3 V DC. Chaque broche supporte un courant d’environ 16 mA maximum, pour une consommation totale recommandée autour de 50 mA sur l’ensemble des GPIO. Le but du montage est de rester très en dessous de ces valeurs grâce aux résistances de protection.

Pour ce montage, on utilise :

Un Raspberry Pi avec connecteur GPIO 40 broches (Pi 1 à 5, Zero, W, 2, et futures versions avec format 40 broches conservé).
Un bouton poussoir NO.
Une résistance de protection de 1 kΩ en série avec le circuit de bouton.
Une résistance de pull-down de 4,7 kΩ ou 10 kΩ si l’on choisit un câblage avec résistance externe.
Des câbles Dupont (connecteur 2 broches pour le bouton ou fils individuels).
Une plaque de prototypage (breadboard) pour un montage propre et évolutif.

Info utile : même si le GPIO supporte 16 mA par broche, un bouton poussoir n’a aucun besoin d’un tel courant. L’usage d’une résistance de 1 kΩ réduit nettement le courant et protège la broche en cas d’erreur de câblage.

Comprendre le GPIO du Raspberry Pi avant de brancher un bouton

Le connecteur du Raspberry Pi utilise un format 40 broches standard. Pour ce tutoriel, plusieurs GPIO sont disponibles : GPIO 2 (pin 3), GPIO 3, GPIO 19 et GPIO 26 (pin 37), avec une masse accessible sur le GND pin 39. Le choix dépend du projet, mais la logique reste identique.

Les broches sont numérotées de deux façons :

Numérotation physique : pin 1 à pin 40 sur le connecteur.
Numérotation logique : GPIO 2, GPIO 3, GPIO 4, etc.

En Python, les bibliothèques RPi.GPIO et gpiozero utilisent la numérotation BCM (GPIO 2, 3, 4, 17, 27, etc.). Il est donc utile de bien distinguer le numéro physique (position) et le numéro logique (BCM) de la broche utilisée.

Rôle des résistances de pull-up et pull-down

Une entrée numérique laissée flottante fournit une lecture instable. Le Raspberry Pi propose donc des résistances de tirage internes (pull-up ou pull-down) activables en logiciel, et l’on peut également utiliser des résistances externes de 4,7 kΩ ou 10 kΩ pour stabiliser l’état logique au repos.

Deux montages sont possibles :

Montage pull-down : la résistance relie le GPIO à GND. Au repos, l’entrée lit 0. Le bouton relie la broche au 3,3 V pour lire 1 lors de l’appui.
Montage pull-up : la résistance relie le GPIO au 3,3 V. Au repos, l’entrée lit 1. Le bouton relie la broche à GND pour lire 0 lors de l’appui.

Le bouton utilisé ici est NO, donc ouvert au repos. On choisit la stratégie qui convient le mieux au code. Avec gpiozero, le paramètre pull_up=True autorise un montage très simple, le bouton étant relié entre la broche et GND.

Schéma de câblage d’un bouton poussoir sur Raspberry Pi

Pour un débutant, la clarté du schéma conditionne souvent la réussite du montage. On s’appuie sur un exemple concret avec GPIO 26 (pin 37) et la masse GND pin 39. Le principe reste identique avec GPIO 2, GPIO 3 ou GPIO 19.

Câblage basique avec résistance de protection et pull-down

Le câblage suivant sécurise la broche tout en offrant une lecture stable :

Relier une extrémité du bouton poussoir à la broche GPIO 26 (pin 37) via une résistance de 1 kΩ en série.
Relier l’autre extrémité du bouton au 3,3 V si l’on utilise un pull-down, ou à GND si l’on utilise un pull-up.
Ajouter une résistance de pull-down de 10 kΩ entre la broche GPIO 26 et GND (pour lecture à 0 au repos).
Relier le GND du montage au GND pin 39 du Raspberry Pi.

Ainsi, au repos, la broche est maintenue à 0 par la résistance de pull-down. Lors de l’appui, le bouton applique le 3,3 V sur le GPIO via la résistance de 1 kΩ, ce qui évite tout risque de court-circuit direct entre 3,3 V et GND.

Attention câblage : ne jamais relier directement une sortie 5 V à un GPIO du Raspberry Pi. Les GPIO acceptent uniquement 3,3 V. Une tension supérieure endommage irrémédiablement la carte.

Câblage simplifié avec gpiozero et résistance interne

La bibliothèque gpiozero exploite les résistances internes. On peut alors câbler le bouton avec très peu de composants :

Le bouton entre GPIO 26 et GND.
Activation du pull-up interne dans le code (pull_up=True).

Dans cette configuration, l’entrée lit 1 au repos (tirée vers le haut) et 0 lors de l’appui (contact vers GND). Une résistance de 1 kΩ en série reste vivement recommandée pour limiter le courant en cas d’erreur de câblage ou de faux contact.

Préparer l’environnement logiciel pour utiliser un bouton en Python

Le tutoriel utilise le langage Python et s’appuie sur deux bibliothèques principales : RPi.GPIO et gpiozero. Elles sont compatibles avec tous les modèles de Raspberry Pi : séries 1A, 1B, 2, 3, 4, 5, Zero et W.

Pour des projets avancés ou pour s’affranchir des limitations du mode BCM classique, l’outil pigpio propose une gestion plus fine et plus rapide des GPIO, utilisable en local ou via réseau. Pour un débutant, RPi.GPIO et gpiozero offrent déjà une base complète.

Installation et vérification de Python et des bibliothèques

Sur Raspberry Pi OS récent, Python est déjà installé. Pour vérifier :

python3 --version
pip3 --version

Si nécessaire, l’installation ou la mise à jour se fait via :

sudo apt update
sudo apt install python3 python3-pip python3-gpiozero python3-rpi.gpio

La bibliothèque gpiozero simplifie la vie d’un débutant grâce à des classes orientées objet comme LED et Button. Elle repose en interne sur RPi.GPIO ou pigpio selon la configuration.

Présentation des bibliothèques RPi.GPIO et gpiozero

Les deux bibliothèques gèrent les mêmes broches, mais avec des approches différentes :

Critère	RPi.GPIO	gpiozero
Style de code	Procédural, proche du matériel	Orienté objet, plus descriptif
Gestion du bouton	Configuration manuelle du mode, pull-up/pull-down	Classe Button avec paramètres `pull_up`, `bounce_time`, `hold_time`
Événements	`GPIO.wait_for_edge()`, callbacks	Propriétés (`.when_pressed`, `.when_held`), gestion simplifiée
Apprentissage	Idéal pour comprendre la base brute des GPIO	Idéal pour un démarrage rapide et lisible

Conseil pédagogique : commencer avec gpiozero pour mettre le bouton en service rapidement, puis revisiter le même montage avec RPi.GPIO pour maîtriser les notions bas niveau.

Utiliser un bouton poussoir avec RPi.GPIO : la base en Python

La bibliothèque RPi.GPIO donne un accès direct aux registres des GPIO. Elle convient à un lecteur qui veut comprendre chaque étape : choix du mode de numérotation, configuration de la broche en entrée, activation du pull-up/pull-down, gestion des événements.

Script minimal avec lecture d’état du bouton

Un script basique lit l’état du bouton en boucle :

import RPi.GPIO as GPIO
import time

BUTTON_GPIO = 26  # Utilisation du GPIO 26

GPIO.setmode(GPIO.BCM)  # Numérotation BCM
GPIO.setup(BUTTON_GPIO, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Pull-up interne

try:
    while True:
        state = GPIO.input(BUTTON_GPIO)
        if state == GPIO.LOW:
            print("Bouton pressé")
        else:
            print("Bouton relâché")
        time.sleep(0.1)

except KeyboardInterrupt:
    pass

finally:
    GPIO.cleanup()

Dans cet exemple, le bouton est relié entre GPIO 26 et GND avec un pull-up interne activé. Le script interprète l’appui comme un niveau bas (GPIO.LOW).

Utiliser GPIO.wait_for_edge pour détecter les appuis

La fonction GPIO.wait_for_edge() surveille un changement d’état sans interroger la broche en permanence. Pour un bouton, on utilise souvent un front descendant (FALLING) lorsque l’on part d’un montage en pull-up.

import RPi.GPIO as GPIO

BUTTON_GPIO = 26

GPIO.setmode(GPIO.BCM)
GPIO.setup(BUTTON_GPIO, GPIO.IN, pull_up_down=GPIO.PUD_UP)

try:
    print("En attente d'un appui sur le bouton...")
    GPIO.wait_for_edge(BUTTON_GPIO, GPIO.FALLING)
    print("Appui détecté !")

except KeyboardInterrupt:
    pass

finally:
    GPIO.cleanup()

La fonction GPIO.wait_for_edge(GPIO.FALLING) bloque l’exécution jusqu’à la détection d’un appui (front descendant). La lecture devient plus réactive et plus propre que dans une boucle de scrutation rapide.

Gestion simple de l’anti-rebond

Un bouton mécanique provoque souvent plusieurs transitions rapides à chaque appui. Pour limiter ce rebond, on ajoute un court délai après la détection :

import RPi.GPIO as GPIO
import time

BUTTON_GPIO = 26

GPIO.setmode(GPIO.BCM)
GPIO.setup(BUTTON_GPIO, GPIO.IN, pull_up_down=GPIO.PUD_UP)

try:
    while True:
        GPIO.wait_for_edge(BUTTON_GPIO, GPIO.FALLING)
        time.sleep(0.05)  # anti-rebond logiciel
        if GPIO.input(BUTTON_GPIO) == GPIO.LOW:
            print("Appui validé")

except KeyboardInterrupt:
    pass

finally:
    GPIO.cleanup()

Ce délai laisse au contact le temps de se stabiliser. Le script relit ensuite l’état pour confirmer la validité de l’appui.

Utiliser un bouton poussoir avec gpiozero : approche orientée objet

La bibliothèque gpiozero introduit des classes dédiées comme Button et LED. Elle gère pour vous une grande partie des détails, notamment le pull-up, l’anti-rebond et les événements d’appui long.

Instanciation d’un Button avec paramètres utiles

Les paramètres typiques de la classe Button sont :

pull_up : True ou False, active une résistance de tirage interne.
active_state : permet de définir si l’état actif correspond à HIGH ou LOW.
bounce_time : durée de filtrage logiciel du rebond, en secondes.
hold_time : durée pour détecter un appui long.
hold_repeat : répéter l’événement tant que le bouton reste pressé.

Exemple de code de base :

from gpiozero import Button
from signal import pause

button = Button(26, pull_up=True, bounce_time=0.05)

def on_press():
    print("Bouton pressé")

def on_release():
    print("Bouton relâché")

button.when_pressed = on_press
button.when_released = on_release

pause()

La fonction pause() maintient le script en attente des événements. Le code reste lisible et proche du langage naturel : un bon point pour un débutant.

Gestion de l’appui long avec hold_time

La classe Button expose une fonctionnalité d’appui long via l’attribut hold_time. Pour un arrêt sécurisé du Raspberry Pi, on peut exiger un appui continu d’une seconde afin d’éviter un arrêt accidentel.

from gpiozero import Button
from signal import pause
import os

button = Button(26, pull_up=True, hold_time=1, hold_repeat=False)

def on_held():
    print("Appui long détecté, arrêt du système...")
    os.system("sudo shutdown -h now")

button.when_held = on_held

pause()

Le paramètre hold_repeat=False assure un déclenchement unique, même si le bouton reste maintenu plusieurs secondes. Pour un arrêt propre, cette stratégie réduit drastiquement les risques de manipulation involontaire.

Exemple pratique : contrôler une LED avec un bouton poussoir

Un exercice simple et pédagogique consiste à allumer ou éteindre une LED à l’aide d’un bouton. Ce cas de figure introduit la notion d’entrée (bouton) et de sortie (LED) sur le même projet. Un tutoriel dédié à la LED complète utilement ce chapitre : contrôle d’une LED avec Raspberry Pi et Python.

Montage LED + bouton sur GPIO

Le montage associe :

Une LED reliée à un GPIO via une résistance série, par exemple 10 kΩ pour limiter fortement le courant.
Un bouton poussoir NO relié entre un GPIO et GND, avec pull-up interne.
Un GND commun pour l’ensemble du montage.

La LED reste pilotée en tension, sans jamais dépasser le courant autorisé par la GPIO. Même si la luminosité semble faible avec 10 kΩ, la sécurité reste maximale pour la démonstration.

Code gpiozero pour LED et bouton

Avec gpiozero, le code pour associer une LED et un bouton devient très concis :

from gpiozero import LED, Button
from signal import pause

led = LED(19)            # LED sur GPIO 19
button = Button(26, pull_up=True, bounce_time=0.05)

def toggle_led():
    led.toggle()
    print("LED allumée" if led.is_lit else "LED éteinte")

button.when_pressed = toggle_led

pause()

Chaque appui sur le bouton inverse l’état de la LED. Ce type de montage constitue une étape naturelle avant d’aborder des projets plus élaborés nécessitant plusieurs entrées et sorties combinées.

Exemple avancé : utiliser un bouton pour arrêter proprement le Raspberry Pi

Le bouton poussoir sert souvent à déclencher un arrêt propre du Raspberry Pi. L’idée consiste à éviter de couper brutalement l’alimentation, ce qui engendre une corruption possible de la carte SD.

Commande d’arrêt via sudo shutdown -h now

En ligne de commande, l’arrêt propre se fait avec :

sudo shutdown -h now

Cette commande demande au système de terminer les processus, synchroniser le système de fichiers, puis couper proprement. Un script Python peut lancer exactement cette commande par l’intermédiaire du module os ou subprocess.

Script combo : appui long pour arrêt sécurisé

Voici un exemple complet avec gpiozero qui déclenche un arrêt après un appui long d’une seconde :

from gpiozero import Button
from signal import pause
import os

button = Button(3, pull_up=True, hold_time=1, hold_repeat=False)

def shutdown():
    print("Arrêt sécurisé demandé par le bouton...")
    os.system("sudo shutdown -h now")

button.when_held = shutdown

pause()

Cette configuration utilise GPIO 3, souvent associé à une fonctionnalité de réveil/arrêt sur certains modèles de Raspberry Pi. La combinaison d’un appui long et de cette broche offre un comportement proche d’un bouton d’alimentation.

Précision système : pour exécuter la commande shutdown sans mot de passe depuis Python, il est possible de configurer sudoers afin d’autoriser l’utilisateur pi (ou un autre) à lancer shutdown -h now sans authentification interactive.

Gestion avancée des événements : rebond, multiples boutons, synchronisation

Au-delà du bouton unique, il est fréquent de prévoir plusieurs boutons pour différents scénarios : navigation dans un menu, commande de relais, sélection de mode. Python et les GPIO du Raspberry Pi gèrent facilement ces cas avec un peu d’organisation.

Combiner plusieurs boutons en gpiozero

Le pattern suivant illustre l’utilisation de trois boutons distincts :

from gpiozero import Button
from signal import pause

btn_next = Button(2, pull_up=True, bounce_time=0.05)
btn_prev = Button(19, pull_up=True, bounce_time=0.05)
btn_ok   = Button(26, pull_up=True, bounce_time=0.05)

btn_next.when_pressed = lambda: print("Suivant")
btn_prev.when_pressed = lambda: print("Précédent")
btn_ok.when_pressed   = lambda: print("Valider")

pause()

Chaque bouton déclenche une action distincte. L’utilisation d’une fonction lambda convient pour des actions simples. Pour un projet plus conséquent, mieux vaut créer des fonctions nommées et organiser le code en modules.

Anti-rebond matériel et logiciel

L’anti-rebond combine souvent deux approches :

Logiciel : bounce_time dans gpiozero ou petits délais dans le code RPi.GPIO.
Matériel : condensateur et résistance formant un filtre RC, ou utilisation de boutons de meilleure qualité.

Pour des projets simples ou pédagogiques, l’anti-rebond logiciel suffit largement. Lorsqu’on aborde des applications critiques ou des fréquences d’appui élevées, un filtrage matériel ajoute une marge de sécurité intéressante.

Aller plus loin : intégrer le bouton à des projets complets

Une fois la maîtrise du bouton acquise, le Raspberry Pi se transforme en plateforme d’interaction : menus sur écran, stations de mesure, objets connectés, consoles de contrôle. Le bouton devient un point d’entrée naturel pour piloter des scripts Python plus évolués.

Association du bouton avec des capteurs

Le bouton sert souvent à déclencher une mesure, un enregistrement ou un affichage. Par exemple, associé à un capteur de température, il permet de lancer une acquisition ponctuelle, ou de basculer entre différents modes d’affichage. Un tutoriel dédié approfondit ce sujet : utiliser un capteur de température avec Raspberry Pi.

On peut ainsi :

Lancer une acquisition sur appui court.
Démarrer un enregistrement continu sur appui long.
Arrêter la mesure sur double appui.

Ces scénarios rendent l’interface physique beaucoup plus conviviale que de simples scripts lancés en ligne de commande.

Interaction avec d’autres sorties : LED, buzzer, relais

Le même bouton contrôle une LED de statut, un buzzer piézo ou un relais. Un bip indique la prise en compte de l’appui, une LED confirme un état actif, un relais pilote une charge plus élevée (moteur, lampe, alimentation d’un module externe), à condition de respecter l’isolement et d’utiliser un circuit de commande adapté.

Pour un projet simple et pédagogique, il est courant d’associer :

Un bouton d’action.
Une LED témoin.
Un petit buzzer pour feedback sonore.

Ce trio suffit à illustrer la plupart des notions utiles : entrées numériques, sorties numériques, gestion d’événements et retour utilisateur.

Compatibilité matérielle actuelle et futures évolutions GPIO

Les informations disponibles indiquent un maintien du format 40 broches pour le Raspberry Pi 6. Les évolutions se concentrent davantage sur la partie contrôleur, notamment via le composant RP1 qui offre une augmentation de vitesse grâce à une liaison PCIe Gen3 x4. Le support PCIe Gen3 x1 ouvre la voie à des périphériques à plus grande bande passante.

Pour un bouton poussoir, cette évolution n’implique pas de changement majeur. La demande de modifications du brochage GPIO reste faible, ce qui laisse penser que les tutoriels basés sur un connecteur 40 broches conservent une forte pérennité, même avec les nouvelles générations de cartes.

« La stabilité du format GPIO sur les dernières générations de Raspberry Pi donne une base solide. Un montage simple, réalisé aujourd’hui par un débutant, reste généralement valide sur la plupart des modèles suivants. »

Erreurs fréquentes et bonnes pratiques avec un bouton poussoir

Un bouton semble trivial, pourtant plusieurs pièges reviennent régulièrement. Un débutant gagne du temps en les identifiant dès le départ et en adoptant quelques bonnes pratiques.

Erreurs courantes à éviter

Relier directement un GPIO au 5 V.
Oublier la masse commune entre le bouton et le Raspberry Pi.
Négliger l’anti-rebond, ce qui entraîne plusieurs déclenchements pour un seul appui.
Utiliser la mauvaise numérotation (confusion entre numéro de pin et numéro de GPIO).
Oublier GPIO.cleanup() avec RPi.GPIO, laissant les broches dans un état incertain.

Bonnes pratiques pour un montage fiable

Pour un montage propre et durable :

Utiliser systématiquement une résistance série de 1 kΩ sur le chemin du bouton.
Prendre l’habitude d’ajouter un pull-up ou pull-down (interne ou externe) sur toute entrée.
Tester les lectures de GPIO dans un petit script avant d’écrire la logique complète du projet.
Documenter le câblage (schéma, photo, ou simple liste) dès le départ.

Astuce de débogage : en cas de comportement étrange du bouton, écrire un mini-script qui affiche uniquement l’état lu en temps réel (0 ou 1) et vérifier le câblage avec un multimètre. Cette étape isole très vite les erreurs de montage.

Compléments utiles pour aller plus loin en Python sur Raspberry Pi

Une fois à l’aise avec le bouton poussoir, d’autres ressources complètent la compréhension de l’écosystème Raspberry Pi :

Les bases de la manipulation des entrées/sorties en Python via les broches GPIO : programmation Python des GPIO du Raspberry Pi.
Le contrôle pas à pas d’une LED, qui s’associe naturellement au bouton : tutoriel LED et Raspberry Pi.
La gestion de capteurs analogiques ou numériques, déclenchés par un bouton ou un timer : lecture d’un capteur de température en Python.

Chaque ressource élargit progressivement le champ des possibles tout en conservant les mêmes fondations : un câblage rigoureux, une gestion prudente des niveaux logiques 3,3 V et un code Python structuré.