def fill(pixels, color=(255,255,255)): for i in range(pixels.count()): pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(color[0], color[1], color[2])) pixels.show()
# Simple demo of of the WS2801/SPI-like addressable RGB LED lights. import time import RPi.GPIO as GPIO import random # Import the WS2801 module. import Adafruit_WS2801 import Adafruit_GPIO.SPI as SPI # Configure the count of pixels: PIXEL_COUNT = 48 PIXEL_CLOCK = 11 PIXEL_DOUT = 10 pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, clk=PIXEL_CLOCK, do=PIXEL_DOUT) #new functions #colour lists and functions coloor = {'r': 255, 'g': 0, 'b': 0} #define pallette to be used palette = 'xmascolours' #create a list of tuples, each one defining two shades of base colours: red, orange, yellow, green purple and blue, we then randomly select from this to produce a random #colour palette that is also distinctive listcolours = [ (178, 31, 53), (216, 39, 53), (255, 116, 53), (255, 203, 53),
def draw(self, pixels): red = math.ceil((self.__health - 1) * 255 // self.MAX_HEALTH) green = math.ceil((self.__health - 1) * 255 // self.MAX_HEALTH) blue = math.ceil((self.__health - 1) * 255 // self.MAX_HEALTH) pixels.set_pixel(self.get_current_position(), Adafruit_WS2801.RGB_to_color(255, green, blue))
class LedsPhysical: red = Adafruit_WS2801.RGB_to_color(255, 0, 0) green = Adafruit_WS2801.RGB_to_color(0, 255, 0) blue = Adafruit_WS2801.RGB_to_color(0, 0, 255) white = Adafruit_WS2801.RGB_to_color(255, 255, 255) yellow = Adafruit_WS2801.RGB_to_color(255, 255, 0) black = Adafruit_WS2801.RGB_to_color(0, 0, 0) def __init__(self): # ------- # |* * *| # ----------------- # * * *|* * *|* * * # ----------------- # # |3 4 5| # ------------------- # 0 1 2 6 7 8 9 10 11 # ------------------- self.count = 12 self.front_panel = [LedsPhysical.black] * 6 self.left_panel = [LedsPhysical.black] * 3 self.right_panel = [LedsPhysical.black] * 3 self.pixels = Adafruit_WS2801.WS2801Pixels(self.count, spi=SPI.SpiDev(0, 0), gpio=GPIO) def __enter__(self): pass def __exit__(self, exc_type, exc_value, traceback): self.close() def close(self): pass def display(self): nested_output = self.left_panel + self.front_panel + self.right_panel for n, item in enumerate(nested_output): self.pixels.set_pixel(n, item) self.pixels.show() def set_front_panel(self, panel_list): if len(panel_list) == 6: self.front_panel = panel_list else: print("Warning - ignoring incorrect panel parameter %s" % panel_list) self.display() def set_front_panel_item(self, front_panel_position, colour): """Front panel: top row: 0 1 2 next row: 3 4 5 Colour is tuple r,g,b """ self.front_panel[front_panel_position] = colour self.display() def set_left_panel(self, panel_list): if len(panel_list) == 3: self.left_panel = panel_list else: print("Warning - ignoring incorrect panel parameter %s" % panel_list) self.display() def set_right_panel(self, panel_list): if len(panel_list) == 3: self.right_panel = panel_list else: print("Warning - ignoring incorrect panel parameter %s" % panel_list) self.display() def clear_all(self): self.front_panel = [LedsPhysical.black] * 6 self.left_panel = [LedsPhysical.black] * 3 self.right_panel = [LedsPhysical.black] * 3 self.display()
def ws2801_all(self, r, g, b): pixels.clear() for x in range(PIXEL_COUNT): pixels.set_pixel(x, Adafruit_WS2801.RGB_to_color(r, g, b)) pixels.show()
def lighton(self, brightness): for i in range(self.PIXEL_COUNT): self.pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(int(255*brightness), int(200*brightness), int(150*brightness))) self.pixels.show()
SENSOR_PORT = 18 GPIO.setmode(GPIO.BCM) GPIO.setup(SENSOR_PORT, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) sensor_current = False sensor_previous = False # Configure the count of pixels: PIXEL_COUNT = 9 # Alternatively specify a hardware SPI connection on /dev/spidev0.0: SPI_PORT = 0 SPI_DEVICE = 0 pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO) redRGB = webcolors.name_to_rgb('red') orangeRGB = webcolors.name_to_rgb('orange') def flash_face(pixels, lefteye, righteye, mouth, blink_times=20): for i in range(blink_times): # blink two times, then wait pixels.clear() face(pixels, lefteye, righteye, mouth) time.sleep(0.5) pixels.clear() pixels.show()
def xmas_two_party(wait=0.001): for i in range(pixels.count()): ga_Listening() ga_Responding() phone_Ring(pixels) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(255, 0, 0)) pixels.show() time.sleep(1) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(0, 255, 0)) pixels.show() time.sleep(1) ga_Listening() ga_Responding() phone_Ring(pixels) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(255, 0, 0)) pixels.show() time.sleep(1) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(0, 255, 0)) pixels.show() time.sleep(1) ga_Listening() ga_Responding() phone_Ring(pixels) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(255, 0, 0)) pixels.show() time.sleep(1) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(0, 255, 0)) pixels.show() time.sleep(1) ga_Listening() ga_Responding() phone_Ring(pixels) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(255, 0, 0)) pixels.show() time.sleep(1) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(0, 255, 0)) pixels.show() time.sleep(1) ga_Listening() ga_Responding() phone_Ring(pixels) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(255, 0, 0)) pixels.show() time.sleep(1) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(0, 255, 0)) pixels.show() time.sleep(1) ga_Listening() ga_Responding() phone_Ring(pixels) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(255, 0, 0)) pixels.show() time.sleep(1) pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(0, 255, 0)) pixels.show() time.sleep(1) if wait > 0.0: time.sleep(wait)
def color(self, rgb, g=False, b=False): if g is not False and b is not False: return Adafruit_WS2801.RGB_to_color(b, g, rgb) else: return Adafruit_WS2801.RGB_to_color(rgb[2], rgb[1], rgb[0])
def get_color(self): return Adafruit_WS2801.RGB_to_color(150, 150, 0)
import Adafruit_WS2801 import Adafruit_GPIO.SPI as SPI import datetime import time import urllib import os light_sensor_port = 40 GPIO.setmode(GPIO.BOARD) GPIO.setup(light_sensor_port, GPIO.IN) PIXEL_COUNT = 114 SPI_PORT = 0 SPI_DEVICE = 0 pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO) color_white_bright = Adafruit_WS2801.RGB_to_color(200, 200, 200) color_white_dark = Adafruit_WS2801.RGB_to_color(30, 30, 30) color_green = Adafruit_WS2801.RGB_to_color(0, 128, 0) color_red = Adafruit_WS2801.RGB_to_color(139, 0, 0) dot_top_left = 11 dot_bottom_left = 0 dot_bottom_right = 102 dot_top_right = 113 word_es = [10, 12] word_ist = [32, 51, 52] word_vor = [7, 15, 28]
def __init__(self, SPI_PORT = 0, SPI_DEVICE = 0, PIXEL_COUNT = 14): self.pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) self.clear()
import Adafruit_GPIO.SPI as SPI import RPi.GPIO as GPIO import time import requests #### Configuration #### PIXEL_COUNT = 96 lights = { '1': [0, 1, 2] } clientId = 'ID1234' base_url = 'https://10398rsvyj.execute-api.us-west-2.amazonaws.com/prod' # Light color for when all builds are successful success_color = Adafruit_WS2801.RGB_to_color(0, 200, 0) # Light color for when a light shows a build failure failure_color = Adafruit_WS2801.RGB_to_color(200, 0, 0) # Light color when we can't get the status of the lights connection_error_color = Adafruit_WS2801.RGB_to_color(200, 200, 0) status_url = base_url + '/lights/status' SPI_PORT = 0 SPI_DEVICE = 0 #### END Configuration #### pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO)
def turn_off(): for i in range(0, PIXEL_N): color = Adafruit_WS2801.RGB_to_color(0,0,0) pixels.set_pixel(i, color) pixels.show()
def speak(pixels, eyes, mouth): eyecolor = Adafruit_WS2801.RGB_to_color(eyes[0], eyes[1], eyes[2]) pixels.set_pixel(pixels.count() - 1, eyecolor) pixels.set_pixel(pixels.count() - 2, eyecolor) mouthcolor = Adafruit_WS2801.RGB_to_color(mouth[0], mouth[1], mouth[2])
def get_color(self): if self.active: return Adafruit_WS2801.RGB_to_color(0, 255, 0) else: return Adafruit_WS2801.RGB_to_color(0, 5, 0)
def blinkDrum(drum): for k in range(drum.startLED, drum.endLED): pixels.set_pixel( k, Adafruit_WS2801.RGB_to_color(drum.color[0], drum.color[1], drum.color[2]))
def test_pixels(pixels, selected): for i in range(pixels.count()): pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(89, 17, 88)) pixels.show() print(i) time.sleep(2)
def digital_clock_horizontal(timer_value=1, timer_unit="minutes", display_on_lights_bool=0): import numpy as np import time import math import os if display_on_lights_bool == 1: import Adafruit_WS2801 import Adafruit_GPIO.SPI as SPI import RPi.GPIO as GPIO try: GPIO.setmode(GPIO.BCM) GPIO.setup(12, GPIO.OUT) GPIO.setup(16, GPIO.OUT) GPIO.output(16, GPIO.HIGH) GPIO.output(12, GPIO.LOW) except Exception as ex: print(ex) print("Error Encountered") if display_on_lights_bool == 1: PIXEL_COUNT = 160 PIXEL_CLOCK = 11 PIXEL_DOUT = 10 pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, clk=PIXEL_CLOCK, do=PIXEL_DOUT) pixels.clear() pixels.show() #RBG hour_color = Adafruit_WS2801.RGB_to_color(0, 255, 0) #blue minute_color = Adafruit_WS2801.RGB_to_color(255, 50, 255) #yellow second_color = Adafruit_WS2801.RGB_to_color(255, 255, 0) #magenta if timer_unit == "seconds": timer_color = Adafruit_WS2801.RGB_to_color(50, 0, 255) #green elif timer_unit == "minutes": timer_color = Adafruit_WS2801.RGB_to_color(255, 0, 0) #red elif timer_unit == "hours": timer_color = Adafruit_WS2801.RGB_to_color(200, 255, 0) #purple else: print("Error getting timer color") exit() number_one = [[0, 1], [1, 0], [1, 1], [2, 1], [3, 1], [4, 0], [4, 1], [4, 2]] number_two = [[0, 0], [0, 1], [0, 2], [1, 2], [2, 0], [2, 1], [2, 2], [3, 0], [4, 0], [4, 1], [4, 2]] number_three = [[0, 0], [0, 1], [0, 2], [1, 2], [2, 0], [2, 1], [2, 2], [3, 2], [4, 0], [4, 1], [4, 2]] number_four = [[0, 0], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1], [2, 2], [3, 2], [4, 2]] number_five = [[0, 0], [0, 1], [0, 2], [1, 0], [2, 0], [2, 1], [2, 2], [3, 2], [4, 0], [4, 1], [4, 2]] number_six = [[0, 0], [0, 1], [0, 2], [1, 0], [2, 0], [2, 1], [2, 2], [3, 0], [3, 2], [4, 0], [4, 1], [4, 2]] number_seven = [[0, 0], [0, 1], [0, 2], [1, 0], [1, 2], [2, 2], [3, 2], [4, 2]] number_eight = [[0, 0], [0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1], [2, 2], [3, 0], [3, 2], [4, 0], [4, 1], [4, 2]] number_nine = [[0, 0], [0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1], [2, 2], [3, 2], [4, 2]] number_zero = [[0, 0], [0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 2], [3, 0], [3, 2], [4, 0], [4, 1], [4, 2]] def print_timer(grid, seconds_remaining, timer_unit): #Get the timer value if timer_unit == "seconds": timer = math.ceil(seconds_remaining) elif timer_unit == "minutes": timer = math.ceil(seconds_remaining / 60) elif timer_unit == "hours": timer = math.ceil(seconds_remaining / (60 * 24)) else: print("Error getting timer") exit() ## Check if timer entered new unit (e.g. minutes -> seconds), then change the unit and the value. Like going from 1 minute to 59 seconds. if timer_unit == "hours" and (seconds_remaining / (60 * 24)) < 1: timer = math.ceil(seconds_remaining / 60) timer_unit = "minutes" if display_on_lights_bool == 1: timer_color = Adafruit_WS2801.RGB_to_color(255, 0, 0) #red if timer_unit == "minutes" and (seconds_remaining / 60) < 1: timer = math.ceil(seconds_remaining) timer_unit = "seconds" if display_on_lights_bool == 1: timer_color = Adafruit_WS2801.RGB_to_color(50, 0, 255) #green if timer > 9: digit_seven = math.floor(timer / 10) else: digit_seven = math.floor(timer / 10) digit_eight = timer % 10 digit_list = [digit_seven, digit_eight] for value in range(len(digit_list)): digit = digit_list[value] if digit == 1: digit_list[value] = number_one elif digit == 2: digit_list[value] = number_two elif digit == 3: digit_list[value] = number_three elif digit == 4: digit_list[value] = number_four elif digit == 5: digit_list[value] = number_five elif digit == 6: digit_list[value] = number_six elif digit == 7: digit_list[value] = number_seven elif digit == 8: digit_list[value] = number_eight elif digit == 9: digit_list[value] = number_nine else: if value % 2 != 0: digit_list[value] = number_zero else: digit_list[value] = [ ] #prevents us from printing a zero for the most significant digit for index in digit_list[0]: #digit 7 (timer) index = [index[0] + 5, index[1] + 9] grid[index[0], index[1]] = 4 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), timer_color) for index in digit_list[1]: index = [index[0] + 5, index[1] + 13] grid[index[0], index[1]] = 4 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), timer_color) return (grid, timer, timer_unit) def print_big_clock(grid): ## Get the time current_time = time.localtime() hour = current_time.tm_hour minute = current_time.tm_min second = current_time.tm_sec ## Get the numbers to print. Stored in digit_one, digit_two .... digit_six if hour > 9: digit_one = 1 else: digit_one = 0 digit_two = hour % 10 if minute > 9: digit_three = math.floor(minute / 10) else: digit_three = 0 digit_four = minute % 10 if second > 9: digit_five = math.floor(second / 10) else: digit_five = 0 digit_six = second % 10 digit_list = [ digit_one, digit_two, digit_three, digit_four, digit_five, digit_six ] for value in range(len(digit_list)): digit = digit_list[value] if digit == 1: digit_list[value] = number_one elif digit == 2: digit_list[value] = number_two elif digit == 3: digit_list[value] = number_three elif digit == 4: digit_list[value] = number_four elif digit == 5: digit_list[value] = number_five elif digit == 6: digit_list[value] = number_six elif digit == 7: digit_list[value] = number_seven elif digit == 8: digit_list[value] = number_eight elif digit == 9: digit_list[value] = number_nine else: if value % 2 != 0: digit_list[value] = number_zero else: digit_list[value] = [ ] #prevents us from printing a zero for the most significant digit for index in digit_list[0]: #digit one index = [ index[0] + 0, index[1] + 0 ] #shift the upper left corner of the first hour digit to [0,0] grid[index[0], index[1]] = 1 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), hour_color) for index in digit_list[1]: #digit two index = [ index[0] + 0, index[1] + 4 ] #shift the upper left corner of the second hour digit to [0,4], leaving a column between the digits grid[index[0], index[1]] = 1 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), hour_color) for index in digit_list[2]: #digit three index = [ index[0] + 0, index[1] + 9 ] #shift the upper left corner of the first minute digit to [0,9], leaving two columns between the minute and hour grid[index[0], index[1]] = 2 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), minute_color) for index in digit_list[3]: #digit four index = [index[0] + 0, index[1] + 13] grid[index[0], index[1]] = 2 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), minute_color) for index in digit_list[4]: #digit 5 (seconds) index = [index[0] + 5, index[1] + 0] grid[index[0], index[1]] = 3 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), second_color) for index in digit_list[5]: index = [index[0] + 5, index[1] + 4] grid[index[0], index[1]] = 3 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), second_color) return (grid, hour, minute, second) [old_grid, hour, minute, second] = print_big_clock(np.zeros([10, 16])) if timer_value > 99 and timer_unit == "seconds": print("Invalid timer entry") exit() if timer_unit == "seconds": timer_end = time.time() + timer_value elif timer_unit == "minutes": timer_end = time.time() + (60 * timer_value) elif timer_unit == "hours": timer_end = time.time() + (24 * 60 * timer_value) else: print("Error getting timer_end") exit() while 1: [new_grid, hour, minute, second] = print_big_clock(np.zeros( [10, 16])) #Get the clock board state so we can check if it's changed seconds_remaining = timer_end - time.time() if seconds_remaining > 0: #Check if the timer is done [new_grid, time_remaining, timer_unit] = print_timer(new_grid, seconds_remaining, timer_unit) elif seconds_remaining < 0 and ( (seconds_remaining > -0.5) or (seconds_remaining > -1.5 and seconds_remaining < -1) or (seconds_remaining > -2.5 and seconds_remaining < -2) or (seconds_remaining > -3.5 and seconds_remaining < -3) or (seconds_remaining > -4.5 and seconds_remaining < -4)): for i in range(5, 10): for j in range(8, 16): new_grid[i, j] = 8 if display_on_lights_bool == 1: pixels.set_pixel(j + (16 * i), second_color) GPIO.output(12, GPIO.HIGH) GPIO.output(16, GPIO.HIGH) else: GPIO.output(12, GPIO.LOW) GPIO.output(16, GPIO.LOW) if (new_grid != old_grid).any( ): #If it's true that new_grid != old_grid for any elements in the arrays (i.e. if the two arrays are different)... if display_on_lights_bool == 1: pixels.clear() [new_grid, hour, minute, second] = print_big_clock(np.zeros([10, 16])) if seconds_remaining > 0: #redundant lines, but it resets the pixels after the clear [new_grid, time_remaining, timer_unit] = print_timer(new_grid, seconds_remaining, timer_unit) old_grid = new_grid if minute == 0: #Flash the light strands on the hour if display_on_lights_bool == 1: GPIO.output(12, GPIO.HIGH) GPIO.output(16, GPIO.HIGH) time.sleep(1) GPIO.output(12, GPIO.LOW) GPIO.output(16, GPIO.LOW) time.sleep(0.5) GPIO.output(12, GPIO.HIGH) GPIO.output(16, GPIO.HIGH) time.sleep(1) GPIO.output(12, GPIO.LOW) GPIO.output(16, GPIO.LOW) print("Time is ", hour, minute, second) if seconds_remaining > 0: print("Timer value is: ", time_remaining, timer_unit) else: print("Timer done") #os.system('cls') print(new_grid) if display_on_lights_bool == 1: pixels.show()
def _RGB_to_color(self, rgb): # lib requires int r, g, b = self._get_rgb(rgb) # lib actually requires BGR instead of RGB return Adafruit_WS2801.RGB_to_color(int(b), int(g), int(r))
def print_timer(grid, seconds_remaining, timer_unit): #Get the timer value if timer_unit == "seconds": timer = math.ceil(seconds_remaining) elif timer_unit == "minutes": timer = math.ceil(seconds_remaining / 60) elif timer_unit == "hours": timer = math.ceil(seconds_remaining / (60 * 24)) else: print("Error getting timer") exit() ## Check if timer entered new unit (e.g. minutes -> seconds), then change the unit and the value. Like going from 1 minute to 59 seconds. if timer_unit == "hours" and (seconds_remaining / (60 * 24)) < 1: timer = math.ceil(seconds_remaining / 60) timer_unit = "minutes" if display_on_lights_bool == 1: timer_color = Adafruit_WS2801.RGB_to_color(255, 0, 0) #red if timer_unit == "minutes" and (seconds_remaining / 60) < 1: timer = math.ceil(seconds_remaining) timer_unit = "seconds" if display_on_lights_bool == 1: timer_color = Adafruit_WS2801.RGB_to_color(50, 0, 255) #green if timer > 9: digit_seven = math.floor(timer / 10) else: digit_seven = math.floor(timer / 10) digit_eight = timer % 10 digit_list = [digit_seven, digit_eight] for value in range(len(digit_list)): digit = digit_list[value] if digit == 1: digit_list[value] = number_one elif digit == 2: digit_list[value] = number_two elif digit == 3: digit_list[value] = number_three elif digit == 4: digit_list[value] = number_four elif digit == 5: digit_list[value] = number_five elif digit == 6: digit_list[value] = number_six elif digit == 7: digit_list[value] = number_seven elif digit == 8: digit_list[value] = number_eight elif digit == 9: digit_list[value] = number_nine else: if value % 2 != 0: digit_list[value] = number_zero else: digit_list[value] = [ ] #prevents us from printing a zero for the most significant digit for index in digit_list[0]: #digit 7 (timer) index = [index[0] + 5, index[1] + 9] grid[index[0], index[1]] = 4 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), timer_color) for index in digit_list[1]: index = [index[0] + 5, index[1] + 13] grid[index[0], index[1]] = 4 if display_on_lights_bool == 1: pixels.set_pixel(index[1] + (16 * index[0]), timer_color) return (grid, timer, timer_unit)
class theLEDs(threading.Thread): # Configure the count of pixels: PIXEL_COUNT = 24 runvar = True # Alternatively specify a hardware SPI connection on /dev/spidev0.0: SPI_PORT = 0 SPI_DEVICE = 0 pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO) comparesecond = 0 t = 0 nowdata = [1, 2, 3] config = {'status': None, 'brightness': None, 'show': None, 'r': None, 'g': None, 'b': None} json_file = "/opt/mycroft/skills/skill-my-alarm/settings.json" def __init__(self): threading.Thread.__init__(self) with open(self.json_file, 'r') as file: data = json.load(file) LED = data['LED'] self.config['status'] = LED['status'] self.config['brightness'] = float(LED['brightness']) self.config['show'] = LED['show'] self.config['r'] = int(LED['r']) self.config['g'] = int(LED['g']) self.config['b'] = int(LED['b']) def config_led(self, config = {'status': None, 'brightness': None, 'show': None, 'r': None, 'g': None, 'b': None}): for c in self.config: if config[c] is not None: self.config[c] = config[c] json_data = None with open(self.json_file, 'r') as file: json_data = json.load(file) json_data['LED'] = self.config with open(self.json_file, 'w') as file: json.dump(json_data, file) def set_leds(self, number): highnumber = number/10 lownumber = number%10 leds = [[0, 0, 0, 0],[0, 0, 0, 0]] leds[0][3] = int(lownumber/8) leds[0][2] = int(lownumber%8/4) leds[0][1] = int(lownumber%8%4/2) leds[0][0] = int(lownumber%8%4%2/1) leds[1][0] = int(highnumber/8) leds[1][1] = int(highnumber%8/4) leds[1][2] = int(highnumber%8%4/2) leds[1][3] = int(highnumber%8%4%2/1) return leds def show(self, type, r, g, b, brightness): nowdata = [None, None, None] if type == 'time': now = datetime.datetime.now() nowdata = [now.second, now.minute, now.hour] elif type == 'date': now = datetime.datetime.now() nowdata = [now.year, now.month, now.day] else: return 0 for k in range(len(nowdata)): leds = self.set_leds(nowdata[k]) for i in range(len(leds)): for j in range(len(leds[i])): if leds[i][j] == 1: self.pixels.set_pixel(j+(k*8)+i*4, Adafruit_WS2801.RGB_to_color(int(r*brightness), int(g*brightness), int(b*brightness))) else: self.pixels.set_pixel(j+(k*8)+i*4, Adafruit_WS2801.RGB_to_color(0, 0, 0)) self.pixels.show() def lighton(self, brightness): for i in range(self.PIXEL_COUNT): self.pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(int(255*brightness), int(200*brightness), int(150*brightness))) self.pixels.show() def off(self): self.pixels.clear() self.pixels.show() def run(self): self.pixels.clear() self.pixels.show() while True: while self.config['status']: if self.config['show'] == "time": while self.config['show'] == "time": self.show('time', self.config['r'],self.config['g'], self.config['b'], self.config['brightness']) time.sleep(0.1) elif self.config['show'] == "date": while self.config['show'] == "date": self.show('date', self.config['r'],self.config['g'], self.config['b'], self.config['brightness']) time.sleep(0.1) elif self.config['show'] == "light": while self.config['show'] == "light": self.lighton(self.config['brightness']) time.sleep(0.1) elif self.config['show'] == "off": self.off() while self.config['show'] == "off": pass def stop(self): self.config['show'] = 'off' self.off() GPIO.cleanup()
def run(self): """The rambilight algorithm is optimized to be fast but also offer a smooth experience. Some mechanics are implemented to due technical issues (e.g. bright spikes in picamera pictures.). If you do not have them u may adapt the algorithm. There are three concepts to guarantee a smooth experience: * The algorithm is based on shift-registers containing the last n values for each coordinate the colors are measured for. The colors in this register are averaged for cleaner experience. To prevent the mentioned bright spikes in the stream that let the LEDs flicker, `num_outliers` outliers are ignored (biggest distance to previous color). * Actual color values are transitioned over time. This means, that a color needs `fade_levels` steps to actually be displayed. This mechanism makes the light-switching in fast changing scenes less noisy. * Noise in the meaning of flickering (change delta sign rapidely) is punished by tracking it. If the penalty is too high, only the former pixel is rendered. * The image is blurred in spots where the colors are measured in. The blurring is limited to these spots. This increases the performance drastically. Blurring averts very small changes in color due to camera noise, that result in distracting background noise. The algorithm runs with 30-40 fps on a raspberry pi rev. 3. """ shift_register_length = 8 num_outliers = 4 fade_levels = 9 blur_area = 6 blur_strength = 10 max_denoise_penalty = 20 denoise_penalty_threshold = 3 denoise_machine = [(0,0,(255,255,255))] * self.real_led_num registers = [[(255,255,255)] * shift_register_length] * self.real_led_num former_pixels = [(255,255,255)] * self.real_led_num while True: # check stopped/paused conditions before starting if self.stopped: break if self.paused: time.sleep(1) continue frame = self.stream.read() for (coord, led_num) in self.coordinates_to_led: # find the area that must be blurred and blur it. x_min = max(coord[1] - blur_area, 0) x_max = coord[1] + blur_area y_min = max(coord[0] - blur_area, 0) y_max = coord[0] + blur_area region = frame[x_min:x_max, y_min:y_max] pixel = np.mean(region, axis=(0,1)) r = int(pixel[2]) g = int(pixel[1]) b = int(pixel[0]) # extract former pixel former_r, former_g, former_b = former_pixels[led_num] if r < 22 and b < 22 and g < 22 and r+b+g < 55: r,g,b = (0,0,0) # denoising (former_penalty_state, former_delta, (dr, dg, db)) = denoise_machine[led_num] delta = sign((r + g + b) - (former_r + former_g + former_b)) penalty = former_delta != delta penalty_state = former_penalty_state + 5 if penalty else former_penalty_state - 1 render_change = penalty_state < denoise_penalty_threshold # push the new value into the shift register and find the average new_register = shift_elements(registers[led_num], (r,g,b)) smoothed_r, smoothed_g, smoothed_b = average_without_outliers(new_register, num_outliers, (former_r, former_g, former_b)) # calculate the step in respect of the number of fade_levels step_r = (smoothed_r - former_r) / fade_levels step_g = (smoothed_g - former_g) / fade_levels step_b = (smoothed_b - former_b) / fade_levels new_r = step_r + former_r new_g = step_g + former_g new_b = step_b + former_b (new_dr, new_dg, new_db) = (new_r, new_g, new_b) if render_change else (dr,dg,db) denoise_machine[led_num] = (min(max_denoise_penalty, penalty_state), delta, (new_dr, new_dg, new_db)) # do the hls conversion, desaturation and brightness adjustments h, l, s = colorsys.rgb_to_hls(new_dr/255, new_dg/255, new_db/255) (hue, lightness, saturation) =( int(round(h * 360)), int(round(l * 100)) , int(round(s * 100))) new_sat = int(((100.0-(saturation * 0.45))/100.0) * saturation) (dh, dl, ds) = (hue, int(lightness * self.brightness), new_sat) r, g, b = colorsys.hls_to_rgb(dh/360, dl/100, ds/100) d_r, d_g, d_b = (int(round(r * 255)) ,int(round(g * 255)), int(round(b * 255))) shifted_r, shifted_b, shifted_g = shift_color((d_r, d_g, d_b), (self.r_shift, self.g_shift, self.b_shift)) ws = 250 #white threshold output = Adafruit_WS2801.RGB_to_color(shifted_r if shifted_r < ws else ws, shifted_g if shifted_g < ws else ws, shifted_b if shifted_b < ws else ws) ws2801.pixels.set_pixel(led_num, output) # finally set the former pixel and update the register former_pixels[led_num] = (new_r, new_g, new_b) registers[led_num] = new_register ws2801.pixels.show()
import time import RPi.GPIO as GPIO from random import randint # Import the WS2801 module. import Adafruit_WS2801 import Adafruit_GPIO.SPI as SPI # Configure the count of pixels: PIXEL_COUNT = 50 # Alternatively specify a hardware SPI connection on /dev/spidev0.0: SPI_PORT = 0 SPI_DEVICE = 0 pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO) class Pixel_Section: def __init__(self, leds, offset, length, step=1): max_pixels = leds.count() if offset > max_pixels: print("Eror: offset too far") offset = 0 string_length = length * step if offset + string_length > max_pixels: print("Error : not enough pixels for that....") print("Going from {0:} to {1:} exceeds max {2:}".format( offset, offset + string_length, max_pixels)) string_length = max_pixels - offset
def test_led(pixels): for i in range(pixels.count()): pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(255, 255, 255)) pixels.show()
def adacolor(rgb, g=False, b=False): if g and b: return Adafruit_WS2801.RGB_to_color(b, g, rgb) else: return Adafruit_WS2801.RGB_to_color(rgb[2], rgb[1], rgb[0])
def change_color(pixels, r, g, b): print(r, g, b) pixels.set_pixels(Adafruit_WS2801.RGB_to_color(r, g, b)) pixels.show()
# Import the WS2801 module. import Adafruit_WS2801 import Adafruit_GPIO.SPI as SPI from random import randrange import configparser cfgpath = "/home/pi/HomeAutomation-python-Base/LED.cfg" initcfg = configparser.ConfigParser() initcfg.read(cfgpath) # Configure the count of pixels: PIXEL_COUNT = int(initcfg["LED"]["PixelCount"]) # Alternatively specify a hardware SPI connection on /dev/spidev0.0: SPI_PORT = 0 SPI_DEVICE = 0 pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO) #defekte Pixel 0,1,43 defekt = [0, 1, 43] # Define the wheel function to interpolate between different hues. def wheel(pos): if pos < 85: return Adafruit_WS2801.RGB_to_color(pos * 3, 255 - pos * 3, 0) elif pos < 170: pos -= 85 return Adafruit_WS2801.RGB_to_color(255 - pos * 3, 0, pos * 3) else: pos -= 170 return Adafruit_WS2801.RGB_to_color(0, pos * 3, 255 - pos * 3)
pixels.clear() # first set all pixels at the begin for k in range(i): pixels.set_pixel( k, Adafruit_WS2801.RGB_to_color(color[0], color[1], color[2])) # set then the pixel at position j pixels.set_pixel( j, Adafruit_WS2801.RGB_to_color(color[0], color[1], color[2])) pixels.show() time.sleep(0.02) if __name__ == "__main__": pixels = Adafruit_WS2801.WS2801Pixels(96, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO) pixels.clear() pixels.show() blue = Adafruit_WS2801.RGB_to_color(0, 0, 255) white = Adafruit_WS2801.RGB_to_color(100, 100, 100) red = Adafruit_WS2801.RGB_to_color(255, 0, 0) green = Adafruit_WS2801.RGB_to_color(0, 255, 0) # for color in [red, green, white, blue]: # for i in range(96): # pixels.set_pixel(i, color) # pixels.show() # time.sleep(0.1) # while True:
for i in range(run_for): #print(i) r_window_a_do.next() r_window_b_do.next() r_window_c_do.next() r_window_d_do.next() l_window_a_do.next() l_window_b_do.next() l_window_c_do.next() l_window_d_do.next() pixels.show() time.sleep(.7) for trips in range(3): reverse = randint(0,1) == 1 colour = Adafruit_WS2801.color_to_RGB(get_random_colour(360)) run_for = whole_window.length whole_window_do = whole_window.appear_from_end(color=colour, reverse=reverse) #snowman_1_do= snowman1.rainbow_cycle(steps=run_for, full_wheel=120, # arc_span=10, laps=3) #snowman_2_do = snowman2.rainbow_cycle(steps=run_for, full_wheel=120, # arc_span=10, laps=3, reverse=True) for i in range(whole_window.length-1): #print(i) whole_window_do.next() #snowman_1_do.next() #snowman_2_do.next() pixels.show() time.sleep(0.1)
import Adafruit_WS2801 as af import Adafruit_GPIO.SPI as SPI import time from datetime import datetime import RPi.GPIO as GPIO SPI_PORT = 0 SPI_DEVICE = 0 print("number of leds: ") n = int(input()) leds = af.WS2801Pixels(n, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO) leds.clear() leds.show() time.sleep(1) stamp = datetime.now() for i in range(leds.count()): leds.clear() leds.set_pixel(i, af.RGB_to_color(255, 255, 255)) leds.show() total_time = (datetime.now() - stamp).total_seconds() print("total time:", total_time)