def begin(self): """Initialize library, must be called once before other functions are called. """ resp = ws.ws2811_init(self._leds) if resp != 0: raise RuntimeError('ws2811_init failed with code {0}'.format(resp))
def begin(self): """Initialize library, must be called once before other functions are called. """ resp = ws.ws2811_init(self._leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format(resp, message))
def colorChange(color): print(color) # LED configuration. LED_CHANNEL = 0 LED_COUNT = 16 # How many LEDs to light. LED_FREQ_HZ = 800000 # Frequency of the LED signal. Should be 800khz or 400khz. LED_DMA_NUM = 5 # DMA channel to use, can be 0-14. LED_GPIO = 18 # GPIO connected to the LED signal line. Must support PWM! LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest LED_INVERT = 0 # Set to 1 to invert the LED signal, good if using NPN # transistor as a 3.3V->5V level converter. Keep at 0 # for a normal/non-inverted signal. leds = ws.new_ws2811_t() # Initialize all channels to off for channum in range(2): channel = ws.ws2811_channel_get(leds, channum) ws.ws2811_channel_t_count_set(channel, 0) ws.ws2811_channel_t_gpionum_set(channel, 0) ws.ws2811_channel_t_invert_set(channel, 0) ws.ws2811_channel_t_brightness_set(channel, 0) channel = ws.ws2811_channel_get(leds, LED_CHANNEL) ws.ws2811_channel_t_count_set(channel, LED_COUNT) ws.ws2811_channel_t_gpionum_set(channel, LED_GPIO) ws.ws2811_channel_t_invert_set(channel, LED_INVERT) ws.ws2811_channel_t_brightness_set(channel, LED_BRIGHTNESS) ws.ws2811_t_freq_set(leds, LED_FREQ_HZ) ws.ws2811_t_dmanum_set(leds, LED_DMA_NUM) # Initialize library with LED configuration. resp = ws.ws2811_init(leds) if resp != 0: raise RuntimeError('ws2811_init failed with code {0}'.format(resp)) try: DOT_COLOR = int(color[1:7],16) # Update each LED color in the buffer. for i in range(LED_COUNT): # Pick a color based on LED position and an offset for animation. # Set the LED color buffer value. ws.ws2811_led_set(channel, i, DOT_COLOR) time.sleep(.15) # Send the LED color data to the hardware. resp = ws.ws2811_render(leds) if resp != 0: raise RuntimeError('ws2811_render failed with code {0}'.format(resp)) # Delay for a small period of time. time.sleep(.25) finally: # Ensure ws2811_fini is called before the program quits. ws.ws2811_fini(leds) # Example of calling delete function to clean up structure memory. Isn't # strictly necessary at the end of the program execution here, but is good practice. ws.delete_ws2811_t(leds)
def __init__(self, device): # Call the constructor of the base class. super(OutputRaspi, self).__init__(device) import _rpi_ws281x as ws # pylint: disable=import-error output_id = "output_raspi" # LED strip configuration: self._led_count = int( self._device_config["LED_Count"]) # Number of LED pixels. self._led_pin = int( self._device_config["output"][output_id] ["LED_Pin"]) # GPIO pin connected to the pixels (18 uses PWM!). self._led_freq_hz = int( self._device_config["output"][output_id] ["LED_Freq_Hz"]) # LED signal frequency in hertz (usually 800khz) self._led_dma = int( self._device_config["output"][output_id] ["LED_Dma"]) # DMA channel to use for generating signal (try 10) self._led_brightness = int( self._device_config["output"][output_id] ["LED_Brightness"]) # Set to 0 for darkest and 100 for brightest self._led_invert = int( self._device_config["output"][output_id]["LED_Invert"] ) # True to invert the signal (when using NPN transistor level shift) self._led_channel = int( self._device_config["output"][output_id] ["LED_Channel"]) # set to '1' for GPIOs 13, 19, 41, 45 or 53 self._led_brightness_translated = int(255 * (self._led_brightness / 100)) print("LED Brightness: " + str(self._led_brightness)) print("LED Brightness Translated: " + str(self._led_brightness_translated)) self._leds = ws.new_ws2811_t() self.channel = ws.ws2811_channel_get(self._leds, 0) ws.ws2811_channel_t_count_set(self.channel, self._led_count) ws.ws2811_channel_t_gpionum_set(self.channel, self._led_pin) ws.ws2811_channel_t_invert_set(self.channel, self._led_invert) ws.ws2811_channel_t_brightness_set(self.channel, self._led_brightness_translated) ws.ws2811_t_freq_set(self._leds, self._led_freq_hz) ws.ws2811_t_dmanum_set(self._leds, self._led_dma) # Initialize library with LED configuration. resp = ws.ws2811_init(self._leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format( resp, message))
def init(maxBrightness=10): global LED_COUNT global LED_BRIGHTNESS global LED_GPIO global CHANNEL global LEDS if (LEDS == False): LEDS = ws.new_ws2811_t() else: # Ensure ws2811_fini is called before the program quits. ws.ws2811_fini(LEDS) # Example of calling delete function to clean up structure memory. Isn't # strictly necessary at the end of the program execution here, but is good practice. ws.delete_ws2811_t(LEDS) LEDS = ws.new_ws2811_t() SPLIT_LED_COUNT = [420, 402] LED_COUNT = 420 + 402 LED_BRIGHTNESS = maxBrightness LED_GPIO = [18, 13] CHANNEL = [] LED_CHANNEL = [0, 1] # Create a ws2811_t structure from the LED configuration. # Note that this structure will be created on the heap so you need to be careful # that you delete its memory by calling delete_ws2811_t when it's not needed. # Initialize all channels to off for channum in range(2): channel = ws.ws2811_channel_get(LEDS, channum) ws.ws2811_channel_t_count_set(channel, 0) ws.ws2811_channel_t_gpionum_set(channel, 0) ws.ws2811_channel_t_invert_set(channel, 0) ws.ws2811_channel_t_brightness_set(channel, 0) CHANNEL.append(ws.ws2811_channel_get(LEDS, channum)) ws.ws2811_channel_t_count_set(CHANNEL[channum], SPLIT_LED_COUNT[channum]) ws.ws2811_channel_t_gpionum_set(CHANNEL[channum], LED_GPIO[channum]) ws.ws2811_channel_t_invert_set(CHANNEL[channum], LED_INVERT) ws.ws2811_channel_t_brightness_set(CHANNEL[channum], LED_BRIGHTNESS) ws.ws2811_channel_t_strip_type_set(CHANNEL[channum], LED_STRIP) ws.ws2811_t_freq_set(LEDS, LED_FREQ_HZ) ws.ws2811_t_dmanum_set(LEDS, LED_DMA_NUM) # Initialize library with LED configuration. resp = ws.ws2811_init(LEDS) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format( resp, message)) fill({"R": 0, "G": 0, "B": 0}) render() print('Initialized ✓')
def begin(self): """Initialize library, must be called once before other functions are called. """ resp = ws.ws2811_init(self._leds) if resp != 0: raise RuntimeError('ws2811_init failed with code {0}'.format(resp)) # Set LED data array on the ws2811_t structure. Be sure to do this AFTER # the init function is called as it clears out the LEDs. ws.ws2811_t_leds_set(self._leds, self._led_data.data)
def neopixel_write(gpio, buf): global _led_strip # we'll have one strip we init if its not at first if _led_strip is None: # Create a ws2811_t structure from the LED configuration. # Note that this structure will be created on the heap so you # need to be careful that you delete its memory by calling # delete_ws2811_t when it's not needed. _led_strip = ws.new_ws2811_t() # Initialize all channels to off for channum in range(2): channel = ws.ws2811_channel_get(_led_strip, channum) ws.ws2811_channel_t_count_set(channel, 0) ws.ws2811_channel_t_gpionum_set(channel, 0) ws.ws2811_channel_t_invert_set(channel, 0) ws.ws2811_channel_t_brightness_set(channel, 0) channel = ws.ws2811_channel_get(_led_strip, LED_CHANNEL) # Initialize the channel in use ws.ws2811_channel_t_count_set(channel, math.ceil(len(buf)/3)) # we manage 4 vs 3 bytes in the library ws.ws2811_channel_t_gpionum_set(channel, gpio._pin.id) ws.ws2811_channel_t_invert_set(channel, LED_INVERT) ws.ws2811_channel_t_brightness_set(channel, LED_BRIGHTNESS) ws.ws2811_channel_t_strip_type_set(channel, LED_STRIP) # Initialize the controller ws.ws2811_t_freq_set(_led_strip, LED_FREQ_HZ) ws.ws2811_t_dmanum_set(_led_strip, LED_DMA_NUM) resp = ws.ws2811_init(_led_strip) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format(resp, message)) atexit.register(neopixel_cleanup) channel = ws.ws2811_channel_get(_led_strip, LED_CHANNEL) if gpio._pin.id != ws.ws2811_channel_t_gpionum_get(channel): raise RuntimeError("Raspberry Pi neopixel support is for one strip only!") # assign all colors! for i in range(len(buf) // 3): r = buf[3*i] g = buf[3*i+1] b = buf[3*i+2] pixel = (r << 16) | (g << 8) | b ws.ws2811_led_set(channel, i, pixel) resp = ws.ws2811_render(_led_strip) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_render failed with code {0} ({1})'.format(resp, message)) time.sleep(0.001 * ((len(buf)//100)+1)) # about 1ms per 100 bytes
def begin(self): """Initialize library, must be called once before other functions are called. """ with _ws821x_lock: resp = ws.ws2811_init(self._leds) if resp != 0: str_resp = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format(resp, str_resp)) self._init_successful = True
def InitializeNeopixel(): # Initialize all channels to off for channum in range(2): channel = ws.ws2811_channel_get(leds, channum) ws.ws2811_channel_t_count_set(channel, 0) ws.ws2811_channel_t_gpionum_set(channel, 0) ws.ws2811_channel_t_invert_set(channel, 0) ws.ws2811_channel_t_brightness_set(channel, 0) channel = ws.ws2811_channel_get(leds, LED_CHANNEL) ws.ws2811_channel_t_count_set(channel, LED_COUNT) ws.ws2811_channel_t_gpionum_set(channel, LED_PIN) ws.ws2811_channel_t_invert_set(channel, LED_INVERT) ws.ws2811_channel_t_brightness_set(channel, LED_BRIGHTNESS) ws.ws2811_t_freq_set(leds, LED_FREQ_HZ) ws.ws2811_t_dmanum_set(leds, LED_DMA) # Initialize library with LED configuration. ws.ws2811_init(leds) return channel
def begin(self): """ Initializes library, must be called once before other functions are called. Parameters ---------- self : Function of class Adafruit_Neopixel Returns ------- None """ resp = ws.ws2811_init(self._leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format( resp, message))
def init(self): self.channel_off() self.channel = ws.ws2811_channel_get(self.leds, self.led_channel) ws.ws2811_channel_t_count_set(self.channel, self.height * self.width) ws.ws2811_channel_t_gpionum_set(self.channel, self.gpio) ws.ws2811_channel_t_invert_set(self.channel, self.invert) ws.ws2811_channel_t_brightness_set(self.channel, self.brightness) ws.ws2811_t_freq_set(self.leds, self.freq_hz) ws.ws2811_t_dmanum_set(self.leds, self.dma_num) # Initialize library with LED configuration. resp = ws.ws2811_init(self.leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format( resp, message)) print("init success")
def start(self, delegate, style): print("Setting up LED environment...") try: self.LED_BRIGHTNESS = style['brightness'] or 64 self.LED_COUNT = style['led_count'] or 630 self.leds = ws.new_ws2811_t() clean_up = style['cleanup'] == 1 # Initialize all channels to off for channum in range(2): self.channel = ws.ws2811_channel_get(self.leds, channum) ws.ws2811_channel_t_count_set(self.channel, 0) ws.ws2811_channel_t_gpionum_set(self.channel, 0) ws.ws2811_channel_t_invert_set(self.channel, 0) ws.ws2811_channel_t_brightness_set(self.channel, 0) self.channel = ws.ws2811_channel_get(self.leds, self.LED_CHANNEL) ws.ws2811_channel_t_count_set(self.channel, self.LED_COUNT) ws.ws2811_channel_t_gpionum_set(self.channel, self.LED_GPIO) ws.ws2811_channel_t_invert_set(self.channel, self.LED_INVERT) ws.ws2811_channel_t_brightness_set( self.channel, self.LED_BRIGHTNESS) ws.ws2811_t_freq_set(self.leds, self.LED_FREQ_HZ) ws.ws2811_t_dmanum_set(self.leds, self.LED_DMA_NUM) # Initialize library with LED configuration. resp = ws.ws2811_init(self.leds) if resp != 0: raise RuntimeError( 'ws2811_init failed with code {0}'.format(resp)) print( "Starting {0} via {1}...".format( style['style_name'], style['method_name']) ) delegate(style) finally: if clean_up: self.cleanup() ws.ws2811_fini(self.leds) ws.delete_ws2811_t(self.leds)
def start(self, delegate, style): print("Setting up LED environment...") try: self.LED_BRIGHTNESS = style['brightness'] or 64 self.LED_COUNT = style['led_count'] or 630 self.leds = ws.new_ws2811_t() clean_up = style['cleanup'] == 1 # Initialize all channels to off for channum in range(2): self.channel = ws.ws2811_channel_get(self.leds, channum) ws.ws2811_channel_t_count_set(self.channel, 0) ws.ws2811_channel_t_gpionum_set(self.channel, 0) ws.ws2811_channel_t_invert_set(self.channel, 0) ws.ws2811_channel_t_brightness_set(self.channel, 0) self.channel = ws.ws2811_channel_get(self.leds, self.LED_CHANNEL) ws.ws2811_channel_t_count_set(self.channel, self.LED_COUNT) ws.ws2811_channel_t_gpionum_set(self.channel, self.LED_GPIO) ws.ws2811_channel_t_invert_set(self.channel, self.LED_INVERT) ws.ws2811_channel_t_brightness_set(self.channel, self.LED_BRIGHTNESS) ws.ws2811_t_freq_set(self.leds, self.LED_FREQ_HZ) ws.ws2811_t_dmanum_set(self.leds, self.LED_DMA_NUM) # Initialize library with LED configuration. resp = ws.ws2811_init(self.leds) if resp != 0: raise RuntimeError( 'ws2811_init failed with code {0}'.format(resp)) print("Starting {0} via {1}...".format(style['style_name'], style['method_name'])) delegate(style) finally: if clean_up: self.cleanup() ws.ws2811_fini(self.leds) ws.delete_ws2811_t(self.leds)
def set_leds(self, status): """ Set the color according to the humidity threshold In the optimal state when no threshold is reached the led is turned off. @param status: An integer array with 4 integers between 0 and 4 @type status: int[4] @return: None """ leds = ws.new_ws2811_t() channel = ws.ws2811_channel_get(leds, self.get_channel()) ws.ws2811_channel_t_count_set(channel, self.get_count()) ws.ws2811_channel_t_gpionum_set(channel, self.get_gpio()) ws.ws2811_channel_t_invert_set(channel, self.get_invert()) ws.ws2811_channel_t_brightness_set(channel, self.get_brightness()) ws.ws2811_t_freq_set(leds, self.get_freq()) ws.ws2811_t_dmanum_set(leds, self.get_dma()) try: resp = ws.ws2811_init(leds) except Exception as err: raise RuntimeError('ws2811_init failed with code {0} ({1}) {}', resp, err) finally: if resp != ws.WS2811_SUCCESS: ws.ws2811_get_return_t_str(resp) try: for i in range(self.get_count()): ws.ws2811_led_set(channel, i, self.get_color(status[i])) resp = ws.ws2811_render(leds) if resp != ws.WS2811_SUCCESS: ws.ws2811_get_return_t_str(resp) time.sleep(0.015) except Exception as err: raise RuntimeError('ws2811_render failed with code {0} ({1})'.format(resp, err)) finally: logging.getLogger().info("LED status:\t\t\t{}".format(status)) ws.ws2811_fini(leds) ws.delete_ws2811_t(leds)
channel = ws.ws2811_channel_get(leds, channum) ws.ws2811_channel_t_count_set(channel, 0) ws.ws2811_channel_t_gpionum_set(channel, 0) ws.ws2811_channel_t_invert_set(channel, 0) channel = ws.ws2811_channel_get(leds, LED_CHANNEL) ws.ws2811_channel_t_count_set(channel, LED_COUNT) ws.ws2811_channel_t_gpionum_set(channel, LED_GPIO) ws.ws2811_channel_t_invert_set(channel, LED_INVERT) ws.ws2811_t_freq_set(leds, LED_FREQ_HZ) ws.ws2811_t_dmanum_set(leds, LED_DMA_NUM) # Initialize library with LED configuration. resp = ws.ws2811_init(leds) if resp != 0: raise RuntimeError('ws2811_init failed with code {0}'.format(resp)) # Wrap following code in a try/finally to ensure cleanup functions are called # after library is initialized. try: offset = 0 while True: # Update each LED color in the buffer. for i in range(LED_COUNT): # Pick a color based on LED position and an offset for animation. color = DOT_COLORS[(i + offset) % len(DOT_COLORS)] # Set the LED color buffer value. ws.ws2811_led_set(channel, i, color)
# Create a ws2811_t structure from the LED configuration. # Note that this structure will be created on the heap so you need to be careful # that you delete its memory by calling delete_ws2811_t when it's not needed. leds = ws.new_ws2811_t() ws.ws2811_t_count_set(leds, LED_COUNT) ws.ws2811_t_freq_set(leds, LED_FREQ_HZ) ws.ws2811_t_dmanum_set(leds, LED_DMA_NUM) ws.ws2811_t_gpionum_set(leds, LED_GPIO) ws.ws2811_t_invert_set(leds, LED_INVERT) # Create an array of LED data. You don't need to clean this up because the fini # function will free it automatically. led_data = ws.new_led_data(LED_COUNT) # Initialize library with LED configuration. resp = ws.ws2811_init(leds) if resp != 0: raise RuntimeError('ws2811_init failed with code {0}'.format(resp)) # Wrap following code in a try/finally to ensure cleanup functions are called # after library is initialized. try: # Set LED data array on the ws2811_t structure. Be sure to do this AFTER the # init function is called as it clears out the LEDs. ws.ws2811_t_leds_set(leds, led_data) # Loop forever or until ctrl-c is pressed. offset = 0 while True: # Update each LED color in the buffer. for i in range(LED_COUNT): # Pick a color based on LED position and an offset for animation.
def ws2811_init(*args): return _rpi_ws281x.ws2811_init(*args)
def ws2811_init(ws2811): return _rpi_ws281x.ws2811_init(ws2811)
def __init__(self, device): # Call the constructor of the base class. super(OutputRaspi, self).__init__(device) self.logger = logging.getLogger(__name__) import _rpi_ws281x as ws # pylint: disable=import-error output_id = "output_raspi" # LED strip configuration: self._led_count = int( self._device_config["led_count"]) # Number of LED pixels. self._led_pin = int( self._device_config["output"][output_id] ["led_pin"]) # GPIO pin connected to the pixels (18 uses PWM!). self._led_freq_hz = int( self._device_config["output"][output_id] ["led_freq_hz"]) # LED signal frequency in hertz (usually 800khz). self._led_dma = int( self._device_config["output"][output_id] ["led_dma"]) # DMA channel to use for generating signal (try 10). self._led_brightness = int( self._device_config["led_brightness"] ) # Set to '0' for darkest and 100 for brightest. self._led_invert = int( self._device_config["output"][output_id]["led_invert"] ) # Set to 'True' to invert the signal (when using NPN transistor level shift). self._led_channel = int( self._device_config["output"][output_id] ["led_channel"]) # set to '1' for GPIOs 13, 19, 41, 45 or 53. self._led_strip = self._device_config["led_strip"] # Set Fallback Strip self._led_strip_translated = ws.WS2811_STRIP_RGB self._led_strip_mapper = { "sk6812_strip_rgbw": ws.SK6812_STRIP_RGBW, "sk6812_strip_rbgw": ws.SK6812_STRIP_RBGW, "sk6812_strip_grbw": ws.SK6812_STRIP_GRBW, "sk6812_strip_gbrw": ws.SK6812_STRIP_GBRW, "sk6812_strip_brgw": ws.SK6812_STRIP_BRGW, "sk6812_strip_bgrw": ws.SK6812_STRIP_BGRW, "sk6812_shift_wmask": ws.SK6812_SHIFT_WMASK, "ws2811_strip_rgb": ws.WS2811_STRIP_RGB, "ws2811_strip_rbg": ws.WS2811_STRIP_RBG, "ws2811_strip_grb": ws.WS2811_STRIP_GRB, "ws2811_strip_gbr": ws.WS2811_STRIP_GBR, "ws2811_strip_brg": ws.WS2811_STRIP_BRG, "ws2811_strip_bgr": ws.WS2811_STRIP_BGR, "ws2812_strip": ws.WS2812_STRIP, "sk6812_strip": ws.SK6812_STRIP, "sk6812w_strip": ws.SK6812W_STRIP } try: led_strip = self._led_strip_mapper[self._led_strip] if led_strip is not None: self._led_strip_translated = led_strip self.logger.debug(f"Found Led Strip {self._led_strip}") except Exception as e: self.logger.exception( f"Could not find LED Strip Type. Exception: {str(e)}") pass self._led_brightness_translated = int(255 * (self._led_brightness / 100)) self.logger.debug(f"LED Brightness: {self._led_brightness}") self.logger.debug( f"LED Brightness converted: {self._led_brightness_translated}") self._leds = ws.new_ws2811_t() self.channel = ws.ws2811_channel_get(self._leds, self._led_channel) ws.ws2811_channel_t_strip_type_set(self.channel, self._led_strip_translated) ws.ws2811_channel_t_count_set(self.channel, self._led_count) ws.ws2811_channel_t_gpionum_set(self.channel, self._led_pin) ws.ws2811_channel_t_invert_set(self.channel, self._led_invert) ws.ws2811_channel_t_brightness_set(self.channel, self._led_brightness_translated) ws.ws2811_t_freq_set(self._leds, self._led_freq_hz) ws.ws2811_t_dmanum_set(self._leds, self._led_dma) # Initialize library with LED configuration. resp = ws.ws2811_init(self._leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError( f'ws2811_init failed with code {resp} ({message})')
def neopixel_write(gpio, buf): """NeoPixel Writing Function""" global _led_strip # we'll have one strip we init if its not at first if _led_strip is None: # Create a ws2811_t structure from the LED configuration. # Note that this structure will be created on the heap so you # need to be careful that you delete its memory by calling # delete_ws2811_t when it's not needed. _led_strip = ws.new_ws2811_t() # Initialize all channels to off for channum in range(2): channel = ws.ws2811_channel_get(_led_strip, channum) ws.ws2811_channel_t_count_set(channel, 0) ws.ws2811_channel_t_gpionum_set(channel, 0) ws.ws2811_channel_t_invert_set(channel, 0) ws.ws2811_channel_t_brightness_set(channel, 0) channel = ws.ws2811_channel_get(_led_strip, LED_CHANNEL) # Initialize the channel in use count = 0 if len(buf) % 3 == 0: # most common, divisible by 3 is likely RGB LED_STRIP = ws.WS2811_STRIP_RGB count = len(buf) // 3 elif len(buf) % 4 == 0: LED_STRIP = ws.SK6812_STRIP_RGBW count = len(buf) // 4 else: raise RuntimeError("We only support 3 or 4 bytes-per-pixel") ws.ws2811_channel_t_count_set( channel, count ) # we manage 4 vs 3 bytes in the library ws.ws2811_channel_t_gpionum_set(channel, gpio._pin.id) ws.ws2811_channel_t_invert_set(channel, LED_INVERT) ws.ws2811_channel_t_brightness_set(channel, LED_BRIGHTNESS) ws.ws2811_channel_t_strip_type_set(channel, LED_STRIP) # Initialize the controller ws.ws2811_t_freq_set(_led_strip, LED_FREQ_HZ) ws.ws2811_t_dmanum_set(_led_strip, LED_DMA_NUM) resp = ws.ws2811_init(_led_strip) if resp != ws.WS2811_SUCCESS: if resp == -5: raise RuntimeError( "NeoPixel support requires running with sudo, please try again!" ) message = ws.ws2811_get_return_t_str(resp) raise RuntimeError( "ws2811_init failed with code {0} ({1})".format(resp, message) ) atexit.register(neopixel_cleanup) channel = ws.ws2811_channel_get(_led_strip, LED_CHANNEL) if gpio._pin.id != ws.ws2811_channel_t_gpionum_get(channel): raise RuntimeError("Raspberry Pi neopixel support is for one strip only!") if ws.ws2811_channel_t_strip_type_get(channel) == ws.WS2811_STRIP_RGB: bpp = 3 else: bpp = 4 # assign all colors! for i in range(len(buf) // bpp): r = buf[bpp * i] g = buf[bpp * i + 1] b = buf[bpp * i + 2] if bpp == 3: pixel = (r << 16) | (g << 8) | b else: w = buf[bpp * i + 3] pixel = (w << 24) | (r << 16) | (g << 8) | b ws.ws2811_led_set(channel, i, pixel) resp = ws.ws2811_render(_led_strip) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError( "ws2811_render failed with code {0} ({1})".format(resp, message) ) time.sleep(0.001 * ((len(buf) // 100) + 1)) # about 1ms per 100 bytes