MicroPython : LED RVB adressables WS2812B avec ESP32 et ESP8266

Ce tutoriel montre comment contrôler les LED RVB adressables WS2812B (néopixels) avec l’ESP32 et l’ESP8266 à l’aide de MicroPython.

Il existe une bibliothèque intégrée dans MicroPython qui rend extrêmement facile le contrôle de ces LED : le
néopixel bibliothèque. Nous vous montrerons comment contrôler des LED individuelles, créer des fonctions pour produire des effets d’éclairage impressionnants et construire un projet simple pour illustrer comment tout fonctionne.

Ce tutoriel peut être appliqué à n’importe quelle bande ou carte PCB qui a des LED RVB adressables WS2812B (néopixels) comme :

Dans ce didacticiel, nous contrôlerons deux anneaux LED RVB adressables et un bâton LED adressable câblé en série.

Conditions préalables

Pour suivre ce tutoriel, vous devez avoir installé le firmware MicroPython sur votre ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

Présentation des LED RVB WS2812B

Les LED WS2812B sont des LED RVB adressables qui peuvent être connectées en série et contrôlées individuellement à l’aide d’une seule broche numérique d’un microcontrôleur. Ces LED ont un circuit intégré intégré directement dans la LED qui rend tout cela possible.

Vous pouvez souder plusieurs anneaux et bâtons LED et ils se comporteront comme une seule pièce. Chaque PCB a des broches IN et OUT qui rendent le câblage très simple :

La figure suivante montre à quoi ressemble notre configuration après avoir soudé les LED.

Câbler la bande LED RGB à l’ESP32 ou à l’ESP8266 est très simple. Vous devez appliquer 5V au VCC broche, GND à Terre et connectez un GPIO à la broche Din (données). Nous connecterons la broche de données à
GPIO 5.

Contrôle des LED RVB WS2812B

Il existe un module MicroPython intégré appelé néopixel pour contrôler les LED adressables WS2812B. Par exemple, le script suivant contrôle 4 pixels individuels :

# Complete project details at https://Raspberryme.com

import machine, neopixel

n = 48
p = 5

np = neopixel.NeoPixel(machine.Pin(p), n)

np[0] = (255, 0, 0)
np[3] = (125, 204, 223)
np[7] = (120, 153, 23)
np[10] = (255, 0, 153)
np.write()

Afficher le code brut

Importation de bibliothèques

Tout d’abord, importez le
néopixel et machine modules:

import machine, neopixel

Créer un objet néopixel

Définissez le nombre de pixels de votre bande sur le n variable:

n = 48

Enregistrez le numéro GPIO qui contrôlera la bande sur le p variable:

p = 5

Créez un objet NeoPixel appelé
np sur le GPIO que vous avez défini précédemment et avec le nombre de LED que vous avez également défini :

np = neopixel.NeoPixel(machine.Pin(p), n)

Contrôle des pixels individuels

Après avoir initialisé l’objet neopixel, vous pouvez commencer à contrôler les LED. Contrôler un pixel individuel est très facile. Vous pouvez considérer la bande comme un tableau avec néléments (nombre de pixels dans cette bande échantillon). Ensuite, il nous suffit de définir une couleur pour un élément spécifique. Par exemple, pour définir le premier pixel sur rouge :

np[0] = (255, 0, 0)

La figure suivante peut vous aider à mieux comprendre son fonctionnement :

Ensuite, utilisez le écrivez() méthode pour que les modifications prennent effet.

np.write()

Effets d’éclairage des LED RVB WS2812

Maintenant que vous savez contrôler les pixels individuels, vous pouvez créer vos propres effets d’éclairage. Nous fournirons quelques fonctions (basées sur les exemples de la bibliothèque) que vous pourrez utiliser dans vos propres projets.

Effacer tous les pixels

Effacer tous les pixels revient à régler tous les pixels sur la couleur (0, 0, 0).

def clear():
  for i in range(n):
    np[i] = (0, 0, 0)
    np.write()

Définir tous les pixels sur la même couleur

De la même manière, pour définir tous les pixels sur la même couleur, vous pouvez utiliser la fonction suivante qui accepte comme arguments les paramètres de couleur r, g et b .

def set_color(r, g, b):
  for i in range(n):
    np[i] = (r, g, b)
  np.write()

Effet rebond

le rebondir() La fonction crée un effet de rebond et accepte les paramètres r, g et b pour définir la couleur et le temps d’attente. Le temps d’attente détermine la rapidité de l’effet de rebond.

def bounce(r, g, b, wait):
  for i in range(4 * n):
    for j in range(n):
      np[j] = (r, g, b)
    if (i // n) % 2 == 0:
      np[i % n] = (0, 0, 0)
    else:
      np[n – 1 – (i % n)] = (0, 0, 0)
    np.write()
    time.sleep_ms(wait)

Cet effet montre un pixel désactivé qui traverse toutes les positions de la bande.

Effet cycle

L’effet de cycle fonctionne de la même manière que l’effet de rebond. Il y a un pixel allumé qui traverse toutes les positions de la bande tandis que les autres pixels sont éteints.

def cycle(r, g, b, wait):
  for i in range(4 * n):
    for j in range(n):
      np[j] = (0, 0, 0)
    np[i % n] = (r, g, b)
    np.write()
    time.sleep_ms(wait)

Effet arc-en-ciel mobile

Pour produire un effet arc-en-ciel en mouvement, vous avez besoin de deux fonctions. le roue() La fonction génère le spectre de couleurs arc-en-ciel en faisant varier chaque paramètre de couleur entre 0 et 255.

def wheel(pos):
  Input a value 0 to 255 to get a color value.
  The colours are a transition r - g - b - back to r.
  if pos < 0 or pos > 255:
    return (0, 0, 0)
  if pos < 85:
    return (255 - pos * 3, pos * 3, 0)
  if pos < 170:
    pos -= 85
    return (0, 255 - pos * 3, pos * 3)
  pos -= 170
  return (pos * 3, 0, 255 - pos * 3)

Après cela, utilisez le cycle_arc-en-ciel() fonction qui utilise les résultats de la roue() fonction pour répartir l’arc-en-ciel sur le nombre de LED de votre bande.

def rainbow_cycle(wait):
  for j in range(255):
    for i in range(n):
      rc_index = (i * 256 // n) + j
      np[i] = wheel(rc_index & 255)
    np.write()
    time.sleep_ms(wait)

Cette fonction prend en argument le temps d’attente. Le temps d’attente définit la vitesse à laquelle l’effet arc-en-ciel se déplace.

Connaissant le fonctionnement de ces fonctions, vous pouvez créer vos propres projets pour produire des effets d’éclairage étonnants. Pour voir comment tout fonctionne ensemble, dans la section suivante, nous allons construire un projet simple pour contrôler un tas de LED RVB adressables.

LED RVB WS2812B avec MicroPython : exemple de projet

Ici, nous allons construire un circuit simple avec 4 boutons poussoirs. Il produira différents effets d’éclairage en fonction du bouton-poussoir enfoncé.

Pièces requises

Dans ce projet, nous utilisons deux anneaux LED RVB adressables de différentes tailles et un bâton LED RVB adressable. Cependant, vous pouvez utiliser une bande LED RVB ou des LED RVB adressables dans d’autres configurations.

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schématique

Dans ESP32 et ESP8266, nous câblerons le circuit comme suit :

Noter: vous pouvez choisir n’importe quelle autre broche numérique, si nécessaire.

ESP32

Vous pouvez également suivre le diagramme schématique suivant pour câbler le circuit pour ESP32 :

ESP8266

Suivez le diagramme schématique suivant si vous utilisez un EPS8266 :

Code

Téléchargez le code suivant sur votre ESP32 ou ESP8266 en tant que main.py.

# Complete project details at https://Raspberryme.com

from machine import Pin
import machine, neopixel, time

# define interrupt handling functions
def button_handler(pin):
  global button_pressed
  button_pressed = pin

# configure pushbuttons as interrupts
button1 = Pin(15, Pin.IN)
button1.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button2 = Pin(14, Pin.IN)
button2.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button3 = Pin(12, Pin.IN)
button3.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button4 = Pin(13, Pin.IN)
button4.irq(trigger=Pin.IRQ_RISING, handler=button_handler)

button_pressed = button1

# LED strip configuration
# number of pixels
n = 48
# strip control gpio
p = 5 
np = neopixel.NeoPixel(machine.Pin(p), n)

# FUNCTIONS FOR LIGHTING EFFECTS
# bounce
def bounce(r, g, b, wait):
  for i in range(2 * n):
    for j in range(n):
      np[j] = (r, g, b)
    if (i // n) % 2 == 0:
      np[i % n] = (0, 0, 0)
    else:
      np[n - 1 - (i % n)] = (0, 0, 0)
    np.write()
    time.sleep_ms(wait)

# cycle
def cycle(r, g, b, wait):
  for i in range(n):
    for j in range(n):
      np[j] = (0, 0, 0)
    np[i % n] = (r, g, b)
    np.write()
    time.sleep_ms(wait)

# function to go through all colors 
def wheel(pos):
  # Input a value 0 to 255 to get a color value.
  # The colours are a transition r - g - b - back to r.
  if pos < 0 or pos > 255:
    return (0, 0, 0)
  if pos < 85:
    return (255 - pos * 3, pos * 3, 0)
  if pos < 170:
    pos -= 85
    return (0, 255 - pos * 3, pos * 3)
  pos -= 170
  return (pos * 3, 0, 255 - pos * 3)

# rainbow 
def rainbow_cycle(wait):
  for j in range(255):
    for i in range(n):
      rc_index = (i * 256 // n) + j
      np[i] = wheel(rc_index & 255)
    np.write()
    time.sleep_ms(wait)

# turn off all pixels
def clear():
  for i in range(n):
    np[i] = (0, 0, 0)
    np.write()

while True:
  if button_pressed == button1:
    clear()
  elif button_pressed == button2:
    bounce(23, 210, 15, 70)
  elif button_pressed == button3:
    cycle(123, 0, 154, 50)
  elif button_pressed == button4:
    rainbow_cycle(1)

Afficher le code brut

Comment fonctionne le code

Continuez à lire cette section si vous voulez savoir comment fonctionne le code. Sinon, vous pouvez passer à la section « Démonstration ».

Commencez par importer les bibliothèques nécessaires :

from machine import Pin
import machine, neopixel, time

Les boutons-poussoirs seront définis comme des interruptions. Nous devons donc créer une fonction de gestion des interruptions qui s’exécutera à chaque fois qu’une interruption se produit – dans ce cas, le bouton_handler() une fonction.

def button_handler(pin):
  global button_pressed
  button_pressed = pin

La fonction de gestion des interruptions a un paramètre d’entrée (épingler) dans lequel un objet de classe Épingler sera passé lorsque l’interruption se produira. Cela nous permet de savoir quelle broche a généré l’interruption.

Dans notre exemple, la fonction d’interruption de poignée est appelée bouton_handler et il enregistre le bouton-poussoir qui a été appuyé sur le bouton_pressé variable.

def button_handler(pin):
  global button_pressed
  button_pressed = pin

Noter: bouton_pressé est définie comme une variable globale, car nous voulons qu’elle soit accessible dans tout le code, pas seulement à l’intérieur du bouton_handler() une fonction.

Après cela, configurez les boutons-poussoirs en tant que broches d’interruption :

button1 = Pin(15, Pin.IN)
button1.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button2 = Pin(14, Pin.IN)
button2.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button3 = Pin(12, Pin.IN)
button3.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button4 = Pin(13, Pin.IN)
button4.irq(trigger=Pin.IRQ_RISING, handler=button_handler)

Par défaut, le bouton_pressé la variable est égale à bouton1, car ce bouton efface les voyants et nous voulons qu’ils soient éteints par défaut.

button_pressed = button1

Ensuite, nous créons un objet neopixel sur
GPIO 5, avec 48 LED. Vous devriez changer le n variable avec le nombre de LED que vous contrôlez.

n = 48 # number of pixels
p = 5  # strip control gpio
np = neopixel.NeoPixel(machine.Pin(p), n)

Après cela, nous définissons les fonctions que nous avons vues dans une section précédente : rebondir(),cycle(), roue(), cycle_arc-en-ciel(),etdégager().

Dans la boucle while, nous vérifions quel bouton a été pressé et appelons une fonction différente selon le bouton pressé :

• Bouton 1 : efface la bande (tous les néopixels éteints)
• Bouton 2 : effet rebond
• Bouton 3 : effet cycle
• Bouton 4 : effet arc-en-ciel

while True:
  if button_pressed == button1:
    clear()
  elif button_pressed == button2:
    bounce(23, 210, 15, 10)
  elif button_pressed == button3:
    cycle(123, 0, 154, 20)
  elif button_pressed == button4:
    rainbow_cycle(1)

Noter: vous pouvez modifier les arguments des fonctions précédentes pour définir les LED dans des couleurs différentes ou ajuster le attendre paramètre pour rendre l’effet plus rapide ou plus lent.

Manifestation

Après avoir téléchargé le code précédent sur votre ESP32 ou ESP8266 en tant que main.py, appuyez sur le bouton ESP Enable/Reset pour exécuter le nouveau code.

Appuyez sur chaque bouton-poussoir pour produire différents effets. Vous pouvez regarder la vidéo ci-dessous pour une démonstration en direct :

Noter: lorsque vous appuyez sur le bouton poussoir pour sélectionner un effet, celui-ci ne démarre que lorsque l’effet en cours s’arrête.

Conclusion

Dans ce didacticiel, vous avez appris à contrôler les LED RVB adressables WS2812B (anneaux, bandes ou bâtons). Le contrôle de ces LED avec MicroPython est simple grâce au néopixel bibliothèque. Vous avez également appris à définir plusieurs interruptions avec MicroPython.

Maintenant, vous pouvez appliquer les concepts appris dans ce didacticiel dans vos propres projets. Par exemple, vous pouvez créer un serveur Web avec différents boutons qui contrôlent les LED à distance.

Nous avons d’autres tutoriels sur les LED RVB qui pourraient vous plaire :

Autres tutoriels sur MicroPython et ESP32 et ESP8266 :

Nous espérons que vous avez apprécié ce projet et appris quelque chose de nouveau.

Merci d’avoir lu.