NeoPixeles en CircuitPython

Los NeoPixeles son una forma revolucionaria y muy popular para agregarle luces y color a tu proyecto. Estas tiras de luces RGB tienen controladoras dentro de cada LED, así que solo le envías los datos RGB y los LEDs realizan todo el trabajo por ti. ¡Son la combinación perfecta para CircuitPython!

Puedes controlar 300 LEDs tipo NeoPixel con control de brillo (se le define brightness=1.0 a la hora de crear el objeto) y 1000 LEDs sin control de brillo. Esto porque el ajustar el brillo requiere que se regenere dinamicamente los datos a enviar, con cada escritura.

¡Vas a necesitar la librería neopixel.mpy si no las tienes ahorita en tu carperta /lib! La puedes obtener del Compilado de Librerías para CircuitPython. Si necesitas ayuda instalando la librería, puedes revisar la página de Librerías para CircuitPython.

Cableándolo

Primero, vas a necesitar soldar tus NeoPixeles. Verifica que tu conexión sea hacia el lado de DATA INPUT o DIN. ¡Conectarse a DATA OUT o a DOUT es un error común! Estas conexiones están etiquetadas y algunas tienen flechas para resaltar hacia donde deben fluir los datos.

Para alimentar los pixeles desde la tarjeta, el regulador de salida de 3.3V puede manejar picos de alrededor de 500mA, lo cual es suficiente para 50 pixeles de uso 'promedio'. Si quieres luces realmente brillantes y muchos pixeles, recomendamos alimentar directamente de una fuente externa.

  • En las Gemma M0 y las CircuitPlayground Express es con el pad de Vout - el pad tiene conexión directa de USB o de la batería, dependiendo de cual sea el voltaje mayor.
  • En las Trinket M0, Feather M0 Express, Feather M4 Express, ItsyBitsy M0 Express y ItsyBitsy M4 Express los pines de USB o BAT te van a dar alimentación directa del puerto USB o de la batería.
  • En las Metro M0 Express y las Metro M4 Express, utilice el pin de 5V sin importar si estás conectado por USB o por el conector de barril para DC.

Si la alimentación a los NeoPixeles es mayor a 5.5V vas a tener dificultar con algunas tiras, en cuyo caso puede que sea necesario que bajes el voltaje a 4.5V-5V o utilizar un level shifter.

¡No utilice el pin VIN de forma directa en las Metro M0 Express o Metro M4 Express! ¡El voltaje puede alcanzar los 9V y esto va a destruir tus NeoPixeles!
Tome nota que el orden de los cables en tu tira de NeoPixeles o su forma no sean exactamente igual al diagrama. Revise la tira por marcas que ayuden a verificar cual pin corresponde para DIN, 5V y GND.

El Código

Este ejemplo incluye múltiples efectos visuales. Copie y pegue el código en code.py utilizando tu editor favorito, y salve el archivo.

# CircuitPython demo - NeoPixel
import time
import board
import neopixel

pixel_pin = board.A1
num_pixels = 8

pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.3, auto_write=False)


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)


def color_chase(color, wait):
    for i in range(num_pixels):
        pixels[i] = color
        time.sleep(wait)
        pixels.show()
    time.sleep(0.5)


def rainbow_cycle(wait):
    for j in range(255):
        for i in range(num_pixels):
            rc_index = (i * 256 // num_pixels) + j
            pixels[i] = wheel(rc_index & 255)
        pixels.show()
        time.sleep(wait)


RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)

while True:
    pixels.fill(RED)
    pixels.show()
    # Increase or decrease to change the speed of the solid color change.
    time.sleep(1)
    pixels.fill(GREEN)
    pixels.show()
    time.sleep(1)
    pixels.fill(BLUE)
    pixels.show()
    time.sleep(1)

    color_chase(RED, 0.1)  # Increase the number to slow down the color chase
    color_chase(YELLOW, 0.1)
    color_chase(GREEN, 0.1)
    color_chase(CYAN, 0.1)
    color_chase(BLUE, 0.1)
    color_chase(PURPLE, 0.1)

    rainbow_cycle(0)  # Increase the number to slow down the rainbow

Creando el LED

Lo primero que tenemos que hacer es instanciar al objeto LED. El objeto para NeoPixel tiene dos parámetros que son requeridos y dos más que son opcionales. Vas a tener que indicarle cual es el pin que estás utilizando para controlar tus NeoPixeles y también decirle el número de pixeles que vas a utilizar en la tira. De forma opcional puedes definirle brightness y auto_write.

Los NeoPixeles se pueden manejar con cualquier pin. Hemos escogido A1. Para configurar el pin, asigne la variable  pixel_pin hacia el pin que desea utilizar, en nuestro caso board.A1.

Para definir la cantidad de pixeles en la tira, asigne a la variable num_pixels el número de pixeles que desea utilizar, en nuestro ejemplo una tira de8.

Hemos escogido definir el brillo en un 30% con brightness=0.3.

Para omisión, auto_write=True, que quiere decir que cualquier cambio que realices a los pixeles, se envía de forma automática. Como True es el valor por omisión, si quieres que sea de esta forma, no debes agregarle nada a tu objeto LED. Hemos escogido el definir auto_write=False. Si usted define auto_write=False, debe incluir pixels.show() cada vez que deseas enviar datos a tus pixeles. Esto hace que el código sea más complicado, ¡pero puede hacer que las animaciones sean más rápidas!

Utilitarios para NeoPixeles

Hemos incluído algunas funciones utilitarias para crear efectos visuales muy divertidos, que puedes encontrar en este código. El primero es wheel() de la cual acabamos de aprender en LED RGB Integrado. Luego tenemos color_chase() (persecución de color) la cual pide que le digas un color y la cantidad de segundos que deseas entre cada paso de la persecución. Luego tenemos a rainbow_cycle()(ciclo de arcoiris), la cual pide que le indices el tiempo en segundos que deseas que tome la animación. Por último, hemos incluído una lista de variables para nuestros colores. Esto hace mucho más sencillo reutilizar colores en cualquier lado del código, así como agregar más colores para usar en múltiples lugares. El asignar colores RGB ha sido explicado en esta sección sobre el LED RGB Integrado en CircuitPython.

Ciclo Principal

Gracias a nuestros utilitarios, el ciclo principal es muy sencillo. Hemos incluido el código para configurar todos los NeoPixeles que estamos usando a rojo, verde y azul por un segundo cada uno. Luego llamamos a color_chase(), una vez para cada color de nuestra lista, con una pausa de 0.1 segundos antes de cambiar el LED en la persecución. Por último llamamos a rainbow_cycle(0), lo que quiere decir que la animación es tan rápida como sea posible. ¡Aumente ambos números para bajar la velocidad de cada animación!

Tome nota que si utiliza una tira con más LEDs, va a tomar más tiempo para que las animaciones completen.

Tenemos mucho más conocimiento de propósito general sobre NeoPixeles en nuestra guía NeoPixel UberGuide https://learn.adafruit.com/adafruit-neopixel-uberguide

NeoPixeles RGBW

Los NeoPixeles se pueden conseguir en RGB que quiere decir que contiene tres LEDs, uno rojo, uno verde y uno azul. También se pueden conseguir RGBW, que quiere decir que contiene cuatro LEDS, rojo, verde, azul y blanco. El código para manejar NeoPixeles tipo RGBW es un poco diferente al de RGB.

Si trata de correr código de RGB con NeoPixeles de tipo RGBW, aproximadamente ¾ de los LEDs van a prender, y van a ser de un color incorrecto aunque se vea que están cambiando. Esto porque los NeoPixeles requieren que se les envíe un pedazo de información para cada color disponible (rojo, verde, azul y probablemente blanco).

De esta manera, los LEDs RGB requiere tres pedazos de información mientras que los LEDs RGBW requieren CUATRO piezas de información. Así que cuando cree un objeto de LED para trabajar con LEDs de tipo RGBW, les vas a agregar bpp=4, lo cual define la cantidad de pedazos de información por bit a cuatro (¡las cuatro piezas de información!).

Luego, debes incluir un número adicional en cada tupla de color que crees. Por ejemplo, rojo va a ser (255, 0, 0, 0). Así es como envías las cuarta pieza de información. ¡Revise el ejemplo a continuación para observar como se ve nuestro código usando LEDs de tipo RGBW!

# CircuitPython demo - NeoPixel RGBW

import time
import board
import neopixel

pixel_pin = board.A1
num_pixels = 8

pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.3, auto_write=False,
                           pixel_order=(1, 0, 2, 3))


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, 0)
    if pos < 85:
        return (255 - pos * 3, pos * 3, 0, 0)
    if pos < 170:
        pos -= 85
        return (0, 255 - pos * 3, pos * 3, 0)
    pos -= 170
    return (pos * 3, 0, 255 - pos * 3, 0)


def color_chase(color, wait):
    for i in range(num_pixels):
        pixels[i] = color
        time.sleep(wait)
        pixels.show()
    time.sleep(0.5)


def rainbow_cycle(wait):
    for j in range(255):
        for i in range(num_pixels):
            rc_index = (i * 256 // num_pixels) + j
            pixels[i] = wheel(rc_index & 255)
        pixels.show()
        time.sleep(wait)


RED = (255, 0, 0, 0)
YELLOW = (255, 150, 0, 0)
GREEN = (0, 255, 0, 0)
CYAN = (0, 255, 255, 0)
BLUE = (0, 0, 255, 0)
PURPLE = (180, 0, 255, 0)

while True:
    pixels.fill(RED)
    pixels.show()
    # Increase or decrease to change the speed of the solid color change.
    time.sleep(1)
    pixels.fill(GREEN)
    pixels.show()
    time.sleep(1)
    pixels.fill(BLUE)
    pixels.show()
    time.sleep(1)

    color_chase(RED, 0.1)  # Increase the number to slow down the color chase
    color_chase(YELLOW, 0.1)
    color_chase(GREEN, 0.1)
    color_chase(CYAN, 0.1)
    color_chase(BLUE, 0.1)
    color_chase(PURPLE, 0.1)

    rainbow_cycle(0)  # Increase the number to slow down the rainbow

Lea la Documentación

Para un vistazo a mayor profundidad de lo que neopixel puede hacer, revise NeoPixel en "Read the Docs".

This guide was first published on Jun 24, 2020. It was last updated on Jun 24, 2020.
This page (NeoPixeles en CircuitPython ) was last updated on Jul 07, 2020.