Raspberry Pi et LED en Python : premier projet GPIO pas à pas

Envie de contrôler des LED avec un Raspberry Pi et quelques lignes de Python ? Ce projet GPIO pas à pas ouvre la porte aux montages électroniques, aux prototypes IoT et aux automatisations à la maison sans matériel coûteux.

Dans ce guide, tu relies le code aux composants réels : broches GPIO, résistances, LED simple ou RGB, scripts Python et bonnes pratiques. De quoi poser des bases solides pour tous tes futurs montages autour du Raspberry Pi.

Élément clé	Résumé
Objectif 🧪	Découvrir le contrôle d’une LED via les broches GPIO du Raspberry Pi grâce à un script Python simple.
Matériel requis 🔧	Raspberry Pi, une LED, résistance, câbles et breadboard.
Principe GPIO ⚙️	Utilisation d’une broche configurée en sortie pour envoyer un signal allumant ou éteignant la LED.
Code Python 💡	Script utilisant une bibliothèque GPIO pour alterner ON/OFF et comprendre le comportement du matériel.
Compétence acquise 🚀	Première approche pratique de l’électronique et du pilotage matériel via Python.

📌

Télécharger l’image

Comprendre le contexte : pourquoi associer Raspberry Pi, LED et Python ?

Le Raspberry Pi s’est imposé comme une plateforme polyvalente pour l’apprentissage de la programmation, de l’électronique et des architectures embarquées. Entre 2012 et 2024, plus de 61 millions de Raspberry Pi ont été vendus, toutes versions confondues. Les séries Raspberry Pi 3 à elles seules représentent environ 23 millions d’unités, sans compter les modèles dédiés comme le Raspberry Pi Pico (environ 4 millions d’unités).

En 2026, le Raspberry Pi ne se limite plus aux projets de loisir. On le retrouve dans les homelab, la cybersécurité, les projets IoT et de plus en plus dans les solutions industrielles. Le marché industriel lié au Raspberry Pi est estimé à 385 millions de dollars, avec un taux de croissance d’environ 15,7 % par an. Un simple projet de LED contrôlées en Python sert de base à des usages bien plus avancés : signalisation, diagnostic visuel, tableaux de bord physiques, retours d’état machines, etc.

Avant d’empiler les services Docker sur un homelab ou d’écrire un scanner réseau, beaucoup de passionnés commencent par une étape simple : faire clignoter une LED depuis un script Python. Ce type de montage, relié aux broches GPIO, donne une compréhension concrète des signaux logiques, des niveaux de tension et de la synchronisation logicielle.

À retenir : un projet LED + GPIO en Python ne sert pas uniquement à voir une lumière s’allumer. Il structure la compréhension des entrées/sorties, des temporisations, des états logiques et de la communication entre logiciel et matériel. Ces principes se réutilisent ensuite pour des relais, des capteurs, des moteurs ou des interfaces industrielles.

Raspberry Pi et GPIO : bases indispensables avant le premier montage

Les GPIO (General Purpose Input/Output) du Raspberry Pi sont des broches configurables en entrée ou en sortie. Elles permettent de piloter des LED, lire l’état de boutons, interagir avec des capteurs et dialoguer avec des modules externes.

Chaque broche GPIO se commande en Python via une librairie dédiée. Le code indique à la broche si elle doit envoyer un signal haut (niveau logique 1) ou bas (niveau logique 0). Dans le cas d’une LED, un GPIO en sortie fournit le signal à travers une résistance de limitation pour allumer ou éteindre la diode électroluminescente.

Différences de tension : Raspberry Pi vs Arduino

Un point technique fondamental concerne la tension logique. Sur un Raspberry Pi, les GPIO fonctionnent en 3,3 V. À l’inverse, un Arduino Nano classique utilise du 5 V sur la plupart de ses broches. Cette distinction influe sur le choix des composants, des résistances et des schémas de câblage.

Dans un projet mixte Raspberry Pi + Arduino, la communication série se configure souvent à 9600 bauds. Côté Raspberry Pi, un script Python envoie des instructions via le port série. Côté microcontrôleur, un programme interprète ces ordres et commande les sorties physiques. Ce schéma devient utile lorsque tu veux piloter des LED, des moteurs ou des servo-moteurs alimentés en 5 V, tout en gardant la logique principale sur le Raspberry Pi.

Carte	Tension logique GPIO	Rôle typique dans un projet LED	Exemples d’usages avancés
Raspberry Pi (3, 4, 5)	3,3 V	Contrôle direct de LED simples ou RGB via Python	Tableaux de bord lumineux, indicateurs d’état pour homelab, IoT, monitoring serveur
Arduino Nano	5 V	Gestion d’un grand nombre de LED, animations complexes, PWM	Bargraph LED, matrices, contrôleurs de rubans LED adressables, pilotage industriel

Info pratique : lorsque tu relies un Arduino à un Raspberry Pi, n’ignore jamais la différence de tension. Utilise une liaison série USB ou un convertisseur de niveau logique. Un branchement direct 5 V sur un GPIO 3,3 V du Raspberry Pi expose la carte à un risque de détérioration immédiate.

Repérer les broches GPIO avec le bon pinout

Pour éviter les erreurs de câblage, il vaut mieux connaître le pinout de son Raspberry Pi. La numérotation du connecteur 40 broches distingue généralement le numéro physique de la broche et le numéro logique GPIO. Une confusion entre ces deux schémas conduit rapidement à une LED qui reste éteinte ou, pire, à une mauvaise connexion.

Pour approfondir le sujet, un guide dédié aux broches reste utile : détails complets sur le pinout du Raspberry Pi. Ce type de ressource clarifie quelles broches fournissent du 5 V, du 3,3 V, la masse (GND) ou des fonctions spécifiques (I2C, SPI, UART).

« Une bonne compréhension du pinout et des niveaux de tension protège le Raspberry Pi, simplifie le débogage et accélère chaque nouveau montage. Les erreurs de broche coûtent plus de temps que l’écriture du script Python lui‑même. »

Matériel nécessaire pour un premier projet LED en Python avec GPIO

Un projet LED simple ne demande pas une grande quantité de matériel. Il s’appuie surtout sur quelques composants de base bien choisis et correctement assemblés. L’objectif reste de partir d’un montage minimal et évolutif vers un ensemble plus dense (jusqu’à plusieurs LED, voire une LED RGB).

Liste des composants pour piloter des LED avec un Raspberry Pi

Pour ton premier montage GPIO en Python, la configuration suivante fonctionne très bien :

Un Raspberry Pi (modèle 3, 4 ou 5, ou un équivalent récent).
Une breadboard pour les connexions sans soudure.
Entre 1 et 8 LED classiques (rouge, verte, jaune, bleue). Un minimum de 1 pour tester, jusque 8 pour créer une petite barre d’indication.
En option, une LED RGB 3 pins pour jouer sur les couleurs (anode commune ou cathode commune suivant le modèle).
Résistances pour limiter le courant dans chaque LED.
Câbles de connexion (dupont male‑femelle et male‑male).
Une alimentation stable pour le Raspberry Pi (USB‑C ou micro‑USB suivant le modèle).

Si tu utilises un Arduino Nano en complément, ajoute :

Un Arduino Nano ou équivalent.
Un câble USB pour relier l’Arduino au Raspberry Pi, à ton PC ou à un hub.

Conseil matériel : démarre avec 2 ou 3 LED seulement. Une fois la logique du code validée (allumage, extinction, clignotement), étends le montage jusqu’à 8 LED sans changer les principes de base.

Pourquoi les résistances restent indispensables

Une LED branchée directement entre une broche GPIO et la masse sans résistance impose un courant excessif sur la broche. Les GPIO du Raspberry Pi ne supportent qu’un courant limité par broche et par groupe de broches. Sans limitation, la LED risque de se détériorer et la broche GPIO aussi.

Une résistance en série avec la LED définit le courant. Pour des LED classiques, une résistance entre 220 Ω et 470 Ω convient généralement en 3,3 V. Tu adaptes la valeur suivant la luminosité souhaitée et la chute de tension de la LED (qui varie selon la couleur : rouge, verte, bleue, etc.).

Câblage étape par étape : connecter une LED au Raspberry Pi

Le câblage d’une LED sur GPIO repose sur un schéma type très simple : une broche de sortie, une résistance, la LED, puis la masse. À partir de cette base, tu peux multiplier les LED ou passer à une LED RGB.

Schéma de principe pour une LED simple

Pour une LED unique reliée à un GPIO, la structure générale ressemble à ceci :

Broche GPIO choisie (par exemple GPIO17) en mode sortie.
Sortie GPIO → résistance (220 Ω par exemple).
Résistance → anode de la LED (patte la plus longue).
Cathode de la LED → GND (masse du Raspberry Pi).

Cette organisation en série garantit un courant contrôlé et une polarité correcte. Une inversion de polarité (LED à l’envers) conduit simplement à une LED qui ne s’allume pas, sans danger particulier dans ce cas précis.

Astuce de câblage : consacre une ou deux lignes complètes de la breadboard pour la masse (GND) en les reliant aux broches GND du Raspberry Pi. Tu simplifies ensuite la connexion de plusieurs LED ou composants sur un même rail de masse.

Étendre le montage à plusieurs LED

Pour piloter plusieurs LED (jusqu’à 8 recommandées sur un premier projet), le schéma se répète. Chaque LED reçoit sa propre résistance et sa propre broche GPIO. La masse reste commune.

Dans la pratique, on choisit souvent des broches GPIO contiguës pour simplifier le repérage dans le code, par exemple : GPIO17, GPIO18, GPIO27, GPIO22, GPIO23, GPIO24, GPIO25, GPIO5. Chaque broche pilote une LED indépendante pour créer des séquences lumineuses.

Cas particulier de la LED RGB 3 pins

Une LED RGB 3 pins regroupe trois LED dans un même boîtier : rouge, vert et bleu. Suivant le modèle, tu peux avoir une anode commune ou une cathode commune. La broche commune se relie respectivement au 3,3 V ou au GND, tandis que les deux autres broches reçoivent les signaux des GPIO via des résistances.

Dans un premier projet, tu peux piloter simplement deux couleurs sur trois, par exemple rouge et vert, puis ajouter le bleu ensuite. Chaque couleur reçoit sa propre broche GPIO, ce qui permet de composer des indications : vert pour OK, rouge pour alerte, etc.

Préparer l’environnement Python pour le GPIO

Une fois la partie matérielle en place, tu passes à la configuration logicielle. Le Raspberry Pi exécute un système Linux (Raspberry Pi OS dans la majorité des cas) qui fournit un interpréteur Python 3 par défaut.

Le cœur du projet consiste à utiliser un module Python pour initialiser les GPIO, définir leurs modes (entrée ou sortie) et envoyer les signaux adaptés aux LED. La séquence classique comprend :

import des bibliothèques nécessaires,
choix du schéma de numérotation des broches (BOARD ou BCM),
configuration des GPIO en sortie,
écriture d’états haut/bas sur chaque broche,
nettoyage de la configuration avant de quitter le script.

Bibliothèques utiles côté Raspberry Pi

Pour un Raspberry Pi classique, on utilise fréquemment la librairie RPi.GPIO ou son équivalent moderne gpiozero. Dans le cadre de ce guide, on se concentre sur la logique proche du matériel :

GPIO.setup() pour configurer le mode de la broche,
GPIO.output() pour activer ou désactiver une LED,
GPIO.HIGH et GPIO.LOW pour représenter les niveaux logiques.

En parallèle, pour un microcontrôleur comme l’Arduino Nano ou une carte avec MicroPython, les méthodes on(), off() et toggle() remplissent le même rôle. Elles changent l’état d’une broche de sortie à haute fréquence ou selon un timing défini dans le code.

Communication série entre Raspberry Pi et microcontrôleur

Lorsque tu veux déléguer une partie du contrôle des LED à un Arduino ou à une carte MicroPython, une liaison série à 9600 bauds constitue une base robuste. Côté Raspberry Pi, un script Python utilise un module serial pour envoyer des commandes textuelles. Côté microcontrôleur, un programme reçoit ces instructions et appelle les fonctions correspondantes.

Par exemple, un script Python envoie la chaîne LED1_ON ou LED1_OFF. Le microcontrôleur interprète ces chaînes et active la broche souhaitée via on() ou off(). Ce schéma répartit la logique : le Raspberry Pi gère l’interface utilisateur, le réseau ou un tableau de bord web, tandis que l’Arduino gère les sorties temps réel.

Limite à connaître : la liaison série à 9600 bauds suffit largement pour piloter des LED. Pour des flux plus lourds (capteurs haute fréquence, streaming de données), une liaison plus rapide ou un autre protocole (I2C, SPI) devient préférable.

Écrire ton premier script Python GPIO pour allumer une LED

Une fois la librairie GPIO installée et la LED câblée, tu peux passer à ton premier script. L’objectif : allumer la LED, la laisser quelques secondes, puis l’éteindre proprement.

Initialisation des GPIO en Python

Le squelette d’un script Python pour contrôler une LED via GPIO s’organise autour de plusieurs étapes claires :

import des modules RPi.GPIO et time,
choix du mode de numérotation (par exemple BCM),
déclaration de la broche utilisée pour la LED,
configuration de cette broche en sortie.

L’instruction clé pour la configuration est GPIO.setup(). Elle définit le comportement de la broche, par exemple GPIO.setup(17, GPIO.OUT) pour une LED reliée au GPIO17.

Allumer et éteindre une LED avec GPIO.output()

Une fois la broche configurée, tes actions se résument à deux instructions principales :

GPIO.output(LED, GPIO.HIGH) pour allumer la LED,
GPIO.output(LED, GPIO.LOW) pour l’éteindre.

Ces instructions créent ou suppriment la différence de potentiel entre la broche et la masse, ce qui fait circuler un courant dans la LED à travers la résistance. Tu ajoutes des pauses avec time.sleep() pour rendre les changements visibles.

« Une LED qui s’allume en réponse à une instruction Python montre que ton environnement, ton câblage et ta logique fonctionnent ensemble. Ce retour visuel sert de validation concrète avant d’aller plus loin. »

Faire clignoter plusieurs LED : logique de séquence en Python

Une fois l’allumage simple validé, tu peux enrichir le projet en contrôlant plusieurs LED. L’idée consiste à déclarer un tableau de broches et à parcourir ce tableau pour allumer les LED dans différents ordres. Cette approche introduit doucement la notion de boucle, de structure de données et de temporisation.

Gestion d’une liste de broches GPIO

En Python, tu peux définir une liste des broches associées aux LED :

LEDS = [17, 18, 27, 22] par exemple.

Ensuite, tu appelles GPIO.setup() sur chaque broche pour les passer en mode sortie. Une fois la liste prête, tu peux écrire des boucles qui parcourent cette structure pour créer des effets : chenillard, clignotement synchronisé, effets de va‑et‑vient.

Introduire des délais et des motifs de clignotement

La création de motifs lumineux repose sur trois paramètres :

l’ordre d’allumage des LED,
la durée d’allumage et d’extinction (time.sleep()),
le nombre de répétitions.

En combinant ces éléments, tu crées des signaux visuels utiles : une LED rouge qui clignote rapidement en cas d’alerte, une LED verte qui reste allumée en cas de service opérationnel, une séquence qui balaye toutes les LED lors d’un démarrage de script pour signaler l’initialisation.

Idée d’évolution : associer le clignotement des LED à l’état de services réseau (ping, HTTP, base de données). Le Raspberry Pi exécute des scripts de supervision, et les GPIO traduisent les résultats sous forme lumineuse pour un diagnostic rapide dans un homelab.

Associer boutons et LED : aller plus loin dans l’interaction

Après le contrôle d’une LED uniquement via un script, une étape logique consiste à ajouter des boutons poussoirs. Un bouton relié à un GPIO en entrée permet à l’utilisateur de déclencher des actions en temps réel : allumer une LED, activer un mode, lancer un script, etc.

Dans ce contexte, une bonne compréhension du câblage des boutons, du rebond et des résistances de pull‑up/pull‑down devient utile. Un guide dédié couvre ce sujet de manière détaillée : utilisation d’un bouton avec le Raspberry Pi en Python.

Connexion d’un bouton simple avec une LED

Le montage standard relie une borne du bouton à un GPIO et l’autre à la masse ou au 3,3 V. Le code active ensuite une résistance de tirage interne (pull‑up ou pull‑down) pour garantir un état stable lorsque le bouton n’est pas pressé. Lorsque l’utilisateur appuie, l’état du GPIO change et le script en déduit l’événement.

En réponse à cet événement, le script appelle à nouveau GPIO.output() pour allumer ou éteindre la LED. Tu peux ainsi créer un interrupteur logiciel, une bascule (toggle), ou même un mode de clignotement variable selon le nombre de pressions.

Combiner Raspberry Pi, Arduino et MicroPython pour des projets LED avancés

Un premier projet GPIO avec une LED ne limite pas l’architecture au seul Raspberry Pi. De nombreux montages combinent un Raspberry Pi pour le contrôle haut niveau (réseau, interface, stockage) et une carte type Arduino ou MicroPython pour le pilotage bas niveau des LED et d’autres actionneurs.

Architecture mixte : Python côté Raspberry Pi, MicroPython côté microcontrôleur

Dans une architecture mixte, le Raspberry Pi se charge :

de la logique d’application en Python 3,
de la communication réseau (MQTT, HTTP, WebSocket),
de la gestion de fichiers de configuration ou de logs.

Le microcontrôleur (Arduino Nano ou carte MicroPython) se consacre :

au contrôle temps réel des LED,
à la génération d’effets lumineux précis (PWM, dégradés),
aux lectures rapides de capteurs ou d’entrées physiques.

Les fonctions on(), off() et toggle() en MicroPython facilitent cette séparation des rôles. La couche Python sur Raspberry Pi envoie des commandes structurées via le module serial, et le microcontrôleur applique les changements immédiatement sur ses GPIO.

Exemples d’ordres envoyés par un script Python via le port série

Dans une configuration typique, le script Python joue le rôle d’interface de commande. Il interprète les événements (requêtes web, timer, lecture de fichier) et envoie des ordres simples au microcontrôleur :

ALLUMER_LED → le microcontrôleur appelle un équivalent de GPIO.output(LED, GPIO.HIGH),
ETEINDRE_LED → il exécute un GPIO.output(LED, GPIO.LOW),
MODE_CLIGNOTE → il lance une boucle de clignotement contrôlée localement.

Cette séparation facilite aussi la maintenance : le code Python sur le Raspberry Pi gère l’interface utilisateur et les règles, tandis que le firmware MicroPython ou Arduino se concentre sur le comportement des LED.

« La combinaison Raspberry Pi + microcontrôleur donne un équilibre efficace entre puissance de calcul, connectivité réseau et contrôle temps réel. Un simple projet de LED offre une base claire pour mettre en place cette architecture hybride. »

Applications concrètes des LED GPIO en homelab, IoT et industrie

Au‑delà de l’apprentissage, un projet LED GPIO en Python se décline dans des environnements variés. Les ventes de kits récents (Raspberry Pi 4, packs de développement, kits avec accessoires) montrent une forte utilisation dans les environnements de laboratoire à domicile, les projets IoT et les petites installations industrielles.

Homelab et supervision locale

Dans un homelab, une barre de LED reliée au Raspberry Pi sert d’indicateur rapide. Quelques idées fréquentes :

une LED par service (NAS, VPN, serveur web, base de données),
une LED dédiée à la charge CPU ou à l’espace disque,
un motif de clignotement spécifique en cas de défaillance détectée.

Le script Python interroge les services via des commandes système ou des API, puis pilote les GPIO en conséquence. En un coup d’œil, tu repères l’état général sans ouvrir de console.

Projets IoT et prototypes fonctionnels

En IoT, les LED connectées aux GPIO du Raspberry Pi signalent l’état de modules distribués. Elles indiquent par exemple :

la connexion à un broker MQTT,
la réception de nouvelles mesures de capteurs,
la présence d’une erreur lors de l’envoi des données (réseau coupé, API indisponible).

Sur un prototype, une simple LED rouge ou une LED RGB renseigne rapidement les développeurs et les testeurs sur l’état interne du système, sans même avoir besoin d’un écran.

Contexte industriel et signalisation simple

Dans l’industrie, le Raspberry Pi trouve sa place pour des interfaces de contrôle ou de monitoring. Les LED pilotées par GPIO fournissent alors une signalisation claire :

indication de marche/arrêt d’une machine,
alerte en cas de dépassement de seuil (température, pression, niveau),
confirmation visuelle de la réception d’un ordre depuis un système central.

L’intérêt réside dans la flexibilité : une modification dans un script Python suffit pour changer le comportement des LED, adapter les seuils ou ajouter de nouvelles conditions. La même logique se transpose ensuite à d’autres types d’actionneurs, tout en conservant la même approche GPIO.

Approfondir : GPIO, Python et bonnes pratiques de développement

Une fois le projet LED opérationnel, plusieurs axes d’approfondissement se dessinent. Ils permettent de passer d’un simple script d’essai à une base fiable pour d’autres projets plus structurés.

Structurer le code Python pour plusieurs GPIO

Plutôt que de gérer chaque LED avec des lignes répétitives, tu peux regrouper la logique dans des fonctions ou des classes :

une fonction allumer(led) qui encapsule GPIO.output(led, GPIO.HIGH),
une fonction eteindre(led) pour GPIO.output(led, GPIO.LOW),
une fonction clignoter(led, duree, cycles) qui gère la temporisation.

Cette organisation rend le code plus lisible, plus facile à maintenir et plus simple à étendre à d’autres montages.

Comprendre la temporisation et la gestion des délais

La gestion de time.sleep() dans les scripts LED enseigne la notion de temporisation bloquante. Pour des projets plus évolués, cette approche montre vite ses limites, notamment quand tu dois gérer plusieurs événements en parallèle (clignotement, lecture de capteurs, réponses réseau).

Des solutions alternatives existent : threads Python, boucles d’événements asynchrones, ou délégation des tâches répétitives au microcontrôleur via MicroPython ou Arduino. Les principes restent les mêmes, mais l’architecture change pour gérer plus de contraintes en parallèle.

Aller plus loin sur le matériel GPIO

Pour approfondir les concepts de broches, de tensions, de modes d’entrée/sortie et de câblage, une exploration plus détaillée du GPIO du Raspberry Pi apporte une vraie clarté. Un tutoriel dédié, par exemple sur l’utilisation des GPIO avec Python, constitue une bonne ressource complémentaire : guide complet sur les GPIO du Raspberry Pi en Python.

En associant ce type de ressource à ton projet LED, tu consolides la compréhension des signaux logiques, des schémas de câblage et de la structure du code. Chaque nouvelle LED, chaque nouveau capteur ou actionneur se greffe ensuite sur ces bases communes.