class WS2812(Driver): """ Legacy driver. Passes through calls to some other driver. """ def __init__(self, width, height, led_pin=18, map=None, name=None): self.map = map if self.map is None: n_leds = self.height * self.width else: n_leds = len(self.map) super().__init__(np.zeros((height, width, 3), dtype=np.uint8), 8, name=name) self.pixelstrip = PixelStrip(n_leds, led_pin, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_GAMMA) def __enter__(self): self.pixelstrip.begin() return super().__enter__() def show(self): if self.map is not None: outbuf = self.rawbuf[self.map] else: outbuf = self.rawbuf outbuf = outbuf.reshape(-1, 3) for i in range(outbuf.shape[0]): self.pixelstrip.setPixelColorRGB(i, *outbuf[i].tolist()) # ugh self.pixelstrip.show() super().show()
def start_strip(self): """ Start PixelStrip object :returns strip: (rpi_ws281x.PixelStrip) The initialised strip object """ self._logger.info("Initialising LED strip") try: strip = PixelStrip( num=int(self.strip_settings["count"]), pin=int(self.strip_settings["pin"]), freq_hz=int(self.strip_settings["freq_hz"]), dma=int(self.strip_settings["dma"]), invert=bool(self.strip_settings["invert"]), brightness=int(self.strip_settings["brightness"]), channel=int(self.strip_settings["channel"]), strip_type=constants.STRIP_TYPES[self.strip_settings["type"]], ) strip.begin() self._logger.info("Strip successfully initialised") return strip except Exception as e: # Probably wrong settings... self._logger.error(repr(e)) self._logger.error( "Strip failed to initialize, no effects will be run.") raise StripFailedError("Error intitializing strip")
def pixel_strip(): """ Initialized and started PixelStrip fixture """ ps = PixelStrip(NUM_PIXELS, 0) ps.begin() return ps
def setup_strip(): global LED_BRIGHTNESS global which_effect which_effect = False # LED strip configuration: LED_COUNT = 300 # Number of LED pixels. LED_PIN = 18 # GPIO pin connected to the pixels (18 uses PWM!). # LED_PIN = 10 # GPIO pin connected to the pixels (10 uses SPI /dev/spidev0.0). LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz) LED_DMA = 10 # DMA channel to use for generating signal (try 10) LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest LED_INVERT = ( False # True to invert the signal (when using NPN transistor level shift) ) LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53 strip = PixelStrip( LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, ) # Intialize the library (must be called once before other functions). logger.debug(f"Setting up strip") strip.begin() clear_strip(strip) return strip
class LED: def __init__(self): # LED Strip configuration: # Number of LED pixels LED_COUNT = 4 # GPIO pin connected to the pixels (10 uses SPI /dev/spidev0.0) LED_PIN = 10 # LED signal frequency in hertz (usually 800khz) LED_FREQ_HZ = 800000 # DMA channel to use for generating signal (try 10) LED_DMA = 10 # Set to 0 for darkest and 255 for brightest LED_BRIGHTNESS = 100 # True to invert the signal (when using NPN transistor level shift) LED_INVERT = False # set to '1' for GPIOs 13. 19, 41, 45 or 53 LED_CHANNEL = 0 # Create NeoPixel object with appropriate configuration. self.strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) # Intialize the library (must be called once before other functions). self.strip.begin() def set_color(self, led, red, green, blue): self.strip.setPixelColor(led, Color(red, green, blue)) self.strip.show()
def setup_led_strips(): # Create PixelStrip object with appropriate configuration global strip strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_STRIP) # Initialize the library (must be called once before other functions) strip.begin()
def start_strip(self): """ Start PixelStrip object :returns rpi_ws281x.PixelStrip """ self._logger.info("Initialising LED strip") strip_settings = self.settings['strip'] try: strip = PixelStrip( num=strip_settings['led_count'], pin=strip_settings['led_pin'], freq_hz=strip_settings['led_freq_hz'], dma=strip_settings['led_dma'], invert=strip_settings['led_invert'], brightness=strip_settings['led_brightness'], channel=strip_settings['led_channel'], strip_type=STRIP_TYPES[strip_settings['strip_type']]) strip.begin() self._logger.info("Strip object successfully initialised") return strip except Exception as e: # Probably wrong settings... self._logger.error( "Strip failed to initialize, no effects will be run.") self._logger.error("Please check your settings.") self._logger.error("Here's the exception: {}".format(e)) return None
class PlasmaWS281X(Plasma): """Class for Plasma light devices in the WS281X/SK6812 family.""" name = "WS281X" options = { 'pixel_count': int, "gpio_pin": int, "strip_type": str, "channel": int, "brightness": int, "freq_hz": int, "dma": int, "invert": bool } option_order = ("gpio_pin", "strip_type", "channel", "brightness", "freq_hz", "dma", "invert") def __init__(self, pixel_count=1, gpio_pin=13, strip_type='WS2812', channel=None, brightness=255, freq_hz=800000, dma=10, invert=False): """Initialise WS281X device. :param pixel_count: Number of individual RGB LEDs :param gpio_pin: BCM GPIO pin for output signal :param strip_type: Strip type: one of WS2812 or SK6812 :param channel: LED channel (0 or 1, or None for automatic) :param brightness: Global WS281X LED brightness scale :param freq_hz: WS281X output signal frequency (usually 800khz) :param dma: DMA channel :param invert: Invert signals for NPN-transistor based level shifters """ from rpi_ws281x import PixelStrip, ws strip_types = {} for t in ws.__dict__: if '_STRIP' in t: k = t.replace('_STRIP', '') v = getattr(ws, t) strip_types[k] = v strip_type = strip_types[strip_type] if channel is None: if gpio_pin in [13]: channel = 1 elif gpio_pin in [12, 18]: channel = 0 self._strip = PixelStrip(pixel_count, gpio_pin, freq_hz, dma, invert, brightness, channel, strip_type) self._strip.begin() Plasma.__init__(self, pixel_count) def show(self): """Output the buffer.""" for i in range(self._strip.numPixels()): r, g, b, brightness = self._pixels[i] self._strip.setPixelColorRGB(i, r, g, b) self._strip.show()
class PlasmaWS281X(Plasma): def __init__(self, light_count, gpio_pin=13, strip_type='WS2812', channel=1, brightness=255, freq_hz=800000, dma=10, invert=False): from rpi_ws281x import PixelStrip, ws strip_types = {} for t in ws.__dict__: if '_STRIP' in t: k = t.replace('_STRIP', '') v = getattr(ws, t) strip_types[k] = v strip_type = strip_types[strip_type] self._strip = PixelStrip(light_count, gpio_pin, freq_hz, dma, invert, brightness, channel, strip_type) self._strip.begin() Plasma.__init__(self, light_count) def show(self): """Output the buffer.""" for i in range(self._strip.numPixels()): r, g, b, brightness = self._pixels[i] self._strip.setPixelColorRGB(i, r, g, b) self._strip.show()
class Canvas(): def __init__(self): # strip = None # self.DotCount = LED_COUNT # Create NeoPixel object with appropriate configuration. self.strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) # Intialize the library (must be called once before other functions). self.strip.begin() self.DotCount = self.strip.numPixels() def FillSolid(self, color): for i in range(self.strip.numPixels()): self.strip.setPixelColor(i, color) # def DrawPixels(self, position, size, color): # dot = int(position) # if dot < 0:return # if dot >= self.DotCount:return # # print("{dot:.2f}, {position:.2f}, {size:.2f}".format(dot=dot, position=position, size=size)) # self.strip.setPixelColor(dot, color) def DrawPixels(self, position, size, color): left_dot = int(position - size / 2) right_dot = int(position + size / 2) if right_dot < 0: return if left_dot < 0: left_dot = 0 if left_dot >= self.DotCount: return if right_dot >= self.DotCount: right_dot = self.DotCount # print("{dot:.2f}, {position:.2f}, {size:.2f}".format(dot=dot, position=position, size=size)) for dot in range(left_dot, right_dot + 1): self.strip.setPixelColor(dot, color)
class __LedCore: def __init__(self): # Create NeoPixel object with appropriate configuration. self.strip = PixelStrip( settings.LED_COUNT, settings.LED_PIN, settings.LED_FREQ_HZ, settings.LED_DMA, settings.LED_INVERT, settings.LED_BRIGHTNESS, settings.LED_CHANNEL, ) # Intialize the library (must be called once before other functions). self.strip.begin() self.thread = None self.strip_actions = StripActions() def strip_action(self, name, **kwargs): if (issubclass(type(self.thread), StoppableThread) and self.thread.is_alive() and not self.thread.stopped()): self.thread.stop() self.thread.join() self.thread = getattr(self.strip_actions, name)(self.strip, **kwargs) return self.thread
class WS2812(Driver): """ Legacy driver. Passes through calls to some other driver. """ def __init__(self, width, height, serpentine=False, name=None): self.serpentine = serpentine super().__init__(np.zeros((height, width, 3), dtype=np.uint8), 8, name=name) self.pixelstrip = PixelStrip(self.height * self.width, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_GAMMA) def __enter__(self): self.pixelstrip.begin() return super().__enter__() def show(self): if self.serpentine: # TODO: handle serpentine, but i don't have hardware to test :( outbuf = self.rawbuf else: outbuf = self.rawbuf outbuf = outbuf.reshape(self.width * self.height, 3) for i in range(outbuf.shape[0]): self.pixelstrip.setPixelColorRGB(i, *outbuf[i].tolist()) # ugh self.pixelstrip.show() super().show()
class Solid: def __init__(self): self.strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) self.strip.begin() def start(self): for i in range(300): self.strip.setPixelColor(i, Color(255, 255, 255)) self.strip.show()
def init(): global strip LED_COUNT = cfg["WS8211"].getint("count", 6) LED_PIN = cfg["WS8211"].getint("pin", 12) LED_FREQ_HZ = cfg["WS8211"].getint("frequence", 800000) LED_DMA = cfg["WS8211"].getint("dma", 10) LED_INVERT = cfg["WS8211"].getboolean("invert", False) LED_BRIGHTNESS = cfg["WS8211"].getint("brightness", 50) LED_CHANNEL = cfg["WS8211"].getint("channel", 0) strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) strip.begin()
class NeoPixel(object): """ Hanlder fot the rapberrypi and led control """ def __init__(self, pixels): # the imports must be hidden since they won't work on pc from rpi_ws281x import PixelStrip # init the pixel strip self.np = PixelStrip(pixels, 18, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) self.np.begin() self.pixel_count = pixels def set(self, index, a, b, g, r): """ Set the a pixel color :param index: int, the pixel index :param a: int, the alpha value, add for compatibility :param b: int, blue value :param g: int, green value :param r: int, red value :return: """ from rpi_ws281x import Color try: # create color and set it color = Color(r, g, b) self.np.setPixelColor(index, color) except IndexError: print("error") def send(self): """ Show the colors :return: """ self.np.show() def close(self): """ Set the strip to black and disconnect :return: """ from rpi_ws281x import Color c = Color(0, 0, 0) for idx in range(self.pixel_count): self.np.setPixelColor(idx, c) self.np.show() self.np._cleanup() print("Closing PiHandler")
class Steps(list): def __init__(self): # Create NeoPixel object with appropriate configuration. self.strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) # Intialize the library (must be called once before other functions). self.strip.begin() for i, led_counter in enumerate(NUMBER_OF_LEDS): # get last led start = 0 if i == 0 else (self[-1][-1] + 1) # define step step = Step(self.strip, start, start + led_counter) self.append(step) def __len__(self): return sum(NUMBER_OF_LEDS) def off(self, step_ms=0, led_ms=0): for step in self: step.off(led_ms) wait(step_ms) def color_test(self): for i, step in enumerate(self): color = Color(255, 0, 0) if i % 2 == 0 else Color(0, 255, 0) for led in step: self.strip.setPixelColor(led, color) self.strip.show() def pong(self, ms=10): for step in self: step.pong_init() while True: for step in self: step.pong_loop(ms=0) wait(ms) def rainbow(self, wait_ms=20, iterations=1): """Draw rainbow that fades across all pixels at once.""" for i in range(self.strip.numPixels()): self.strip.setPixelColor(i, wheel(i & 255)) self.strip.show() wait(wait_ms) def rainbowCycle(self, wait_ms=20, iterations=5): """Draw rainbow that uniformly distributes itself across all pixels.""" for j in range(256*iterations): for i in range(self.strip.numPixels()): self.strip.setPixelColor(i, wheel((int(i * 256 / self.strip.numPixels()) + j) & 255)) self.strip.show() wait(wait_ms)
def main(): parser = argparse.ArgumentParser( description='Project an image onto a LED matrix.') parser.add_argument('filename', type=str, help='filename of the image to display') parser.add_argument('boardsize', type=int, help='the width and height of the LED matrix') parser.add_argument('gpionum', type=int, help='the target GPIO pin') parser.add_argument('--verbose', '-v', action='store_true', help='enables verbose output') args = parser.parse_args() global VERBOSE VERBOSE = args.verbose try: from rpi_ws281x import PixelStrip except ImportError: class PixelStrip(): """PixelStrip stub.""" def __init__(self, *args, **kwargs): print( "rpi_ws281x not found - this won't actually draw anything." ) def begin(self): pass def setPixelColorRGB(self, *args): pass def show(self): print("Done mock drawing.") np = PixelStrip(args.boardsize**2, args.gpionum, brightness=LED_INTENSITY) np.begin() my_grid = led_grid.LEDGrid(np, grid.SerpentinePattern.TOP_RIGHT, args.boardsize, args.boardsize) image = process_image(args.filename, args.boardsize) draw_led_matrix(my_grid, image) np.show() try: terminal_output.print_led_grid(my_grid) except: traceback.print_exc()
class Light(Thread): def __init__(self, light_state:LightState): super().__init__() self.state = light_state self.periodic = None self.refresh_period_or_duty_cycle() self.strip = PixelStrip(self.state.get_num_pixels(), 18) async def loop(self): while True: await self.periodic.wait_for_period_boundary() self.set_first_half_of_period() await self.periodic.wait_for_semi_period_boundary() self.set_second_half_of_period() def set_first_half_of_period(self): if not self.state.get_power(): self.set_off() else: self.set_on() def set_second_half_of_period(self): if not self.state.get_power() or self.state.get_blink(): self.set_off() else: self.set_on() def set_on(self): self.strip.setBrightness(self.state.get_brightness()) for pixel in range(self.state.get_num_pixels()): self.strip.setPixelColorRGB(pixel, self.state.get_red(), self.state.get_green(), self.state.get_blue()) self.strip.show() def set_off(self): for pixel in range(self.state.get_num_pixels()): self.strip.setPixelColorRGB(pixel, 0, 0, 0) self.strip.show() def refresh_period_or_duty_cycle(self): self.periodic = Periodic( period_sec=self.state.get_period(), semi_period_percent=self.state.get_duty_cycle() ) def run(self): self.strip.begin() asyncio.run(self.loop())
def setup(): global ws2812, _is_setup if _is_setup: return ws2812 = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_GAMMA) ws2812.begin() set_layout(HAT) atexit.register(_clean_shutdown) _is_setup = True
def set_color(self, color): rgb = int(color, 16) r = int(rgb / 256 / 256) rgb = rgb - r * 256 * 256 g = int(rgb / 256) b = rgb - g * 256 # Create NeoPixel object with appropriate configuration. strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) # Intialize the library (must be called once before other functions). strip.begin() for i in range(0, strip.numPixels(), 1): strip.setPixelColor(i, Color(g, r, b)) strip.show()
class Fade: def __init__(self): self.gammaTable = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 27, 28, 29, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 37, 38, 39, 40, 40, 41, 42, 43, 44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 76, 77, 78, 79, 80, 81, 83, 84, 85, 86, 88, 89, 90, 91, 93, 94, 95, 96, 98, 99, 100, 102, 103, 104, 106, 107, 109, 110, 111, 113, 114, 116, 117, 119, 120, 121, 123, 124, 126, 128, 129, 131, 132, 134, 135, 137, 138, 140, 142, 143, 145, 146, 148, 150, 151, 153, 155, 157, 158, 160, 162, 163, 165, 167, 169, 170, 172, 174, 176, 178, 179, 181, 183, 185, 187, 189, 191, 193, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 227, 229, 231, 233, 235, 237, 239, 241, 244, 246, 248, 250, 252, 255 ] self.strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) self.strip.begin() self.cols = [] self.hues = np.arange(360, step=10) for i in range(36): self.cols.append(hsv2rgb(self.hues[i] / 360, 1, 1)) def start(self): while True: for col in self.cols: for i in range(100): b = i * (1 / 100) color = Color(self.gammaTable[int(col[0] * b)], self.gammaTable[int(col[1] * b)], self.gammaTable[int(col[2] * b)]) for j in range(LED_COUNT): self.strip.setPixelColor(j, color) self.strip.show() for i in range(100, 0, -1): b = i * (1 / 100) color = Color(self.gammaTable[int(col[0] * b)], self.gammaTable[int(col[1] * b)], self.gammaTable[int(col[2] * b)]) for j in range(LED_COUNT): self.strip.setPixelColor(j, color) self.strip.show()
def create(size, name="neopixel"): pin = settings["glow"]["neopixel"]["pin"] freq_hz = settings["glow"]["neopixel"]["freq_hz"] dma = settings["glow"]["neopixel"]["dma"] invert = settings["glow"]["neopixel"]["invert"] brightness = settings["glow"]["neopixel"]["brightness"] channel = settings["glow"]["neopixel"]["channel"] strip = None if name.lower() == "neopixel": # Create NeoPixel object with appropriate configuration. strip = PixelStrip(size, pin, freq_hz, dma, invert, brightness, channel) # Intialize the library (must be called once before other functions). strip.begin() return strip
class Quicksort: def partition(self, arr, start, end): pivot = arr[end] i = start for j in range(start, end): if arr[j] <= arr[ end]: # if arr[j] is less than arr[i] we swap the values arr[i], arr[j] = arr[j], arr[i] # cols = hueToRgb(arr) col = hsv2rgb(arr[j] / 360, 1, 1) col2 = hsv2rgb(arr[i] / 360, 1, 1) self.strip.setPixelColor(j, Color(col[0], col[1], col[2])) self.strip.show() self.strip.setPixelColor(i, Color(col2[0], col2[1], col2[2])) i = i + 1 self.strip.show() arr[i], arr[end] = arr[end], arr[i] col = hsv2rgb(arr[i] / 360, 1, 1) col2 = hsv2rgb(arr[end] / 360, 1, 1) self.strip.setPixelColor(i, Color(col[0], col[1], col[2])) self.strip.show() self.strip.setPixelColor(end, Color(col2[0], col2[1], col2[2])) self.strip.show() return i def quicksort(self, arr, start, end): if start < end: index = self.partition(arr, start, end) self.quicksort(arr, start, index - 1) self.quicksort(arr, index + 1, end) def __init__(self): self.strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) self.strip.begin() def start(self): while True: hues = np.arange(300) random.shuffle(hues) cols = hueToRgb(hues) for k in range(300): color = Color(cols[k][0], cols[k][1], cols[k][2]) self.strip.setPixelColor(k, color) self.strip.show() self.quicksort(hues, 0, len(hues) - 1)
def run(): prev_animation = None prev_brightness = None strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_STRIP) strip.begin() threading.Thread(target=app.run).start() print('Press Ctrl-C to quit.') len_animations = None try: while True: if len(curr_animations) != len_animations: len_animations = len(curr_animations) clear(strip) generators = [] for animation in curr_animations: generators.append(animation(VStrip(strip))) if curr_brightness != prev_brightness: strip.setBrightness(curr_brightness) prev_brightness = curr_brightness vstrips = [] for gen in generators: vstrips.append(next(gen)) # vstrip.reverse() for pos in range(strip.numPixels()): col = np.array([0., 0., 0.]) transparency = 1 for v in vstrips: cur_col = np.array(v.getPixelColor(pos)) col += cur_col[:3] * transparency transparency *= cur_col[3] col = np.maximum( np.minimum(np.array(np.floor(col), dtype=np.int), 255), 0) strip.setPixelColor(pos, Color(*col.tolist())) strip.show() except KeyboardInterrupt: clear(strip)
class RpiWs281xLedstrip(AbstractLight): def __init__(self) -> None: super().__init__(led_count=LED_COUNT) self.pixel_strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) self.pixel_strip.begin() def write(self): assert self.pixel_strip.numPixels() == len(self.leds) # Update the value for each of the pixels in the strip for i in range(startLED, self.pixel_strip.numPixels()): [red, green, blue, brightness] = self.leds[i] colors = (int(c * brightness * 255) for c in (red, green, blue)) self.pixel_strip.setPixelColorRGB(i, *colors, 255) # Flush the new values to the strip self.pixel_strip.show()
def action(deviceName): strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) strip.begin() if deviceName == 'white': colorWipe(strip, color(255, 255, 255)) return redirect('/', code=302) if deviceName == 'off': colorWipe(strip, color(0, 0, 0)) return redirect('/', code=302) if deviceName == 'red': colorWipe(strip, color(255, 0, 0)) return redirect('/', code=302) if deviceName == 'purple': colorWipe(strip, color(75, 130, 0)) return redirect('/', code=302) if deviceName == 'yellow': colorWipe(strip, color(255, 0, 103)) return redirect('/', code=302)
class RaspberryPiHAL: def __init__(self, config): self.num_pixels = config['LedMatrix']['columns'] * config['LedMatrix'][ 'stride'] self.strip = PixelStrip(self.num_pixels, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) self.strip.begin() def init_display(self, num_pixels=64): self.clear_display() def clear_display(self): c = Color(0, 0, 0) for i in range(self.num_pixels): self.strip.setPixelColor(i, c) self.strip.show() def update_display(self, num_modified_pixels): if not num_modified_pixels: return self.strip.show() def put_pixel(self, addr, r, g, b): self.strip.setPixelColor(addr % self.num_pixels, Color(r, g, b)) def reset(self): self.clear_display() def process_input(self): #TODO: implement return 0 def set_rtc(self, t): #Not relevant pass def set_auto_time(self, enable=True): #Not relevant pass def suspend_host(self, restart_timeout_seconds): #Not relevant pass
def main(): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.bind((LISTEN_IP, LISTEN_PORT)) matrix = list() for i in range(SIZE_W * SIZE_H * 3): matrix.append(0) pixels = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) pixels.begin() display_clear(pixels) try: while True: wait_for_data(sock, matrix) display_data(matrix, pixels) except KeyboardInterrupt: display_clear(pixels) sock.close()
class LedManager(object): # TODO: - Log and document this class # LED strip configuration: __LED_COUNT = 3 # Number of LED pixels. __LED_PIN = 18 # GPIO pin connected to the pixels (must support PWM!). __LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz) __LED_DMA = 10 # DMA channel to use for generating signal (try 10) __LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest __LED_INVERT = False # True to invert the signal (when using NPN transistor level shift) __LED_CHANNEL = 0 __LED_STRIP = ws.WS2812_STRIP __instance = None def __init__(self): if LedManager.__instance is None: LedManager.__instance = self self.strip = PixelStrip(self.__LED_COUNT, self.__LED_PIN, self.__LED_FREQ_HZ, self.__LED_DMA, self.__LED_INVERT, self.__LED_BRIGHTNESS, self.__LED_CHANNEL, self.__LED_STRIP) self.strip.begin() else: raise Exception("This class is a Singleton") @staticmethod def get_instance(): """ :rtype: LedManager """ if LedManager.__instance is None: LedManager() return LedManager.__instance # Define function that colors all LEDs of the given color. def color_wipe(self, led_color, wait_ms=50): for i in range(0, self.strip.numPixels()): self.strip.setPixelColor(i, led_color.value) self.strip.show() time.sleep(wait_ms / 1000.0)
class LedStrip(object): def __init__(self): self.status = 'off' self.strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) self.strip.begin() self.set_color(BLACK) def toggle_light(self): if self.status == STATUS_ON: self.set_color(BLACK) self.status = STATUS_OFF else: self.set_color(SOFT_WHITE) self.status = STATUS_ON def set_color(self, color, wait_ms=200): for i in range(self.strip.numPixels()): self.strip.setPixelColor(i, color) self.strip.show() time.sleep(wait_ms / 1000) def get_status(self): return self.status
for j in range(256*iterations): for i in range(strip.numPixels()): strip.setPixelColor(i, wheel(((i * 256 / strip.numPixels()) + j) & 255)) strip.show() time.sleep(wait_ms/1000.0) # Main loop: if __name__ == '__main__': # Create NeoPixel object with appropriate configuration. #strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) if __version__ == "legacy": strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL) else: strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_GAMMA)# Intialize the library (must be called once before other functions). strip.begin() ## Color wipe animations. colorWipe(strip, Color(127, 0, 0), WAIT_MS) # Red wipe colorWipe(strip, Color(0, 127, 0), WAIT_MS) # Green wipe colorWipe(strip, Color(0, 0, 127), WAIT_MS) # Blue wipe colorWipe(strip, Color(0, 0, 0), WAIT_MS) # Off wipe ## Rainbow animations. #rainbow(strip) #rainbowCycle(strip) #colorWipe(strip, Color(0, 0, 0)) # Off wipe while True: try: data = raw_input()