Beispiel #1
0
def init_strip():
    strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA,
                              LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
    strip.begin()
    logging.info('neopixel LED strip initialized')

    return strip
Beispiel #2
0
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()
Beispiel #3
0
 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()
Beispiel #4
0
 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 __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()
Beispiel #6
0
        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()
Beispiel #7
0
 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 __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()
Beispiel #9
0
class Led_Array(object):
    def __init__(self):
        self.LED_COUNT      = 256      # Number of LED pixels.
        self.LED_PIN        = 18      # GPIO pin connected to the pixels (must support PWM!).
        self.LED_FREQ_HZ    = 800000  # LED signal frequency in hertz (usually 800khz)
        self.LED_DMA        = 5       # DMA channel to use for generating signal (try 5)
        self.LED_BRIGHTNESS = 255     # 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.ROW_WIDTH      = 8       # Number of LEDs in each row of the array

        # Create NeoPixel object with appropriate configuration.
        self.led_array = Adafruit_NeoPixel( self.LED_COUNT,
                                            self.LED_PIN,
                                            self.LED_FREQ_HZ,
                                            self.LED_DMA,
                                            self.LED_INVERT,
                                            self.LED_BRIGHTNESS)

    	# Intialize the library (must be called once before other functions).
        self.led_array.begin()

    def _info(self):
        return self.LED_COUNT, self.LED_PIN, self.LED_BRIGHTNESS, self.ROW_WIDTH

    def setRowColor(self, row_number, color):
        strip = self.led_array
        start = 0 + row_number*self.ROW_WIDTH
        end = start + self.ROW_WIDTH
        for i in range(start, end):
            strip.setPixelColor(i, color)
        # strip.show()

    def fill_up_to(self, row, color):
        #strip = self.led_array
        for i in range(row+1):
            self.setRowColor(i,color)

    def empty_array(self):
        strip = self.led_array
        for i in range(256):
            strip.setPixelColorRGB(i,0,0,0)
        # strip.show()

    def render(self):
        strip = self.led_array
        strip.show()

    def fill_rect(self, i, width, color):
        start = i
        end = start + width
        if (end < start):
            raise NameError('cant create a negative rectangle')
        if(start > 31):
            start = 31
            end = 31
        for i in range(start,end):
            self.setRowColor(i,color)
Beispiel #10
0
 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()
Beispiel #11
0
 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()
Beispiel #12
0
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()
Beispiel #13
0
    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")
Beispiel #14
0
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()
    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()
Beispiel #16
0
def _get_strip():
    strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA,
                              LED_INVERT, LED_BRIGHTNESS)

    strip.begin()

    for i in range(0, strip.numPixels(), 1):
        strip.setPixelColor(i, Color(0, 0, 0))

    strip.setBrightness(100)

    return strip
Beispiel #17
0
    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 __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 onJoin(self, details):

        self._serial = get_serial()
        self._prefix = 'io.crossbar.demo.iotstarterkit.{}.colorstrip'.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]))

        yield self.color_wipe(255, 255, 255)

        self.log.info("ColoramaDisplay ready!")

        while True:
            yield self.flash(delay=20, repeat=5)
            yield self.set_color(40, 40, 40)
            yield sleep(5)
            cols = []
            for i in range(3):
                cols.append(random.randint(0, 255))
            yield self.color_wipe(*cols, wait_ms=20, repeat=5)
Beispiel #20
0
    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 __init__(self):
        self.LED_COUNT = 64  # Number of LED pixels.
        self.LED_PIN = 18  # GPIO pin connected to the pixels (must support PWM!).
        self.LED_FREQ_HZ = 800000  # LED signal frequency in hertz (usually 800khz)
        self.LED_DMA = 5  # DMA channel to use for generating signal (try 5)
        self.LED_BRIGHTNESS = 255  # 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.ROW_WIDTH = 8  # Number of LEDs in each row of the array

        # Create NeoPixel object with appropriate configuration.
        self.led_array = Adafruit_NeoPixel(self.LED_COUNT, self.LED_PIN,
                                           self.LED_FREQ_HZ, self.LED_DMA,
                                           self.LED_INVERT,
                                           self.LED_BRIGHTNESS)

        # Intialize the library (must be called once before other functions).
        self.led_array.begin()
    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')
Beispiel #23
0
    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")
Beispiel #24
0
    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)
class Led_Array(object):
    def __init__(self):
        self.LED_COUNT = 256  # Number of LED pixels.
        self.LED_PIN = 18  # GPIO pin connected to the pixels (must support PWM!).
        self.LED_FREQ_HZ = 800000  # LED signal frequency in hertz (usually 800khz)
        self.LED_DMA = 5  # DMA channel to use for generating signal (try 5)
        self.LED_BRIGHTNESS = 255  # 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.ROW_WIDTH = 8  # Number of LEDs in each row of the array

        # Create NeoPixel object with appropriate configuration.
        self.led_array = Adafruit_NeoPixel(
            self.LED_COUNT, self.LED_PIN, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, self.LED_BRIGHTNESS
        )

        # Intialize the library (must be called once before other functions).
        self.led_array.begin()

    def _info(self):
        return self.LED_COUNT, self.LED_PIN, self.LED_BRIGHTNESS, self.ROW_WIDTH

    def setRowColor(self, row_number, color):
        strip = self.led_array
        start = 0 + row_number * self.ROW_WIDTH
        end = start + self.ROW_WIDTH
        for i in range(start, end):
            strip.setPixelColor(i, color)
        # strip.show()

    def fill_up_to(self, row, color):
        # strip = self.led_array
        for i in range(row + 1):
            self.setRowColor(i, color)

    def empty_array(self):
        strip = self.led_array
        for i in range(256):
            strip.setPixelColorRGB(i, 0, 0, 0)
        # strip.show()

    def render(self):
        strip = self.led_array
        strip.show()
Beispiel #26
0
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 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)
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
Beispiel #29
0
    def onJoin(self, details):

        self._serial = get_serial()
        self._prefix = u'io.crossbar.demo.iotstarterkit.{}.colorstrip'.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]))

        yield self.color_wipe(255, 255, 255)

        self.log.info("ColoramaDisplay ready!")

        # flash + set pixels to white to indicate component running
        yield self.flash(delay=20, repeat=5)
        yield self.set_color(40, 40, 40)
 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")
Beispiel #31
0
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)
Beispiel #32
0
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_
Beispiel #33
0
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()
Beispiel #34
0
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)
Beispiel #35
0
    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
Beispiel #36
0
 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 __init__(self):
        self.LED_COUNT = 256  # Number of LED pixels.
        self.LED_PIN = 18  # GPIO pin connected to the pixels (must support PWM!).
        self.LED_FREQ_HZ = 800000  # LED signal frequency in hertz (usually 800khz)
        self.LED_DMA = 5  # DMA channel to use for generating signal (try 5)
        self.LED_BRIGHTNESS = 255  # 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.ROW_WIDTH = 8  # Number of LEDs in each row of the array

        # Create NeoPixel object with appropriate configuration.
        self.led_array = Adafruit_NeoPixel(
            self.LED_COUNT, self.LED_PIN, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, self.LED_BRIGHTNESS
        )

        # Intialize the library (must be called once before other functions).
        self.led_array.begin()
Beispiel #38
0
    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!")
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()
    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()
Beispiel #41
0
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
Beispiel #42
0
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
Beispiel #43
0
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()
Beispiel #44
0
    start = 0 + row_number*ROW_WIDTH
    end = start + ROW_WIDTH
    for i in range(start, end):
        strip.setPixelColor(i, color)
    strip.show()

def fill_up_to(strip, row, color):
    for i in range(row + 1):
        setRowColor(strip,i,color)

def empty_array(strip):
    for i in range(256):
        strip.setPixelColorRGB(i,0,0,0)
    strip.show()
# Main program logic follows:
if __name__ == '__main__':
    # Create NeoPixel object with appropriate configuration.
    led_array = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS)
	# Intialize the library (must be called once before other functions).
    led_array.begin()

    while True:
        color = Color(0, 0, 60)
        # setRowColor(led_array,1,color)
        # fill_up_to(led_array,0,color)
        # sleep(0.1)
        fill_up_to(led_array,7,color)
        sleep(5)
        empty_array(led_array)
        sleep(3)