Beispiel #1
0
	def __del__(self):
		# Clean up memory used by the library when not needed anymore.
		if self._leds is not None:
			ws.ws2811_fini(self._leds)
			ws.delete_ws2811_t(self._leds)
			self._leds = None
			self._channel = None
Beispiel #2
0
 def __del__(self):
     # Clean up memory used by the library when not needed anymore.
     if self._leds is not None:
         ws.ws2811_fini(self._leds)
         ws.delete_ws2811_t(self._leds)
         self._leds = None
         self._channel = None
Beispiel #3
0
	def _cleanup(self):
		# Clean up memory used by the library when not needed anymore.
		if self._leds is not None:
			print("Exiting cleanly")
			ws.ws2811_fini(self._leds)
			ws.delete_ws2811_t(self._leds)
			self._leds = None
			self._channel = None
Beispiel #4
0
 def _cleanup(self):
     # Clean up memory used by the library when not needed anymore.
     if self._leds is not None:
         print("Exiting cleanly")
         ws.ws2811_fini(self._leds)
         ws.delete_ws2811_t(self._leds)
         self._leds = None
         self._channel = None
Beispiel #5
0
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 _cleanup(self):
        # Clean up memory used by the library when not needed anymore.
        if self._leds is not None:
            if self._init_successful:
                ws.ws2811_fini(self._leds)

            ws.delete_ws2811_t(self._leds)
            self._leds = None
            self._channel = None
Beispiel #7
0
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 ✓')
Beispiel #8
0
def neopixel_cleanup():
    global _led_strip

    if _led_strip is not None:
        # Ensure ws2811_fini is called before the program quits.
        ws.ws2811_fini(_led_strip)
        # 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(_led_strip)
        _led_strip = None
Beispiel #9
0
    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)
Beispiel #10
0
    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)
Beispiel #11
0
 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)
Beispiel #12
0
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)

        # 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(0.25)

        # Increase offset to animate colors moving.  Will eventually overflow, which
        # is fine.
        offset += 1

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)
Beispiel #13
0
# 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.
			color = DOT_COLORS[(i + offset) % len(DOT_COLORS)]
			# Set the LED color buffer value.
			ws.led_data_setitem(led_data, i, color)
		# 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(0.25)
		# Increase offset to animate colors moving.  Will eventually overflow, which
		# is fine.
		offset += 1
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)
Beispiel #14
0
 def __del__(self):
     ws.delete_ws2811_t(self._data)
Beispiel #15
0
def shutdown(leds):
    ws.ws2811_fini(leds)
    ws.delete_ws2811_t(leds)
Beispiel #16
0
 def stop(self):
     self.colorwipe()
     self.render()
     ws.ws2811_fini(self.leds)
     ws.delete_ws2811_t(self.leds)