Piloter les GPIO depuis Linux

Piloter les GPIO depuis Linux, c’est commander les broches d’entrée/sortie du Raspberry Pi depuis un programme, en Python le plus souvent, alors qu’un système d’exploitation tourne en arrière-plan. Le principe reste celui de tout GPIO : une broche en sortie applique un niveau logique, une broche en entrée le lit. Mais ici, le programme ne touche pas le matériel directement : il passe par une bibliothèque, puis par le noyau Linux, avant d’atteindre la broche. Cette couche supplémentaire est à la fois un confort (du code Python lisible) et une limite (pas de temps réel dur).

À quoi ça sert ?

C’est le pont entre la puissance logicielle du SBC et le monde physique : lire un capteur, allumer une LED, piloter un relais ou commander un moteur depuis un programme qui, par ailleurs, fait de la vision ou parle au réseau. Sans GPIO, le Pi reste un ordinateur coupé du système mécatronique. Avec, il en devient une cible de commande à part entière (au sens du critère « programmer ou paramétrer un contrôleur numérique »).

Les bibliothèques

Trois bibliothèques Python coexistent. On n’en utilise qu’une à la fois.

• gpiozero — la bibliothèque de haut niveau recommandée. Elle raisonne en objets (LED, Button, Servo, DistanceSensor…) plutôt qu’en broches brutes, ce qui rend le code court et lisible. Elle s’appuie automatiquement sur la bonne couche bas niveau selon la carte (y compris le Pi 5).
• RPi.GPIO — l’ancienne bibliothèque historique, plus verbeuse (on configure chaque broche à la main). Très présente dans les anciens tutoriels, mais ne fonctionne pas sur le Raspberry Pi 5.
• lgpio — une bibliothèque bas niveau moderne, compatible Pi 5, qu’on utilise directement quand on a besoin de finesse. C’est l’une des couches sur lesquelles gpiozero peut reposer.

Tip

Commencez par gpiozero. On descend vers lgpio seulement si un besoin précis l’exige. C’est exactement la logique des couches d’abstraction d’un microcontrôleur : on reste haut tant que ça suffit.

Toutes ces bibliothèques désignent les broches par leur numéro GPIO « BCM » (par exemple GPIO17), qui n’est pas le numéro de position physique sur le connecteur. C’est une source de confusion classique : un brochage du connecteur 40 broches du Pi est indispensable pour câbler juste.

Allumer une LED

Câblage : la broche GPIO17 → une résistance (~330 Ω) → l’anode de la LED → la cathode → une broche GND. La résistance limite le courant. Le niveau de sortie est à 3,3 V.

Avec gpiozero, le programme tient en quelques lignes :

from gpiozero import LED
from time import sleep
 
led = LED(17)        # GPIO17 (numérotation BCM)
 
while True:
    led.on()
    sleep(0.5)
    led.off()
    sleep(0.5)

LED(17) crée l’objet, on() / off() pilotent l’état. La bibliothèque offre même un raccourci pour le clignotement : led.blink(on_time=0.5, off_time=0.5) fait la même chose en tâche de fond, sans boucle bloquante.

Warning

Le courant que peut fournir une broche du Pi est limité (de l’ordre de quelques milliampères à ~16 mA par broche, avec un total à ne pas dépasser sur l’ensemble). On ne branche jamais un moteur ou un actionneur de puissance directement sur une broche : il faut un transistor, un pont en H ou un relais, comme sur un microcontrôleur. Une LED avec sa résistance est dans les clous. Au-delà, on passe par un étage de puissance.

Lire un bouton

Câblage : un bouton entre GPIO2 et GND. On active la résistance de tirage interne (vers le haut) : au repos la broche lit un niveau haut, à l’appui elle est tirée vers la masse (niveau bas). gpiozero gère ce tirage par défaut.

from gpiozero import LED, Button
from time import sleep
 
bouton = Button(2)   # GPIO2, tirage interne vers le haut (appui = niveau bas)
led = LED(17)
 
while True:
    if bouton.is_pressed:
        led.on()
    else:
        led.off()
    sleep(0.01)

Button expose is_pressed, mais aussi une approche par événements, plus idiomatique :

from gpiozero import Button
from signal import pause
 
bouton = Button(2)
bouton.when_pressed  = lambda: print("Appui")
bouton.when_released = lambda: print("Relâché")
 
pause()   # laisse le programme vivre, en attente d'événements

C’est l’équivalent, côté SBC, de la lecture d’une entrée logique sur microcontrôleur, en plus concis : l’anti-rebond et la gestion d’événements sont déjà dans la bibliothèque.

Pas de temps réel dur

Voilà la différence de fond avec un microcontrôleur, et elle conditionne ce qu’on peut confier au Pi. Entre le script et la broche, le noyau Linux s’intercale : son ordonnanceur peut suspendre le programme à tout moment pour exécuter une autre tâche. Conséquences :

• la durée d’un sleep() n’est pas garantie au millième près : elle peut s’allonger si le système est occupé ;
• la gigue (variation du temps de réaction) rend le Pi inadapté à une boucle de commande cadencée finement ;
• la PWM logicielle (par exemple PWMLED) tremble : pour un signal propre, il faut une PWM matérielle, et même elle reste moins fiable qu’un timer de microcontrôleur.

La règle pratique : le SBC pour le haut niveau (décision, vision, réseau), le microcontrôleur pour le temps réel (asservissement, commande moteur cadencée). Quand un projet a besoin des deux, on les fait travailler ensemble (voir le SBC dans un projet).

Niveaux de tension — 3,3 V

Les broches du Pi sont en 3,3 V et ne tolèrent pas le 5 V. Lire la sortie d’un capteur alimenté en 5 V, ou la broche d’un Arduino, directement sur une entrée du Pi peut endommager la broche. La parade : un adaptateur de niveau (level shifter) entre les 5 V et le Pi. Le détail est dans niveaux de tension.

Pièges

Confondre numéro BCM et numéro physique. LED(17) vise GPIO17, pas la 17ᵉ broche du connecteur. Toujours câbler avec un brochage sous les yeux.

Appliquer 5 V sur une entrée. Le GPIO n’est pas tolérant 5 V. Un signal 5 V passe par un adaptateur de niveau, jamais en direct.

Tirer trop de courant d’une broche. Une LED avec résistance, oui ; un moteur, non. Au-delà de quelques milliampères, étage de puissance obligatoire.

Attendre du temps réel. Une régulation rapide ou un signal cadencé au microseconde ne se font pas de façon fiable sous Linux. Si le projet l’exige, déporter cette partie sur un microcontrôleur.

Utiliser RPi.GPIO sur un Pi 5. L’ancienne bibliothèque n’y fonctionne pas. Préférer gpiozero (qui s’adapte) ou lgpio.

Aller plus loin

• Documentation de gpiozero — recettes pour LED, boutons, capteurs, moteurs.
• Brochage GPIO du Raspberry Pi — le connecteur 40 broches, numéros BCM et fonctions.

Voir aussi

• Raspberry Pi — hub du module SBC
• Le SBC dans un projet — répartir haut niveau (SBC) et temps réel (microcontrôleur)
• GPIO — la notion d’entrée/sortie logique, indépendante de la carte
• Niveaux de tension — la logique 3,3 V et l’adaptation depuis le 5 V
• sortie — lire une entrée, piloter une sortie