GPIO Raspberry Pi : guide de programmation en Python pour débuter

Programmer les GPIO du Raspberry Pi en Python ouvre la porte à un pilotage précis du monde physique : LED, boutons, capteurs, relais, moteurs. Avec quelques lignes de code seulement, le nano-ordinateur cesse d’être un simple PC miniature pour devenir un véritable contrôleur temps réel.

Les bases semblent simples : lire une entrée, activer une sortie, utiliser une librairie. Mais entre les niveaux logiques 3,3 V, les limites de courant, le choix des bibliothèques et les subtilités propres aux modèles (Pi 4, Pi 5, Pico, Pico W…), les questions arrivent vite. La suite de ce guide clarifie chaque étape et pose les bons réflexes pour un câblage fiable et un code Python robuste.

Élément clé	Synthèse
🔌 GPIO	Broches du Raspberry Pi permettant d’interagir avec capteurs et actionneurs.
🐍 Python	Langage simple et adapté pour contrôler les GPIO via des librairies dédiées.
📚 Bibliothèque RPi.GPIO	Permet de configurer, lire et écrire sur les broches rapidement.
⚙️ Usage typique	Allumer une LED, lire un bouton, automatiser de petits montages électroniques.
🧭 Mode de numérotation	Deux modes: BCM (recommandé) ou BOARD selon le repérage choisi.

📌

Télécharger l’image

Comprendre les GPIO du Raspberry Pi avant de coder en Python

Les GPIO (General Purpose Input/Output) du Raspberry Pi constituent une interface électronique polyvalente. Elles servent à piloter des LED, lire l’état de boutons poussoirs, communiquer avec des capteurs numériques ou commander des servomoteurs. Python s’y prête très bien grâce à un écosystème de bibliothèques mûr et documenté.

Avant d’écrire une ligne de code, une vision claire du brochage, des tensions acceptées et des limites de courant protège le matériel et évite des comportements aléatoires. Une mauvaise compréhension des niveaux logiques ou une erreur de branchement conduit à des dysfonctionnements, voire à une destruction définitive des broches.

Modèles de Raspberry Pi et différences de GPIO

La famille Raspberry Pi se divise en deux grandes catégories pour les GPIO :

Cartes 40 broches : Raspberry Pi 4 Model B, Raspberry Pi 5 (2 à 16 Go), Raspberry Pi 3B+, Raspberry Pi Zero / Zero 2 W, et les générations suivantes comme le Raspberry Pi 6 qui conservent le layout 40 broches.
Cartes 20 broches type microcontrôleur : Raspberry Pi Pico, Pico H, Pico W, Pico WH, Pico 2, Pico 2 W, basées sur un microcontrôleur RP2040, avec deux rangées de 20 pins.

Les deux familles ne se programment pas tout à fait de la même manière en Python :

Les Pi 4 / Pi 5 fonctionnent avec un système Linux complet (Raspberry Pi OS) ; on utilise Python classique et des bibliothèques comme RPi.GPIO, gpiozero ou pigpio.
Les Pico / Pico W tournent avec MicroPython ou CircuitPython directement sur le microcontrôleur, avec des bibliothèques dédiées à ce contexte embarqué.

Pour un vrai tour d’horizon des modèles et de l’écosystème, un passage par le guide général sur Raspberry Pi s’avère utile : guide Raspberry Pi pour débutant.

Tensions, masse et sécurité de base

Les GPIO des Raspberry Pi 40 broches fonctionnent avec une logistique 3,3 V. Les broches d’alimentation sont les suivantes :

3,3 V : pins 1 et 17 (sorties régulées pour alimenter capteurs basse consommation).
5 V : pins 2 et 4 (reliées directement à l’alimentation du Pi, sans régulation interne supplémentaire pour les GPIO).
GND (masse) : pins 6, 9, 14, 20, 25, 30, 34, 39.

Les broches GPIO logiques acceptent uniquement 3,3 V maximum. Une mise sous 5 V sur une entrée provoque une destruction irréversible du SoC ou de la rangée de GPIO concernée. Aucun composant de protection interne n’absorbe cette erreur.

À retenir avant tout câblage GPIO

Ne jamais connecter directement une sortie 5 V (Arduino, alimentation externe, capteur 5 V) sur une broche GPIO du Raspberry Pi.
Utiliser un convertisseur de niveau logique ou un pont diviseur résistif pour adapter les signaux vers 3,3 V.
Vérifier systématiquement le brochage (pinout) avant branchement. Un schéma complet se consulte facilement ici : brochage complet Raspberry Pi.

Limites de courant et risques de surchauffe

Les broches GPIO ne remplacent pas une alimentation de puissance. Elles gèrent un courant limité :

Courant maximal par broche : environ 16 mA.
Courant total cumulé sur l’ensemble des GPIO : environ 50 mA.

Sur Raspberry Pi Pico, les valeurs typiques sont :

Courant par GPIO : 2, 4, 8 ou 12 mA selon la configuration, avec 4 mA par défaut.
Courant total conseillé : environ 50 mA sur l’ensemble des sorties.

Un dépassement de ces valeurs entraîne des baisses de tension, des redémarrages intempestifs, voire une dégradation lente des transistors de sortie. L’utilisation de transistors, MOSFET ou drivers dédiés pour piloter des relais, moteurs et rubans LED limite ces risques.

Notions logiques et fonctionnement d’un GPIO en Python

Un GPIO fonctionne selon deux états numériques : niveau bas (0 logique) et niveau haut (1 logique). Python manipule ces états via des fonctions simples de lecture et d’écriture, mais la couche électrique sous-jacente mérite une explication.

Niveaux logiques et seuils de détection

Pour les Raspberry Pi 40 broches, la tension de référence des GPIO est 3,3 V. On considère en pratique :

En dessous d’environ 0,8 V : lecture en niveau bas.
Au-dessus d’environ 1,8 V : lecture en niveau haut.
Entre ces valeurs : zone intermédiaire, à éviter pour garantir un comportement stable.

En Python, la bibliothèque renvoie généralement 0 ou 1 (ou False / True) et masque cette complexité, mais le câblage doit fournir des niveaux suffisamment franches pour rester en dehors de la zone grise.

Entrée, sortie, pull-up et pull-down

Chaque GPIO se configure en entrée ou en sortie.

Mode sortie : la broche délivre un signal 0 V ou 3,3 V, capable de fournir un petit courant vers une LED, un optocoupleur ou un driver.
Mode entrée : la broche mesure l’état logique envoyé par un bouton poussoir, un capteur ou un circuit externe.

En entrée, la notion de résistances de tirage internes (pull-up et pull-down) intervient. Sans ce tirage, l’entrée flotte et oscille entre 0 et 1 au gré des perturbations électriques.

Pull-up : relie légèrement la broche au 3,3 V, l’état par défaut devient 1.
Pull-down : relie légèrement la broche à la masse, l’état par défaut devient 0.

Les bibliothèques Python modernes gèrent ces résistances via des options de configuration, ce qui simplifie fortement le câblage des boutons et capteurs simples.

Installer Python et préparer l’environnement GPIO

Sur Raspberry Pi OS, Python est déjà présent. La préparation consiste surtout à installer les bibliothèques adaptées et à adopter une structure de projet claire.

Choisir la bibliothèque Python pour les GPIO

Plusieurs bibliothèques de programmation GPIO coexistent :

Bibliothèque	Niveau	Avantages principaux	Cas d’usage typique
RPi.GPIO	Bas niveau	Contrôle fin des broches, historique, très répandu	Tutoriels classiques, scripts simples, compréhension des bases
gpiozero	Haut niveau	Abstraction par objets (LED, Button, Servo), code concis	Projets pédagogiques, prototypes rapides, simplification du code
pigpio	Bas niveau réseau	Daemon, contrôle à distance, PWM précis	Projets exigeants, multi-langage, pilotage à distance
smbus-cffi	Spécialisé I²C	Accès au bus I²C via SMBus	Capteurs I²C, écrans, convertisseurs analogiques
spidev	Spécialisé SPI	Interface SPI souple	Convertisseurs ADC/DAC, mémoires SPI, écrans TFT

Pour débuter, gpiozero simplifie énormément les scripts. RPi.GPIO reste pertinent pour comprendre ce qui se passe réellement sur les broches. Les deux approches se complètent.

Installation des bibliothèques GPIO sous Raspberry Pi OS

Sur une installation récente de Raspberry Pi OS, gpiozero et RPi.GPIO sont généralement déjà présents. En cas de besoin, l’installation s’effectue via pip ou apt :

sudo apt update
sudo apt install python3-gpiozero python3-rpi.gpio python3-pigpio python3-spidev

Pour un développement plus structuré (interface graphique, réglages, logs), l’ajout de Tkinter et de modules de gestion de configuration en Python renforce le confort de travail.

Programmer les GPIO avec RPi.GPIO : base indispensable

La bibliothèque RPi.GPIO donne un accès direct aux broches du Raspberry Pi en Python. Elle sert de référence pour assimiler les notions de numérotation, de modes d’accès et de gestion propre des ressources.

Numérotation BCM vs BOARD

RPi.GPIO propose deux systèmes de numérotation :

BOARD : numérotation physique des pins (1 à 40), selon leur position sur le connecteur.
BCM : numéros logiques des GPIO internes (GPIO17, GPIO18, etc.).

Pour suivre la documentation officielle et les schémas récents, la numérotation BCM reste la plus pratique. Le brochage détaillé BCM par pin se consulte ici : référence du pinout Raspberry Pi.

Exemple : allumer une LED avec RPi.GPIO

Scénario : une LED connectée entre GPIO17 et une résistance en série vers GND. Le code minimal avec RPi.GPIO ressemble à ceci :

import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BCM)        # Utilisation des numéros BCM
GPIO.setup(17, GPIO.OUT)      # GPIO17 en sortie

try:
    while True:
        GPIO.output(17, GPIO.HIGH)  # LED allumée
        sleep(1)
        GPIO.output(17, GPIO.LOW)   # LED éteinte
        sleep(1)
except KeyboardInterrupt:
    pass
finally:
    GPIO.cleanup()            # Libération propre des GPIO

Le bloc try / except / finally garantit la libération correcte des ressources, même en cas d’interruption par Ctrl+C. Cette bonne pratique évite des conflits à l’exécution de scripts suivants.

Lire un bouton poussoir en entrée

Pour un bouton relié à GPIO18 et à GND, avec résistance de tirage interne activée, le code devient :

import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Tirage interne vers 3,3 V

try:
    while True:
        state = GPIO.input(18)
        if state == GPIO.LOW:   # Bouton appuyé (relié à GND)
            print("Bouton pressé")
        sleep(0.05)
except KeyboardInterrupt:
    pass
finally:
    GPIO.cleanup()

L’utilisation de la résistance de tirage interne simplifie le montage : un seul fil entre GND et le bouton, puis entre le bouton et la broche GPIO18.

Programmer les GPIO avec gpiozero : approche orientée objets

gpiozero encapsule la logique RPi.GPIO avec des classes Python prêtes à l’emploi. Une LED devient un objet LED, un bouton un objet Button, un servomoteur un objet Servo.

Une LED en une ligne de code

Avec gpiozero, le clignotement de LED se résume à quelques instructions très lisibles :

from gpiozero import LED
from time import sleep

led = LED(17)   # GPIO17

while True:
    led.on()
    sleep(1)
    led.off()
    sleep(1)

Pour un clignotement automatique, la bibliothèque propose même une méthode dédiée :

from gpiozero import LED
from signal import pause

led = LED(17)
led.blink(on_time=1, off_time=1)

pause()  # Laisse le script tourner indéfiniment

Écouter un bouton par événements

Le grand intérêt de gpiozero réside dans sa gestion d’événements. Il n’est plus nécessaire de boucler en permanence pour lire l’état d’un bouton :

from gpiozero import Button, LED
from signal import pause

button = Button(18, pull_up=True)
led = LED(17)

button.when_pressed = led.on
button.when_released = led.off

pause()

La librairie s’occupe des rebonds mécaniques du bouton et des détails bas niveau, ce qui raccourcit fortement le code.

Servomoteurs et PWM avec gpiozero

Pour piloter un servomoteur à rotation limitée (type 0–180° ou 0–360°), gpiozero propose la classe Servo. La commande s’effectue par un signal PWM sur une broche GPIO. Un câblage correct repose sur trois fils : alimentation (souvent 5 V), GND commun et signal PWM 3,3 V.

from gpiozero import Servo
from time import sleep

servo = Servo(18)   # GPIO18 PWM conseillé

while True:
    servo.min()   # Position 0°
    sleep(1)
    servo.mid()   # Position centrale
    sleep(1)
    servo.max()   # Position 180° (ou extrême)
    sleep(1)

Astuce pour les servos gourmands

Les servomoteurs tirent souvent des courants de pointe élevés. Une alimentation séparée, avec masse commune au Raspberry Pi, évite des redémarrages inopinés. La broche GPIO fournit alors uniquement le signal de commande, pas la puissance.

PWM, I²C, SPI et UART : exploiter les fonctions avancées

Au-delà des simples entrées/sorties numériques, les GPIO supportent plusieurs protocoles de communication : PWM, I²C, SPI, UART. Python s’interface avec ces bus grâce à des bibliothèques spécialisées.

PWM : contrôle fin de la puissance

Le PWM (Pulse Width Modulation) module la durée de l’impulsion haute dans un cycle. En variant le rapport cyclique, on ajuste l’intensité perçue d’une LED, la vitesse d’un moteur ou la position d’un servo.

Sur Raspberry Pi Pico, la plage de fréquence PWM s’étend d’environ 7,5 Hz jusqu’à plusieurs MHz, ce qui couvre un large éventail d’applications. Pour le pilotage de servos, on utilise généralement une période d’environ 20 ms avec :

500 µs pour une extrémité (≈ 0°).
2500 µs pour l’autre extrémité (≈ 180–360° selon le modèle).

En Python classique sur Pi 4/5, RPi.GPIO gère un PWM logiciel ou matériel selon la broche, tandis que pigpio apporte un contrôle plus stable pour des exigences plus strictes (robotique, audio, éclairage précis).

I²C : capteurs et écrans sur deux fils

Le bus I²C utilise deux lignes (SDA et SCL) partagées par plusieurs périphériques adressables. Sur Raspberry Pi, une seule affectation par pin est possible à la fois, mais plusieurs composants coexistent sur le même bus.

En Python, la bibliothèque smbus-cffi ou le module smbus2 facilitent la communication. Un exemple typique consiste à lire un capteur de température / humidité ou piloter un afficheur LCD I²C avec un simple adressage et quelques registres à écrire.

SPI : échanges rapides avec ADC, DAC et écrans

Le bus SPI offre une communication synchrone plus rapide que l’I²C, avec un canal maître-esclave dédié. La bibliothèque spidev fournit une interface Python directe pour envoyer et recevoir des octets.

Cette approche convient bien pour :

Convertisseurs analogique-numérique (ADC).
Convertisseurs numérique-analogique (DAC).
Écrans TFT, modules RF, mémoires Flash.

UART : console série et modules externes

Le port UART natif du Raspberry Pi sert de liaison série classique (RX/TX) vers des modules GPS, des microcontrôleurs, ou un PC. Via Python, la bibliothèque pyserial gère les échanges au format texte ou binaire. Une configuration correcte de la vitesse (baudrate) et du format de trame (bits de données, parité) garantit la fiabilité des transmissions.

Spécificités du Raspberry Pi Pico / Pico W en MicroPython

Les Raspberry Pi Pico et Pico W fonctionnent comme des microcontrôleurs. Le code MicroPython tourne directement sur la puce RP2040, sans système d’exploitation complet. Les GPIO se programment via le module standard machine.

Configuration de base d’un GPIO en MicroPython

Pour piloter une LED sur Pico, le code suivant illustre la configuration minimale :

from machine import Pin
from time import sleep

led = Pin(15, Pin.OUT)

while True:
    led.value(1)
    sleep(1)
    led.value(0)
    sleep(1)

La logique reste proche de RPi.GPIO, mais les appels passent directement par les registres matériels sans couche Linux.

ADC, VREF et VSYS sur Pico W

Les Pico W et Pico 2 W intègrent un convertisseur analogique-numérique (ADC) sur certaines broches :

GPIO26, 27, 28, 29 : entrées ADC.
AGND : masse de référence analogique.
VREF : tension de référence, proche de 3,3 V filtré.

La broche GPIO29 connectée à VSYS (via un diviseur) permet de mesurer environ un tiers de la tension d’alimentation (entre 0,6 V et 1,83 V typiquement), valeur ensuite convertie en tension réelle via un petit calcul en Python.

L’alimentation USB des Pico s’accepte sur une plage d’environ 2,1 V à 5,8 V, avec une valeur nominale autour de 5,5 V sur VSYS. Ces caractéristiques renforcent la souplesse de déploiement sur batterie ou adaptateur externe.

Courant et profils de consommation sur Pico

Comme évoqué plus haut, chaque GPIO du Pico offre une intensité réglable (2, 4, 8 ou 12 mA) avec 4 mA par défaut. Le respect du courant total de l’ordre de 50 mA sur les GPIO préserve la fiabilité du RP2040, surtout en fonctionnement continu.

Conseil d’organisation pour projets Pico

Regrouper dans un même module Python toutes les fonctions liées au matériel (GPIO, ADC, PWM). Les autres modules traitent la logique métier (robotique, interface, stockage). Ce découpage simplifie la maintenance et le portage vers d’autres cartes.

Gestion des erreurs, limites matérielles et bonnes pratiques

La programmation GPIO en Python implique une double vigilance : gestion des erreurs logicielles et respect des contraintes matérielles. Une approche rigoureuse évite la plupart des pannes.

Risques de surtension et surcourant

Les avertissements principaux sont clairs :

Absence de protection intégrée : aucune diode de clamp ou fusible électronique ne protège les GPIO.
Surtension > 3,3 V : risque de destruction définitive de la puce.
Surcourant : desserre progressivement la marge de fiabilité, provoque des pannes aléatoires et une baisse de performance.
Baisse de tension en cas de dépassement de courant : le Raspberry Pi devient instable, surtout avec une alimentation USB limite.

« Une seule erreur de branchement à 5 V sur un GPIO peut suffire à rendre une carte inutilisable. Un multimètre, un schéma de pinout fiable et un contrôle systématique avant mise sous tension évitent cette issue. »

Bonnes pratiques de développement Python pour les GPIO

Quelques règles simples structurent un code GPIO fiable :

Centraliser la configuration des broches dans un module ou une section dédiée.
Utiliser GPIO.cleanup() ou les fonctions de libération équivalentes (gpiozero libère automatiquement la plupart du temps).
Gérer les exceptions (try/except) pour éviter un blocage au milieu d’une séquence de commande.
Prévoir un mécanisme d’arrêt propre (bouton, commande réseau, signal logiciel).
Journaliser les événements importants (logs) pour faciliter le diagnostic.

Exemples de projets concrets pour s’exercer en Python

Rien ne vaut des projets pratiques pour ancrer les notions. Plusieurs idées exploitent les GPIO avec Python de manière progressive.

Contrôle de LED et animations lumineuses

Point de départ classique : une ou plusieurs LED reliées aux GPIO via des résistances. À partir d’un simple clignotement, un script Python peut générer des effets plus élaborés :

Chenillard façon « K2000 ».
Indicateurs d’état pour un serveur ou un NAS maison.
Bargraphe piloté par la charge CPU ou le trafic réseau.

Un tutoriel dédié au pilotage des LED en Python approfondit ces aspects : contrôle de LED en Python sur Raspberry Pi.

Robotique simple et domotique de base

Les GPIO servent de fondation à des projets concrets :

Robot suiveur de ligne : lecture de capteurs infrarouge, commande de moteurs via un pont en H, régulation par boucles Python.
Bras robotisé : pilotage de plusieurs servos, gestion des trajectoires, enregistrement de séquences.
Domotique : station météo avec capteurs I²C, volets roulants via relais, alarme basique avec détecteurs magnétiques.

« En liant quelques GPIO à des capteurs d’ouverture et à une sirène, un simple script Python offre déjà une alarme fonctionnelle, extensible et adaptable à un appartement ou un atelier. »

Console personnalisée et interfaces utilisateur

Une autre voie consiste à créer une console de jeu ou un tableau de contrôle :

Boutons reliés aux GPIO pour contrôler des émulateurs.
Écran SPI ou HDMI pour l’affichage.
Pilotage via Python de menus, de paramètres et de profils utilisateur.

La combinaison de gpiozero pour les entrées physiques et de bibliothèques comme Tkinter ou Pygame pour l’interface offre une base solide pour un projet ludique mais structuré.

Aller plus loin : structurer ses scripts et son apprentissage

Pour maîtriser durablement la programmation GPIO en Python, une progression structurée rend les choses plus claires :

Phase 1 : sorties simples (LED, relais) avec RPi.GPIO ou gpiozero.
Phase 2 : entrées (boutons, détecteurs) et gestion d’événements.
Phase 3 : PWM, I²C, SPI, servos, moteurs.
Phase 4 : projets complets (robot, station météo, domotique).

Chaque phase profite d’une organisation du code par modules, d’une séparation claire entre la logique matérielle, la logique métier et l’interface utilisateur. Une fois ces réflexes intégrés, l’écosystème Raspberry Pi offre une plateforme très souple pour prototyper et déployer des systèmes embarqués écrits en Python.