MicroPython : LED RVB adressables WS2812B avec ESP32 et ESP8266

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.

ws2812b led rvb adressable micropython esp32 esp8266

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.

WS2812B adressable RGB LED Strips, anneaux, PCB sticks

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.

adressable ws2812 rvb led neopixel

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 :

1642324329 328 MicroPython LED RVB adressables WS2812B avec ESP32 et ESP8266

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

ws2812b neopixel câblé en série

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 :

ws2812b contrôle les pixels individuels micropython

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

np.write()
ws2812b contrôle les pixels individuels micropython

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()
1642324329 544 MicroPython LED RVB adressables WS2812B avec ESP32 et ESP8266

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()
1642324329 605 MicroPython LED RVB adressables WS2812B avec ESP32 et ESP8266

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.

1642324329 78 MicroPython LED RVB adressables WS2812B avec ESP32 et ESP8266

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)
1642324329 602 MicroPython LED RVB adressables WS2812B avec ESP32 et ESP8266

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.

1642324329 521 MicroPython LED RVB adressables WS2812B avec ESP32 et ESP8266

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é.

led ws2812b avec circuit micropython esp32 esp8266

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 !

1642324329 666 MicroPython LED RVB adressables WS2812B avec ESP32 et ESP8266

Schématique

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

Bouton 1 GPIO 14
Bouton 2 GPIO 12
Bouton 3 GPIO 13
Bouton 4 GPIO 15
Broche de données LED RVB adressable GPIO 5

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 :

bouton poussoir esp32 neopixel projet ws2812b

ESP8266

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

esp8266 bouton-poussoir neopixel projet ws2812b

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.

Emballer

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.

  • BTF-LIGHTING WS2812B Fils en alliage ECO RVB 5050SMD Individuel adressable 8X32 256 pixels Matrice LED FPCB polychrome flexible Fonctionne avec les contrôleurs K-1000C,SP107E,etc.
    Économique et pratique, rentable. Le fil en alliage n'est pas aussi cher que le fil d'or pur, réduit le coût d'utilisation.Idéal pour les petits projets et les débutants.Plus de choix pour les clients. 8X32 256Pixels. 32 pixels horizontaux et 8 pixels verticaux. Largeur: 8 cm (3,15 pouces) Longueur: 32 cm (12,59 pouces) .Très intelligent. Chaque LED est adressable individuellement. Vous pouvez régler chaque LED comme vous le souhaitez pour faire défiler les messages ou dessiner de petites images. Large compatibilité. Il fonctionne parfaitement avec Arduino, Raspberry Pi, la bibliothèque FastLED, la bibliothèque Rainbowduino, SP107E, K1000C, T1000S, etc. et effet de poursuite. Conception chaînable et pliable. Vous pouvez étendre le panneau en les raccordant un par un avec les connecteurs JST à 3 broches. Le FPCB flexible peut être légèrement plié et courbé autour des surfaces. Peut être épissé en un grand écran pixel. Économise ton argent. Il fonctionne presque comme NeoPixel mais beaucoup moins cher que NeoPixel. Il est robuste, beau et très comparable à d'autres produits similaires. Faire des écrans LED, des panneaux publicitaires, appliquer à l'hôtel, au KTV, aux bars, aux enseignes publicitaires extérieures, à la décoration de fête de Noël ou de mariage, il a de la colle adhésive à l'arrière, de sorte que vous pouvez le coller au mur ou à d'autres objets à votre guise.
  • BTF-LIGHTING Numérique Adressable Led Music Controller X2 (X1 version mise à jour) Pour WS2811 WS2812B WS2815 6803 WS2813 Led bande. DC5C-24V
    DC5-24V . WS2811/WS2812B/USC1903/WS2815 LED pixel strip,module,bulb,can control max 1000ICs .You can chose 1903IC or 6812 IC chip for WS2812B led strips.lighting effect vedio£ºhttps://youtu.be/Q24vOk9DQ18 3.5MM Audio Input Port. There are will be up to 27 types music-controlling mode and 14 type NO-MUSIC control mode,free to switch.Avoiding the noise from outside. https://youtu.be/Q24vOk9DQ18 For example 2001/2002/2003 music program .It¡¯s jump Height is according to Music Rhythm ,Audio Volume and the Audio Sensitive Knob on the receiver.If you want to have a better effect you should read the user manual. Every music program is adjusted. Not every music program¡¯s jump height is according to the music Rhythm .the user manual will show you every music program description and remark. It's multi-function wireless touch remote control,Used conveniently at night with LED backlight.The remote control distance can up to 20 meters.