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 raw_render(self): resp = ws.ws2811_render(self.leds) 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))
def show(self, output_array): import _rpi_ws281x as ws # pylint: disable=import-error # Typecast the array to int output_array = output_array.clip(0, 255).astype(int) # sort the colors. grb g = np.left_shift(output_array[1][:].astype(int), 16) # pylint: disable=assignment-from-no-return r = np.left_shift(output_array[0][:].astype(int), 8) # pylint: disable=assignment-from-no-return b = output_array[2][:].astype(int) rgb = np.bitwise_or(np.bitwise_or(r, g), b).astype(int) # You can only use ws2811_leds_set with the custom version. #ws.ws2811_leds_set(self.channel, rgb) for i in range(self._led_count): ws.ws2811_led_set(self.channel, i, rgb[i].item()) resp = ws.ws2811_render(self._leds) 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))
def render(): global LEDS resp = ws.ws2811_render(LEDS) 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))
def initialize(width, height, amplitude): leds = ws.new_ws2811_t() 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, 0) ws.ws2811_channel_t_count_set(channel, width * height) ws.ws2811_channel_t_gpionum_set(channel, 18) ws.ws2811_channel_t_invert_set(channel, 0) ws.ws2811_channel_t_brightness_set(channel, amplitude) ws.ws2811_t_freq_set(leds, 800000) ws.ws2811_t_dmanum_set(leds, 5) resp = ws.ws2811_init(leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed : {0} ({1})'.format( resp, message)) return (channel, leds)
def show(self): """Update the display with the data from the LED buffer.""" resp = ws.ws2811_render(self._leds) 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))
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 show(self, t=0.0): """Update the display with the data from the LED buffer.""" with _ws821x_lock: resp = ws.ws2811_render(self._leds) if resp != 0: str_resp = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_render failed with code {0} ({1})'.format(resp, str_resp)) time.sleep(t)
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. """ 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 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)
def set(channel, leds, colorArray): position = 0 if not isinstance(colorArray[0], list): colorArray = [colorArray] for row in colorArray: for element in row: ws.ws2811_led_set(channel, position, ctypes.c_uint32(element).value) position += 1 resp = ws.ws2811_render(leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_render failed : {0} ({1})'.format( resp, message))
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 show(self): """ Update the display with the data from the LED buffer. Parameters ---------- self : Function of class Adafruit_Neopixel Returns ------- None """ resp = ws.ws2811_render(self._leds) 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))
def show(self, output_array): import _rpi_ws281x as ws # pylint: disable=import-error # Typecast the array to int. output_array = output_array.clip(0, 255).astype(int) # Check if we have a white channel or not. if len(output_array[:]) == 4 and "SK6812" in self._led_strip: # Sort the colors as RGB type. g = np.left_shift(output_array[1][:].astype(int), 24) # pylint: disable=assignment-from-no-return r = np.left_shift(output_array[0][:].astype(int), 16) # pylint: disable=assignment-from-no-return b = np.left_shift(output_array[2][:].astype(int), 8) # pylint: disable=assignment-from-no-return w = output_array[3][:].astype(int) grbw = np.bitwise_or(np.bitwise_or(np.bitwise_or(r, g), b), w).astype(int) # You can only use ws2811_leds_set with the custom version. for i in range(self._led_count): ws.ws2811_led_set(self.channel, i, int(grbw[i].item())) else: # Sort the colors as RGB type. g = np.left_shift(output_array[1][:].astype(int), 16) # pylint: disable=assignment-from-no-return r = np.left_shift(output_array[0][:].astype(int), 8) # pylint: disable=assignment-from-no-return b = output_array[2][:].astype(int) grb = np.bitwise_or(np.bitwise_or(r, g), b).astype(int) # You can only use ws2811_leds_set with the custom version. for i in range(self._led_count): ws.ws2811_led_set(self.channel, i, grb[i].item()) resp = ws.ws2811_render(self._leds) if resp != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError( f'ws2811_render failed with code {resp} ({message})')
def ws2811_get_return_t_str(*args): return _rpi_ws281x.ws2811_get_return_t_str(*args)
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_channel_t_strip_type_set(channel, 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)) # 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)
def show(self): """Update the display with the data from the LED buffer.""" resp = ws.ws2811_render(self._leds) 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))
def ws2811_get_return_t_str(state): return _rpi_ws281x.ws2811_get_return_t_str(state)
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 != ws.WS2811_SUCCESS: message = ws.ws2811_get_return_t_str(resp) raise RuntimeError('ws2811_init failed with code {0} ({1})'.format(resp, message)) # 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)
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
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})')