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 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 ws2811_init(*args): return _rpi_ws281x.ws2811_init(*args)
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