Le Raspberry Pi PICO permet de réaliser des applications attrayantes pour un prix de revient minime. Cette animation d’un ruban de LEDs avec un effet de rebond s’obtient assez simplement en pilotant les LEDs Neopixel avec un court programme en MicroPython. Cet article est basé sur un programme de KenKenMkIISR.

LEDs rebondissantes avec Neopixel et Raspberry Pi PICO

D’une manière plus générale cet article vous explique comment

• Installer MicroPython sur le Raspberry Pi PICO
• Utiliser l’IDE Thonny Python
• Transférer une librairie Python sur le PICO
• Exécuter et tester un programme avec Thonny Python IDE
• Charger un programme pour qu’il démarre automatiquement sur Raspberry Pi PICO

Ces notions sont utiles dans cet article mais vous pourrez les transposer dans d’autres applications.

Bouncing LEDs

Les démonstrations pour rubans LED disponibles dans le commerce sont souvent jolies mais ennuyeuses. Celle-ci est plus captivante (à mon avis) et un peu hypnotique. Des blocs de LEDs  s’allument et tombent en subissant une accélération. Ils rebondissent en atteignant le bloc précédent, les rebonds sont proportionnels à la hauteur de la chute.

La bande de LED est compatible NeoPixel d’Adafruit ou WS2812B. Elle est contrôlée par un Raspberry Pi Pico et comporte une alimentation de puissance.

Matériel utilisé

• Raspberry Pi 4 2Go pour piloter le PICO (vous pouvez aussi utiliser un PC)
• Raspberry Pi PICO muni de connecteurs soudés
• Ruban de LEDs de 2m, 144 LEDs WS2812 / mètre
• Carte prototype pour les connexions
• Breadboard
• Alimentation 5V/10A

Installer le MicroPython sur le Raspberry Pi PICO

Vous trouverez la dernière version de MicroPython sur le site micropython.org. Téléchargez la dernière version stable. Si vous aimez expérimenter prenez une des versions instables (unstable). Au moment où j’écris ces lignes c’est la version rp2-pico-20210418-v1.15.uf2 qui est la plus récente version stable.

Téléchargez ce fichier .uf2. C’est un format de flashing USB (USB Flashing Format = UF2) créé par Microsoft pour MakeCode.

Vous retrouvez le fichier dans le dossier de Téléchargements (ici sur le Pi4). Comme j’utilise aussi les modules Pimoroni – voir articles précédents), j’ai aussi le MicroPython de Pimoroni en stock.

Connectez le Raspberry Pi PICO à un port USB en maintenant le bouton BOOTSEL appuyé. Le PICO est alors vu comme une clé USB que vous auriez connecté au PC ou au Pi4. Cliquez sur Valider pour ouvrir la fenêtre donnant accès à cette mémoire de masse dans le PICO. Elle se nomme RPI-RP2.

Quand la fenêtre est ouverte vous n’avez plus qu’à glisser/déposer le fichier uf2 de MicroPython dans la fenêtre RPI-RP2.

A la fin du transfert, le Raspberry Pi PICO reboote et lance le MicroPython. On va le vérifier tout de suite.

Utiliser Thonny IDE sur le Raspberry Pi 4

Sur le Raspberry Pi 4 ouvrez le menu principal puis > Programmation > Thonny Python IDE.

Dans Thonny Cliquez sur Run > Select Interpreter…

Vérifiez que c’est bien MicroPython pour PICO qui va exécuter le code, sinon sélectionnez le dans la liste déroulante (Cette option est disponible dans les versions de Thonny les plus récentes. Au besoin mettez votre IDE Thonny à jour).

Éventuellement passez Thonny en Français ( Tools > Options > General). Redémarrez Thonny.

Vous devriez voir le prompt de MicroPython et l’indication qu’il s’exécute bien sur le PICO. Vous pouvez même tester si ça fonctionne en entrant manuellement les instructions pour allumer et éteindre la LED embarquée sur le PICO :
Dans la partie basse de la fenêtre (Console), entrez les lignes suivantes une par une :

>>> from machine import Pin
>>> led = Pin(25, Pin.OUT)
>>> led.value(1)
>>> led.value(0)
>>>

Vous devriez voir la LED embarquée, connectée au GPIO 25, s’allumer puis s’éteindre. Vous venez de piloter manuellement la carte PICO. On peut passer à la suite.

Connecter le ruban de LEDs

Le ruban de LEDs

Le ruban de LEDs que j’ai choisi (pub gratuite) est disponible en plusieurs longueurs de 0,5 à 5 mètres, plusieurs couleurs de ruban, plusieurs densités de LED (de 30 à 144 LEDs par mètre) et plusieurs protections (IP 30, 65, 67). Vous choisirez celui qui vous convient le mieux. Dans mon cas, pour décorer un stand j’ai choisi un ruban de 2 mètres avec 144 LEDs par mètre.

Le brochage

 

Si on regarde le ruban de LEDs de près, on voit qu’il est constitué de tronçons soudés ensemble. Les données vont de la gauche vers la droite. ici on a juste la soudure entre 2 tronçons. On voit que le tronçon gauche porte l’indication DO (Data Output) alors que sur la partie droite on a DI (Data Input). En haut la masse GND (ou 0 volt) et en bas le + 5v. La flèche en haut du ruban indique le sens de circulation des données. L’ensemble est noyé dans une résine silicone qui assure isolation et étanchéité.

Schématiquement ça donne ceci. De la gauche arrivent les données destinées à allumer les LEDs. Elles peuvent provenir d’un tronçon de ruban précédent ou, dans notre cas, d’une sortie GPIO du Raspberry Pi PICO. On pourrait adapter à d’autres SBC, Arduino ou Raspberry Pi.

Le ruban est livré avec des connecteurs 3 points, montés à chaque extrémité :

Côté entrée du ruban de LED on trouve un connecteur femelle et deux fils. Le connecteur comporte un fil rouge (+5v), un fil blanc (masse) et un fil central vert (entrée des données).
Les deux fils supplémentaires permettent de connecter une alimentation externe avec le rouge au 5 volts et le blanc à la masse.

A l’autre extrémité du ruban de LEDs on trouve une prise mâle destinée à chaîner les rubans. elle permet si besoin de connecter un autre ruban… et ainsi de suite.

Comme cette prise n’est pas utile dans mon cas, je l’ai récupérée pour la connecter à l’alim et au Raspberry Pi Pico. Elle me sert à brancher le Pico sur l’entrée du ruban.

L’alimentation

Chaque LED Neopixel allumée en blanc au maximum (RVB = 0xFFFFFF) consomme 60 mA. J’ai deux mètres de ruban avec 144 Leds par mètre soit 288 LEDs au total. La conso maxi sera de

0,060 x 288 = 17 A bon… ça fait beaucoup et je n’ai en stock qu’une alim de 5V/10A trouvée sur Aliexpress. Il faudra qu’elle fasse l’affaire 😛

L’alimentation du Raspberry Pi PICO (schéma ci-dessus) se fait en micro-USB. On voit que la borne VBUS (broche 40) permet d’entrer du 5 volt. c’est là que je vais injecter la tension de l’alimentation.

Voilà le schéma de branchement définitif. L’alimentation est connectée au Pico et au Ruban de LEDs. La sortie du Raspberry Pi Pico est en 3,3 volts, alors que le ruban de LEDs attend du 5 volts. Pour respecter les tensions il faudrait intercaler un convertisseur de niveau… Mais comme le 3,3 volts est au dessus du seuil de déclenchement de l’entrée du ruban… ça fonctionne et je ne m’en suis pas plus préoccupé.

Au passage notez que j’ai ajouté deux switch en bas à gauche, pour régler la luminosité et le sens de chute. Il suffira de tester ces deux entrées au lancement du programme pour adapter le fonctionnement aux conditions de l’expo où le montage sera utilisé.

Installer la librairie ws2812b.py

Maintenant que la quincaillerie est en place, on va pouvoir installer les logiciels. Il faut commencer par mettre dans le Pico la librairie de gestion des LEDs WS2812B. pour cela vous pouvez utiliser rshell en ligne de commande, ou le faire en mode graphique.
Comme cet article s’adresse plutôt à des débutants je vous propose de le faire avec Thonny.

Rendez vous sur la page web https://github.com/benevpi/pico_python_ws2812b, cliquez sur le bouton vert Code pour enregistrer l’archive .zip.

Faites un clic droit sur le fichier .zip puis Extraire ici. cela créera le dossier pico_python_ws2812b_main. Vous y trouverez la bibliothèque de fonctions ws2812b.py qui nous intéresse.

[stextbox id=’info’ caption=’Bibliothèque ws2812b’]Pour les sodomiseurs de diptères, je signale que je sais que cette bibliothèque est remplacée par https://github.com/blaz-r/pi_pico_neopixel qui gère en plus les Néopixels comportant 4 LEDs : R, V, B + une blanche. Mais cette bibliothèque ci suffit dans ce cas. Si vous en avez besoin… N’hésitez pas à utiliser la nouvelle.[/stextbox]

Ouvrez cette bibliothèque dans Thonny via Fichier > Ouvrir > Cet ordinateur

Vous disposez maintenant de la bibliothèque capable de gérer un certain nombre de fonctions pour les LEDs Neopixel du ruban de LEDs. Pour les curieux, c’est un bon moyen de découvrir comment les fonctions sont écrites.

Il reste à transférer la bibliothèque ws2812b.py dans le Pico : Cliquez sur Fichier > Enregistrer sous > Raspberry Pi Pico et donnez lui bien le nom suivant : ws2812b.py (en respectant les minuscules). C’est sous ce nom que notre programme va l’appeler et s’il y a une erreur dans le nom, il ne trouvera pas la librairie.

Programme de rebond des LEDs

Il reste à mettre en place le programme de rebond des LEDs. Vous pouvez le saisir à partir du listing ci-dessous ou le télécharger en cliquant sur ce lien : télécharger bouncing_led.    Et après vous direz que je ne suis pas gentil… Il y a aussi un programme de démo type arc-en-ciel pour le ruban de LEDs. Pour cette démo arc-en-ciel j’ai adapté le programme Adafruit pour le Raspberry Pi.

# Bouncing LED par KenKen pour le Raspberry Pi Pico
# Télécharger ws2812b.py avec le lien ci-dessous et
# enregistrez le sur le Raspberry Pi Pico avec le même nom
# https://github.com/benevpi/pico_python_ws2812b
# Version française framboise314 - Mai 2021

from machine import Pin
import time
import ws2812b

LED_NUM = 288                               # Nombre de Neopixels sur le ruban
DIN_GPIO = 0                                # GPIO sur lequel le ruban est connecté
SENS_GPIO = Pin(15, Pin.IN, Pin.PULL_UP)    # GPIO pour inverser le sens de défilement avec R de pull-up
LUMIERE_GPIO = Pin(14, Pin.IN, Pin.PULL_UP) # GPIO pour modifier la luminosité 40% ou 80% avec R de pull-up
REVERSE = False                             # If True, LED block will fall off from the end of the LED strip

BLOCK = 8      # Longueur d'un bloc de LEDs - Défaut 8
BRIGHT = 40    # Luminosité des LED - Défaut 40 
GRAVITY = 20   # Accélération de la gravité - Défaut 20

# Coefficient de rebond = R1/R2
R1 = 3         # Coefficient de rebond R1 - Défaut 3
R2 = 5         # Coefficient de rebond R2 - Défaut 5
REFMINV = -80  # Vitesse minimum de rebond (Ajuster si le rebond ne s'arrête pas) - Défaut -80

# création de l'instance du ruban
strip = ws2812b.ws2812b(LED_NUM, 0, DIN_GPIO)

def set_block(pos, c):
# Crée un bloc de LEDs
# pos: Position de début du bloc de LEDs
# c: Couleur 0=noir, 1=rouge ... 8=vert ... 16=bleu ... 24=rouge

    if c == 0:
        r = 0; g = 0; b = 0
    elif c <= 8:
        r = (8 - c) * BRIGHT >> 3
        g = c * BRIGHT >>3
        b = 0
    elif c <= 16:
        r = 0
        g = (16 - c) * BRIGHT >> 3
        b = (c - 8) * BRIGHT >> 3
    elif c <= 24:
        r = (c - 16) * BRIGHT >> 3
        g = 0
        b = (24 - c) * BRIGHT >> 3
    else:
        return
    for i in range(BLOCK):
        if pos < 0:
            return
        if REVERSE:
            strip.set_pixel(LED_NUM - pos -1, r, g, b)
        else:
            strip.set_pixel(pos, r, g, b)
        pos -= 1

col = 1 # Couleur du blog de LED qui chute

# Tester si on doit inverser le sens de chute
if SENS_GPIO.value() == 0 :
    REVERSE = True

# Modifier la luminosité à 80% - Défaut => 40%
if LUMIERE_GPIO.value() == 0 :
    BRIGHT = 80
    
    
while True:
    # Note: La position et la vitesse sont décalés de 8 bits vers la gauche pour travailler avec des entiers
    bottom = LED_NUM << 8 # Configurer la fin sur la dernière LED du ruban

    # Boucler la chute des blocs
    while bottom >0:      # Répéter jusqu'à ce que la fin dépasse le haut du ruban
        y = 0             # Début du bloc de LEDs
        v = 0             # Vitesse de chute
        while y < bottom: # Répéter tant que le bloc de Leds est au dessus de la fin
            set_block(y >> 8, col) # Configurer les LEDs du bloc
            strip.show()           # Afficher le ruban   
            time.sleep_ms(5)       # Attendre 5 ms 
            set_block(y >> 8, 0)   # Effacer les LEDs
            v += GRAVITY           # Mettre à jour la vitesse de chute
            y += v                 # Mettre à jour la position
            if y >= bottom:        # Quand on atteint la fin
                y = bottom - 256   #  Mettre la position du bloc de LEDs à Une position au dessus de la fin
                v = -v * R1 // R2  #  Rebondir
                if v > REFMINV:    #  Arrêter quand la vitesse de rebond est inférieure à REFMINV
                    set_block((bottom >> 8) - 1, col) # Fixer le bloc de LEDs à une position au dessus de la fin
                    bottom -= BLOCK << 8         # Augmenter la position de fin de la longueur d'un bloc
                    col = (col + 18) % 24 + 1    # Passer à la couleur suivante

    strip.show()
    time.sleep_ms(500)

    y = 0 # Position du bout de la ligne de LEDs
    v = 0 # Vitesse de chute

    # On vide toute la ligne de LEDs
    while y < (LED_NUM << 8): # Répéter jusqu'à la disparition de l'extrémité de la ligne de LEDs
        y += v                # Mettre à jour la position
        v += GRAVITY // 2     # Mettre à jour la vitesse de chute (avec frottement)
        for i in range(LED_NUM-1, (y >> 8) - 1, -1):
            y1 = (i << 8) + (y & 0xff) - v # Position actuelle de la LED arrivant en position 1
            if y1 >= y:       # Copier la couleur de la LED en position y1 en i
                if REVERSE:
                    strip.pixels[LED_NUM - i -1] = strip.pixels[LED_NUM - (y1 >> 8) -1]
                else :
                    strip.pixels[i] = strip.pixels[y1 >> 8]
            else:             # Eteindre les LEDs au dessus du bout de la ligne de LEDs
                if REVERSE:
                    strip.set_pixel(LED_NUM - i -1, 0, 0, 0)
                else :
                    strip.set_pixel(i, 0, 0, 0)
        strip.show()
        time.sleep_ms(5)

    time.sleep_ms(500)        # Attendre 500 ms

Vous pouvez modifier des paramètres tels que le nombre total de diodes, la longueur d’un bloc, l’accélération de la gravité et le coefficient de rebondissement.

Cliquez sur le bouton d’exécution de Thonny pour lancer le programme.

Lancement automatique du programme

Une fois que votre programme est définitif, vous pouvez le charger dans le Pico pour qu’il soit automatiquement exécuté à chaque démarrage

Enregistrez le programme bouncing_LED.py comme précédemment mais cette fois choisissez de l’enregistrer sur le Raspberry Pi Pico.

Donnez lui le nom main.py pour qu’il soit lancé automatiquement à chaque démarrage du Pico.

Supprimer main.py

Tout ça c’est bien joli, mais oups ! vous devez réutiliser le Pico pour un autre usage et il faut supprimer main.py. Pas de panique, je vous explique.

 

Quand vous lancez Thonny, puisque votre programme main.py est en cours d’exécution, il ne peut pas se connecter au Raspberry Pi Pico. Cliquez sur le bouton d’arrêt du programme.

Vous reprenez la main et le prompt de MicroPython s’affiche.

Cliquez sur Fichier > Ouvrir > Raspberry Pi Pico. La fenêtre qui s’ouvre vous affiche les fichiers présents sur le Pico.

Faites un clic droit sur main.py et sélectionnez supprimer dans le menu.

L’opération est irréversible. si vous cliquez sur Oui… main.py disparait.

Voilà vous venez de supprimer main.py et vous pouvez réutiliser votre Pico normalement. éventuellement supprimez aussi la bibliothèque ws2812b.py si vous n’en avez plus besoin.

Vidéo

 

La vidéo de KenKen avec un Arduino

Ma vidéo avec un Raspberry Pi Pico

 

Ce programme est libre : il peut être utilisé librement par tout le monde, y compris dans les lieux publics. Vous pouvez également le modifier. N’hésitez pas à l’utiliser.

 

Sources

• https://micropython.org/download/rp2-pico/
• https://fr.aliexpress.com/item/1005001380692187.html
• https://github.com/KenKenMkIISR/Bouncing-LED
• https://raw.githubusercontent.com/benevpi/pico_python_ws2812b/main/ws2812b.py
• https://raw.githubusercontent.com/KenKenMkIISR/Bouncing-LED/master/LED_bouncing_Pico.py