Skip to content

NeoPixel

NeoPixel Demo

NeoPixels are Red-Green-Blue LEDs that are assembled in a way that makes them easy to control with three wires: GND, +5V and a serial data line. They are very popular with our students because they are powerful, easy to program and full of bling.

Note

As of September of 2021 there is no built-in support for NeoPixels in the MicroPython runtime for the Raspberry Pi RP2040 microcontroller. Other microcontrollers (like the ESP32, ESP8266), NeoPixel support is built in to the runtime library. The RP2040 may have direct support in the future, but for the short time we will have to download a NeoPixel library or add a NeoPixel function to our code. To find out if your current runtime has support for the NeoPixel run the help('modules') command at the RPEL prompt.

Controlling NeoPixels is challenging since the timing of data being sent must be very precise. Python alone is not fast enough to send bits out of a serial port. So a small function that uses assembly code is used. This code can be called directly from a neopixel driver file so that the user's don't need to see this code.

MicroPython Example Code on ESP8266

Circuit connections

LED Strip Pico Name Pico Pin Description
GND GND 3 Ground
5v VBUS 40 Voltage from the USB bus. Top right with USB on top
Data GP0 1 Topmost left with USB on top

Setup Parameters

1
2
NUM_LEDS = 12
PIN_NUM = 0

Initialize the Strip Object

1
2
3
4
5
NUMBER_PIXELS = 12
STATE_MACHINE = 0
LED_PIN = 0
strip = Neopixel(NUMBER_PIXELS, STATE_MACHINE, LED_PIN, "GRB")

Turn all the Pixels Red

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from neopixel import Neopixel
NUMBER_PIXELS = 12
STATE_MACHINE = 0
LED_PIN = 0
strip = Neopixel(NUMBER_PIXELS, STATE_MACHINE, LED_PIN, "GRB")
for i in range(0, NUMBER_PIXELS):
    strip.set_pixel(i, (255,0,0))
strip.show()

Turn All the Pixels Red, Green and Blue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import time
# We are using https://github.com/blaz-r/pi_pico_neopixel
from neopixel import Neopixel
NUMBER_PIXELS = 12
STATE_MACHINE = 0
LED_PIN = 0
# We are using the GRB variety, not RGB
strip = Neopixel(NUMBER_PIXELS, STATE_MACHINE, LED_PIN, "GRB")
# set 100% brightness
strip.brightness(100)
delay = .1
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
while True:
    for i in range(0, NUMBER_PIXELS):
        strip.set_pixel(i, red)
        strip.show()
        time.sleep(delay)
    for i in range(0, NUMBER_PIXELS):
        strip.set_pixel(i, green)
        strip.show()
        time.sleep(delay)
    for i in range(0, NUMBER_PIXELS):
        strip.set_pixel(i, blue)
        strip.show()
        time.sleep(delay)

Full code (no library)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
# Example using PIO to drive a set of WS2812 LEDs.
import array, time
from machine import Pin
import rp2
# Configure the number of WS2812 LEDs.
NUM_LEDS = 60
PIN_NUM = 22
brightness = 0.2
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=24)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()
# Create the StateMachine with the ws2812 program, outputting on pin
sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(PIN_NUM))
# Start the StateMachine, it will wait for data on its FIFO.
sm.active(1)
# Display a pattern on the LEDs via an array of LED RGB values.
ar = array.array("I", [0 for _ in range(NUM_LEDS)])
##########################################################################
def pixels_show():
    dimmer_ar = array.array("I", [0 for _ in range(NUM_LEDS)])
    for i,c in enumerate(ar):
        r = int(((c >> 8) & 0xFF) * brightness)
        g = int(((c >> 16) & 0xFF) * brightness)
        b = int((c & 0xFF) * brightness)
        dimmer_ar[i] = (g<<16) + (r<<8) + b
    sm.put(dimmer_ar, 8)
    time.sleep_ms(10)
def pixels_set(i, color):
    ar[i] = (color[1]<<16) + (color[0]<<8) + color[2]
def pixels_fill(color):
    for i in range(len(ar)):
        pixels_set(i, color)
def color_chase(color, wait):
    for i in range(NUM_LEDS):
        pixels_set(i, color)
        time.sleep(wait)
        pixels_show()
    time.sleep(0.2)
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 rainbow_cycle(wait):
    for j in range(255):
        for i in range(NUM_LEDS):
            rc_index = (i * 256 // NUM_LEDS) + j
            pixels_set(i, wheel(rc_index & 255))
        pixels_show()
        time.sleep(wait)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)
WHITE = (255, 255, 255)
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)
print("fills")
for color in COLORS:
    pixels_fill(color)
    pixels_show()
    time.sleep(0.2)
print("chases")
for color in COLORS:
    color_chase(color, 0.01)
print("rainbow")
rainbow_cycle(0)

References

Core Electronics: How to use WS2812B RGB LEDs with Raspberry Pi Pico - HTML page, sample code and video

MicroPython Library for NeoPixel - note the lack of support for the RP2040 microcontroller.

rp2 port no module named array