差别

这里会显示出您选择的修订版和当前版本之间的差别。

--- mp_ws2812 [2021/09/30 12:06]
gongyusu 创建
+++ mp_ws2812 [2021/10/16 15:29] (当前版本)
gongyusu [1. 连线图]
@@ 行 1: / 行 1: @@
 ## WS2812B RGB三色灯的控制
-### neopixel.py
+  - [[https://makersportal.com/blog/ws2812-ring-light-with-raspberry-pi-pico|ws2812的控制]]
+  - [[https://github.com/makerportal/rpi-pico-ws2812|Github上的资源整理]]
+{{ :ws2812timing.png |}}
+### WS2812B教程内容
+[[mp_ws2812b|]]
+### 1. 连线图
+The wiring diagram between the Raspberry Pi Pico and a 16-pixel RGB LED ring light is shown below:
+Wiring Diagram
+The pinout wiring is also given in the table below:
+Power Supply	Pico	Ring Light
++	N/A	5V
+N/A	GPIO13	DI
+-	GND	GND
+Most of the GPIO pins can be used to control the WS2812 LED array, thus, the specification of GPIO13 for controlling the light is arbitrary. Be sure to change the pin in the codes as well, if using another pin for wiring.
+{{::WS2812_Pin.png|}}
+### 2. ws2812的使用示例
+The 16-Pixel RGB LED ring light array will be controlled using the scheme outlined in the Raspberry Pi Pico MicroPython getting started document, where we can get started with the tutorial entitled “Using PIO to drive a set of NeoPixel Ring (WS2812 LEDs).” The tutorial contains a script that will be used to create a state machine on the RPi Pico. The state machine will be used to control the LEDs on the ring light using a single pin on the Pico (GPIO13 in the wiring above). The full MicroPython example script can also be found at the Raspberry Pi Pico’s NeoPixel Ring repository.
+The code to start the state machine on the Pico's GPIO pin #20 is given below:
 <code python>
+# Example using PIO to drive a set of WS2812 LEDs.
 import array, time
 from machine import Pin
 import rp2
-# PIO state machine for RGB. Pulls 24 bits (rgb -> 3 * 8bit) automatically
+# Configure the number of WS2812 LEDs.
+NUM_LEDS = 16
+PIN_NUM = 6
+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()
-# PIO state machine for RGBW. Pulls 32 bits (rgbw -> 4 * 8bit) automatically
-@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=32)
-def sk6812():
     T1 = 2
     T2 = 5
@@ 行 38: / 行 55: @@
-# Delay here is the reset time. You need a pause to reset the LED strip back to the initial LED
+# Create the StateMachine with the ws2812 program, outputting on pin
-# however, if you have quite a bit of processing to do before the next time you update the strip
+sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(PIN_NUM))
-# you could put in delay=0 (or a lower delay)
-#
-# Class supports different order of individual colors (GRB, RGB, WRGB, GWRB ...). In order to achieve
-# this, we need to flip the indexes: in 'RGBW', 'R' is on index 0, but we need to shift it left by 3 * 8bits,
-# so in it's inverse, 'WBGR', it has exactly right index. Since micropython doesn't have [::-1] and recursive rev()
-# isn't too efficient we simply do that by XORing (operator ^) each index with 3 (0b11) to make this flip.
-# When dealing with just 'RGB' (3 letter string), this means same but reduced by 1 after XOR!.
-# Example: in 'GRBW' we want final form of 0bGGRRBBWW, meaning G with index 0 needs to be shifted 3 * 8bit ->
-# 'G' on index 0: 0b00 ^ 0b11 -> 0b11 (3), just as we wanted.
-# Same hold for every other index (and - 1 at the end for 3 letter strings).
-class Neopixel:
+# Start the StateMachine, it will wait for data on its FIFO.
-    def __init__(self, num_leds, state_machine, pin, mode="RGB", delay=0.0001):
+sm.active(1)
-        self.pixels = array.array("I", [0 for _ in range(num_leds)])
-        self.mode = set(mode)   # set for better performance
-        if 'W' in self.mode:
-            # RGBW uses different PIO state machine configuration
-            self.sm = rp2.StateMachine(state_machine, sk6812, freq=8000000, sideset_base=Pin(pin))
-            # dictionary of values required to shift bit into position (check class desc.)
-            self.shift = {'R': (mode.index('R') ^ 3) * 8, 'G': (mode.index('G') ^ 3) * 8,
-                          'B': (mode.index('B') ^ 3) * 8, 'W': (mode.index('W') ^ 3) * 8}
-        else:
-            self.sm = rp2.StateMachine(state_machine, ws2812, freq=8000000, sideset_base=Pin(pin))
-            self.shift = {'R': ((mode.index('R') ^ 3) - 1) * 8, 'G': ((mode.index('G') ^ 3) - 1) * 8,
-                          'B': ((mode.index('B') ^ 3) - 1) * 8, 'W': 0}
-        self.sm.active(1)
-        self.num_leds = num_leds
-        self.delay = delay
-        self.brightnessvalue = 255
-    # Set the overal value to adjust brightness when updating leds
+# Display a pattern on the LEDs via an array of LED RGB values.
-    def brightness(self, brightness=None):
+ar = array.array("I", [0 for _ in range(NUM_LEDS)])
-        if brightness == None:
-            return self.brightnessvalue
-        else:
-            if brightness < 1:
-                brightness = 1
-        if brightness > 255:
-            brightness = 255
-        self.brightnessvalue = brightness
-    # Create a gradient with two RGB colors between "pixel1" and "pixel2" (inclusive)
+##########################################################################
-    # Function accepts two (r, g, b) / (r, g, b, w) tuples
+def pixels_show():
-    def set_pixel_line_gradient(self, pixel1, pixel2, left_rgb_w, right_rgb_w):
+    dimmer_ar = array.array("I", [0 for _ in range(NUM_LEDS)])
-        if pixel2 - pixel1 == 0:
+    for i,c in enumerate(ar):
-            return
+        r = int(((c >> 8) & 0xFF) * brightness)
-        right_pixel = max(pixel1, pixel2)
+        g = int(((c >> 16) & 0xFF) * brightness)
-        left_pixel = min(pixel1, pixel2)
+        b = int((c & 0xFF) * brightness)
+        dimmer_ar[i] = (g<<16) + (r<<8) + b
+    sm.put(dimmer_ar, 8)
+    time.sleep_ms(10)
-        for i in range(right_pixel - left_pixel + 1):
+def pixels_set(i, color):
-            fraction = i / (right_pixel - left_pixel)
+    ar[i] = (color[1]<<16) + (color[0]<<8) + color[2]
-            red = round((right_rgb_w[0] - left_rgb_w[0]) * fraction + left_rgb_w[0])
-            green = round((right_rgb_w[1] - left_rgb_w[1]) * fraction + left_rgb_w[1])
-            blue = round((right_rgb_w[2] - left_rgb_w[2]) * fraction + left_rgb_w[2])
-            # if it's (r, g, b, w)
-            if len(left_rgb_w) == 4 and 'W' in self.mode:
-                white = round((right_rgb_w[3] - left_rgb_w[3]) * fraction + left_rgb_w[3])
-                self.set_pixel(left_pixel + i, (red, green, blue, white))
-            else:
-                self.set_pixel(left_pixel + i, (red, green, blue))
-    # Set an array of pixels starting from "pixel1" to "pixel2" (inclusive) to the desired color.
+def pixels_fill(color):
-    # Function accepts (r, g, b) / (r, g, b, w) tuple
+    for i in range(len(ar)):
-    def set_pixel_line(self, pixel1, pixel2, rgb_w):
+        pixels_set(i, color)
-        for i in range(pixel1, pixel2 + 1):
-            self.set_pixel(i, rgb_w)
-    # Set red, green and blue value of pixel on position <pixel_num>
+def color_chase(color, wait):
-    # Function accepts (r, g, b) / (r, g, b, w) tuple
+    for i in range(NUM_LEDS):
-    def set_pixel(self, pixel_num, rgb_w):
+        pixels_set(i, color)
-        pos = self.shift
+        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)
-        red = round(rgb_w[0] * (self.brightness() / 255))
+BLACK = (0, 0, 0)
-        green = round(rgb_w[1] * (self.brightness() / 255))
+RED = (255, 0, 0)
-        blue = round(rgb_w[2] * (self.brightness() / 255))
+YELLOW = (255, 150, 0)
-        white = 0
+GREEN = (0, 255, 0)
-        # if it's (r, g, b, w)
+CYAN = (0, 255, 255)
-        if len(rgb_w) == 4 and 'W' in self.mode:
+BLUE = (0, 0, 255)
-            white = round(rgb_w[3] * (self.brightness() / 255))
+PURPLE = (180, 0, 255)
+WHITE = (255, 255, 255)
+COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)
-        self.pixels[pixel_num] = white << pos['W'] | blue << pos['B'] | red << pos['R'] | green << pos['G']
+print("fills")
+for color in COLORS:
+    pixels_fill(color)
+    pixels_show()
+    time.sleep(0.2)
-    # Converts HSV color to rgb tuple and returns it
+print("chases")
-    # Function accepts integer values for <hue>, <saturation> and <value>
+for color in COLORS:
-    # The logic is almost the same as in Adafruit NeoPixel library:
+    color_chase(color, 0.01)
-    # https://github.com/adafruit/Adafruit_NeoPixel so all the credits for that
-    # go directly to them (license: https://github.com/adafruit/Adafruit_NeoPixel/blob/master/COPYING)
-    def colorHSV(self, hue, sat, val):
-        if hue >= 65536:
-            hue %= 65536
-        hue = (hue * 1530 + 32768) // 65536
+print("rainbow")
-        if hue < 510:
+rainbow_cycle(0)
-            b = 0
-            if hue < 255:
-                r = 255
-                g = hue
-            else:
-                r = 510 - hue
-                g = 255
-        elif hue < 1020:
-            r = 0
-            if hue < 765:
-                g = 255
-                b = hue - 510
-            else:
-                g = 1020 - hue
-                b = 255
-        elif hue < 1530:
-            g = 0
-            if hue < 1275:
-                r = hue - 1020
-                b = 255
-            else:
-                r = 255
-                b = 1530 - hue
-        else:
-            r = 255
-            g = 0
-            b = 0
-        v1 = 1 + val
-        s1 = 1 + sat
-        s2 = 255 - sat
-        r = ((((r * s1) >> 8) + s2) * v1) >> 8
-        g = ((((g * s1) >> 8) + s2) * v1) >> 8
-        b = ((((b * s1) >> 8) + s2) * v1) >> 8
-        return r, g, b
-    # Rotate <num_of_pixels> pixels to the left
-    def rotate_left(self, num_of_pixels):
-        if num_of_pixels == None:
-            num_of_pixels = 1
-        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]
-    # Rotate <num_of_pixels> pixels to the right
-    def rotate_right(self, num_of_pixels):
-        if num_of_pixels == None:
-            num_of_pixels = 1
-        num_of_pixels = -1 * num_of_pixels
-        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]
-    # Update pixels
-    def show(self):
-        # If mode is RGB, we cut 8 bits of, otherwise we keep all 32
-        cut = 8
-        if 'W' in self.mode:
-            cut = 0
-        for i in range(self.num_leds):
-            self.sm.put(self.pixels[i], cut)
-        time.sleep(self.delay)
-    # Set all pixels to given rgb values
-    # Function accepts (r, g, b) / (r, g, b, w)
-    def fill(self, rgb_w):
-        for i in range(self.num_leds):
-            self.set_pixel(i, rgb_w)
-        time.sleep(self.delay)
 </code>