class StripController: def __init__(self): self.ledCount_ = 100 self.height_ = 10 self.neopixel_ = Adafruit_NeoPixel( self.ledCount_, # LED count 18, # LED pin 800000, # LED signal frequency (Hz) 10, # DMA channel False, # Invert signal 100, # Brightness (0, 255) 0) # LED channel self.neopixel_.begin() def set(self, index, color): if index >= self.ledCount_: raise Exception('setting out of bounds pixel', index) self.neopixel_.setPixelColor(index, color) def show(self): self.neopixel_.show() def cleanUpGrid(self): width = self.ledCount_ / self.height_ return [[BLACK] * width] * self.height_
class PiWS281X(DriverBase): """ Driver for controlling WS281X LEDs via the rpi_ws281x C-extension. Only supported on the Raspberry Pi 2 & 3 """ def __init__(self, num, gamma=gamma.NEOPIXEL, c_order=ChannelOrder.RGB, gpio=18, ledFreqHz=800000, ledDma=5, ledInvert=False, **kwds): """ num - Number of LED pixels. gpio - GPIO pin connected to the pixels (must support PWM! GPIO 13 or 18 (pins 33 or 12) on RPi 3). ledFreqHz - LED signal frequency in hertz (800khz or 400khz) ledDma - DMA channel to use for generating signal (Between 1 and 14) ledInvert - True to invert the signal (when using NPN transistor level shift) """ super().__init__(num, c_order=c_order, gamma=gamma, **kwds) self.gamma = gamma self._strip = Adafruit_NeoPixel(num, gpio, ledFreqHz, ledDma, ledInvert, 255, 0, 0x081000) # Intialize the library (must be called once before other functions). self._strip.begin() def set_brightness(self, brightness): self._strip.setBrightness(brightness) return True def _compute_packet(self): self._render() data = self._buf self._packet = [tuple(data[(p * 3):(p * 3) + 3]) for p in range(len(data) // 3)] def _send_packet(self): for i, p in enumerate(self._packet): self._strip.setPixelColor(i, NeoColor(*p)) self._strip.show()
class DriverPiWS281X(DriverBase): def __init__(self, num, gamma=gamma.NEOPIXEL, c_order=ChannelOrder.RGB, ledPin=18, ledFreqHz=800000, ledDma=5, ledInvert=False): """ num - Number of LED pixels. ledPin - GPIO pin connected to the pixels (must support PWM! pin 13 or 18 on RPi 3). ledFreqHz - LED signal frequency in hertz (800khz or 400khz) ledDma - DMA channel to use for generating signal (Between 1 and 14) ledInvert - True to invert the signal (when using NPN transistor level shift) """ super(DriverPiWS281X, self).__init__(num, c_order=c_order, gamma=gamma) self.gamma = gamma self._strip = Adafruit_NeoPixel(num, ledPin, ledFreqHz, ledDma, ledInvert, 255, 0, 0x081000) # Intialize the library (must be called once before other functions). self._strip.begin() # Set Brightness of the strip. A brightness of 0 is the darkest and 255 is # the brightest def setMasterBrightness(self, brightness): self._strip.setBrightness(brightness) # Push new data def update(self, data): # handle channel order and gamma correction self._fixData(data) data = self._buf pixels = [tuple(data[(p * 3):(p * 3) + 3]) for p in range(len(data) / 3)] for i in range(len(data) / 3): self._strip.setPixelColor(i, NeoColor(pixels[i][0], pixels[i][1], pixels[i][2])) self._strip.show()
class LEDStripPWM(LEDStrip): def __init__(self, array: TileArray): super().__init__(array) from neopixel import Adafruit_NeoPixel # Create NeoPixel object with appropriate configuration. self.strip = Adafruit_NeoPixel(array.size(), 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 draw(self, image: np.ndarray, delay: float = 0.001): from neopixel import Color start = time.time() for y in range(image.shape[0]): for x in range(image.shape[1]): idx = self.array.index(x, y) r = int(image[y][x][0]) g = int(image[y][x][1]) b = int(image[y][x][2]) color = Color(g, r, b) self.strip.setPixelColor(idx, color) self.strip.show() end = time.time() delta = end - start if delay > delta: time.sleep(delay - delta)
class NeoPixelRenderer(Renderer): def __init__(self, led_dma=10, led_strip=ws.WS2811_STRIP_GRB): super(NeoPixelRenderer, self).__init__() self.led_dma = 10 self.led_strip = led_strip self.strip = None def setup(self, pixel_count, world): super(NeoPixelRenderer, self).setup(pixel_count, world) self.strip = Adafruit_NeoPixel( pixel_count, LED_PIN, LED_FREQ_HZ, self.led_dma, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, self.led_strip) self.strip.begin() self.log.debug("LED strip initialized") for idx in range(0, pixel_count): self.strip.setPixelColorRGB(idx, 0, 0, 0, 0) self.strip.show() self.log.debug("LED strip cleared") def render_buffer(self, pixel_buffer): super(NeoPixelRenderer, self).render_buffer(pixel_buffer) if self._is_buffer_changed(pixel_buffer): for idx, pixel in enumerate(pixel_buffer): self.strip.setPixelColorRGB(idx, int(pixel.r), int(pixel.g), int(pixel.b)) # , int(pixel.w)) self.strip.show()
class NeoPixels(object): LED_COUNT = 256 # Number of LED pixels. LED_PIN = 21 # GPIO pin connected to the pixels (must support PWM!). 18=PWM, 21=PCM, 10=SPI-MOSI LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz) LED_DMA = 5 # DMA channel to use for generating signal (try 5) 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) def __init__(self): from neopixel import Adafruit_NeoPixel as NeoPixel self._pixels = NeoPixel(num=self.LED_COUNT, pin=self.LED_PIN, freq_hz=self.LED_FREQ_HZ, dma=self.LED_DMA, invert=self.LED_INVERT, brightness=self.LED_BRIGHTNESS) try: self._pixels.begin() _logger.info("Initialized NeoPixel OK") except RuntimeError: _logger.error("Failed to initialize NeoPixels") raise self.write_pixels(np.zeros((16, 16, 3))) def write_pixels(self, data): for y, row in enumerate((data * 255).astype(np.uint8)): for x, color in enumerate(row): self._pixels.setPixelColorRGB(y * 16 + x, *color) self._pixels.show()
class LEDStrip(object): def __init__(self, array: TileArray): from neopixel import Adafruit_NeoPixel # Create NeoPixel object with appropriate configuration. self.strip = Adafruit_NeoPixel(array.size(), 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.array = array def draw(self, image: np.ndarray, delay: float = 0.001): """ Draws a matrix of color values to the dancefloor tiles. Handles the math of calculating what pixels correspond to which LEDs in the chain of LED strips. The input image should have a shape of (height, width, 3) where height is the LEDs in the vertical direction and width is the total LEDs in the horizontal direction. :param image: Matrix of colors to display on the dancefloor :param delay: Seconds to wait after finishing writing to the LED strips """ from neopixel import Color start = time.time() for y in range(image.shape[0]): for x in range(image.shape[1]): idx = self.array.index(x, y) r = int(image[y][x][0]) g = int(image[y][x][1]) b = int(image[y][x][2]) color = Color(g, r, b) self.strip.setPixelColor(idx, color) self.strip.show() end = time.time() delta = end - start if delay > delta: time.sleep(delay - delta)
class Matrix: def __init__(self): # LED strip configuration: self.led_count = 256 # Number of LED pixels. self.led_pin = 18 # GPIO pin connected to the pixels (18 uses PWM!). self.led_freq_hz = 800000 # LED signal frequency in hertz (usually 800khz) self.led_dma = 10 # DMA channel to use for generating signal (try 10) self.led_brightness = 15 # Set to 0 for darkest and 255 for brightest self.led_invert = False # True to invert the signal (when using NPN transistor level shift) self.led_channel = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53 self.matrix = Adafruit_NeoPixel(self.led_count, self.led_pin, self.led_freq_hz, self.led_dma, self.led_invert, self.led_brightness, self.led_channel) self.matrix.begin() self.frame = Frame(rows=8, cols=32) def color_wipe(self, color: Color = Color()): for x, y, pixel in self.frame.fill(): pixel.color = color def display_text(self, color: Color = Color(), row_1=""): t = Text(row_1) t = t.array for i in range(self.frame.cols()): for x, y, pixel in self.frame.fill(): if t[x][y]: pixel.color = color def scrolling_text(self, color: Color = Color(), repetitions=1, row_1="", row_2=""): t = Text(row_1) t = t.array for rep in range(repetitions): for i in range(len(t)): for x, y, pixel in self.frame.fill(): if t[y][x]: pixel.color = color self.render() t[i].append(t[i].pop(0)) time.sleep(1) self.cleanup() def render(self): for position, color in self.frame.canvas(): self.matrix.setPixelColor(position, color) self.matrix.show() def cleanup(self): self.color_wipe()
class LEDStrip: axis = None green = None red = None blue = None neopixel_Object = None LED_COUNT = 38 # Number of LED pixels. LED_PIN = None # GPIO pin connected to the pixels (18 uses 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 # set to '1' for GPIOs 13, 19, 41, 45 or 53 limitHeight = LED_COUNT def __init__(self, axis, GPIO_Pin, LED_COUNT=38, LED_FREQ_HZ=800000, LED_DMA=10, LED_BRIGHTNESS=255, LED_INVERT=False, LED_CHANNEL=0): print("Initializing LED Strip on GPIO Pin " + str(GPIO_Pin)) from neopixel import Adafruit_NeoPixel self.LED_COUNT = LED_COUNT self.LED_PIN = GPIO_Pin self.LED_FREQ_HZ = LED_FREQ_HZ self.LED_DMA = LED_DMA self.LED_BRIGHTNESS = LED_BRIGHTNESS self.LED_INVERT = LED_INVERT self.LED_CHANNEL = LED_CHANNEL self.green = 0 self.red = 0 self.blue = 0 self.neopixel_Object = Adafruit_NeoPixel(self.LED_COUNT, self.LED_PIN, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, self.LED_BRIGHTNESS, self.LED_CHANNEL) self.neopixel_Object.begin() updateColorsThread = Thread(target=self.updateColors) updateColorsThread.start() print("Started updateColors Thread") def updateColors(self): oldGreen = self.green oldRed = self.red oldBlue = self.blue limit = 40 while True: if self.green != oldGreen or self.red != oldRed or self.blue != oldBlue: oldGreen = self.green oldRed = self.red oldBlue = self.blue print("Green: " + "{:>3}".format(str(self.green)) + ", Red: " + "{:>3}".format( str(self.red)) + ", Blue: " + "{:>3}".format(str(self.blue)) + "\n") color = Color(self.green, self.red, self.blue) for i in range(self.neopixel_Object.numPixels()): if i < self.limitHeight: self.neopixel_Object.setPixelColor(i, color) self.neopixel_Object.show() time.sleep(50 / 1000.0)
class Lightstrip(object): def __init__(self, cfg): nps = cfg['neopixel'] self.strip = Adafruit_NeoPixel(nps['led-count'], \ nps['led-pin'], nps['led-freq-hz'], nps['led-dma'], \ nps['led-invert'], nps['led-brightness'], nps['led-channel']) self.reversed = cfg['custom']['reversed'] self.strip.begin() def _cleanup(self): self.strip._cleanup() def show(self): self.strip.show() # Sets the pixel without updating the strip # Allows reversal of direction of the strip # Ensures bounded pixel index from [0, numPixels) def setPixel(self, n, color): pixelNum = self.strip.numPixels() - 1 - n if self.reversed else n pixelNum %= self.strip.numPixels() self.strip.setPixelColor(pixelNum, color) # Sets the pixel and immediately updates the lightstrip visually def setPixelUpdate(self, n, color): self.setPixel(n, color) self.show() def setBrightness(self, n): self.strip.setBrightness(n) def getBrightness(self): self.strip.getBrightness() def setReversed(self, rev): self.reversed = rev def getReversed(self): return self.reversed def numPixels(self): return self.strip.numPixels() # The only animation I am baking into the lightstrip class because # it has pretty universal importance among other animations and # the runner class too def clear(self): for i in range(self.strip.numPixels()): self.setPixel(i, Color(0, 0, 0)) self.show() def clearPixel(self, n): self.setPixel(n, Color(0, 0, 0))
class LightController(object): LED_COUNT = 43 # 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 = 5 # DMA channel to use for generating signal (try 5) 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) def __init__(self): self.led_count = 43 self.led_pin = 18 self.leds = Adafruit_NeoPixel(self.LED_COUNT, self.LED_PIN, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, self.LED_BRIGHTNESS) def cut_light_ranges(self, hue, disable_range): x = disable_range[0] * 255. / (255 - disable_range[1] + disable_range[0]) if hue < x: hue *= (255 - disable_range[1] + disable_range[0]) / 255. else: hue = disable_range[1] + ((hue - x) * (255. - disable_range[1])) / (255. - x) return hue def cb_light(self, msg): disabled_range = [30, 100] hue = self.cut_light_ranges(msg.data, disabled_range) hue = hue / 255. # Hue between (0., 1.) #r, g, b = map(int, hsv_to_rgb(hue, 1, 255)) r, g, b = map(int, hsv_to_rgb(0, 0, msg.data)) self.set_all(r, g, b) def set_all(self, r, g, b): for i in range(self.LED_COUNT): self.leds.setPixelColor(i, Color(g, r, b)) self.leds.show() def run(self): try: self.leds.begin() except RuntimeError as e: raise RuntimeError( repr(e) + "\nAre you running this script with root permissions?") else: self.set_all(0, 0, 0) rospy.Subscriber("apex_playground/environment/light", UInt8, self.cb_light) rospy.spin()
class PiWS281X(DriverBase): """ Driver for controlling WS281X LEDs via the rpi_ws281x C-extension. Only supported on the Raspberry Pi 2 & 3 """ def __init__(self, num, gamma=gamma.NEOPIXEL, c_order=ChannelOrder.RGB, gpio=18, ledFreqHz=800000, ledDma=5, ledInvert=False, **kwds): """ num - Number of LED pixels. gpio - GPIO pin connected to the pixels (must support PWM! GPIO 13 or 18 (pins 33 or 12) on RPi 3). ledFreqHz - LED signal frequency in hertz (800khz or 400khz) ledDma - DMA channel to use for generating signal (Between 1 and 14) ledInvert - True to invert the signal (when using NPN transistor level shift) """ super().__init__(num, c_order=c_order, gamma=gamma, **kwds) self.gamma = gamma if gpio not in PIN_CHANNEL.keys(): raise ValueError('{} is not a valid gpio option!') self._strip = Adafruit_NeoPixel(num, gpio, ledFreqHz, ledDma, ledInvert, 255, PIN_CHANNEL[gpio], 0x081000) # Intialize the library (must be called once before other functions). self._strip.begin() def set_brightness(self, brightness): self._strip.setBrightness(brightness) return True def _compute_packet(self): self._render() data = self._buf self._packet = [ tuple(data[(p * 3):(p * 3) + 3]) for p in range(len(data) // 3) ] def _send_packet(self): for i, p in enumerate(self._packet): self._strip.setPixelColor(i, NeoColor(*p)) self._strip.show()
def main(): global radien global streifen global pix global T n = 0 #Zählervariable neuesBild(path) gp.setmode(gp.BCM) # Welche Nummern für die Pins verwendet werden gp.setwarnings(False) # Keine Warnungen gp.setup(MAGNET_PIN, gp.IN) # Anschluss #Erschaffen des Led-Streifen-Objekts streifen = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) streifen.begin() #initialisieren des LED-Streifens startPrint() #Drucken der Anfangseinstellungen while True: t1 = time() #Startzeit der Umdrehung t1 if gp.input(MAGNET_PIN) == False: #Zeitmessung einmal je Umdrehung w = 2 * pi / T #Berrechnen der Aktuellen Winkelgeschwindigkeit while gp.input(MAGNET_PIN) == False: t = time() - t1 #Ausrechnen der größe des Zeitabschnitts if t < 5: streifenBedienen(t, w) streifen.show() else: for i in range(0, LED_COUNT): streifen.setPixelColor(i, Color(0,0,0)) streifen.show() n +=1 if n > 3: #jede dritte Umdrehung wird das bild neu in den Zwischenspeicher gepackt n = 0 neuesBild("/home/pi/Bilder/Bild.") print("\b\b\b\b\b\b\b" + str(int(w * 0.3*3.6)) + " km/h") T = time() - t1 #Ausrechnen von T nach T = t2 - t1
class __Instance: # LED strip configuration: LED_COUNT = 150 - 27 # 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 = 5 # DMA channel to use for generating signal (try 5) 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) def __init__(self): random.seed() self.__strip = Adafruit_NeoPixel(self.LED_COUNT, self.LED_PIN, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, self.LED_BRIGHTNESS) self.__strip.begin() LIT_COUNT = 10 last = [0] * LIT_COUNT def twinkle(self): while True: for i in range(0, self.LIT_COUNT): self.__strip.setPixelColor(self.last[i], color.Black()) self.last[i] = random.randint(0, self.__strip.numPixels()) self.__strip.setPixelColor(self.last[i], color.Random()) self.__strip.show() util.delay(150) def walk(self): while True: for i in range(0, self.__strip.numPixels()): self.__strip.setPixelColor(i, color.Random()) self.__strip.show() util.delay(100.0) util.delay(750.0) def set_color(self, color): for i in range(0, self.__strip.numPixels()): self.__strip.setPixelColor(i, color) self.__strip.show() def cylon(self): red = 0 for i in range(0, self.__strip.numPixels()): self.__strip.setPixelColor(i, color.Color(red, 0, 0)) red += 1 self.__strip.show()
class NeopixelSequencePlayer(SequencePlayer): def __init__(self): super().__init__() self.strip = Adafruit_NeoPixel(cfg.LED_COUNT, cfg.LED_DATA_PIN, cfg.LED_FREQ_HZ, cfg.LED_DMA, cfg.LED_INVERT, cfg.LED_BRIGHTNESS, cfg.LED_CHANNEL, cfg.LED_STRIP) self.strip.begin() def setrangecolor(self, start, end, color, write=True): super().setrangecolor(start, end, color, write) if write: self.strip.show() def setcolor(self, led, color, write=True): self.strip.setPixelColor(led, color.topixel()) if write: self.strip.show()
def main(): global radien global streifen global pix global T n = 0 #Zählervariable neuesBild(path) gp.setmode(gp.BCM) # Welche Nummern für die Pins verwendet werden gp.setwarnings(False) # Keine Warnungen gp.setup(MAGNET_PIN, gp.IN) # Anschluss #Erschaffen des Led-Streifen-Objekts streifen = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) streifen.begin() #initialisieren des LED-Streifens startPrint() #Drucken der Anfangseinstellungen while True: t1 = time() #Startzeit der Umdrehung t1 if gp.input(MAGNET_PIN) == False: #Zeitmessung einmal je Umdrehung w = 2 * pi / T #Berrechnen der Aktuellen Winkelgeschwindigkeit while gp.input(MAGNET_PIN) == False: t = time() - t1 #Ausrechnen der größe des Zeitabschnitts if t < 5: streifenBedienen(t, w) streifen.show() else: for i in range(0, LED_COUNT): streifen.setPixelColor(i, Color(0, 0, 0)) streifen.show() n += 1 if n > 3: #jede dritte Umdrehung wird das bild neu in den Zwischenspeicher gepackt n = 0 neuesBild("/home/pi/Bilder/Bild.") print("\b\b\b\b\b\b\b" + str(int(w * 0.3 * 3.6)) + " km/h") T = time() - t1 #Ausrechnen von T nach T = t2 - t1
class Control: def __init__(self): self.strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, 0, ws.WS2812_STRIP) self.strip.begin() self.running = True def color_temp(self, temp, brightness=1.0): r, g, b = convert_K_to_RGB(temp) r = int(r * brightness) g = int(g * brightness) b = int(b * brightness) self.color(r, g, b) def color(self, r, g, b): color = Color(r, g, b) for i in range(self.strip.numPixels()): self.strip.setPixelColor(i, color) while True: self.strip.show() if self.running: time.sleep(20 / 1000.0) else: return def rainbow(self): while True: for j in range(256): for i in range(self.strip.numPixels()): self.strip.setPixelColor(i, wheel((i + j) & 255)) self.strip.show() if self.running: time.sleep(20 / 1000.0) else: return def rainbow_onecolor(self): while True: for j in range(256): for i in range(self.strip.numPixels()): self.strip.setPixelColor(i, wheel(j & 255)) self.strip.show() if self.running: time.sleep(20 / 1000.0) else: return
class wordclock_display: """ Class to display any content on the wordclock display Depends on the (individual) wordclock layout/wiring """ def __init__(self, config, wci): """ Initialization """ # Get the wordclocks wiring-layout self.wcl = wiring.wiring(config) self.wci = wci try: default_brightness = config.getint('wordclock_display', 'brightness') except: default_brightness = 255 print( 'WARNING: Default brightness value not set in config-file: ' 'To do so, add a "brightness" between 1..255 to the [wordclock_display]-section.') if config.getboolean('wordclock', 'developer_mode'): from GTKstrip import GTKstrip self.strip = GTKstrip(wci) self.default_font = os.path.join('/usr/share/fonts/TTF/', config.get('wordclock_display', 'default_font') + '.ttf') else: try: from neopixel import Adafruit_NeoPixel, ws self.strip = Adafruit_NeoPixel(self.wcl.LED_COUNT, self.wcl.LED_PIN, self.wcl.LED_FREQ_HZ, self.wcl.LED_DMA, self.wcl.LED_INVERT, default_brightness , 0, ws.WS2811_STRIP_GRB) except: print('Update deprecated external dependency rpi_ws281x. ' 'For details see also https://github.com/jgarff/rpi_ws281x/blob/master/python/README.md') self.default_font = os.path.join('/usr/share/fonts/truetype/freefont/', config.get('wordclock_display', 'default_font') + '.ttf') # Initialize the NeoPixel object self.strip.begin() self.default_fg_color = wcc.WWHITE self.default_bg_color = wcc.BLACK self.base_path = config.get('wordclock', 'base_path') # Choose language try: language = ''.join(config.get('wordclock_display', 'language')) except: # For backward compatibility language = ''.join(config.get('plugin_time_default', 'language')) print(' Setting language to ' + language + '.') if language == 'dutch': self.taw = time_dutch.time_dutch() elif language == 'english': self.taw = time_english.time_english() elif language == 'german': self.taw = time_german.time_german() elif language == 'german2': self.taw = time_german2.time_german2() elif language == 'swabian': self.taw = time_swabian.time_swabian() elif language == 'swabian2': self.taw = time_swabian2.time_swabian2() elif language == 'bavarian': self.taw = time_bavarian.time_bavarian() elif language == 'swiss_german': self.taw = time_swiss_german.time_swiss_german() elif language == 'swiss_german2': self.taw = time_swiss_german2.time_swiss_german2() else: print('Could not detect language: ' + language + '.') print('Choosing default: german') self.taw = time_german.time_german() def setPixelColor(self, pixel, color): """ Sets the color for a pixel, while considering the brightness, set within the config file """ self.strip.setPixelColor(pixel, color) def getBrightness(self): """ Sets the color for a pixel, while considering the brightness, set within the config file """ return self.strip.getBrightness() def setBrightness(self, brightness): """ Sets the color for a pixel, while considering the brightness, set within the config file """ self.strip.setBrightness(brightness) self.show() def setColorBy1DCoordinates(self, *args, **kwargs): """ Sets a pixel at given 1D coordinates """ return self.wcl.setColorBy1DCoordinates(*args, **kwargs) def setColorBy2DCoordinates(self, *args, **kwargs): """ Sets a pixel at given 2D coordinates """ return self.wcl.setColorBy2DCoordinates(*args, **kwargs) def get_wca_height(self): """ Returns the height of the WCA """ return self.wcl.WCA_HEIGHT def get_wca_width(self): """ Returns the height of the WCA """ return self.wcl.WCA_WIDTH def get_led_count(self): """ Returns the overall number of LEDs """ return self.wcl.LED_COUNT def dispRes(self): """ Returns the resolution of the wordclock array as string E.g. to choose the correct resolution of animations and icons """ return str(self.wcl.WCA_WIDTH) + 'x' + str(self.wcl.WCA_HEIGHT) def setColorToAll(self, color, includeMinutes=True): """ Sets a given color to all leds If includeMinutes is set to True, color will also be applied to the minute-leds. """ if includeMinutes: for i in range(self.wcl.LED_COUNT): self.setPixelColor(i, color) else: for i in self.wcl.getWcaIndices(): self.setPixelColor(i, color) def setColorTemperatureToAll(self, temperature, includeMinutes=True): """ Sets a color to all leds based on the provided temperature in Kelvin If includeMinutes is set to True, color will also be applied to the minute-leds. """ self.setColorToAll(wcc.color_temperature_to_rgb(temperature), includeMinutes) def resetDisplay(self): """ Reset display """ self.setColorToAll(wcc.BLACK, True) def showIcon(self, plugin, iconName): """ Dispays an icon with a specified name. The icon needs to be provided within the graphics/icons folder. """ self.setImage( self.base_path + '/wordclock_plugins/' + plugin + '/icons/' + self.dispRes() + '/' + iconName + '.png') def setImage(self, absPathToImage): """ Set image (provided as absolute path) to current display """ img = Image.open(absPathToImage) width, height = img.size for x in range(0, width): for y in range(0, height): rgb_img = img.convert('RGB') r, g, b = rgb_img.getpixel((x, y)) self.wcl.setColorBy2DCoordinates(self.strip, x, y, wcc.Color(r, g, b)) self.show() def animate(self, plugin, animationName, fps=10, count=1, invert=False): """ Runs an animation plugin: Plugin-name num_of_frames: Number of frames to be displayed count: Number of runs fps: frames per second invert: Invert order of animation """ animation_dir = self.base_path + '/wordclock_plugins/' + plugin + '/animations/' + self.dispRes() + '/' + animationName + '/' num_of_frames = len([file_count for file_count in os.listdir(animation_dir)]) if invert: animation_range = range(num_of_frames - 1, -1, -1) else: animation_range = range(0, num_of_frames) for _ in range(count): for i in animation_range: self.setImage(animation_dir + str(i).zfill(3) + '.png') if self.wci.waitForExit(1.0 / fps): return def showText(self, text, font=None, fg_color=None, bg_color=None, fps=10, count=1): """ Display text on display """ if font is None: font = self.default_font if fg_color is None: fg_color = self.default_fg_color if bg_color is None: bg_color = self.default_bg_color text = ' ' + text + ' ' fnt = fontdemo.Font(font, self.wcl.WCA_HEIGHT) text_width, text_height, text_max_descent = fnt.text_dimensions(text) text_as_pixel = fnt.render_text(text) # Display text count times for i in range(count): # Erase previous content self.setColorToAll(bg_color, includeMinutes=True) # Assure here correct rendering, if the text does not fill the whole display render_range = self.wcl.WCA_WIDTH if self.wcl.WCA_WIDTH < text_width else text_width for y in range(text_height): for x in range(render_range): self.wcl.setColorBy2DCoordinates(self.strip, x, y, fg_color if text_as_pixel.pixels[y * text_width + x] else bg_color) # Show first frame for 0.5 seconds self.show() if self.wci.waitForExit(0.5): return # Shift text from left to right to show all. for cur_offset in range(text_width - self.wcl.WCA_WIDTH + 1): for y in range(text_height): for x in range(self.wcl.WCA_WIDTH): self.wcl.setColorBy2DCoordinates(self.strip, x, y, fg_color if text_as_pixel.pixels[ y * text_width + x + cur_offset] else bg_color) self.show() if self.wci.waitForExit(1.0 / fps): return def setMinutes(self, time, color): if time.minute % 5 != 0: for i in range(1, time.minute % 5 + 1): self.setPixelColor(self.wcl.mapMinutes(i), color) def show(self): """ This function provides the current color settings to the LEDs """ self.strip.show()
class PiWS281X(DriverBase): """ Driver for controlling WS281X LEDs via the rpi_ws281x C-extension. Only supported on the Raspberry Pi 2, 3, and Zero This driver needs to be run as sudo and requires the rpi_ws281x C extension. Install rpi_ws281x with the following shell commands: git clone https://github.com/jgarff/rpi_ws281x.git cd rpi_ws281x sudo apt-get install python-dev swig scons sudo scons cd python # If using default system python3 sudo python3 setup.py build install # If using virtualenv, enter env then run python setup.py build install Provides the same parameters of :py:class:`.driver_base.DriverBase` as well as those below: :param int gpio: GPIO pin to output to. Typically 18 or 13 :param int ledFreqHz: WS2812B base data frequency in Hz. Only change to 400000 if using very old WS218B LEDs :param int ledDma: DMA channel to use for generating signal (between 1 and 14) :param bool ledInvert: True to invert the signal (when using NPN transistor level shift) """ def __init__(self, num, gamma=gamma.NEOPIXEL, c_order="RGB", gpio=18, ledFreqHz=800000, ledDma=5, ledInvert=False, color_channels=3, brightness=255, **kwds): if not NeoColor: raise ValueError(WS_ERROR) super().__init__(num, c_order=c_order, gamma=gamma, **kwds) self.gamma = gamma if gpio not in PIN_CHANNEL.keys(): raise ValueError('{} is not a valid gpio option!') try: strip_type = STRIP_TYPES[color_channels] except: raise ValueError('In PiWS281X, color_channels can only be 3 or 4') self._strip = Adafruit_NeoPixel(num, gpio, ledFreqHz, ledDma, ledInvert, brightness, PIN_CHANNEL[gpio], strip_type) # Intialize the library (must be called once before other functions). try: self._strip.begin() except RuntimeError as e: if os.geteuid(): if os.path.basename(sys.argv[0]) in ('bp', 'bibliopixel'): command = ['bp'] + sys.argv[1:] else: command = ['python'] + sys.argv error = SUDO_ERROR.format(command=' '.join(command)) e.args = (error, ) + e.args raise def set_brightness(self, brightness): self._strip.setBrightness(brightness) return True def _compute_packet(self): self._render() data = self._buf self._packet = [ tuple(data[(p * 3):(p * 3) + 3]) for p in range(len(data) // 3) ] def _send_packet(self): for i, p in enumerate(self._packet): self._strip.setPixelColor(i, NeoColor(*p)) self._strip.show()
class wordclock_display: """ Class to display any content on the wordclock display Depends on the (individual) wordclock layout/wiring """ def __init__(self, config, wci): """ Initialization """ # Get the wordclocks wiring-layout self.wcl = wiring.wiring(config) self.wci = wci self.config = config self.base_path = config.get('wordclock', 'base_path') max_brightness = 255 try: self.setBrightness(config.getint('wordclock_display', 'brightness')) except: self.brightness = max_brightness print( 'WARNING: Default brightness value not set in config-file: ' 'To do so, add a "brightness" between 1..255 to the [wordclock_display]-section.' ) if config.getboolean('wordclock', 'developer_mode'): from GTKstrip import GTKstrip self.strip = GTKstrip(wci) self.default_font = 'wcfont.ttf' else: try: from neopixel import Adafruit_NeoPixel, ws self.strip = Adafruit_NeoPixel( self.wcl.LED_COUNT, self.wcl.LED_PIN, self.wcl.LED_FREQ_HZ, self.wcl.LED_DMA, self.wcl.LED_INVERT, max_brightness, 0, ws.WS2811_STRIP_GRB) except: print( 'Update deprecated external dependency rpi_ws281x. ' 'For details see also https://github.com/jgarff/rpi_ws281x/blob/master/python/README.md' ) if config.get('wordclock_display', 'default_font') == 'wcfont': self.default_font = self.base_path + '/wcfont.ttf' else: self.default_font = os.path.join( '/usr/share/fonts/truetype/freefont/', config.get('wordclock_display', 'default_font') + '.ttf') # Initialize the NeoPixel object self.strip.begin() self.default_fg_color = wcc.WWHITE self.default_bg_color = wcc.BLACK # Choose language try: language = ''.join(config.get('wordclock_display', 'language')) except: # For backward compatibility language = ''.join(config.get('plugin_time_default', 'language')) print(' Setting language to ' + language + '.') if language == 'dutch': self.taw = time_dutch.time_dutch() elif language == 'english': self.taw = time_english.time_english() elif language == 'english_c3jr': self.taw = time_english_c3jr.time_english() elif language == 'german': self.taw = time_german.time_german() elif language == 'german2': self.taw = time_german2.time_german2() elif language == 'swabian': self.taw = time_swabian.time_swabian() elif language == 'swabian2': self.taw = time_swabian2.time_swabian2() elif language == 'bavarian': self.taw = time_bavarian.time_bavarian() elif language == 'swiss_german': self.taw = time_swiss_german.time_swiss_german() elif language == 'swiss_german2': self.taw = time_swiss_german2.time_swiss_german2() else: print('Could not detect language: ' + language + '.') print('Choosing default: german') self.taw = time_german.time_german() def setPixelColor(self, pixel, color): """ Sets the color for a pixel, while considering the brightness, set within the config file """ self.strip.setPixelColor(pixel, color) def getBrightness(self): """ Sets the color for a pixel, while considering the brightness, set within the config file """ return self.brightness def setBrightness(self, brightness): """ Sets the color for a pixel, while considering the brightness, set within the config file """ brightness_before = self.getBrightness() brightness = max(min(255, brightness), 0) for i in range(self.wcl.LED_COUNT): color = self.getPixelColor(i) color = (color / brightness_before) ^ (1 / 2.2) * brightness self.setPixelColor(i, color) self.brightness = brightness self.show() def setColorBy1DCoordinates(self, *args, **kwargs): """ Sets a pixel at given 1D coordinates """ return self.wcl.setColorBy1DCoordinates(*args, **kwargs) def setColorBy2DCoordinates(self, *args, **kwargs): """ Sets a pixel at given 2D coordinates """ return self.wcl.setColorBy2DCoordinates(*args, **kwargs) def get_wca_height(self): """ Returns the height of the WCA """ return self.wcl.WCA_HEIGHT def get_wca_width(self): """ Returns the width of the WCA """ return self.wcl.WCA_WIDTH def get_led_count(self): """ Returns the overall number of LEDs """ return self.wcl.LED_COUNT def dispRes(self): """ Returns the resolution of the wordclock array as string E.g. to choose the correct resolution of animations and icons """ return str(self.wcl.WCA_WIDTH) + 'x' + str(self.wcl.WCA_HEIGHT) def setColorToAll(self, color, includeMinutes=True): """ Sets a given color to all leds If includeMinutes is set to True, color will also be applied to the minute-leds. """ if includeMinutes: for i in range(self.wcl.LED_COUNT): self.setPixelColor(i, color) else: for i in self.wcl.getWcaIndices(): self.setPixelColor(i, color) def setColorTemperatureToAll(self, temperature, includeMinutes=True): """ Sets a color to all leds based on the provided temperature in Kelvin If includeMinutes is set to True, color will also be applied to the minute-leds. """ self.setColorToAll(wcc.color_temperature_to_rgb(temperature), includeMinutes) def resetDisplay(self): """ Reset display """ self.setColorToAll(wcc.BLACK, True) def showIcon(self, plugin, iconName): """ Dispays an icon with a specified name. The icon needs to be provided within the graphics/icons folder. """ self.setImage(self.base_path + '/wordclock_plugins/' + plugin + '/icons/' + self.dispRes() + '/' + iconName + '.png') def setImage(self, absPathToImage): """ Set image (provided as absolute path) to current display """ img = Image.open(absPathToImage) width, height = img.size for x in range(0, width): for y in range(0, height): rgb_img = img.convert('RGB') r, g, b = rgb_img.getpixel((x, y)) self.wcl.setColorBy2DCoordinates(self.strip, x, y, wcc.Color(r, g, b)) self.show() def animate(self, plugin, animationName, fps=10, count=1, invert=False): """ Runs an animation plugin: Plugin-name num_of_frames: Number of frames to be displayed count: Number of runs fps: frames per second invert: Invert order of animation """ animation_dir = self.base_path + '/wordclock_plugins/' + plugin + '/animations/' + self.dispRes( ) + '/' + animationName + '/' num_of_frames = len( [file_count for file_count in os.listdir(animation_dir)]) if invert: animation_range = range(num_of_frames - 1, -1, -1) else: animation_range = range(0, num_of_frames) for _ in range(count): for i in animation_range: self.setImage(animation_dir + str(i).zfill(3) + '.png') if self.wci.waitForExit(1.0 / fps): return def showText(self, text, font=None, fg_color=None, bg_color=None, fps=10, count=1): """ Display text on display """ if font is None: font = self.default_font if fg_color is None: fg_color = self.default_fg_color if bg_color is None: bg_color = self.default_bg_color text = ' ' + text + ' ' fnt = fontdemo.Font(font, self.wcl.WCA_HEIGHT) text_width, text_height, text_max_descent = fnt.text_dimensions(text) text_as_pixel = fnt.render_text(text) # Display text count times for i in range(count): # Erase previous content self.setColorToAll(bg_color, includeMinutes=True) # Assure here correct rendering, if the text does not fill the whole display render_range = self.wcl.WCA_WIDTH if self.wcl.WCA_WIDTH < text_width else text_width for y in range(text_height): for x in range(render_range): self.wcl.setColorBy2DCoordinates( self.strip, x, y, fg_color if text_as_pixel.pixels[y * text_width + x] else bg_color) # Show first frame for 0.5 seconds self.show() if self.wci.waitForExit(0.5): return # Shift text from left to right to show all. for cur_offset in range(text_width - self.wcl.WCA_WIDTH + 1): for y in range(text_height): for x in range(self.wcl.WCA_WIDTH): self.wcl.setColorBy2DCoordinates( self.strip, x, y, fg_color if text_as_pixel.pixels[y * text_width + x + cur_offset] else bg_color) self.show() if self.wci.waitForExit(1.0 / fps): return def setMinutes(self, time, color): if time.minute % 5 != 0: for i in range(1, time.minute % 5 + 1): self.setPixelColor(self.wcl.mapMinutes(i), color) def show(self): """ This function provides the current color settings to the LEDs """ self.strip.show()
def set_led(i, r, g, b): if i < LED_COUNT: ws2812.setPixelColorRGB(i, r, g, b) def readSensor(): lastBuf[0] = inBuf[0] lastBuf[1] = inBuf[1] for i in range(0, 2): adc = spi.xfer2([1, (8 + i) << 4, 0]) # request channel inBuf[i] = (adc[1] & 3) << 8 | adc[2] # join two bytes together difBuf[0] = abs(inBuf[0] - lastBuf[0]) # work out changes difBuf[1] = abs(inBuf[1] - lastBuf[1]) def initHardware(): global spi, lastX, lastY, ch0Low, ch1Low spi = spidev.SpiDev() spi.open(0, 0) spi.max_speed_hz = 1000000 # Main program logic: if __name__ == '__main__': try: main() except: # clear up the LEDs wipe() ws2812.show()
def exc(): import os import json import math import time from copy import deepcopy from neopixel import Adafruit_NeoPixel basedir = os.path.dirname(os.path.realpath(__file__)) steps = 120 neopixel = Adafruit_NeoPixel(1, 18) neopixel.begin() setting = {'threat': 0, 'cautioning': 0, 'optimum': 1} changelog = [0, 0, 0] if setting['threat'] > 0: changelog[0] = 255 elif setting['cautioning'] > 0: changelog[0] = 255 changelog[1] = 255 elif setting['optimum'] > 0: changelog[1] = 255 if os.path.isfile(basedir + '/ledstate.json'): with open(basedir + '/ledstate.json', 'r') as out: current = json.loads(out.read()) else: raw = neopixel.getPixelColor(0) current = [] for _ in range(3): calc = divmod(raw, 256) raw = calc[0] current.append(calc[1]) current = current[::-1] print(current) bcurrent = [] bchange = [] for pointer in range(len(current)): bcurrent.append( True if current[pointer] > changelog[pointer] else False) bchange.append( True if current[pointer] != changelog[pointer] else False) old = deepcopy(current) for i in range(0, steps + 1): color = [] for pointer in range(len(bchange)): if bchange[pointer]: if not bcurrent[pointer]: x = i offset = current[pointer] else: x = steps - i offset = changelog[pointer] color.append(offset + int( abs(current[pointer] - changelog[pointer]) / steps * x)) # color.append(offset + int(math.cos((1 / steps) * math.pi * x) * (abs(current[pointer] - changelog[pointer]) / 2) + (abs(current[pointer] - changelog[pointer]) / 2))) else: color.append(old[pointer]) print(color) neopixel.setPixelColorRGB(0, color[0], color[1], color[2]) neopixel.show() old = deepcopy(color) # time.sleep(1 / 30) print(color) with open(basedir + '/ledstate.json', 'w') as out: out.write(json.dumps(old))
class ColoramaDisplay(ApplicationSession): @inlineCallbacks def onJoin(self, details): self._serial = get_serial() self._prefix = 'io.crossbar.demo.iotstarterkit.{}.pixelstrip'.format( self._serial) self.log.info("Crossbar.io IoT Starterkit Serial No.: {serial}", serial=self._serial) self.log.info("ColoramaDisplay connected: {details}", details=details) # get custom configuration cfg = self.config.extra self._leds = Adafruit_NeoPixel(cfg['led_count'], cfg['led_pin'], cfg['led_freq_hz'], cfg['led_dma'], cfg['led_invert'], cfg['led_brightness']) self._leds.begin() for proc in [ (self.set_color, 'set_color'), (self.get_color, 'get_color'), (self.flash, 'flash'), (self.lightshow, 'lightshow'), (self.color_wipe, 'color_wipe'), (self.theater_chase, 'theater_chase'), (self.rainbow, 'rainbow'), (self.rainbow_cycle, 'rainbow_cycle'), (self.theater_chaserainbow, 'theater_chaserainbow'), ]: yield self.register(proc[0], '{}.{}'.format(self._prefix, proc[1])) self.flash() self.log.info("ColoramaDisplay ready!") @inlineCallbacks def flash(self, delay=50, repeat=5): delay = float(delay) / 1000. for i in range(repeat): self.set_color(0xe1, 0xda, 0x05) yield sleep(2 * delay) self.set_color(0x52, 0x42, 0x00) yield sleep(delay) @inlineCallbacks def lightshow(self): # Color wipe animations. yield self.color_wipe(255, 0, 0) # Red wipe yield self.color_wipe(0, 255, 0) # Blue wipe yield self.color_wipe(0, 0, 255) # Green wipe # Theater chase animations. yield self.theater_chase(127, 127, 127) # White theater chase yield self.theater_chase(127, 0, 0) # Red theater chase yield self.theater_chase(0, 0, 127) # Blue theater chase # Rainbow animations. yield self.rainbow() yield self.rainbow_cycle() #yield self.theater_chase_rainbow() yield self.flash() # Define functions which animate LEDs in various ways. @inlineCallbacks def color_wipe(self, r, g, b, wait_ms=50): """Wipe color across display a pixel at a time.""" for i in range(self._leds.numPixels()): self.set_color(r, g, b, i) yield sleep(wait_ms / 1000.0) @inlineCallbacks def theater_chase(self, r, g, b, wait_ms=50, iterations=10): """Movie theater light style chaser animation.""" for j in range(iterations): for q in range(3): for i in range(0, self._leds.numPixels(), 3): self.set_color(r, g, b, i + q) yield sleep(wait_ms / 1000.0) for i in range(0, self._leds.numPixels(), 3): self.set_color(0, 0, 0, i + q) def wheel(self, pos): """Generate rainbow colors across 0-255 positions.""" if pos < 85: return (pos * 3, 255 - pos * 3, 0) elif pos < 170: pos -= 85 return (255 - pos * 3, 0, pos * 3) else: pos -= 170 return (0, pos * 3, 255 - pos * 3) @inlineCallbacks def rainbow(self, wait_ms=20, iterations=1): """Draw rainbow that fades across all pixels at once.""" for j in range(256 * iterations): for i in range(self._leds.numPixels()): r, g, b = self.wheel((i + j) & 255) self.set_color(r, g, b, i) yield sleep(wait_ms / 1000.0) @inlineCallbacks def rainbow_cycle(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._leds.numPixels()): r, g, b = self.wheel(((i * 256 / self._leds.numPixels()) + j) & 255) self.set_color(r, g, b, i) yield sleep(wait_ms / 1000.0) @inlineCallbacks def theater_chaserainbow(self, wait_ms=50): """Rainbow movie theater light style chaser animation.""" for j in range(256): for q in range(3): for i in range(0, self._leds.numPixels(), 3): r, g, b = self.wheel((i + j) % 255) self.set_color(r, g, b, i + q) yield sleep(wait_ms / 1000.0) for i in range(0, self._leds.numPixels(), 3): self.set_color(0, 0, 0, i) def set_color(self, red, green, blue, k=None): if k is None: for i in range(self._leds.numPixels()): # FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels? self._leds.setPixelColorRGB(i, green, red, blue) color_change = {'led': i, 'r': red, 'g': green, 'b': blue} self.publish('{}.on_color_set'.format(self._prefix), color_change) else: # FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels? self._leds.setPixelColorRGB(k, green, red, blue) color_change = {'led': k, 'r': red, 'g': green, 'b': blue} self.publish('{}.on_color_set'.format(self._prefix), color_change) self._leds.show() def get_color(self, k): c = self._leds.getPixelColor(k) color = { 'g': c >> 16, 'r': (c >> 8) & 0xff, 'b': c & 0xff, } return color def onLeave(self, details): self.log.info("Session closed: {details}", details=details) self.disconnect() def onDisconnect(self): self.log.info("Connection closed") for i in range(self._leds.numPixels()): self._leds.setPixelColorRGB(i, 0, 0, 0) self._leds.show() try: reactor.stop() except ReactorNotRunning: pass
class RPiMaze(MazeGame): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Set up NeoPixel self.np = Adafruit_NeoPixel(NUM_PIXELS, GPIO_PIN, brightness=INTENSITY) self.np.begin() self.led_grid = led_grid.LEDGrid(self.np, grid.SerpentinePattern.TOP_RIGHT, width=MATRIX_WIDTH, height=MATRIX_HEIGHT) @staticmethod def hexcolor_to_rgb(colorstr): # https://stackoverflow.com/a/29643643 TODO: abstract this out some more color = tuple(int(colorstr.lstrip('#')[i:i+2], 16) for i in (0, 2, 4)) print("%s: %s" % (colorstr, str(color))) return color def draw_point_at(self, x, y, color): try: self.led_grid.set(x, y, color, allowOverwrite=True) except IndexError: pass def _draw_walls(self, wall_points_to_draw): for point in wall_points_to_draw: #print("Drawing LED point %s, %s as a wall" % (point[0], point[1])) self.draw_point_at(point[0], point[1], (255, 255, 255)) def draw_maze_leds(self): """ Draws the maze on an LED strip. """ for pixel in range(NUM_PIXELS): self.np.setPixelColorRGB(pixel, 0, 0, 0) for ypos, row in enumerate(self.maze.by_rows()): for xpos, point in enumerate(row): if point.is_finish: color = self.hexcolor_to_rgb(self.FINISH_COLOR) elif point.is_start: color = self.hexcolor_to_rgb(self.START_COLOR) else: # Empty tile color = (0, 0, 0) for sprite in self.sprites: if sprite.x == xpos and sprite.y == ypos: color = self.hexcolor_to_rgb(sprite.color) print("Setting color to %s for sprite %s at %s, %s" % (color, sprite, xpos, ypos)) if point.is_selected: color = self.hexcolor_to_rgb(self.SELECTED_COLOR) led_xpos = xpos * 2 led_ypos = ypos * 2 #print("Translating player position (%s, %s) into LED position (%s, %s)" % (xpos, ypos, led_xpos, led_ypos)) wall_points_to_draw = { (led_xpos-1, led_ypos-1), (led_xpos-1, led_ypos+1), (led_xpos+1, led_ypos-1), (led_xpos+1, led_ypos+1) } paths = point.paths if 'north' not in paths: wall_points_to_draw.add((led_xpos, led_ypos-1)) if 'south' not in paths: wall_points_to_draw.add((led_xpos, led_ypos+1)) if 'east' not in paths: wall_points_to_draw.add((led_xpos+1, led_ypos)) if 'west' not in paths: wall_points_to_draw.add((led_xpos-1, led_ypos)) self._draw_walls(wall_points_to_draw) self.draw_point_at(led_xpos, led_ypos, color) self.np.show() self.led_grid.show() def draw_maze(self, *args, **kwargs): super().draw_maze(*args, **kwargs) self.draw_maze_leds() return True
def run(steps=120): result = VariousTools.offline_check('generalleds', hardware=False) changelog = [0, 0, 0] if result: setting = {'threat': 0, 'cautioning': 0, 'optimum': 0} plant = Plant.get(localhost=True) all_status = SensorStatus.select().where(SensorStatus.plant == plant) for status in all_status: setting[status.level.label] += 1 if setting['threat'] > 0: changelog[0] = 255 elif setting['cautioning'] > 0: changelog[0] = 255 changelog[1] = 255 elif setting['optimum'] > 0: changelog[1] = 255 basedir = os.path.dirname(os.path.realpath(__file__)) neopixel = Adafruit_NeoPixel(1, 18) neopixel.begin() if os.path.isfile(basedir + '/ledstate.json'): with open(basedir + '/ledstate.json', 'r') as out: current = json.loads(out.read()) else: raw = neopixel.getPixelColor(0) current = [] for _ in range(3): calc = divmod(raw, 256) raw = calc[0] current.append(calc[1]) current = current[::-1] if changelog == current: return True bcurrent = [] bchange = [] for pointer in range(len(current)): bcurrent.append(True if current[pointer] >= changelog[pointer] else False) bchange.append(True if current[pointer] != changelog[pointer] else False) old = deepcopy(current) for i in range(0, steps + 1): color = [] for pointer in range(len(bchange)): if bchange[pointer]: if not bcurrent[pointer]: x = i offset = current[pointer] else: x = steps - i offset = changelog[pointer] color.append(offset + int(abs(current[pointer] - changelog[pointer]) / steps * x)) else: color.append(old[pointer]) print(color) neopixel.setPixelColorRGB(0, color[0], color[1], color[2]) neopixel.show() old = deepcopy(color) time.sleep(1 / 15) with open(basedir + '/ledstate.json', 'w') as out: out.write(json.dumps(color)) time.sleep(1) neopixel.setPixelColorRGB(0, changelog[0], changelog[1], changelog[2]) neopixel.show() return True
class PiWS281X(DriverBase): """ Driver for controlling WS281X LEDs via the rpi_ws281x C-extension. Only supported on the Raspberry Pi 2, 3, and Zero This driver needs to be run as sudo and requires the rpi_ws281x C extension. Install rpi_ws281x with the following shell commands: git clone https://github.com/jgarff/rpi_ws281x.git cd rpi_ws281x sudo apt-get install python-dev swig scons sudo scons cd python # If using default system python3 sudo python3 setup.py build install # If using virtualenv, enter env then run python setup.py build install Provides the same parameters of :py:class:`.driver_base.DriverBase` as well as those below: :param int gpio: GPIO pin to output to. Typically 18 or 13 :param int ledFreqHz: WS2812B base data frequency in Hz. Only change to 400000 if using very old WS218B LEDs :param int ledDma: DMA channel to use for generating signal (Between 1 and 14) :param bool ledInvert: True to invert the signal (when using NPN transistor level shift) """ # Including follow as comment as URLs in docstrings don't play well with sphinx # Discussion re: running as sudo # https://groups.google.com/d/msg/maniacal-labs-users/6hV-2_-Xmqc/wmWJK709AQAJ # https://github.com/jgarff/rpi_ws281x/blob/master/python/neopixel.py#L106 def __init__( self, num, gamma=gamma.NEOPIXEL, c_order="RGB", gpio=18, ledFreqHz=800000, ledDma=5, ledInvert=False, color_channels=3, brightness=255, **kwds): if not NeoColor: raise ValueError(WS_ERROR) super().__init__(num, c_order=c_order, gamma=gamma, **kwds) self.gamma = gamma if gpio not in PIN_CHANNEL.keys(): raise ValueError('{} is not a valid gpio option!') try: strip_type = STRIP_TYPES[color_channels] except: raise ValueError('In PiWS281X, color_channels must be either 3 or 4') self._strip = Adafruit_NeoPixel( num, gpio, ledFreqHz, ledDma, ledInvert, brightness, PIN_CHANNEL[gpio], strip_type) # Intialize the library (must be called once before other functions). try: self._strip.begin() except RuntimeError as e: if os.geteuid(): if os.path.basename(sys.argv[0]) in ('bp', 'bibliopixel'): command = ['bp'] + sys.argv[1:] else: command = ['python'] + sys.argv error = SUDO_ERROR.format(command=' '.join(command)) e.args = (error,) + e.args raise def set_brightness(self, brightness): self._strip.setBrightness(brightness) return True def _compute_packet(self): self._render() data = self._buf self._packet = [tuple(data[(p * 3):(p * 3) + 3]) for p in range(len(data) // 3)] def _send_packet(self): for i, p in enumerate(self._packet): self._strip.setPixelColor(i, NeoColor(*p)) self._strip.show()
class LedController: global debug def __init__(self, display_mode:str, number_of_led_strips:int, number_of_leds_per_strip:int): self.current_beat_index = 0 self.note_led_rows = [] self.number_of_led_strips = number_of_led_strips self.number_of_leds_per_strip = number_of_leds_per_strip # holds the rgb values of each led self.all_colors_as_str = [] self.all_led_rgb_value_lists = [] # colors as [R, G, B] self.color_dict = { 'off': [0, 0, 0], 'white': [255, 255, 255], 'red': [255, 0, 0], 'blue': [0, 0, 255], 'green': [0, 255, 0] } # choose whether or not to highlight the current beat and dim the rest = 'highlight' # or only show the colors of the current beat = 'only_current' self.display_mode = display_mode # self.display_mode = 'only_current' # self.display_mode = 'highlight' # the other leds will be divided by this factor self.display_mode_highlight_factor = 10 self.led_strip = None # led strip settings self.number_of_leds_total = self.number_of_led_strips * self.number_of_leds_per_strip self.led_pin = 21 # uses PCM self.frequency_hz = 800000 self.dma = 10 self.led_brightness = 100 self.led_inverted = False self.led_pin_channel = 0 if debug: print('Settings for LedController(): ') print('Mode: ', self.display_mode) print('Brightness: ', self.led_brightness) print('Number of led strips: ', self.number_of_led_strips) print('Number of leds per strip: ', self.number_of_leds_per_strip) print('Total number of leds: ', self.number_of_leds_total) def initialize_led_strip(self): self.led_strip = Adafruit_NeoPixel(num=self.number_of_leds_total, pin=self.led_pin, freq_hz=self.frequency_hz, dma=self.dma, invert=self.led_inverted, brightness=self.led_brightness, channel=self.led_pin_channel ) self.led_strip.begin() if debug: print('\nInitialized Led strip... Obj: ', self.led_strip) print() def remove_strip_obj(self): self.led_strip = None def set_current_beat(self, beat:int): self.current_beat_index = beat - 1 # will set leds to be the colors from the led obj, depending on the display mode def set_led_colors(self): # choose whether to only show the current beat leds, or to highlight it if debug: print('Setting led colors... using display mode: ', self.display_mode) if self.display_mode == 'only_current': if debug: print('Mode is ', self.display_mode) self.only_show_colors_from_current_beat() self.convert_color_str_to_rgb() elif self.display_mode == 'highlight': if debug: print('Mode is ', self.display_mode) self.highlight_current_beat_leds() def only_show_colors_from_current_beat(self): index = 0 for note_led_row in self.note_led_rows: if index == self.current_beat_index: for note_led_container in note_led_row.row: led = note_led_container.led if led.is_displayed(): self.all_colors_as_str.append(led.get_color()) else: self.all_colors_as_str.append('off') else: for note_led_container in note_led_row.row: self.all_colors_as_str.append('off') index += 1 # convert color str to lists of three rgb values def convert_color_str_to_rgb(self): for color_str in self.all_colors_as_str: rgb_list = self.color_dict[color_str] self.all_led_rgb_value_lists.append(rgb_list) # the leds of the current beat will be displayed at full brightness, the other beats at half def highlight_current_beat_leds(self): index = 0 for note_led_row in self.note_led_rows: if index == self.current_beat_index: for note_led_container in note_led_row.row: led = note_led_container.led if led.is_displayed(): color_str = led.get_color() self.all_colors_as_str.append(color_str) self.add_color_to_rgb_list(color=color_str) else: color_str = 'off' self.all_colors_as_str.append(color_str) self.add_color_to_rgb_list(color=color_str) else: for note_led_container in note_led_row.row: led = note_led_container.led if led.is_displayed(): color_str = led.get_color() self.all_colors_as_str.append(color_str) self.add_color_to_rgb_list(color=color_str, reduced_brightness=True) else: color_str = 'off' self.all_colors_as_str.append(color_str) self.add_color_to_rgb_list(color=color_str) index += 1 def add_color_to_rgb_list(self, color:str, reduced_brightness=False): rgb_list = self.color_dict[color] output_list = [] # if reduced brightness we divide by a factor if reduced_brightness: index = 0 for rgb_val in rgb_list: if not (rgb_val == 0): rgb_val = int(float(rgb_val) / float(self.display_mode_highlight_factor)) output_list.append(rgb_val) index += 1 else: output_list = rgb_list self.all_led_rgb_value_lists.append(output_list) # set the values for each led in the strip obj def update_led_strip_colors(self): led_index = 0 for rgb_list in self.all_led_rgb_value_lists: r = rgb_list[0] g = rgb_list[1] b = rgb_list[2] self.led_strip.setPixelColorRGB(n=led_index, red=r, green=g, blue=b) led_index += 1 # actually output the color values to the strip def display_updated_leds(self): if debug: print('Updating the output of the leds') self.led_strip.show() def clear_led_strip(self): for i in range(self.number_of_leds_total): self.led_strip.setPixelColorRGB(n=i, red=0, green=0, blue=0) time.sleep(0.01) self.led_strip.show() # main function to control the led hardware def update_led_strips(self, led_note_rows:list): if debug: print('Will now update the colors of the ledstrips') # reset the lists self.note_led_rows = led_note_rows self.all_colors_as_str = [] self.all_led_rgb_value_lists = [] self.set_led_colors() self.update_led_strip_colors() if debug: # print('note_led_rows: ', self.note_led_rows) # print('all_colors_as_str: ', self.all_colors_as_str) print('all_led_rgb_value_list: ', self.all_led_rgb_value_lists) self.display_updated_leds()
class LTSmart: mensaje = 'POSTE' contador_pantalla = -8 contador_pantalla_max = 0 contador_barra = 0 def __init__(self, pin, channel, cintas, longitud, longitud_baliza): # ARREGLO LINEAL LED self.long_baliza = longitud_baliza self.Longitud = longitud # Longitud de cada cinta Led self.Numero = cintas # Numero de cintas Leds self.LED_COUNT = longitud * cintas + longitud_baliza # Number of LED pixels. self.LED_PIN = pin # GPIO pin connected to the pixels (must support PWM!). self.LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz) self.LED_DMA = 10 # DMA channel to use for generating signal (try 10) self.LED_BRIGHTNESS = 150 # Set to 0 for darkest and 255 for brightest self.LED_INVERT = False # True to invert the signal (when using NPN transistor level shift) self.LED_CHANNEL = channel self.strip = Adafruit_NeoPixel(self.LED_COUNT, self.LED_PIN, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, self.LED_BRIGHTNESS, self.LED_CHANNEL) self.strip.begin() self.ConvBin2 = [0, 0, 0, 0, 0, 0, 0, 0] #Vector Conversor a Binario self.mensaje_anterior = 'POSTE' self.contador_dp = 0 # Contador para los dos puntos #---------------------------------------------------------------------------# # Escribir pantalla # #---------------------------------------------------------------------------# def screen(self, msg, Rojo, Verde, Azul, sentido, brillo, activar_barra, variable, lim_sup, lim_inf, n1, n2, n3): self.strip.setBrightness(brillo) self.mensaje = msg if self.mensaje_anterior != self.mensaje: self.contador_pantalla = -8 self.CleanScreen(Color(0, 0, 0)) if activar_barra == 0: # La barra está desactivada, muestra el texto completo en la pantalla if sentido == 0: # El texto se muestra estático self.contador_pantalla = self.Longitud - 10 self.Message(self.mensaje, self.contador_pantalla, Color(Verde, Rojo, Azul)) self.strip.show() # Mostrar el programa else: # El texto se desplaza hacia arriba self.contador_pantalla_max = len( self.mensaje) * 8 + self.Longitud if self.contador_pantalla < len( self.mensaje) * 8 + self.Longitud: self.CleanScreen(Color(0, 0, 0)) self.Message(self.mensaje, self.contador_pantalla, Color(Verde, Rojo, Azul)) self.strip.show() # Mostrar el programa else: self.contador_pantalla = -8 else: # La barra está activada, quita el último metro de la pantalla if sentido == 0: # El texto se muestra estático self.nivel(variable, lim_sup, lim_inf, n1, n2, n3) self.contador_pantalla = self.Longitud - 10 - 61 self.Message(self.mensaje, self.contador_pantalla, Color(Verde, Rojo, Azul)) self.strip.show() # Mostrar el programa else: # El texto se desplaza hacia arriba self.contador_pantalla_max = len( self.mensaje) * 8 + self.Longitud - 50 if self.contador_pantalla < len( self.mensaje) * 8 + self.Longitud - 50: self.CleanScreen(Color(0, 0, 0)) self.Message(self.mensaje, self.contador_pantalla, Color(Verde, Rojo, Azul)) self.CleanBarra(self.Longitud - 61, self.Longitud - 1) self.nivel(variable, lim_sup, lim_inf, n1, n2, n3) self.strip.show() #Mostrar el programa else: self.contador_pantalla = -8 self.contador_pantalla += 1 self.mensaje_anterior = self.mensaje #---------------------------------------------------------------------------# # Apagar pantalla # #---------------------------------------------------------------------------# def apagar(self): self.CleanAll(Color(0, 0, 0)) self.strip.show() # Mostrar el programa #---------------------------------------------------------------------------# # Mostrar barra # #---------------------------------------------------------------------------# def nivel(self, variable, lim_sup, lim_inf, n1, n2, n3): # self.CleanScreen(Color(0, 0, 0)) j = self.Longitud - 60 self.line(j, Color(255, 0, 255)) j = self.Longitud - 59 self.line(j, Color(255, 0, 255)) j = self.Longitud - 3 self.line(j, Color(255, 0, 255)) j = self.Longitud - 2 self.line(j, Color(255, 0, 255)) led_nivel = int(round(variable * 56 / (lim_sup - lim_inf))) # print(led_nivel) grb = [0, 0, 0] for k in range(self.Longitud - 58, self.Longitud - 60 + led_nivel - 1): if variable < 1: grb = [0, 0, 0] elif variable < n1: grb = [255, 0, 0] elif variable < n2: grb = [255, 255, 0] elif variable < n3: grb = [100, 255, 0] else: grb = [0, 255, 0] self.line(k, Color(grb[0], grb[1], grb[2])) if self.contador_barra < k: self.contador_barra = k + 1 elif self.contador_barra != k: self.contador_barra = self.contador_barra - 1 self.line(self.contador_barra, Color(255, 255, 255)) #---------------------------------------------------------------------------# # Mostrar baliza # #---------------------------------------------------------------------------# def nivel_baliza(self, variable, lim_sup, lim_inf, n1, n2, n3): grb = [0, 0, 0] if variable < 1: grb = [0, 0, 0] elif variable < n1: grb = [255, 0, 0] elif variable < n2: grb = [255, 255, 0] elif variable < n3: grb = [100, 255, 0] else: grb = [0, 255, 0] for k in range(self.LED_COUNT - self.long_baliza, self.LED_COUNT): self.strip.setPixelColor(k, Color(grb[0], grb[1], grb[2])) #---------------------------------------------------------------------------# # Binario convertido a Leds (Se usa en el medio) # #---------------------------------------------------------------------------# def Bin2Led_medio(self, hexa, posicion, color, direccion): ConvBin = bin(hexa) if direccion == 0: for i in range(2, len(ConvBin)): if ConvBin[i] == '0': self.strip.setPixelColor(posicion + len(ConvBin) - i, Color(0, 0, 0)) else: self.strip.setPixelColor(posicion + len(ConvBin) - i, color) else: for i in range(2, len(ConvBin)): if ConvBin[i] == '0': self.strip.setPixelColor(posicion - len(ConvBin) + i, Color(0, 0, 0)) else: self.strip.setPixelColor(posicion - len(ConvBin) + i, color) #---------------------------------------------------------------------------# # Binario convertido a Leds2 (Se usa en el borde superior) # #---------------------------------------------------------------------------# def Bin2Led_superior(self, hexa, posicion, color, direccion, dif): ConvBin = bin(hexa) if len(ConvBin) != 10: self.ConvBin2 = ['0', '0', '0', '0', '0', '0', '0', '0'] for j in range(2, len(ConvBin)): self.ConvBin2[10 - len(ConvBin) + j - 2] = ConvBin[j] else: for i in range(0, 7): self.ConvBin2[i] = ConvBin[i + 2] # Los leds en la misma dirección if direccion == 0: for i in range(0, dif): if self.ConvBin2[8 - dif + i] == '0': self.strip.setPixelColor(posicion + dif - i, Color(0, 0, 0)) else: self.strip.setPixelColor(posicion + dif - i, color) # Los leds en dirección opuesta else: for i in range(0, dif): if self.ConvBin2[8 - dif + i] == '0': self.strip.setPixelColor(posicion - dif + i, Color(0, 0, 0)) else: self.strip.setPixelColor(posicion - dif + i, color) #---------------------------------------------------------------------------# # Binario convertido a Leds2 (Se usa en el borde inferior) # #---------------------------------------------------------------------------# def Bin2Led_inferior(self, hexa, posicion, color, direccion, dif): ConvBin = bin(hexa) if len(ConvBin) != 10: self.ConvBin2 = ['0', '0', '0', '0', '0', '0', '0', '0'] for j in range(2, len(ConvBin)): self.ConvBin2[10 - len(ConvBin) + j - 2] = ConvBin[j] else: for i in range(0, 7): self.ConvBin2[i] = ConvBin[i + 2] # Los leds en la misma dirección if direccion == 0: for i in range(0, dif): #print(8 - dif + i) if self.ConvBin2[i] == '0': self.strip.setPixelColor(posicion + 8 - i, Color(0, 0, 0)) else: self.strip.setPixelColor(posicion + 8 - i, color) # Los leds en dirección opuesta else: for i in range(0, dif): if self.ConvBin2[i] == '0': self.strip.setPixelColor(posicion - 8 + i, Color(0, 0, 0)) else: self.strip.setPixelColor(posicion - 8 + i, color) #---------------------------------------------------------------------------# # Letras convertidas a Leds # #---------------------------------------------------------------------------# def Letras2Led(self, posicion2, color, hexa): # Borde superior if posicion2 > self.Longitud - 9: dif = self.Longitud - 1 - posicion2 if dif > 0: self.Bin2Led_superior(hexa[4], posicion2, color, 0, dif) self.Bin2Led_superior(hexa[3], 2 * self.Longitud - posicion2 - 1, color, 1, dif) self.Bin2Led_superior(hexa[2], 2 * self.Longitud + posicion2, color, 0, dif) self.Bin2Led_superior(hexa[1], 4 * self.Longitud - posicion2 - 1, color, 1, dif) self.Bin2Led_superior(hexa[0], 4 * self.Longitud + posicion2, color, 0, dif) # Borde inferior elif posicion2 < -1: dif2 = 9 - posicion2 * -1 self.Bin2Led_inferior(hexa[4], posicion2, color, 0, dif2) self.Bin2Led_inferior(hexa[3], 2 * self.Longitud - posicion2 - 1, color, 1, dif2) self.Bin2Led_inferior(hexa[2], 2 * self.Longitud + posicion2, color, 0, dif2) self.Bin2Led_inferior(hexa[1], 4 * self.Longitud - posicion2 - 1, color, 1, dif2) self.Bin2Led_inferior(hexa[0], 4 * self.Longitud + posicion2, color, 0, dif2) # El centro de la pantalla else: self.Bin2Led_medio(hexa[4], posicion2, color, 0) self.Bin2Led_medio(hexa[3], 2 * self.Longitud - posicion2 - 1, color, 1) self.Bin2Led_medio(hexa[2], 2 * self.Longitud + posicion2, color, 0) self.Bin2Led_medio(hexa[1], 4 * self.Longitud - posicion2 - 1, color, 1) self.Bin2Led_medio(hexa[0], 4 * self.Longitud + posicion2, color, 0) #---------------------------------------------------------------------------# # Limpiar pantalla # #---------------------------------------------------------------------------# def CleanScreen(self, color): for i in range(self.LED_COUNT - self.long_baliza): self.strip.setPixelColor(i, color) #---------------------------------------------------------------------------# # Limpiar pantalla y baliza # #---------------------------------------------------------------------------# def CleanAll(self, color): for i in range(self.LED_COUNT): self.strip.setPixelColor(i, color) #---------------------------------------------------------------------------# # Limpiar barra # #---------------------------------------------------------------------------# def CleanBarra(self, j, k): for i in range(j, k): self.line(i, Color(0, 0, 0)) #---------------------------------------------------------------------------# # Dibujar una línea # #---------------------------------------------------------------------------# def line(self, i, color): self.strip.setPixelColor(i, color) self.strip.setPixelColor((2 * self.Longitud - i) - 1, color) self.strip.setPixelColor(2 * self.Longitud + i, color) self.strip.setPixelColor((4 * self.Longitud - i) - 1, color) self.strip.setPixelColor(4 * self.Longitud + i, color) #---------------------------------------------------------------------------# # Mensaje convertido a cada letra, numero o simbolo # #---------------------------------------------------------------------------# def tabla(self, valor, posicion3, color, i): switcher = { # MAYUSCULAS "A": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x3E, 0x48, 0x88, 0x48, 0x3E]), "B": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x6C, 0x92, 0x92, 0x92, 0xFE]), "C": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x44, 0x82, 0x82, 0x82, 0x7C]), "D": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7C, 0x82, 0x82, 0x82, 0xFE]), "E": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x82, 0x92, 0x92, 0x92, 0xFE]), "F": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x80, 0x90, 0x90, 0x90, 0xFE]), "G": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xCE, 0x8A, 0x82, 0x82, 0x7C]), "H": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xFE, 0x10, 0x10, 0x10, 0xFE]), "I": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x82, 0xFE, 0x82, 0x00]), "J": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x80, 0xFC, 0x82, 0x02, 0x04]), "K": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x82, 0x44, 0x28, 0x10, 0xFE]), "L": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x02, 0x02, 0x02, 0x02, 0xFE]), "M": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xFE, 0x40, 0x38, 0x40, 0xFE]), "N": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xFE, 0x08, 0x10, 0x20, 0xFE]), #"Ñ": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xBE,0x84,0x88,0x90,0xBE]), "O": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7C, 0x82, 0x82, 0x82, 0x7C]), "P": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x60, 0x90, 0x90, 0x90, 0xFE]), "Q": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7A, 0x84, 0x8A, 0x82, 0x7C]), "R": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x62, 0x94, 0x98, 0x90, 0xFE]), "S": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x4C, 0x92, 0x92, 0x92, 0x64]), "T": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xC0, 0x80, 0xFE, 0x80, 0xC0]), "U": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xFC, 0x02, 0x02, 0x02, 0xFC]), "V": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xF8, 0x04, 0x02, 0x04, 0xF8]), "W": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xFE, 0x02, 0x1C, 0x02, 0xFE]), "X": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xC6, 0x28, 0x10, 0x28, 0xC6]), "Y": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xC0, 0x20, 0x1E, 0x20, 0xC0]), "Z": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xC2, 0xB2, 0x92, 0x9A, 0x86]), # MINUSCULAS "a": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x02, 0x1E, 0x2A, 0x2A, 0x04]), "b": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x1C, 0x22, 0x22, 0x14, 0xFE]), "c": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x14, 0x22, 0x22, 0x22, 0x1C]), "d": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xFE, 0x14, 0x22, 0x22, 0x1C]), "e": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x18, 0x2A, 0x2A, 0x2A, 0x1C]), "f": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x40, 0x90, 0x7E, 0x10, 0x00]), "g": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x3C, 0x72, 0x4A, 0x4A, 0x30]), "h": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x1E, 0x20, 0x20, 0x10, 0xFE]), "i": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x02, 0xBE, 0x22, 0x00]), "j": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0xBC, 0x02, 0x02, 0x04]), "k": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x22, 0x14, 0x08, 0xFE]), "l": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x02, 0xFE, 0x82, 0x00]), "m": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x3E, 0x20, 0x1E, 0x20, 0x3E]), "n": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x1E, 0x20, 0x20, 0x10, 0x3E]), "o": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x1C, 0x22, 0x22, 0x22, 0x1C]), "p": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x30, 0x48, 0x48, 0x30, 0x7E]), "q": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7E, 0x30, 0x48, 0x48, 0x30]), "r": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x10, 0x20, 0x20, 0x10, 0x3E]), "s": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x24, 0x2A, 0x2A, 0x2A, 0x12]), "t": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x24, 0x12, 0xFC, 0x20, 0x20]), "u": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x3E, 0x04, 0x02, 0x02, 0x3C]), "v": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x38, 0x04, 0x02, 0x04, 0x38]), "w": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x3C, 0x02, 0x0C, 0x02, 0x3C]), "x": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x22, 0x14, 0x08, 0x14, 0x22]), "y": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7C, 0x12, 0x12, 0x12, 0x64]), "z": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x22, 0x32, 0x2A, 0x26, 0x22]), # NUMEROS "0": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7C, 0xA2, 0x92, 0x8A, 0x7C]), "1": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x02, 0xFE, 0x42, 0x00]), "2": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x62, 0x92, 0x92, 0x92, 0x4E]), "3": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xCC, 0xB2, 0x92, 0x82, 0x84]), "4": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x08, 0xFE, 0x48, 0x28, 0x18]), "5": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x9C, 0xA2, 0xA2, 0xA2, 0xE4]), "6": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x8C, 0x92, 0x92, 0x52, 0x3C]), "7": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xE0, 0x90, 0x88, 0x84, 0x82]), "8": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x6C, 0x92, 0x92, 0x92, 0x6C]), "9": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x78, 0x94, 0x92, 0x92, 0x62]), # SIMBOLOS "=": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x28, 0x28, 0x28, 0x28, 0x28]), "(": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x82, 0x44, 0x38, 0x00]), ")": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x38, 0x44, 0x82, 0x00]), ":": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x00, 0x28, 0x00, 0x00]), ";": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x00, 0x2C, 0x02, 0x00]), " ": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x00, 0x00, 0x00, 0x00]), ",": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x00, 0x0C, 0x02, 0x00]), "?": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x60, 0x90, 0x9A, 0x80, 0x40]), ".": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x0C, 0x0C, 0x00, 0x00]), "%": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x46, 0x26, 0x10, 0xC8, 0xC4]), "/": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x04, 0x08, 0x10, 0x20, 0x40]), "@": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7E, 0x81, 0x8F, 0x89, 0x46]), #Tipo 1 #"@": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x72,0xB1,0xB1,0x81,0x7E]), # Tipo 2 "*": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x50, 0xE0, 0x50, 0x00]), #Tipo 1 #"*": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x14,0x08,0x3E,0x08,0x14]), # Tipo 2 "$": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x44, 0x4A, 0xFF, 0x4A, 0x32]), "!": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x00, 0xFA, 0x00, 0x00]), "#": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x44, 0xFF, 0x44, 0xFF, 0x44]), "+": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x10, 0x10, 0x7C, 0x10, 0x10]), "-": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x10, 0x10, 0x10, 0x00]), "_": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x01, 0x01, 0x01, 0x01, 0x01]), # ESPECIALES # Unidades "\x80": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x22, 0x41, 0x22, 0xDC, 0xC0]), # °C "\x81": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x00, 0x00, 0x00, 0xC0, 0xC0 ]), # ° pequeño "\x82": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x00, 0x00, 0xE0, 0xA0, 0xE0 ]), # ° grande "\x83": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x78, 0x04, 0x04, 0x7F, 0x00 ]), # u letra griega # Simbolos "\x84": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x00, 0x00, 0x10, 0x00, 0x00 ]), # Punto centro Pequeño "\x85": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x00, 0x1C, 0x1C, 0x1C, 0x00 ]), # Punto centro Grande # Iconos "\x86": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x30, 0x78, 0x3C, 0x78, 0x30 ]), # Corazón relleno "\x87": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x30, 0x48, 0x24, 0x48, 0x30 ]), # Corazón blanco "\x88": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x38, 0xE4, 0x27, 0xE4, 0x38 ]), # Conector "\x89": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x00, 0x00, 0xFF, 0x00, 0x00]), # Cable "\x90": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0xFC, 0x4C, 0x20, 0x1F, 0x03 ]), # Nota musical "\x91": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0xFF, 0x4F, 0x4F, 0x4F, 0x7F]), # Celular "\x92": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x08, 0x78, 0xFA, 0x78, 0x08]), # Campana "\x93": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x08, 0x44, 0x14, 0x44, 0x08 ]), # Cara feliz #Animaciones "\x94": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x7C, 0x3E, 0x1E, 0x3E, 0x7C ]), # Pacman abierto "\x95": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x7C, 0xFE, 0xFE, 0xFE, 0x7C ]), # Pacman cerrado "\x96": lambda: self.Letras2Led(posicion3 - 8 * i, color, [0x7C, 0xCF, 0xFE, 0xCF, 0x7C]), # Fantom1 "\x97": lambda: self.Letras2Led(posicion3 - 8 * i, color, [ 0x7F, 0xCC, 0xFF, 0xCC, 0x7F ]), # Fantom2 }.get(valor, lambda: None)() def Message(self, mensaje, posicion3, color): for i in range(len(mensaje)): self.tabla(mensaje[i], posicion3, color, i) #---------------------------------------------------------------------------# # Reiniciar contador de Pantalla # #---------------------------------------------------------------------------# def reiniciar(self): self.contador_pantalla = -8
class GpioThread(threading.Thread): KEYWORDS = [ "help", "module", "filter", "transition", "update", "off", "?", "h", "m", "f", "t", "u" ] def __init__(self): threading.Thread.__init__(self) self.strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) self.strip.begin() self.exit = False self.command = None self.reply = None self.lock = threading.Condition() self.isConnected = False self.isConnectedTick = 0 self.commandId = 0 logging.info("GpioThread initialized") def run(self): # self.moduleFactory = DefaultComponents.ColorModule self.moduleFactory = Cannon.Cannon self.filterFactory = DefaultComponents.NoneFilter self.transitionFactory = DefaultComponents.NoneTransition self.moduleFactory.configure([]) self.filterFactory.configure([]) self.transitionFactory.configure([]) self.module = self.filterFactory.getinstance( self.moduleFactory.getinstance()) logging.debug("GpioThread started (Thread name={})".format( threading.Thread.getName(self))) messageNumber = 0 while True: self.lock.acquire() if self.exit: self.lock.release() break if self.command is not None: messageNumber += 1 logging.debug("Received message #{}: {}".format( messageNumber, self.command)) self.reply = self.processCommandT(self.command) self.command = None # self.lock.notify() logging.debug("Notified message #{}: {}".format( messageNumber, self.reply)) self.lock.release() block = self.module.next() self.isConnectedTick += 1 if self.isConnectedTick >= 100: if not self.isConnected: block[0] = [255, 0, 0] block[1] = [0, 0, 0] self.isConnectedTick = 0 self.project(block) logging.info("GpioThread stopping") for i in range(LED_COUNT): self.strip.setPixelColor(i, 0x0) self.strip.show() def processCommandT(self, line): """Apply the changes, ane return the reply to the command""" chunks = line.split() if len(chunks) <= 0: return "ERR: Empty command" if not chunks[0] in GpioThread.KEYWORDS: return "ERR: Unknown keyword {}; use \"help\" or \"?\" for references" if chunks[0] in ["help", "h", "?"]: if len(chunks) == 1: return self.getHelp() return self.getHelp(chunks[1:]) if chunks[0] in ["update", "u"]: self.update( self.filterFactory.getinstance( self.moduleFactory.getinstance())) return "OK: Transition complete" if chunks[0] in ["module", "m"]: if len(chunks) < 2: return self.getHelp(["m"]) module = Defs.MODULES.get(chunks[1]) if module is None: return "ERR: unknown module \"{}\"".format(chunks[1]) self.moduleFactory = module self.moduleFactory.configure(chunks[2:]) return "OK: Module set to \"{}\"; use >> update << to apply changes".format( chunks[1]) if chunks[0] in ["filter", "f"]: if len(chunks) < 2: return self.getHelp(["f"]) factory = Defs.FILTERS.get(chunks[1]) if factory is None: return "ERR: unknown filter \"{}\"".format(chunks[1]) self.filterFactory = factory self.filterFactory.configure(chunks[2:]) return "OK: Filter set to \"{}\"; use >> update << to apply changes".format( chunks[1]) if chunks[0] in ["transition", "t"]: if len(chunks) < 2: return self.getHelp(["t"]) transition = Defs.TRANSITIONS.get(chunks[1]) if transition is None: return "ERR: unknown transition \"{}\"".format(chunks[1]) self.transitionFactory = transition self.transitionFactory.configure(chunks[2:]) return "OK: Transition set to \"{}\"; use >> update << to apply changes".format( chunks[1]) if chunks[0] in ["off"]: Defs.MODULES.get("color").configure(["0x0"]) self.update(Defs.MODULES.get("color").getinstance()) # no filter used return "Strand off" return "TODO: Process commands" def update(self, afterModule): logging.info("Starting transition") transition = self.transitionFactory.newinstance( self.module, afterModule) block = transition.next() while block is not None: self.project(block) block = transition.next() self.module = afterModule logging.info("Transition finished") def getHelp(self, topic=[]): if len(topic) > 0: if topic[0] in ["module", "m"]: if len(topic) > 1: name = topic[1] if name in Defs.MODULES.keys(): module = Defs.MODULES[name] return Const.APP_NAME + " \"{}\":\n{}".format( module.name, module.help) return Const.APP_NAME + " modules: Unknown name \"{}\"".format( name) return Const.APP_NAME + " modules: {}".format( Defs.MODULES.keys()) if topic[0] in ["filter", "f"]: if len(topic) > 1: name = topic[1] if name in Defs.FILTERS.keys(): filter = Defs.FILTERS[name] return Const.APP_NAME + " \"{}\":\n{}".format( filter.name, filter.help) return Const.APP_NAME + " filters: Unknown name \"{}\"".format( name) return Const.APP_NAME + " filters: {}\n".format( Defs.FILTERS.keys()) if topic[0] in ["transition", "t"]: if len(topic) > 1: name = topic[1] if name in Defs.TRANSITIONS.keys(): transition = Defs.TRANSITIONS[name] return Const.APP_NAME + " \"{}\":\n{}".format( transition.name, transition.help) return Const.APP_NAME + " transitions: Unknown name \"{}\"".format( name) return Const.APP_NAME + " transitions: {}\n".format( Defs.TRANSITIONS.keys()) return Const.APP_NAME + " manual. The recognized keywords are\n" \ " module/m: graphics painter configuration\n" \ " filter/f: display filter configuration; filters are used to display only subsections of the graphics\n" \ " transition/t: configure transition used to update to new graphics module or filter\n" \ " update/u: execute the configuration changes\n" \ " off: turn the strand off (display black)\n" \ " help/h/?: display help. use >> help <keyword> << to list available configuration details\n" def ctrl(self, command): self.lock.acquire() self.command = command self.commandId += 1 logging.debug("Setting command #{}: {}".format(self.commandId, command)) self.reply = None boo = self.lock.wait(1) if not boo: logging.warning("Condition timed out. Command={}".format( self.command)) reply = self.reply if reply == None: logging.warning("Command \"{}\": no reply set!") reply = "ERR: no reply received" self.lock.release() return reply def quit(self): self.lock.acquire() self.exit = True logging.info("GpioThread signalled to stop") self.lock.release() def __adjust(self, num): return num * (num >> 2) >> 6 # return num def __toGrbInt(self, tuple): ret = (self.__adjust(tuple[1]) << 16) \ + (self.__adjust(tuple[0]) << 8) \ + self.__adjust(tuple[2]) return ret def project(self, block): # print("Graphics colors={}" # .format(map(hex, map(lambda x: (x[0] << 16) + (x[1] << 8) + x[2], block)))) for i in range(LED_COUNT): self.strip.setPixelColor(i, self.__toGrbInt(block[i])) self.strip.show()
for i, pos in enumerate(self.snake): _set_pixel(strip, pos, Color(255 - (snake_len - i) * 20, 0, 0)) if self.to_clear: _set_pixel(strip, self.to_clear, Color(0, 0, 0)) if self.reward: _set_pixel(strip, self.reward, REWARD_COLORS[self._frame % len(REWARD_COLORS)]) if __name__ == '__main__': stdscr = curses.initscr() curses.cbreak() stdscr.keypad(1) stdscr.nodelay(1) # Create NeoPixel object with appropriate configuration. strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) strip.begin() try: while True: game = Game() while game.is_on: game.input(stdscr.getch()) game.next_frame() game.draw(strip) strip.show() time.sleep(0.15) clrscr(strip) except KeyboardInterrupt: curses.endwin()
class Controller: LEDS = None NEOPIXEL_GPIO_PIN = None NEOPIXEL_FREQUENCY = None NEOPIXEL_DMA = None NEOPIXEL_INVERT = None NEOPIXEL_BRIGHTNESS = None NEOPIXEL_CHANNEL = None NEOPIXEL_STRIP = None neopixel = None thread = None effect = None def __init__(self, leds, neopixel_gpio_pin, neopixel_frequency, neopixel_dma, neopixel_invert, neopixel_brightness, neopixel_channel, neopixel_strip): print("[Neopixel][info] Initialising NeoPixel") self.LEDS = leds self.NEOPIXEL_GPIO_PIN = neopixel_gpio_pin self.NEOPIXEL_FREQUENCY = neopixel_frequency self.NEOPIXEL_DMA = neopixel_dma self.NEOPIXEL_INVERT = neopixel_invert self.NEOPIXEL_BRIGHTNESS = neopixel_brightness self.NEOPIXEL_CHANNEL = neopixel_channel self.NEOPIXEL_STRIP = neopixel_strip self.neopixel = Adafruit_Neopixel( self.LEDS, self.NEOPIXEL_GPIO_PIN, self.NEOPIXEL_FREQUENCY, self.NEOPIXEL_DMA, self.NEOPIXEL_INVERT, self.NEOPIXEL_BRIGHTNESS, self.NEOPIXEL_CHANNEL, self.NEOPIXEL_STRIP ) try: self.neopixel.begin() except AttributeError: print("[Neopixel][error] An error occurred initialising NeoPixel") def pixel_color(self, pixel, color): print("[Controller][info] Setting color: '%s' to NeoPixel pixel '%d'" % (color.get_hex(), pixel)) try: self.neopixel.setPixelColor(pixel, color.get_bit()) self.neopixel.show() except AttributeError: print("[Controller][error] An error occurred setting color to NeoPixel pixel") def color_wheel(self, pos): print("[Controller][info] Generation a color wheel") if pos < 85: return Color(pos * 3, 255 - pos * 3, 0) elif pos < 170: pos -= 85 return Color(255 - pos * 3, 0, pos * 3) else: pos -= 170 return Color(0, pos * 3, 255 - pos * 3) def brightness(self, brightness): print("[Controller][info] Setting brightness: '%d' to NeoPixel pixels" % (brightness)) try: self.neopixel.setBrightness(brightness) self.neopixel.show() except AttributeError: print("[Neopixel][error] An error occurred setting brightness on NeoPixel") def color(self, color): print("[Controller][info] Setting color: '%s' to NeoPixel pixels" % (color.get_hex())) try: for i in range(self.LEDS): self.pixel_color(i, color) self.neopixel.show() except AttributeError: print("[Controller][error] An error occurred setting color to NeoPixel pixels") def start_effect(self, effect, color): print("[Controller][info] Starting effect: '%s' to NeoPixel pixels" % (effect)) try: self.effect = eval(effect + '.' + effect.replace('_', ' ').title().replace(' ', ''))(self) self.thread = threading.Thread(target=self.effect.run, args=(color,)) self.thread.daemon = True self.thread.start() except AttributeError: print("[Controller][error] An error occurred starting effect to NeoPixel pixels") def stop_effect(self): print("[Controller][info] Stopping effect to NeoPixel pixels") try: if self.effect is not None: self.effect.stop() except AttributeError: print("[Controller][error] An error occurred stopping effect to NeoPixel pixels") def quit_effect(self): print("[Controller][info] Quitting effect to NeoPixel pixels") try: if self.effect is not None: self.thread.terminate() except AttributeError: print("[Controller][error] An error occurred quitting effect to NeoPixel pixels") def effects(self): print("[Controller][info] Getting a list of NeoPixel effects") try: effects = [file for file in os.listdir('./neopixelcontroller/lib/effects') if not file.startswith('.') and not file.startswith('__init__') and not file.endswith('.pyc') and not file.startswith('effect_test')] return [effect.replace('.py', '') for effect in effects] except AttributeError: print("[Controller][error] An error occurred get NeoPixel effects") def clear(self): print("[Controller][info] Clearing pixels on NeoPixel") try: self.stop_effect() self.quit_effect() self.color(Color(0, 0, 0)) self.brightness(0) except AttributeError: print("[Controller][error] An error occurred clearing all pixels on NeoPixel") def cleanup(self): print("[Controller][info] NeoPixel clean up") self.clear() def __exit__(self): print("[Controller][info] NeoPixel exit") self.cleanup()
class ColoramaDisplay(ApplicationSession): @inlineCallbacks def onJoin(self, details): self._serial = get_serial() self._prefix = u'io.crossbar.demo.iotstarterkit.{}.pixelstrip'.format(self._serial) self.log.info("Crossbar.io IoT Starterkit Serial No.: {serial}", serial=self._serial) self.log.info("ColoramaDisplay connected: {details}", details=details) # get custom configuration cfg = self.config.extra self._leds = Adafruit_NeoPixel( cfg['led_count'], cfg['led_pin'], cfg['led_freq_hz'], cfg['led_dma'], cfg['led_invert'], cfg['led_brightness']) self._leds.begin() for proc in [ (self.set_color, 'set_color'), (self.get_color, 'get_color'), (self.flash, 'flash'), (self.lightshow, 'lightshow'), (self.color_wipe, 'color_wipe'), (self.theater_chase, 'theater_chase'), (self.rainbow, 'rainbow'), (self.rainbow_cycle, 'rainbow_cycle'), (self.theater_chaserainbow, 'theater_chaserainbow'), ]: yield self.register(proc[0], u'{}.{}'.format(self._prefix, proc[1])) self.flash() self.log.info("ColoramaDisplay ready!") @inlineCallbacks def flash(self, delay=50, repeat=5): delay = float(delay) / 1000. for i in range(repeat): self.set_color(0xe1, 0xda, 0x05) yield sleep(2 * delay) self.set_color(0x52, 0x42, 0x00) yield sleep(delay) @inlineCallbacks def lightshow(self): # Color wipe animations. yield self.color_wipe(255, 0, 0) # Red wipe yield self.color_wipe(0, 255, 0) # Blue wipe yield self.color_wipe(0, 0, 255) # Green wipe # Theater chase animations. yield self.theater_chase(127, 127, 127) # White theater chase yield self.theater_chase(127, 0, 0) # Red theater chase yield self.theater_chase(0, 0, 127) # Blue theater chase # Rainbow animations. yield self.rainbow() yield self.rainbow_cycle() #yield self.theater_chase_rainbow() yield self.flash() # Define functions which animate LEDs in various ways. @inlineCallbacks def color_wipe(self, r, g, b, wait_ms=50): """Wipe color across display a pixel at a time.""" for i in range(self._leds.numPixels()): self.set_color(r, g, b, i) yield sleep(wait_ms / 1000.0) @inlineCallbacks def theater_chase(self, r, g, b, wait_ms=50, iterations=10): """Movie theater light style chaser animation.""" for j in range(iterations): for q in range(3): for i in range(0, self._leds.numPixels(), 3): self.set_color(r, g, b, i + q) yield sleep(wait_ms / 1000.0) for i in range(0, self._leds.numPixels(), 3): self.set_color(0, 0, 0, i + q) def wheel(self, pos): """Generate rainbow colors across 0-255 positions.""" if pos < 85: return (pos * 3, 255 - pos * 3, 0) elif pos < 170: pos -= 85 return (255 - pos * 3, 0, pos * 3) else: pos -= 170 return (0, pos * 3, 255 - pos * 3) @inlineCallbacks def rainbow(self, wait_ms=20, iterations=1): """Draw rainbow that fades across all pixels at once.""" for j in range(256 * iterations): for i in range(self._leds.numPixels()): r, g, b = self.wheel((i + j) & 255) self.set_color(r, g, b, i) yield sleep(wait_ms / 1000.0) @inlineCallbacks def rainbow_cycle(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._leds.numPixels()): r, g, b = self.wheel(((i * 256 / self._leds.numPixels()) + j) & 255) self.set_color(r, g, b, i) yield sleep(wait_ms / 1000.0) @inlineCallbacks def theater_chaserainbow(self, wait_ms=50): """Rainbow movie theater light style chaser animation.""" for j in range(256): for q in range(3): for i in range(0, self._leds.numPixels(), 3): r, g, b = self.wheel((i+j) % 255) self.set_color(r, g, b, i + q) yield sleep(wait_ms / 1000.0) for i in range(0, self._leds.numPixels(), 3): self.set_color(0, 0, 0, i) def set_color(self, red, green, blue, k=None): if k is None: for i in range(self._leds.numPixels()): # FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels? self._leds.setPixelColorRGB(i, green, red, blue) color_change = { u'led': i, u'r': red, u'g': green, u'b': blue } self.publish(u'{}.on_color_set'.format(self._prefix), color_change) else: # FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels? self._leds.setPixelColorRGB(k, green, red, blue) color_change = { u'led': k, u'r': red, u'g': green, u'b': blue } self.publish(u'{}.on_color_set'.format(self._prefix), color_change) self._leds.show() def get_color(self, k): c = self._leds.getPixelColor(k) color = { u'g': c >> 16, u'r': (c >> 8) & 0xff, u'b': c & 0xff, } return color def onLeave(self, details): self.log.info("Session closed: {details}", details=details) self.disconnect() def onDisconnect(self): self.log.info("Connection closed") for i in range(self._leds.numPixels()): self._leds.setPixelColorRGB(i, 0, 0, 0) self._leds.show() try: reactor.stop() except ReactorNotRunning: pass
class BinaryClock: ''' The class, which makes the binary clock run... ''' def __init__(self): GPIO.setmode(GPIO.BOARD) # absolute path to current file old: os.getcwd() self.basePath = os.path.dirname( os.path.abspath( inspect.getfile( inspect.currentframe() ) ) ) # Number of columns in clock self.clock_width = 6 # Number of rows in clock self.clock_height = 4 self.curr_fg_color = Color(0, 0, 0) self.curr_bg_color = Color(0, 0, 0) self.flag_clockIndent = False # Number of LED pixels. LED_COUNT = self.clock_width * self.clock_height # GPIO pin connected to the pixels (18 uses PWM!). LED_PIN = 18 # LED signal frequency in hertz (usually 800khz) LED_FREQ_HZ = 800000 # DMA channel to use for generating signal (try 5) LED_DMA = 5 # Set to 0 for darkest and 255 for brightest LED_BRIGHTNESS = 128 # 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 # Strip type and colour ordering LED_STRIP = ws.WS2811_STRIP_GRB # path to configuration file cfgFilePath = os.path.join(self.basePath, 'config', 'clockConfig.cfg') if not os.path.exists(cfgFilePath): cfgFilePathDefault = os.path.join(self.basePath, 'config', 'clockConfig_default.cfg') copyfile(cfgFilePathDefault, cfgFilePath) # configuration setup self.configuration = bcc.ConfigFile(cfgFilePath) self.configuration.readConfigFile() self.helpers = bch.Helpers(self.configuration) # Create NeoPixel object with appropriate configuration. self.strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_STRIP) # Intialize the library (must be called once before other functions). self.strip.begin() # LED Functions self.stripFunctions = bcl.LEDFunctions(self.strip, self.clock_width, self.clock_height) # Plugins self.plugin2 = p_TimeAsText.ShowTimeAsText(self.strip, self.clock_width, self.clock_height, self.basePath) self.plugin3 = p_MatrixEffect.ShowMatrixEffect(self.strip, self.clock_width, self.clock_height, self.configuration) self.plugin4 = p_SplashScreen.ShowSplashScreen(self.strip, self.clock_width, self.clock_height) self.plugin5 = p_RainbowAllLEDs.ShowRainbowAllLEDs(self.strip, self.configuration) self.plugin6 = p_Fire.ShowFire(self.strip, self.clock_width, self.clock_height, self.configuration) # initialize the observer event watchedDir = os.path.join(self.basePath, 'config') self.event_handler = PatternMatchingEventHandler( patterns=["*.cfg"], ignore_patterns=[], ignore_directories=True) self.event_handler.on_any_event = self.on_any_event self.observer = Observer() self.observer.schedule(self.event_handler, watchedDir, recursive=False) self.observer.start() # ldr gpio pin number self.pin_to_circuit = 7 self.brightness = self.configuration.brightness_general self.arr_ldrValues = [] '''------------------------------------------------------------------------- # O T H E R F U N C T I O N S ----------------------------------------''' def rc_time(self): while True: if self.configuration.running == self.configuration.stop == 1: break if self.configuration.sensitive == 1: GPIO.setup(self.pin_to_circuit, GPIO.OUT) GPIO.output(self.pin_to_circuit, GPIO.LOW) time.sleep(0.1) GPIO.setup(self.pin_to_circuit, GPIO.IN) c = 0 while (GPIO.input(self.pin_to_circuit) == GPIO.LOW): c += 1 if c >= 20000: break self.arr_ldrValues.append(c) # print "c: " + str(c) if len(self.arr_ldrValues) == 10: ldrValue = (sum(self.arr_ldrValues) - max(self.arr_ldrValues) - min(self.arr_ldrValues)) / (len(self.arr_ldrValues) - 2) del self.arr_ldrValues[:] self.brightness = int(math.floor( (238 / (1 + math.exp(0.000475 * (2.25 * ldrValue - 10000)))) + 19)) print str(self.brightness) else: self.brightness = self.configuration.brightness_general print str(self.brightness) time.sleep(0.5) # -------------------------------------------------------------------------- def on_any_event(self, event): self.configuration.readConfigFile() if self.configuration.flag_whipeLEDs: self.stripFunctions.wipeLEDs() # -------------------------------------------------------------------------- def upInTheSky(self): backgroundNoSeconds = [1, 2, 3, 4, 7, 8, 9, 10, 13, 14, 15, 16, 19, 20, 21, 22] arr = [] # get current xy coordinates of lit LEDs for i in range(self.strip.numPixels()): if self.strip.getPixelColor(i) == self.curr_fg_color: arr.append(i) for j in range(4): for i, p in enumerate(arr): x, y = self.stripFunctions.get2DCoordinateFrom1D(p) self.stripFunctions.setColorBy2DCoordinates(x, y - j, self.curr_fg_color) self.strip.show() time.sleep(0.2) if self.configuration.show_seconds == 1: for i in range(self.strip.numPixels()): self.stripFunctions.setColorBy1DCoordinate( i, self.curr_bg_color, flag_forClock=self.flag_clockIndent) else: for i in range(len(backgroundNoSeconds)): self.stripFunctions.setColorBy1DCoordinate( backgroundNoSeconds[i], self.curr_bg_color, flag_forClock=self.flag_clockIndent) self.strip.show() time.sleep(1) '''------------------------------------------------------------------------- # B I N A R Y C L O C K F U N C T I O N S --------------------------''' def runClockBinary(self): while True: # get current time from system now = datetime.datetime.now() # get current minute and second Value for color within hour currTimeValue = now.second + (now.minute * 60) # 3600 iterations per hour over Rainbow colors for j in range(currTimeValue, 3600): if self.configuration.running == self.configuration.stop == 1: # closing animtion self.upInTheSky() self.stripFunctions.wipeLEDs(Color(0, 0, 0)) self.configuration.saveConfigFile() return # check if plugin should run if self.configuration.plugin != 1: return # every hue devided into 3600 steps h = j / 3600.0 self.binaryTime(h) # sleep for 1 second time.sleep(1) # -------------------------------------------------------------------------- def binaryTime(self, hue): # foreground color colorForeground = self.helpers.getRainbowColor( self.configuration.rainbow, hue) self.curr_fg_color = colorForeground backgroundNoSeconds = [1, 2, 3, 4, 7, 8, 9, 10, 13, 14, 15, 16, 19, 20, 21, 22] # set background color if self.configuration.background == 1: colorBackground = Color(self.configuration.background_value, self.configuration.background_value, self.configuration.background_value) else: colorBackground = Color(0, 0, 0) self.curr_bg_color = colorBackground # show / hide seconds if self.configuration.show_seconds == 1: for i in range(self.strip.numPixels()): self.stripFunctions.setColorBy1DCoordinate( i, colorBackground, flag_forClock=self.flag_clockIndent) else: for i in range(len(backgroundNoSeconds)): self.stripFunctions.setColorBy1DCoordinate( backgroundNoSeconds[i], colorBackground, flag_forClock=self.flag_clockIndent) # get current Time curTime = datetime.datetime.now() # separate date elements year = curTime.year month = curTime.month day = curTime.day # separate time elements hour = curTime.hour minute = curTime.minute second = curTime.second # new year countdown if day == 31 and month == 12 and hour == 23 and minute == 59 and second = 50: open(os.path.join(self.basePath, 'other', 'customText.txt'), 'w').close() with open(os.path.join(self.basePath, 'other', 'customText.txt'), "a") as myfile: myfile.write("10 9 8 7 6 5 4 3 2 1 0 Frohes Neues Jahr " + str(year + 1)) self.plugin2.showTimeAsText(fg_color=self.curr_fg_color, bg_color=self.curr_bg_color, fps=10) # ldr log file if hour == 0 and minute == 0 and second == 0: open(os.path.join(self.basePath, 'config', 'ldrValues.log'), 'w').close() if second == 0: with open(os.path.join(self.basePath, 'config', 'ldrValues.log'), "a") as myfile: myfile.write(str(hour) + ":" + str(minute) + " - " + str(self.brightness) + "\n") print(str(hour) + ":" + str(minute) + ":" + str(second)) # column values for hour, minues and seconds # if seconds should not be shown, hour and minute columns += 1 y_posH = 0 if self.configuration.show_seconds == 1 else 1 y_posM = 2 if self.configuration.show_seconds == 1 else 3 y_posS = 4 # hour self.columnValuesWithPixel(hour, y_posH, colorForeground) # minute self.columnValuesWithPixel(minute, y_posM, colorForeground) # second if self.configuration.show_seconds == 1: self.columnValuesWithPixel(second, y_posS, colorForeground) self.strip.setBrightness(self.brightness) self.strip.show()
class WPad(ApplicationSession): """ Connects the Pi's GPIOs to WAMP. """ PINMODES = {'bcm': GPIO.BCM, 'board': GPIO.BOARD} def _select_row(self, row=None): i = 0 for pin in self._row_pins: if row is None or row != i: GPIO.output(pin, GPIO.HIGH) else: GPIO.output(pin, GPIO.LOW) i += 1 def set_color(self, red, green, blue, k=None): if k is None: for i in range(self._ledstrip.numPixels()): self._ledstrip.setPixelColorRGB(i, green, red, blue) else: self._ledstrip.setPixelColorRGB(k, green, red, blue) self._ledstrip.show() @inlineCallbacks def flash(self, r=255, g=255, b=255, delay=25, repeat=10): delay = float(delay) / 1000. for i in range(repeat): self.set_color(r, g, b) yield sleep(2 * delay) self.set_color(0, 0, 0) yield sleep(delay) @inlineCallbacks def _tick(self): self._tick_no += 1 now = time.time() self._tick_sent[self._tick_no] = now try: pub = yield self.publish(u'{}.on_alive'.format(self._prefix), self._tick_no, options=PublishOptions(acknowledge=True, exclude_me=False)) except: self.log.failure() else: self.log.info('TICK sent [tick {}, pub {}]'.format( self._tick_no, pub.id)) def show_load(self): cpu_load = int(round(psutil.cpu_percent(interval=None))) mem_load = int(round(psutil.virtual_memory().percent)) if cpu_load > 99: cpu_load = 99 if mem_load > 99: mem_load = 99 self._cpu_load.popleft() self._cpu_load.append(cpu_load) if not self._is_scrolling: text = "{:0>2d}{:0>2d}".format(mem_load, cpu_load) self._disp.setMessage(text) @inlineCallbacks def scroll_text(self, disp, text): if self._is_scrolling: return self._is_scrolling = True s = text + " " for i in range(len(s)): disp.setMessage(s[i:i + 4]) yield sleep(.2) self._is_scrolling = False @inlineCallbacks def onJoin(self, details): self._tick_sent = {} self._is_scrolling = False extra = self.config.extra self._serial = get_serial() self._my_ip = get_ip_address() self._joined_at = time.strftime("%H:%M") self._app_prefix = u'io.crossbar.demo.wpad' self._prefix = u'{}.wpad.{}'.format(self._app_prefix, self._serial) self.log.info("Crossbar.io IoT Starterkit Serial No.: {serial}", serial=self._serial) self.log.info("WPad connected: {details}", details=details) # setup Neopixel LED strip self._ledstrip = Adafruit_NeoPixel( extra['led_count'], extra['led_pin'], extra['led_freq_hz'], extra['led_dma'], extra['led_invert'], extra['led_brightness']) self._ledstrip.begin() # setup GPIO GPIO.setwarnings(False) pinmode = extra.get("pin_mode", "bcm") if pinmode in WPad.PINMODES: GPIO.setmode(WPad.PINMODES[pinmode]) else: GPIO.setmode(GPIO.BCM) GPIO.cleanup() self._row_pins = extra.get("row_pins", []) for pin in self._row_pins: GPIO.setup(pin, GPIO.OUT) self._select_row(0) # setup ADC self._adc = Adafruit_ADS1x15.ADS1015() def log_adc(): # read values from ADC values = [] for i in range(4): values.append(self._adc.read_adc(i, gain=8)) # normalize values nvalues = [ round(100. * ((2048. - float(x)) / 2048.), 3) for x in values ] nvalues = [nvalues[2], nvalues[3], nvalues[1], nvalues[0]] # illuminate neopixel strip for i in range(4): col = int(round(255. * float(nvalues[i]) / 100.)) self._ledstrip.setPixelColorRGB(i * 2, col, col, col) self._ledstrip.setPixelColorRGB(i * 2 + 1, col, col, col) self._ledstrip.show() # publish WAMP event self.publish(u'{}.on_wpad'.format(self._prefix), nvalues) scan_rate = float(extra.get(u'scan_rate', 50)) self.log.info('Scanning sensors with {} Hz ..'.format(scan_rate)) LoopingCall(log_adc).start(1. / scan_rate) self._cpu_load = deque() for i in range(self._ledstrip.numPixels()): self._cpu_load.append(0) # our quad, alphanumeric display: https://www.adafruit.com/products/2157 self._disp = QuadAlphanum(extra[u'i2c_address']) self._disp.clear() self._disp.setBrightness(int(round(extra[u'brightness'] * 15))) @inlineCallbacks def displayNotice(): yield self.scroll_text( self._disp, "IP {} ({}) ".format(self._my_ip, self._joined_at).upper()) # every couple of secs, display a notice LoopingCall(displayNotice).start(53) def on_tick(tick_no): if tick_no in self._tick_sent: rtt = 1000. * (time.time() - self._tick_sent[tick_no]) del self._tick_sent[tick_no] else: rtt = None self.log.info('TICK received [tick {}, rtt {}]'.format( tick_no, rtt)) self.flash(r=0, g=255, b=0, repeat=1) yield self.subscribe(on_tick, u'{}.on_alive'.format(self._prefix)) self._tick_no = 0 self._tick_loop = LoopingCall(self._tick) self._tick_loop.start(7) LoopingCall(self.show_load).start(1) # signal we are done with initializing our component self.publish(u'{}.on_ready'.format(self._prefix)) self.log.info("WPad ready.") self.flash() def onLeave(self, details): self.log.info("Session closed: {details}", details=details) self.disconnect() def onDisconnect(self): self.log.info("Connection closed") try: reactor.stop() except ReactorNotRunning: pass
class Display(object): """ Args: gpio_pin (int): which GPIO pin the data should be sent on. Note: this is not the physical pin number nor the WiringPi number. Keyword Args: led_frequency (int): the frequency of the LED strand (hertz) dma (int): the DMA channel to use for generating the signal. DO NOT use 5 on the Pi 3 as this has been known to corrupt files. initial_brightness (int): the initial brightness setting of the LEDs. should be a value between 0 and 255. invert (bool): Set to ``True`` to invert the signal (when using NPN transistor level shift) channel (int): set to ``1`` for GPIOs 13, 19, 41, 45, or 53 """ def __init__(self, rows, cols, gpio_pin, led_frequency=800000, dma=10, initial_brightness=255, invert=False, channel=0): self.initial_brightness = initial_brightness self.pixels = self.setup(rows, cols) pixel_count = len(self.pixels) self.count = pixel_count self.num_rows = rows self.num_cols = cols for pixel in self.pixels: pixel.brightness = initial_brightness self.strand = None self.setup_strand(gpio_pin, pixel_count, led_frequency, dma, initial_brightness, invert, channel) def setup(self, rows, cols): raise NotImplementedError() def setup_strand(self, gpio_pin, pixel_count, led_frequency, dma, initial_brightness, invert, channel): from neopixel import Adafruit_NeoPixel self.strand = Adafruit_NeoPixel(pixel_count, gpio_pin, led_frequency, dma, invert, initial_brightness, channel) self.strand.begin() def fill(self, red, green, blue, brightness=255): for pixel in self.pixels: pixel.red = red pixel.green = green pixel.blue = blue pixel.brightness = brightness def pixel_at(self, row, column): return self.pixels[row * self.num_rows + column] def show(self): for pixel in self.pixels: self.strand._led_data[pixel.id] = pixel.render() self.strand.show() def clear(self): for pixel in self.pixels: pixel.clear() self.show() def itergrid(self): for row in range(self.num_rows): for col in range(self.num_cols): yield row, col, self.pixel_at(row, col)