Raspberry PI5 Leds WS2812b

Les rubans de LED WS2812B offrent un potentiel énorme pour les projets créatifs, allant de l’éclairage décoratif aux animations complexes et installations interactives. Ces rubans de LED adressables individuellement permettent de contrôler la couleur et l’intensité de chaque diode LED, ce qui les rend particulièrement prisés pour des projets de domotique, de décoration ou même d’art numérique.

Fonctionnement et caractéristiques des WS2812B

Les rubans de LED WS2812B se distinguent par leur capacité à être pilotés de manière individuelle grâce à une puce intégrée dans chaque LED. Cette puce reçoit et interprète les signaux pour ajuster la couleur et la luminosité de chaque diode de manière indépendante. Cela permet de créer une large gamme d’effets visuels, allant du simple changement de couleur à des animations synchronisées complexes.

Caractéristiques techniques

Contrôle adressable : chaque LED peut être programmée indépendamment pour afficher une couleur spécifique.
Protocole de communication : le contrôle se fait par un signal numérique, généralement transmis par un microcontrôleur ou un ordinateur (via des cartes comme Arduino ou Raspberry Pi).
Puissance et intensité lumineuse : chaque LED est composée de trois diodes (rouge, vert et bleu), permettant de reproduire une vaste palette de couleurs.
Alimentation : ces rubans fonctionnent souvent sous une tension de 5V, mais des alimentations externes sont recommandées pour les installations de grande taille.

Une led consomme au maximum 0.06 ampère; ainsi un ruban de 300 leds peut avoir besoin de300*0.06 ampères soit 18 ampères sous 5 volts, ce qui correspond à une puissance de 90 watts. Il convient en général d’utiliser une alimentation extérieure.

Dans cet article nous allons illustrer le fonctionnement de ce type de ruban avec un raspberry pi5.

Protocole de communication

Les rubans de LED WS2812B utilisent un protocole de communication à un fil (One-Wire), conçu pour transmettre des données de couleur et de luminosité à chaque LED individuellement. Ce protocole repose sur un timing précis pour encoder les bits et transmettre les informations nécessaires à chaque LED.

Les modules python tels que rpi_ws281x ne fonctionne pas à ce jour sur le modèle pi5. Néanmoins il existe un module utilisable pour les pi5 : https://github.com/niklasr22/rpi5-ws2812

Il s’agit d’une interface simple pour la bande LED WS2812 du Raspberry Pi 5. Actuellement, elle ne prend en charge que la communication via l’interface SPI.

Cette bibliothèque a été créée pour le Raspberry Pi 5 car la précédente bibliothèque incontournable rpi_ws281x n’est pas (encore ?) compatible. Cela devrait également fonctionner sur d’autres modèles de Raspberry Pi, mais cela n’a pas été testé.
Préparation

Activez SPI sur le Raspberry Pi 5 :

sudo raspi-config

Accédez à Options d’interface -> SPI et activez-le.

Facultatif : ajoutez votre utilisateur au groupe spi pour éviter d’exécuter le script en tant que root :

sudo adduser YOUR_USER spidev

Installation

pip installer rpi5-ws2812

Câblage
Connectez la broche DIN (Data In) de la bande WS2812 à la broche MOSI (Master Out Slave In) du Raspberry Pi 5. La broche MOSI est la broche 19 / GPIO10 du Raspberry Pi 5.

Module LEDController

Ce module est particulièrement adapté aux projets d’éclairage dynamique, aux décorations festives et à l’intégration dans des installations interactives.

1. Installation et Pré-requis

Module nécessaire :

rpi5_ws2812 : Ce module contient WS2812SpiDriver et Color, indispensables pour le fonctionnement du ruban LED.

Shell

pip install rpi5-ws2812

2. Initialisation du Module

Pour utiliser le module, commencez par créer une instance de LEDController avec le nombre de LEDs de votre ruban.

Python

from rpi5_ws2812.ws2812 import WS2812SpiDriver, Color

# Initialisation du contrôleur LED
controller = LEDController(led_count=144, spi_bus=0, spi_device=0)

led_count : nombre de LEDs sur votre ruban.

spi_bus et spi_device : paramètres SPI pour le Raspberry Pi. Par défaut, SPI bus 0 et device 0 sont utilisés.

3. Utilisation des Animations LED

Ajouter une animation

La méthode add_animation permet d’ajouter une animation avec des paramètres personnalisés :

Python

controller.add_animation(
    start=0, 
    end=10, 
    colors=[Color(255, 0, 0)], 
    frequency=0.5, 
    animation_type="blink", 
    name="blink_red"
)

start : LED de début de l’animation.
end : LED de fin de l’animation.
colors : Liste de couleurs pour l’animation, chaque couleur étant un objet Color.
frequency : Intervalle en secondes entre les cycles d’animation.
animation_type : Type d’animation (voir les types ci-dessous).
name : Nom unique pour identifier l’animation (obligatoire).

Types d’animations disponibles

Voici les types d’animations intégrés dans LEDController :

static : Affiche une couleur fixe.
blink : Clignote entre une couleur et le noir.
caterpillar : Déplace une couleur spécifique comme une chenille.
fire : Simule un effet de flamme avec des variations de rouge.
rainbow : Dégradé arc-en-ciel sur le ruban.
breathe : Effet de respiration (variation de l’intensité).
wave : Onde lumineuse de couleur.
color_wipe : Remplit progressivement les LED de la couleur choisie.

4. Contrôle des Animations

Vous pouvez ajouter plusieurs animations simultanément sur différentes sections du ruban en leur attribuant des noms uniques. Chaque animation s’exécute dans un thread séparé.

Python

controller.add_animation(
    start=30, 
    end=50, 
    colors=[Color(0, 255, 0)], 
    frequency=0.3, 
    animation_type="wave", 
    name="wave_green"
)

Exemple

Python

from rpi5_ws2812.ws2812 import Color
import time

# Initialisation
controller = LEDController(led_count=144)

# Ajouter des animations
controller.add_animation(start=0, end=20, colors=[Color(0, 0, 255)], frequency=0.5, animation_type="breathe", name="breathe_blue")
controller.add_animation(start=30, end=50, colors=[Color(255, 0, 0)], frequency=0.3, animation_type="caterpillar", name="caterpillar_red")
controller.add_animation(start=60, end=80, colors=[Color(0, 255, 0)], frequency=0.1, animation_type="rainbow", name="rainbow_effect")

# Laisser les animations tourner pendant 10 secondes
time.sleep(10)

# Arrêter toutes les animations
controller.stop_all_animations()

# Éteindre toutes les LED
controller.clear()

SOURCE

Python

from rpi5_ws2812.ws2812 import WS2812SpiDriver, Color
import time,threading,math,random

class LEDController:
    def __init__(self, led_count: int, spi_bus=0, spi_device=0):
        """
        Initialise le contrôleur pour gérer le ruban de LED.
        
        :param led_count: Nombre total de LEDs dans le ruban
        """
        self.led_count = led_count
        self.strip = WS2812SpiDriver(spi_bus=spi_bus, spi_device=spi_device, led_count=led_count).get_strip()
        self.animations = {}  # Dictionnaire pour stocker les animations actives
        self.stop_flags = {}  # Drapeaux pour arrêter les animations spécifiques

    def add_animation(self, start: int, end: int, colors: list[Color], frequency: float, animation_type: str, name: str):
        """
        Ajoute une animation avec un nom spécifique pour la contrôler ultérieurement.

        :param start: LED de début pour l'animation
        :param end: LED de fin pour l'animation
        :param colors: Liste de couleurs à utiliser pour l'animation
        :param frequency: Fréquence de l'animation (en secondes)
        :param animation_type: Type d'animation (ex: "static", "blink", etc.)
        :param name: Nom unique pour identifier l'animation
        """
        if name in self.animations:
            raise ValueError(f"Une animation nommée '{name}' existe déjà.")
        stop_flag = threading.Event()
        self.stop_flags[name] = stop_flag
        animation_thread = threading.Thread(
            target=self._run_animation,
            args=(start, end, colors, frequency, animation_type, stop_flag),
            daemon=True
        )
        self.animations[name] = animation_thread
        animation_thread.start()

    def _run_animation(self, start, end, colors, frequency, animation_type, stop_flag):
        """
        Exécute l'animation spécifiée jusqu'à ce que le drapeau d'arrêt soit défini.

        :param start: LED de début pour l'animation
        :param end: LED de fin pour l'animation
        :param colors: Liste de couleurs à utiliser pour l'animation
        :param frequency: Fréquence de l'animation
        :param animation_type: Type de l'animation
        :param stop_flag: Drapeau pour arrêter l'animation
        """
        length = end – start + 1
        while not stop_flag.is_set():
            if animation_type == "static":
                for i in range(start, end + 1):
                    self.strip.set_pixel_color(i, colors[0])
                self.strip.show()
                time.sleep(frequency)

            elif animation_type == "blink":
                for i in range(start, end + 1):
                    self.strip.set_pixel_color(i, colors[0])
                self.strip.show()
                time.sleep(frequency)
                for i in range(start, end + 1):
                    self.strip.set_pixel_color(i, Color(0, 0, 0))
                self.strip.show()
                time.sleep(frequency)

            elif animation_type == "caterpillar":
                for i in range(length):
                    if stop_flag.is_set():
                        break
                    for j in range(length):
                        self.strip.set_pixel_color(start + j, colors[1] if j == i else colors[0])
                    self.strip.show()
                    time.sleep(frequency)

            elif animation_type == "fire":
                for i in range(start, end + 1):
                    intensity = random.randint(100, 255)
                    self.strip.set_pixel_color(i, Color(intensity, random.randint(0, intensity // 2), 0))
                self.strip.show()
                time.sleep(frequency)

            elif animation_type == "rainbow":
                for i in range(start, end + 1):
                    self.strip.set_pixel_color(i, self._wheel((i * 256 // length) & 255))
                self.strip.show()
                time.sleep(frequency)

            elif animation_type == "breathe":
                step = 0
                while not stop_flag.is_set():
                    intensity = int((math.sin(step) + 1) * 127.5)
                    for i in range(start, end + 1):
                        self.strip.set_pixel_color(i, Color(intensity, intensity, intensity))
                    self.strip.show()
                    step += 0.1
                    time.sleep(frequency)

            elif animation_type == "wave":
                step = 0
                while not stop_flag.is_set():
                    for i in range(length):
                        intensity = int((math.sin(i + step) + 1) * 127.5)
                        self.strip.set_pixel_color(start + i, Color(intensity, 0, intensity))
                    self.strip.show()
                    step += 0.3
                    time.sleep(frequency)

            elif animation_type == "color_wipe":
                for i in range(start, end + 1):
                    if stop_flag.is_set():
                        break
                    self.strip.set_pixel_color(i, colors[0])
                    self.strip.show()
                    time.sleep(frequency)

            # Animation spécifique de Noël : Snowfall
            elif animation_type == "snowfall":
                for i in range(length):
                    self.strip.set_pixel_color(start + i, Color(255, 255, 255) if random.random() > 0.8 else Color(0, 0, 0))
                self.strip.show()
                time.sleep(frequency)

            # Animation de Noël : Twinkle (scintillement aléatoire)
            elif animation_type == "twinkle":
                for i in range(start, end + 1):
                    self.strip.set_pixel_color(i, colors[0] if random.random() > 0.8 else Color(0, 0, 0))
                self.strip.show()
                time.sleep(frequency)

            # Animation de Noël : Christmas Chase (alternance rouge et vert en défilement)
            elif animation_type == "christmas_chase":
                for i in range(length):
                    color = colors[i % 2] if i % 2 == 0 else colors[1]
                    self.strip.set_pixel_color(start + (i % length), color)
                self.strip.show()
                time.sleep(frequency)

            # Animation de Noël : Holiday Sparkle (effet de flash aléatoire)
            elif animation_type == "holiday_sparkle":
                for i in range(start, end + 1):
                    color = colors[random.randint(0, len(colors) – 1)]
                    self.strip.set_pixel_color(i, color if random.random() > 0.8 else Color(0, 0, 0))
                self.strip.show()
                time.sleep(frequency)

    def _wheel(self, pos):
        """
        Génère une couleur arc-en-ciel basée sur la position donnée (0-255).

        :param pos: Position de couleur (0-255)
        :return: Couleur RGB correspondante
        """
        if pos < 85:
            return Color(pos * 3, 255 – pos * 3, 0)
        elif pos < 170:
            pos -= 85
            return Color(255 – pos * 3, 0, pos * 3)
        else:
            pos -= 170
            return Color(0, pos * 3, 255 – pos * 3)

    def stop_animation(self, name: str):
        """
        Arrête l'animation en fonction de son nom.

        :param name: Nom de l'animation à arrêter
        """
        if name not in self.animations:
            raise ValueError(f"Aucune animation trouvée avec le nom '{name}'.")
        
        self.stop_flags[name].set()
        self.animations[name].join()
        del self.animations[name]
        del self.stop_flags[name]

    def stop_all_animations(self):
        """Arrête toutes les animations actives."""
        for name in list(self.animations.keys()):
            self.stop_animation(name)

    def clear(self):
        """Éteint toutes les LEDs du ruban."""
        self.strip.set_all_pixels(Color(0, 0, 0))
        self.strip.show()

Exemple

Python

import time
from pi5_ws2812b import LEDController, Color

# Initialisation du contrôleur pour un ruban de 300 LEDs
led_count = 300
controller = LEDController(led_count)

# Définition des couleurs pour les animations
red = Color(255, 0, 0)
green = Color(0, 255, 0)
blue = Color(0, 0, 255)
white = Color(255, 255, 255)
yellow = Color(255, 255, 0)

# Liste des animations à tester avec leur configuration
animations = [
    {"name": "Static Red", "type": "static", "colors": [red], "frequency": 0.5},
    {"name": "Blink Blue", "type": "blink", "colors": [blue], "frequency": 0.5},
    {"name": "Caterpillar Green", "type": "caterpillar", "colors": [green, blue], "frequency": 0.1},
    {"name": "Fire", "type": "fire", "colors": [], "frequency": 0.1},
    {"name": "Rainbow", "type": "rainbow", "colors": [], "frequency": 0.1},
    {"name": "Breathe Yellow", "type": "breathe", "colors": [yellow], "frequency": 0.05},
    {"name": "Wave Purple", "type": "wave", "colors": [Color(128, 0, 128)], "frequency": 0.05},
    {"name": "Color Wipe Red", "type": "color_wipe", "colors": [red], "frequency": 0.05},
    {"name": "Snowfall", "type": "snowfall", "colors": [white], "frequency": 0.2},
    {"name": "Twinkle", "type": "twinkle", "colors": [white], "frequency": 0.2},
    {"name": "Christmas Chase", "type": "christmas_chase", "colors": [red, green], "frequency": 0.1},
    {"name": "Holiday Sparkle", "type": "holiday_sparkle", "colors": [red, green, blue, yellow, white], "frequency": 0.15},
]

try:
    for animation in animations:
        name = animation["name"]
        animation_type = animation["type"]
        colors = animation["colors"]
        frequency = animation["frequency"]

        # Démarre l'animation avec une portion du ruban, par exemple de 0 à 143
        print(f"Starting animation: {name}")
        controller.add_animation(0, led_count – 1, colors, frequency, animation_type, name)

        # Attend 5 secondes avant de passer à l'animation suivante
        time.sleep(5)

        # Arrête l'animation en cours
        controller.stop_animation(name)
        print(f"Stopped animation: {name}")

finally:
    # Nettoie les LEDs et arrête toutes les animations en cas d'interruption
    controller.stop_all_animations()
    controller.clear()
    print("All animations stopped and LEDs cleared.")

Grimeco

Raspberry PI5 Leds WS2812b

Fonctionnement et caractéristiques des WS2812B

Caractéristiques techniques

Protocole de communication

Module LEDController

1. Installation et Pré-requis

2. Initialisation du Module

3. Utilisation des Animations LED

Ajouter une animation

Types d’animations disponibles

4. Contrôle des Animations

Exemple

SOURCE

Exemple

A DECOUVRIR EGALEMENT

Éditeur de Schémas Électroniques

Ollama : Intégration de LLMs en local

Raspberry Radio Internet (Partie 1)

Laisser un commentaire Annuler la réponse