La question du pilotage des LEDs WS2812B sur Raspberry Pi 5 a récemment été soulevée par Victor lors d’un échange sur un réseau social. Le Raspberry Pi 5 introduit une nouvelle architecture matérielle qui complique le pilotage des LEDs WS2812B avec les bibliothèques historiques. Les solutions basées sur le PWM ou le DMA montrent rapidement leurs limites en termes de fiabilité. Cet article présente une méthode robuste utilisant le bus SPI du Raspberry Pi 5 pour piloter des LEDs adressables WS2812B, avec un fonctionnement stable, reproductible et adapté aux projets makers et applications pédagogiques.
Au sommaire :
- 1 Raspberry Pi 5 : piloter des LEDs WS2812B de manière fiable avec le bus SPI
- 1.1 Introduction
- 1.2 Pourquoi les WS2812B posent problème sur Raspberry Pi 5
- 1.3 Pourquoi utiliser le bus SPI pour piloter des WS2812B sur Raspberry Pi 5
- 1.4 La bibliothèque retenue : rpi5-ws2812 (niklasr22)
- 1.5 Vérifier la disponibilité du SPI sur Raspberry Pi 5
- 1.6 Connexion du ruban WS2812B au Raspberry Pi 5
- 1.7 Exemple 1 : test simple (rouge / vert / bleu)
- 1.8 Exemple 2 : chenillard (une LED allumée à la fois)
- 1.9 Vidéo
- 1.10 Conclusion
- 1.11 Sources
Raspberry Pi 5 : piloter des LEDs WS2812B de manière fiable avec le bus SPI
Introduction
Le pilotage des LEDs adressables WS2812B fait partie des grands classiques des projets makers, et le Raspberry Pi a longtemps été une plateforme appréciée pour ce type d’expérimentations. Avec l’arrivée du Raspberry Pi 5, les choses se compliquent : la nouvelle architecture matérielle et logicielle rend les bibliothèques historiques basées sur le PWM ou le DMA peu fiables, voire inutilisables dans certains cas.
C’est suite à une question posée par Victor lors d’un échange sur un réseau social que ce sujet a été approfondi. L’objectif était double : l’aider à faire fonctionner correctement des WS2812B avec un Raspberry Pi 5, et en profiter pour tester de manière rigoureuse une solution réellement exploitable sur cette nouvelle plateforme.
Cet article présente donc un retour d’expérience complet : identification des limites des solutions existantes, choix d’une approche basée sur le bus SPI, mise en œuvre concrète, pièges rencontrés et correctifs appliqués. L’ensemble des tests a été réalisé sur un Raspberry Pi 5 sous Raspberry Pi OS Bookworm, avec un anneau de WS2812B, afin de proposer une méthode fiable, reproductible et adaptée aux projets makers comme aux usages pédagogiques.
Pourquoi les WS2812B posent problème sur Raspberry Pi 5
Rappel rapide sur le fonctionnement des WS2812B

Les WS2812B sont des LEDs adressables qui intègrent leur propre contrôleur. Chaque LED reçoit un flux de données série à un timing très strict (environ 800 kHz) et relaie automatiquement les informations destinées aux LEDs suivantes. Ce fonctionnement impose un respect précis des durées des impulsions logiques, sous peine de provoquer des erreurs d’affichage ou des comportements aléatoires.
Ce qui change avec le Raspberry Pi 5

Avec le Raspberry Pi 5, l’architecture matérielle et la gestion des GPIO ont profondément évolué. Le nouveau SoC et la pile logicielle associée modifient la manière dont les signaux sont générés et planifiés, rendant plus difficile la production de timings précis en sortie GPIO. Des méthodes qui fonctionnaient correctement sur les générations précédentes deviennent alors instables ou imprévisibles sur le Pi 5.
Limites des bibliothèques historiques (PWM, DMA, rpi_ws281x)

Les bibliothèques historiques utilisées pour piloter les WS2812B sur Raspberry Pi reposent généralement sur le PWM ou le DMA pour générer les signaux nécessaires. Sur le Raspberry Pi 5, ces approches montrent rapidement leurs limites : scintillements, LEDs fantômes, pertes de synchronisation ou fonctionnement erratique. La bibliothèque rpi_ws281x, largement utilisée jusque-là, n’est notamment plus adaptée sans modifications profondes, ce qui impose de repenser la méthode de pilotage des WS2812B sur cette nouvelle plateforme.
Pourquoi utiliser le bus SPI pour piloter des WS2812B sur Raspberry Pi 5
Le bus SPI du Raspberry Pi 5 constitue une alternative fiable pour piloter des LEDs WS2812B, car il repose sur un contrôleur matériel dédié, indépendant du système multitâche et du scheduler Linux. Contrairement aux sorties GPIO pilotées par PWM ou DMA, le SPI garantit une horloge stable et un flux de données continu, deux éléments essentiels pour respecter le timing strict imposé par les WS2812B.
En utilisant le SPI, les données destinées aux LEDs sont encodées sous forme de motifs binaires compatibles avec le protocole des WS2812B, puis envoyées de manière déterministe via le matériel. Cette approche devrait éviter les interruptions et les variations de timing responsables des scintillements ou des LEDs fantômes observés avec les bibliothèques historiques sur Raspberry Pi 5. (j’ai quand même noté quelques « pétouilles« )
Enfin, le SPI étant pleinement supporté par la nouvelle architecture du Pi 5, cette solution s’avère stable, reproductible et parfaitement adaptée aux projets makers et pédagogiques nécessitant un pilotage fiable des LEDs adressables.
✔ Lorsque vous voyez /dev/spidev0.0 ou /dev/spidev0.1, il ne s’agit pas d’une émulation logicielle, mais bien de l’accès à un contrôleur SPI matériel intégré directement dans la puce du Raspberry Pi.
✔ Linux s’appuie sur un driver SPI du noyau, basé sur ce contrôleur matériel, qui génère le signal SPI de manière déterministe, indépendamment du scheduler Linux ou de la charge CPU (au moins pour l’émission et la réception des octets).
📎 Référence : documentation officielle Raspberry Pi – SPI bus
GitHub – raspberrypi/documentation
La bibliothèque retenue : rpi5-ws2812 (niklasr22)
La bibliothèque rpi5-ws2812 a été écrite spécifiquement pour le Raspberry Pi 5, car la référence historique rpi_ws281x n’est pas encore compatible avec cette nouvelle plateforme. Un point important : cette bibliothèque ne pilote les WS2812B qu’en utilisant le bus SPI.
📎 Dépôt GitHub : https://github.com/niklasr22/rpi5-ws2812
Comment ça fonctionne (très rapidement)
Les LEDs WS2812B imposent un signal extrêmement sensible au timing, ce qui rend leur pilotage délicat sur un système multitâche comme Linux. Avec rpi5-ws2812, les couleurs (au format GRB) sont encodées en une trame binaire compatible WS2812, puis envoyées via le
contrôleur SPI matériel du Raspberry Pi.
Côté câblage, la ligne DIN des WS2812B est reliée à la broche MOSI du Raspberry Pi (GPIO10, broche 19), ce qui correspond au périphérique /dev/spidev0.0 lorsque l’on utilise SPI0 avec le
chip-select CE0.
L’API est volontairement simple :
WS2812SpiDriver(...).get_strip()set_all_pixels()set_pixel_color()show()
Installation sans environnement virtuel (Bookworm) et pourquoi
Sous Raspberry Pi OS Bookworm (basé sur Debian), pip est bridé par le mécanisme PEP 668 (externally managed environment). L’objectif est d’inciter à utiliser des environnements virtuels (venv) afin d’éviter toute interférence avec les paquets Python du système.
Cependant, lorsqu’on souhaite piloter le SPI en lançant le script en tant que root (sudo python3 ...), un problème classique apparaît : si la bibliothèque est installée uniquement pour l’utilisateur (dans~/.local), root ne la voit pas, ce qui provoque une erreur ModuleNotFoundError.
Sans utiliser de venv, la méthode la plus directe consiste donc à installer la bibliothèque également pour root, en contournant explicitement la protection PEP 668 :
|
1 |
sudo pip3 install --break-system-packages rpi5-ws2812 |
Ce contournement est prévu par la PEP 668 : on force l’installation dans le Python système en acceptant un risque théorique de conflit, ce qui reste acceptable dans le cadre d’un projet maker dédié. 📎 Référence PEP 668 : https://peps.python.org/pep-0668/
Alternative « propre » pour éviter l’utilisation de root
La documentation de rpi5-ws2812 indique qu’il est possible d’éviter sudo en autorisant l’utilisateur à accéder au bus SPI.
En pratique, cela consiste à :
- activer le SPI via
raspi-config, - vérifier que l’utilisateur a accès à
/dev/spidev0.0, - et lancer le script Python sans privilèges root.
Vérifier la disponibilité du SPI sur Raspberry Pi 5
Avant toute chose, il est indispensable de vérifier que le bus SPI est bien activé et accessible sur le Raspberry Pi 5.
Le SPI peut être activé de deux manières :
- en ligne de commande avec
sudo raspi-config→ Interface Options → SPI → Enable - ou en mode graphique via Préférences → Configuration → Interfaces → SPI
Une fois le SPI activé, la commande suivante permet de vérifier les périphériques disponibles :
|
1 |
ls /dev/spidev* |
Sur un Raspberry Pi 5 fonctionnel, on obtient typiquement :
|
1 2 3 |
/dev/spidev0.0 /dev/spidev0.1 /dev/spidev10.0 |
Le pilotage des WS2812B s’effectue via SPI0 / CE0, soit /dev/spidev0.0. Le périphérique spidev10.0 peut apparaître sur le Pi 5, mais il n’est pas utilisable dans ce contexte.
Connexion du ruban WS2812B au Raspberry Pi 5
Le pilotage des LEDs WS2812B via le bus SPI nécessite un câblage simple mais rigoureux. Une attention particulière doit être portée à l’alimentation et au respect des niveaux logiques.
- DIN (Data In) du ruban WS2812B → MOSI du Raspberry Pi 5 (GPIO10, broche 19)
- GND du ruban WS2812B → GND du Raspberry Pi (par exemple broche 6)
- +5 V du ruban WS2812B → alimentation 5 V stable (broche 2 du Raspberry Pi ou alimentation externe dédiée)
⚠️ Les WS2812B fonctionnent exclusivement en 5 V. Il ne faut en aucun cas les alimenter en 3,3 V. La masse (GND) du ruban doit impérativement être commune avec elle du Raspberry Pi.
Dans cette configuration, le bus utilisé est SPI0 / CE0, ce qui correspond au périphérique /dev/spidev0.0.
À propos des niveaux logiques
Le Raspberry Pi 5 délivre un signal logique en 3,3 V sur sa broche MOSI, alors que les WS2812B attendent idéalement un signal proche de 5 V.
Dans de nombreux cas, notamment avec des rubans courts ou des anneaux, le signal 3,3 V fonctionne correctement. Pour une fiabilité maximale, en particulier avec des longueurs importantes, l’utilisation d’un convertisseur de niveau logique 3,3 V → 5 V (74AHCT125, 74HCT245, etc.) est recommandée.
Une fois le câblage réalisé et le SPI activé, le ruban WS2812B est prêt à être piloté via la bibliothèque rpi5-ws2812.
Exemple 1 : test simple (rouge / vert / bleu)
Ce premier programme permet de valider rapidement l’ensemble de la chaîne : SPI, câblage et bibliothèque. Avec un anneau de 16 LEDs, les couleurs rouge, verte et bleue doivent s’afficher successivement.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
#!/usr/bin/env python3 from rpi5_ws2812.ws2812 import Color, WS2812SpiDriver import time # Nombre de LEDs de l’anneau NB_LEDS = 16 def main(): # Driver SPI -> MOSI (GPIO10, pin 19) driver = WS2812SpiDriver( spi_bus=0, spi_device=0, led_count=NB_LEDS ) # Récupération du strip + luminosité strip = driver.get_strip() strip.brightness = 0.2 while True: # Rouge strip.set_all_pixels(Color(255, 0, 0)) strip.show() time.sleep(0.5) # Vert strip.set_all_pixels(Color(0, 255, 0)) strip.show() time.sleep(0.5) # Vert strip.set_all_pixels(Color(0, 0, 255)) strip.show() time.sleep(0.5) if __name__ == "__main__": main() |
Si les trois couleurs s’enchaînent correctement, le SPI, le câblage et la bibliothèque sont opérationnels.
Exemple 2 : chenillard (une LED allumée à la fois)
Ce second exemple montre l’utilisation de l’API officielle de rpi5-ws2812 pour piloter individuellement les LEDs, sans accéder aux structures internes de la bibliothèque.
Une courte trame noire est envoyée avant chaque mise à jour afin de limiter les effets parasites observés sur certains anneaux WS2812B.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
#!/usr/bin/env python3 from rpi5_ws2812.ws2812 import Color, WS2812SpiDriver import time NB_LEDS = 16 def send_frame(strip, colors): # Frame noire pour reset interne strip.set_all_pixels(Color(0, 0, 0)) strip.show() time.sleep(0.0001) # 100 µs # Frame réelle for i in range(NB_LEDS): strip.set_pixel_color(i, colors[i]) strip.show() def main(): driver = WS2812SpiDriver( spi_bus=0, spi_device=0, led_count=NB_LEDS ) strip = driver.get_strip() strip.set_brightness(0.2) position = 0 while True: colors = [Color(0, 0, 0)] * NB_LEDS colors[position] = Color(0, 255, 0) send_frame(strip, colors) time.sleep(0.05) # Calcul de position modulo pour un anneau de LEDs position = (position + 1) % NB_LEDS if __name__ == "__main__": main() |
Ce chenillard valide le pilotage individuel des LEDs et permet d’observer la stabilité du signal SPI dans le temps.
Vidéo
Conclusion
Le pilotage des LEDs WS2812B sur Raspberry Pi 5 nécessite d’adapter les méthodes utilisées jusqu’à présent, les bibliothèques historiques n’étant plus adaptées à la nouvelle architecture. L’utilisation du bus SPI, combinée à une bibliothèque spécifiquement conçue pour le Pi 5 comme rpi5-ws2812, permet d’obtenir une solution fiable et reproductible. Les tests présentés dans cet article montrent qu’il est possible de piloter des LEDs adressables sans artifices ni contournements hasardeux, à condition de respecter le câblage, la configuration du SPI et les bonnes pratiques logicielles. Merci à Victor pour avoir soulevé cette question, qui a permis d’explorer et de valider une approche efficace sur Raspberry Pi 5.



Bonjour, merci beaucoup pour cette article très complet !