def strand_test():
""" Basically the same as the Adafruit stand test """
test_strip = Adafruit_DotStar(ALL_LIGHTS, 12000000, order='bgr')
test_strip.begin()
test_strip.show()
head = 0 # Index of first 'on' pixel
tail = -10 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
counter = ALL_LIGHTS * 3 + 10
while counter > 0: # Loop forever
test_strip.setPixelColor(head, color) # Turn on 'head' pixel
test_strip.setPixelColor(tail, 0) # Turn off 'tail'
test_strip.show() # Refresh strip
time.sleep(1.0 / 100) # Pause 20 milliseconds (~50 fps)
head += 1 # Advance head position
if head >= ALL_LIGHTS: # Off end of strip?
head = 0 # Reset to start
color >>= 8 # Red->green->blue->black
if color == 0:
color = 0xFF0000 # If black, reset to red
tail += 1 # Advance tail position
if tail >= ALL_LIGHTS:
tail = 0 # Off end? Reset
counter -= 1
class LedStrip:
forward = True
numpixels = 80
head = 0
tail = -10
def random_color(self):
return random.choice(colors)
def __init__(self, datapin, clockpin):
self.datapin = datapin
self.clockpin = clockpin
self.strip = Adafruit_DotStar(self.numpixels,
self.datapin,
self.clockpin,
order='bgr')
self.strip.begin()
self.strip.setBrightness(255)
self.color = self.random_color()
def display_pixel(self, pos, color):
self.strip.setPixelColor(pos, color)
def render(self):
self.strip.show()
class LedStrip:
forward = True
numpixels = 80
head = 0
tail = -10
def random_color(self):
return random.choice(color_library)
def __init__(self, datapin, clockpin, brightness):
self.datapin = datapin
self.clockpin = clockpin
self.strip = Adafruit_DotStar(self.numpixels,
self.datapin,
self.clockpin,
order='bgr')
self.strip.begin()
self.set_brightness(brightness)
self.color = self.random_color()
def set_pixel(self, pos, color):
r, g, b = toRGB(color)
self.strip.setPixelColor(pos, gamma[r], gamma[g], gamma[b])
def set_brightness(self, brightness):
self.brightness = clamp(brightness, 0, 255)
self.strip.setBrightness(self.brightness)
def render(self):
self.strip.show()
def strandtest():
#!/usr/bin/python
# Simple strand test for Adafruit Dot Star RGB LED strip.
# This is a basic diagnostic tool, NOT a graphics demo...helps confirm
# correct wiring and tests each pixel's ability to display red, green
# and blue and to forward data down the line. By limiting the number
# and color of LEDs, it's reasonably safe to power a couple meters off
# USB. DON'T try that with other code!
import time
from dotstar import Adafruit_DotStar
numpixels = 72 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 23
clockpin = 24
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
# Alternate ways of declaring strip:
# Adafruit_DotStar(npix, dat, clk, 1000000) # Bitbang @ ~1 MHz
# Adafruit_DotStar(npix) # Use SPI (pins 10=MOSI, 11=SCLK)
# Adafruit_DotStar(npix, 32000000) # SPI @ ~32 MHz
# Adafruit_DotStar() # SPI, No pixel buffer
# Adafruit_DotStar(32000000) # 32 MHz SPI, no pixel buf
# See image-pov.py for explanation of no-pixel-buffer use.
# Append "order='gbr'" to declaration for proper colors w/older DotStar strips)
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
head = 0 # Index of first 'on' pixel
tail = -10 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
stranditer = 4
strandnum = 0
while strandnum <= stranditer: # Loop forever
strip.setPixelColor(head, color) # Turn on 'head' pixel
strip.setPixelColor(tail, 0) # Turn off 'tail'
strip.show() # Refresh strip
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
head += 1 # Advance head position
if(head >= numpixels): # Off end of strip?
head = 0 # Reset to start
color >>= 8 # Red->green->blue->black
if(color == 0): color = 0xFF0000 # If black, reset to red
tail += 1 # Advance tail position
if(tail >= numpixels): tail = 0 # Off end? Reset
strandnum += 1
class PhysicalStrip:
def __init__(self, numpixels):
self._strip = Adafruit_DotStar(numpixels)
self._strip.begin()
def setPixelColor(self, i, color):
self._strip.setPixelColor(i, color)
def show(self):
self._strip.show()
def main(): # set up audio input... recorder = alsaaudio.PCM(alsaaudio.PCM_CAPTURE) recorder.setchannels(CHANNELS) recorder.setrate(RATE) recorder.setformat(INFORMAT) recorder.setperiodsize(FRAMESIZE) # Set up off button GPIO.setmode(GPIO.BCM) GPIO.setup(23,GPIO.IN,pull_up_down = GPIO.PUD_UP) # Initialize colors of each LED... strip = Adafruit_DotStar(numpixels) strip.begin() for i in range(15): time.sleep(float(1.0/float(i+1))) strip.setBrightness(int(stripBright*(i+1)/15)) strip.setPixelColor(i,colors[i][0],colors[i][1],colors[i][2]) strip.setPixelColor(29-i,colors[29-i][0],colors[29-i][1],colors[29-i][2]) strip.show() time.sleep(1) # MAIN LOOP: i=0 bigtime = 0.0 valsold = [] print "IN MAIN LOOP" try: while True: # Check for off button press on = GPIO.input(23) if on == False: shutdown(strip) # Read music and get magnitudes for FRAMESIZE length Y = getMagnitudes(recorder) if Y != None: # Update LED strip based on magnitudes vals = controlLights(strip,Y,valsold) # Update valsold list which is used by my smoothAvg function # to make a running average of brightnesses rather than actual brightnesses valsold.insert(0,vals) if len(valsold) > 20: valsold.pop() if i % 1000 == 0: print "TIME:",time.time()-bigtime print "ITERATION: ",i bigtime = time.time() i+=1 except KeyboardInterrupt: pass
def lightshow():
numpixels = 72 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 23
clockpin = 24
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
strip.begin() # Initialize pins for output
strip.setBrightness(128) # Limit brightness to ~1/4 duty cycle
#First, turn all black
offspot = 1
offcolor = 0x000000
while offspot >= 1:
strip.setPixelColor(offspot, offcolor)
offspot += 1
if offspot == 72:
break
#set initial spots and colors of Jupiter and moons
jupspot = 36 #jupiter position
jupcolor = 0xFF8801 #jupiter color
iospot = iopos #Io position
iocolor = 0x9932cc #Io color
eurspot = eurpos #Europa position
eurcolor = 0x9932cc #Europa color
ganspot = ganpos #Ganymede position
gancolor = 0x9932cc #Ganymede color
calspot = calpos #Calisto position
calcolor = 0x9932cc #Calisto color
lastcolor = 0x000000
lastiospot = (iospot - 1)
gang = [iospot, eurspot, ganspot,
calspot] #list of the four moon positions
while True: # Loop forever
strip.setBrightness(128) # Limit brightness
strip.setPixelColor(jupspot, jupcolor) # Turn on jupiter to orange
strip.setPixelColor(gang, 0) #Turn off last plots
gang[:] = [x + 1 for x in a] # +=1 for each member of gang
strip.setPixelColor(gang, iocolor) # Turn all moons to blue
strip.show() # Refresh strip
time.sleep(1.0 / 5)
if t == now:
strip.setBrightness(128) #max brightness
time.sleep(3)
if (iospot >= numpixels):
iospot = 0
if (lastiospot >= numpixels):
lastiospot = 0
def rgbStrip(R, G, B):
numpixels = 30; # Number of LEDs in strip
# strip = Adafruit_DotStar(numpixels, rgb_strip_datapin, rgb_strip_clockpin)
strip = Adafruit_DotStar(numpixels) # SPI @ ~32 MHz
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
led = 0 # Index of first 'on' pixel
while (led != 30): # Loop for each light
strip.setPixelColor(led, R, G, B) # Set pin color
strip.show() # Refresh strip
led += 1 # Advance head position\
class Blinkt:
def __init__(self, host):
self.host = host
self.strip = Adafruit_DotStar(numpixels, datapin, clockpin)
self.strip.begin()
self.strip.setBrightness(32)
green = self.to_rgb(0,255,0)
self.show_all(green)
def to_rgb(self,r,g,b):
return (g << 16) + (r << 8) + b
def show(self, colour, pixel):
self.strip.setPixelColor(pixel, colour)
self.strip.show()
def show_all(self, colour):
for x in range(0,8):
self.strip.setPixelColor(x, colour)
self.strip.show()
def rgbStrip(R, G, B):
numpixels = 30
# Number of LEDs in strip
# strip = Adafruit_DotStar(numpixels, rgb_strip_datapin, rgb_strip_clockpin)
strip = Adafruit_DotStar(numpixels) # SPI @ ~32 MHz
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
led = 0 # Index of first 'on' pixel
while (led != 30): # Loop for each light
strip.setPixelColor(led, R, G, B) # Set pin color
strip.show() # Refresh strip
led += 1 # Advance head position\
class LedStrip:
forward = True
numpixels = 80
head = 0
tail = -10
def random_color(self):
return random.choice(colors)
def __init__(self, datapin, clockpin):
self.datapin = datapin
self.clockpin = clockpin
self.strip = Adafruit_DotStar(self.numpixels,
self.datapin,
self.clockpin,
order='bgr')
self.strip.begin()
self.strip.setBrightness(255)
self.color = self.random_color()
def step(self):
if self.forward:
if self.head < self.numpixels:
self.strip.setPixelColor(self.head,
self.color) # Turn on 'head' pixel
self.strip.setPixelColor(self.tail, 0) # Turn off 'tail'
self.head += 1
self.tail += 1
else:
self.color = self.random_color()
self.head = 70
self.tail = 80
self.forward = False
else: # backwards
if self.head >= 0:
self.strip.setPixelColor(self.head,
self.color) # Turn on 'head' pixel
self.strip.setPixelColor(self.tail, 0) # Turn off 'tail'
self.head = self.head - 1
self.tail = self.tail - 1
else:
self.head = 10
self.tail = 0
self.color = self.random_color()
self.forward = True
def render(self):
self.strip.show()
class StripClient(object):
def __init__(self, numpixels):
self.numpixels = numpixels
self.strip = Adafruit_DotStar(numpixels)
self.strip.begin()
self.strip.setBrightness(64)
def clear(self):
self.strip.clear()
print("clear")
def setBrightness(self, value):
self.strip.setBrightness(value)
self.strip.show()
print("setBrightness:", value)
def setPixelColor(self, pixel, color):
color_value = ((color[0] & 0xFF) << 8) | (
(color[1] & 0xFF) << 16) | (color[2] & 0xFF)
self.strip.setPixelColor(pixel, color_value)
self.strip.show()
print("setPixelColor:", pixel, color)
def show(self):
self.strip.show()
print("show")
def getPixelColor(self):
self.strip.getPixelColor()
print("getPixelColor")
def numPixels(self):
return self.strip.numPixels()
return self.numpixels
def getBrightness(self):
return self.strip.getBrightness()
return 64
def rgbStripTest():
numpixels = 30
# Number of LEDs in strip
# strip = Adafruit_DotStar(numpixels, datapin, clockpin)
strip = Adafruit_DotStar(numpixels, 12000000) # SPI @ ~32 MHz
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
head = 0 # Index of first 'on' pixel
tail = -10 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
repeat = 0
while True: # Loop forever
strip.setPixelColor(head, color) # Turn on 'head' pixel
strip.setPixelColor(tail, 0) # Turn off 'tail'
strip.show() # Refresh strip
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
head += 1 # Advance head position
if (head >= numpixels): # Off end of strip?
head = 0 # Reset to start
color >>= 8 # Red->green->blue->black
if (color == 0): color = 0xFF0000 # If black, reset to red
tail += 1 # Advance tail position
if (tail >= numpixels):
tail = 0 # Off end? Reset
repeat += 1
if (repeat == 10):
rgbStripOff(strip)
break
def rgbStripTest():
numpixels = 30; # Number of LEDs in strip
# strip = Adafruit_DotStar(numpixels, datapin, clockpin)
strip = Adafruit_DotStar(numpixels, 12000000) # SPI @ ~32 MHz
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
head = 0 # Index of first 'on' pixel
tail = -10 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
repeat = 0
while True: # Loop forever
strip.setPixelColor(head, color) # Turn on 'head' pixel
strip.setPixelColor(tail, 0) # Turn off 'tail'
strip.show() # Refresh strip
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
head += 1 # Advance head position
if(head >= numpixels): # Off end of strip?
head = 0 # Reset to start
color >>= 8 # Red->green->blue->black
if(color == 0): color = 0xFF0000 # If black, reset to red
tail += 1 # Advance tail position
if(tail >= numpixels):
tail = 0 # Off end? Reset
repeat += 1
if(repeat == 10):
rgbStripOff(strip)
break;
numpixels = 72 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 23
clockpin = 24
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
strip.begin() # Initialize pins for output
strip.setBrightness(8) # Limit brightness to ~1/4 duty cycle
#turn all leds to black (off)
offspot = 1
offcolor = 0x000000
nump = 73
while offspot < nump:
strip.setPixelColor(offspot, offcolor)
offspot += 1
strip.show()
#PYEPHEM PART--GET MOON SPOTS
moons = ((ephem.Io(), 'i'),
(ephem.Europa(), 'e'),
(ephem.Ganymede(), 'g'),
(ephem.Callisto(), 'c'))
linelen = 72
maxradii = 36
def put(line, character, radii):
if abs(radii) > maxradii:
# Don't add anything new
for i in range(16):
for j in range(16):
matrixLEDintensity[16 * i + j] = 0
# Add the line intensity to the map and display it
for i in range(16):
for j in range(16):
matrixLEDcurrent[16 * i + j] = matrixLEDcurrent[
16 * i + j] + matrixLEDintensity[16 * i +
j] # Store current values
## pixels( matrixLEDindex[ 16*i+j] ) = matrixLEDcurrent[ 16*i+j ]
if flagPi:
# strip.setPixelColor( matrixLEDindex[ 16*i+j ] , 0 , 0 , matrixLEDcurrent[16*i+j] ) # Write to pixel o/p, g,r,b
strip.setPixelColor(
matrixLEDindex[16 * i + j], colscale *
matrixLEDcurrent[16 * i + j]) # Write to pixel o/p, g,r,b
# --------------------------------------------------------
# DISK
# --------------------------------------------------------
# --------------------------------------------------------
# STRIP
# --------------------------------------------------------
#----- Rest of Strip
pixstart = 0
# pixstop = pixstart+3*300 # Just strip
pixstop = pixstart + 3 * 300 + 255 # Strip and disk
pixlistall = list(range(pixstart, pixstop))
hat.clear()
hat.show()
time.sleep(2)
continue
annimation = None
animation_file = "{}{}.json".format(ANIMATION_PATH, status['name'])
with open(animation_file, 'r') as infile:
annimation = json.loads(infile.read())
fps = 15
for frame in annimation['frames']:
# munge frame array into list of pixels
frame_width = len(frame)
frame_height = len(frame[0])
pixel_index = 0
for y in range(frame_height - 1, -1, -1):
for x in range(0, frame_width):
pixel = frame[x][y].split(",")
hat.setPixelColor(pixel_index, int(pixel[0]), int(pixel[1]),
int(pixel[2]))
pixel_index += 1
hat.show()
time.sleep(1.0 / fps)
@atexit.register
def shutdown():
hat.clear()
hat.show()
r_start = 0xFF
g_start = 0x00
b_start = 0x00
for s in range(0x00,0xFF):
r = r_start - s
g = g_start + s
b = b_start
color = r*0x010000 + g*0x000100 + b*0x000001
time.sleep(delay)
head += 1
for i in range(31): #Step through all pixels in my led strip (1-30)
# strip.setPixelColor(i, color) # Turn on pixel #i
strip.setPixelColor(i, color + i * 0xFF / 32 + s + head) # Turn on pixel #i
strip.show() # Refresh strip
time.sleep(delay) # pause delay seconds
head += 1
#------------------#
# Green -> Blue
#------------------#
r_start = 0x00
g_start = 0xFF
b_start = 0x00
for s in range(0x00,0xFF):
def run_strip(mode="off", brightness=255):
numpixels = 240 # Number of LEDs in strip
print("run_strip inbound mode:", mode)
# Here's how to control the strip from any two GPIO pins:
datapin = 10
clockpin = 11
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
# brightness is an integer from 1 to 255
# mode, in time, should enable other things besides just being full on
# strip.begin() # Initialize pins for output
# strip.setBrightness(brightness) # Limit brightness to ~1/4 duty cycle
# used for mode: comet
# head = 0 # Index of first 'on' pixel
# tail = -10 # Index of last 'off' pixel
color = 0xFFFFFF # 'On' color (starts red)
# some control variables for light power on/off easing
_pow = 3
_frames = 50
_maxb = 255 # _max_brightness, might change when brightness configuration is enabled
if mode == "off":
print("run_strip: turn off strip")
try:
count = 0
const = _maxb**(1 / (_pow * 1.0))
is_turning_off = True
strip.begin()
while is_turning_off:
count += 1
if count == _frames:
is_turning_off = False
strip.setBrightness(_maxb) # now that ramping is done set
# to max configured brightness
else:
brightness = int(_maxb - (count /
(_frames * 1.0) * const)**_pow)
strip.setBrightness(brightness)
for idx in range(numpixels):
strip.setPixelColor(idx, color)
strip.show() # Refresh strip
time.sleep(1.0 / 50)
except KeyboardInterrupt:
print("cleaning up")
GPIO.cleanup()
strip.clear()
strip.show()
print("done")
# try to set color to black/off before turning off to prevent final flash
for idx in range(numpixels):
strip.setPixelColor(idx, 0x000000)
strip.setBrightness(0)
# clean up interrupts?
# GPIO.cleanup()
# strip.clear()
strip.show()
# print("done")
elif mode == "on":
print("run_strip: starting strip")
try:
count = 0
const = _maxb**(1 / (_pow * 1.0))
is_turning_on = True
strip.begin()
while True: # Loop forever
if is_turning_on:
count += 1.0
if count == _frames:
is_turning_on = False
strip.setBrightness(
_maxb) # now that ramping is done set
# to max configured brightness
else:
brightness = int(
(count / (_frames * 1.0) * const)**_pow)
strip.setBrightness(brightness)
for idx in range(numpixels):
strip.setPixelColor(idx, color)
# strip.setPixelColor(head, color) # Turn on 'head' pixel
# strip.setPixelColor(tail, 0) # Turn off 'tail'
strip.show() # Refresh strip
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
# head += 1 # Advance head position
# if(head >= numpixels): # Off end of strip?
# head = 0 # Reset to start
# color >>= 8 # Red->green->blue->black
# if(color == 0): color = 0xFF0000 # If black, reset to red
# tail += 1 # Advance tail position
# if(tail >= numpixels): tail = 0 # Off end? Reset
except KeyboardInterrupt:
print("cleaning up")
GPIO.cleanup()
strip.clear()
strip.show()
print("done")
except SystemError as err:
print("SystemError:", err)
#!/usr/bin/python
import time
from dotstar import Adafruit_DotStar
numpixels = 230 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 17
clockpin = 27
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
# Alternate ways of declaring strip:
# strip = Adafruit_DotStar(numpixels) # Use SPI (pins 10=MOSI, 11=SCLK)
# strip = Adafruit_DotStar(numpixels, 32000000) # SPI @ ~32 MHz
# strip = Adafruit_DotStar() # SPI, No pixel buffer
# strip = Adafruit_DotStar(32000000) # 32 MHz SPI, no pixel buf
# Append "order='gbr'" to declaration for proper colors w/older DotStar strips)
strip.begin() # Initialize pins for output
strip.setBrightness(192) # Limit brightness to ~1/4 duty cycle
# green, red, blue
for i in range(numpixels):
strip.setPixelColor(i, i, 255, 50)
strip.show() # Refresh strip
active = False
# call function again
startTimer()
# initialize
init()
counter = 0
while True:
counter += 1
# flash one LED red if there is trouble connecting
if not active:
for num in range(1, LED_COUNT):
strip.setPixelColor(num, 0, 0, 0)
bri = math.fabs(math.sin(counter * 0.05))
strip.setPixelColor(0, int(255 * bri), 0, 0)
else:
# smooth fade in & out
for idx, hour in enumerate(precipHours):
bri = math.fabs(math.sin((counter + (idx * 25)) * 0.05))
if hour[0] == 'r':
precipColor = rain
elif hour[0] == 's':
precipColor = snow
strip.setPixelColor(hour[1], int(precipColor.r * bri), int(precipColor.g * bri), int(precipColor.b * bri))
strip.show()
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
return makeColor(255 - wheelPos * 3, 0, wheelPos * 3)
def prog1():
for j in reversed(range(pixels)):
for i in range(j):
strip.setPixelColor(i, 0xFF0000)
strip.show()
strip.setPixelColor(i, 0)
time.sleep(delay)
strip.setPixelColor(i, 0xFF0000)
while True:
if GPIO.input(IRLED) == GPIO.LOW:
time.sleep(0.0001) # wait 10 ms to give CPU chance to do other things
# print("I saw the LED")
GPIO.output(LED, False)
for j in reversed(range(pixels)):
for i in range(j):
strip.setPixelColor(i, 0)
strip.show()
time.sleep(delay)
#colorWipe(strip, Color(0,255,0))
else:
#print("I saw an object")
#GPIO.output(LED, True)
prog1()
import time
from dotstar import Adafruit_DotStar
numpixels = 360
datapin = 23
clockpin = 18
strip = Adafruit_DotStar(numpixels, 125000000)
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle
for count in xrange(0, 60):
strip.setPixelColor(count, 0x000000)
strip.show()
class Elevator(threading.Thread):
def __init__(self, kill_event, loop_time=1.0 / 60.0):
self.status = "INIT"
self.q = Queue()
self.kill_event = kill_event
self.timeout = loop_time
self.baudrate = BAUDRATE
self.dev = DEVICE
self.strip = Adafruit_DotStar(NUMPIXELS, DATAPIN, CLOCKPIN)
self.strip.begin()
self.strip.setBrightness(255)
self.serial = serial.Serial(self.dev)
self.serial.baudrate = 115200
# Initial state
self.send_elevator_command(ELEVATOR_DOWN)
self.status = "DOWN"
self.set_lights(OFF)
super(Elevator, self).__init__()
def onThread(self, function, *args, **kwargs):
self.q.put((function, args, kwargs))
def run(self):
self.down()
while True:
if self.kill_event.is_set():
self.close()
return
try:
function, args, kwargs = self.q.get(timeout=self.timeout)
function(*args, **kwargs)
except Empty:
pass
def send_elevator_command(self, command):
self.serial.flushInput() # avoids that the input buffer overfloats
self.serial.write(command)
self.serial.flush()
def up(self):
self.status = "GOING_UP"
self.send_elevator_command(ELEVATOR_UP)
time.sleep(TIME_UP_S)
self.status = "UP"
self.set_lights(GREEN)
def down(self):
self.status = "GOING_DOWN"
self.send_elevator_command(ELEVATOR_DOWN)
self.set_lights(OFF)
time.sleep(TIME_DOWN_S)
self.status = "DOWN"
time.sleep(TIME_TO_LEAVE_ELEVATOR_S)
self.status = "FREE"
def close(self):
self.serial.close()
def set_lights(self, color):
for i in range(NUMPIXELS):
self.strip.setPixelColor(i, color)
if color == OFF:
self.strip.setBrightness(0)
else:
self.strip.setBrightness(255)
self.strip.show()
# Set the strip to all white at lowest brightness, and slowly ramp up.
import time
from dotstar import Adafruit_DotStar
WHITE = 0xFFFFFF
n_pixels = 72 # Number of LEDs in strip
strip = Adafruit_DotStar(n_pixels) # Use SPI (pins 10=MOSI, 11=SCLK)
strip.begin() # Initialize pins for output
# Open log file.
f = open('powerlog.txt', 'w')
f.write("Brightness\tVoltage\n")
for p in range(n_pixels):
strip.setPixelColor(p, WHITE)
for b in range(256):
#print b
# Set the brightness.
strip.setBrightness(b)
strip.show() # Refresh strip
# Prompt user for data entry.
answer = raw_input(str(b)+' ')
# Log it.
f.write(str(b)+"\t"+answer+"\n")
f.flush()
# Wait a fraction of a second to help ensure that the write completes,
# in case the next brightness level crashes the system.
time.sleep(0.1)
#------------------#
r_start = 0xFF
g_start = 0x00
b_start = 0x00
for s in range(0x00,0xFF):
r = r_start - s
g = g_start + s
b = b_start
color = r*0x010000 + g*0x000100 + b*0x000001
for i in range(31): #Step through all pixels in my led strip (1-30)
# strip.setPixelColor(i, color) # Turn on pixel #i
strip.setPixelColor(i, color + i / 32 * 0xFF) # Turn on pixel #i
strip.show() # Refresh strip
time.sleep(delay) # pause delay seconds
#------------------#
# Green -> Blue
#------------------#
r_start = 0x00
g_start = 0xFF
b_start = 0x00
for s in range(0x00,0xFF):
# first resolve an ContactQuality stream on the lab network
print("looking for a ContactQuality stream...")
streams = resolve_stream('type', 'ContactQuality')
# LED Strip Setup
numpixels = 72 # Number of LEDs in strip
strip = Adafruit_DotStar(numpixels, 125000, order='bgr')
print 'strip object created'
strip.begin() # Initialize pins for output
strip.setBrightness(8) # Limit brightness to ~1/4 duty cycle
# reset strip
for ledi in range(0, numpixels):
strip.setPixelColor(ledi, 0x00FF00)
strip.show()
strip.setPixelColor(ledi, 0)
strip.show()
# create a new inlet to read from the stream
inlet = StreamInlet(streams[0])
info = inlet.info()
print(info.as_xml())
print("The channel labels are as follows:")
ch = info.desc().child("channels").child("channel")
for k in range(info.channel_count()):
print ", " + ch.child_value("label"),
ch = ch.next_sibling()
#!/usr/bin/python
import time
from dotstar import Adafruit_DotStar
numpixels = 230 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 17
clockpin = 27
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
# Alternate ways of declaring strip:
# strip = Adafruit_DotStar(numpixels) # Use SPI (pins 10=MOSI, 11=SCLK)
# strip = Adafruit_DotStar(numpixels, 32000000) # SPI @ ~32 MHz
# strip = Adafruit_DotStar() # SPI, No pixel buffer
# strip = Adafruit_DotStar(32000000) # 32 MHz SPI, no pixel buf
# Append "order='gbr'" to declaration for proper colors w/older DotStar strips)
strip.begin() # Initialize pins for output
strip.setBrightness(192) # Limit brightness to ~1/4 duty cycle
# green, red, blue
h = raw_input('Enter hex: ').lstrip('#')
j = tuple(int(h[i:i+2], 16) for i in (0, 2 ,4))
print j
for i in range(numpixels):
strip.setPixelColor(i, j[0], j[1], j[2])
strip.show() # Refresh strip
#!/usr/bin/python
#Turn off all leds
import time
from dotstar import Adafruit_DotStar
#INITIALIZE AND CLEAR DOTSTAR
numpixels = 72 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 23
clockpin = 24
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
strip.begin() # Initialize pins for output
strip.setBrightness(32) # Limit brightness to ~1/4 duty cycle
#turn all leds to black (off)
offspot = 1
offcolor = 0x000000
nump = 73
while offspot < nump:
strip.setPixelColor(offspot, offcolor)
offspot += 1
strip.show()
}
CHECK_TIME = 120 # How often to check the website
TIME_BETWEEN_PIXELS = .02 # Seconds from one pixel to the next
led_number = 0 # Which LED are we setting right now?
tot_time = CHECK_TIME # So we'll check immediately
while True:
if tot_time >= CHECK_TIME:
keywords_found = scrape.match_keywords('http://slashdot.org',
topicwords)
tot_time = 0
print(keywords_found)
tot_hits = sum(keywords_found[i] for i in keywords_found)
if num_pixels % tot_hits == 0 or tot_hits % num_pixels == 0:
keywords_found['blank'] = 1
# Loop over the topics:
for topic in keywords_found:
# For this topic, keywords_found[topic] is the number of keywords
# we matched on Twitter. Show that number of pixels.
# The color for this topic is topiccolors[topic].
for i in range(keywords_found[topic]):
strip.setPixelColor(led_number, topiccolors[topic])
strip.show()
led_number = (led_number + 1) % num_pixels
time.sleep(TIME_BETWEEN_PIXELS)
tot_time += TIME_BETWEEN_PIXELS
#!/usr/bin/python
import time
import math
import array
from dotstar import Adafruit_DotStar
numpixels = 72 # Number of LEDs in strip
strip = Adafruit_DotStar(numpixels) # Use SPI (pins 10=MOSI, 11=SCLK)
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/2 duty cycle
# Initialize CA, for now with 1 pixel
cells = array.array('B',(0,)*numpixels)
# Set strip colors and display them
for i in range(numpixels):
strip.setPixelColor(i, 0x000000)
strip.show() # Refresh strip
class Bartender(MenuDelegate):
def __init__(self):
self.running = False
# set the oled screen height
self.screen_width = SCREEN_WIDTH
self.screen_height = SCREEN_HEIGHT
self.btn1Pin = LEFT_BTN_PIN
self.btn2Pin = RIGHT_BTN_PIN
# configure interrups for buttons
GPIO.setup(self.btn1Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.btn2Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# configure screen
spi_bus = 0
spi_device = 0
#Load the display driver. Attention: 128_64 is the display size. Needed to be changed if different in your setup
self.led = disp = Adafruit_SSD1306.SSD1306_128_64(
rst=RST,
dc=DC,
spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000)
) # Change rows & cols values depending on your display dimensions.
# Initialize library.
self.led.begin()
# Clear display.
self.led.clear()
self.led.display()
# Create image buffer.
# Make sure to create image with mode '1' for 1-bit color.
self.image = Image.new('1', (self.screen_width, self.screen_height))
# Load default font.
#self.font = ImageFont.load_default()
self.font = ImageFont.truetype(FONTFILE, FONTSIZE)
# Create drawing object.
self.draw = ImageDraw.Draw(self.image)
# load the pump configuration from file
self.pump_configuration = Bartender.readPumpConfiguration()
for pump in self.pump_configuration.keys():
GPIO.setup(self.pump_configuration[pump]["pin"],
GPIO.OUT,
initial=GPIO.HIGH)
# setup pixels:
self.numpixels = NUMBER_NEOPIXELS # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = NEOPIXEL_DATA_PIN
clockpin = NEOPIXEL_CLOCK_PIN
self.strip = Adafruit_DotStar(self.numpixels, datapin, clockpin)
#Auskommentiert solange noch kein LED Strip angebracht.
#self.strip.begin() # Initialize pins for output
self.strip.setBrightness(
NEOPIXEL_BRIGHTNESS) # Limit brightness to ~1/4 duty cycle
# turn everything off
for i in range(0, self.numpixels):
self.strip.setPixelColor(i, 0)
self.strip.show()
print "Done initializing"
@staticmethod
def readPumpConfiguration():
return json.load(open('pump_config.json'))
@staticmethod
def writePumpConfiguration(configuration):
with open("pump_config.json", "w") as jsonFile:
json.dump(configuration, jsonFile)
def startInterrupts(self):
GPIO.add_event_detect(self.btn1Pin,
GPIO.FALLING,
callback=self.left_btn,
bouncetime=LEFT_PIN_BOUNCE)
GPIO.add_event_detect(self.btn2Pin,
GPIO.FALLING,
callback=self.right_btn,
bouncetime=RIGHT_PIN_BOUNCE)
def buildMenu(self, drink_list, drink_options):
# create a new main menu
m = Menu("Main Menu")
# add drink options
drink_opts = []
for d in drink_list:
drink_opts.append(
MenuItem('drink', d["name"],
{"ingredients": d["ingredients"]}))
configuration_menu = Menu("Configure")
# add pump configuration options
pump_opts = []
for p in sorted(self.pump_configuration.keys()):
config = Menu(self.pump_configuration[p]["name"])
# add fluid options for each pump
for opt in drink_options:
# star the selected option
selected = "*" if opt["value"] == self.pump_configuration[p][
"value"] else ""
config.addOption(
MenuItem('pump_selection', opt["name"], {
"key": p,
"value": opt["value"],
"name": opt["name"]
}))
# add a back button so the user can return without modifying
config.addOption(Back("Back"))
config.setParent(configuration_menu)
pump_opts.append(config)
# add pump menus to the configuration menu
configuration_menu.addOptions(pump_opts)
# add a back button to the configuration menu
configuration_menu.addOption(Back("Back"))
# adds an option that cleans all pumps to the configuration menu
configuration_menu.addOption(MenuItem('clean', 'Clean'))
# adds an option that shuts down the rpi
configuration_menu.addOption(MenuItem('shutdown', 'Shutdown'))
configuration_menu.setParent(m)
m.addOptions(drink_opts)
m.addOption(configuration_menu)
# create a menu context
self.menuContext = MenuContext(m, self)
def filterDrinks(self, menu):
"""
Removes any drinks that can't be handled by the pump configuration
"""
for i in menu.options:
if (i.type == "drink"):
i.visible = False
ingredients = i.attributes["ingredients"]
presentIng = 0
for ing in ingredients.keys():
for p in self.pump_configuration.keys():
if (ing == self.pump_configuration[p]["value"]):
presentIng += 1
if (presentIng == len(ingredients.keys())):
i.visible = True
elif (i.type == "menu"):
self.filterDrinks(i)
def selectConfigurations(self, menu):
"""
Adds a selection star to the pump configuration option
"""
for i in menu.options:
if (i.type == "pump_selection"):
key = i.attributes["key"]
if (self.pump_configuration[key]["value"] ==
i.attributes["value"]):
i.name = "%s %s" % (i.attributes["name"], "*")
else:
i.name = i.attributes["name"]
elif (i.type == "menu"):
self.selectConfigurations(i)
def prepareForRender(self, menu):
self.filterDrinks(menu)
self.selectConfigurations(menu)
return True
def menuItemClicked(self, menuItem):
if (menuItem.type == "drink"):
self.makeDrink(menuItem.name, menuItem.attributes["ingredients"])
return True
elif (menuItem.type == "pump_selection"):
self.pump_configuration[menuItem.attributes["key"]][
"value"] = menuItem.attributes["value"]
Bartender.writePumpConfiguration(self.pump_configuration)
return True
elif (menuItem.type == "clean"):
self.clean()
return True
elif (menuItem.type == "shutdown"):
self.shutdown()
return True
return False
def clean(self):
waitTime = 20
pumpThreads = []
# cancel any button presses while the drink is being made
# self.stopInterrupts()
self.running = True
for pump in self.pump_configuration.keys():
pump_t = threading.Thread(
target=self.pour,
args=(self.pump_configuration[pump]["pin"], waitTime))
pumpThreads.append(pump_t)
# start the pump threads
for thread in pumpThreads:
thread.start()
# start the progress bar
self.progressBar(waitTime)
# wait for threads to finish
for thread in pumpThreads:
thread.join()
# show the main menu
self.menuContext.showMenu()
# sleep for a couple seconds to make sure the interrupts don't get triggered
time.sleep(2)
def shutdown(self):
shutdowntext = "Shutdown takes 10 seconds. Bye!"
self.led.clear()
self.draw.rectangle((0, 0, self.screen_width, self.screen_height),
outline=0,
fill=0)
words_list = WRAPPER.wrap(text=shutdowntext)
TextNew = ''
for ii in words_list[:-1]:
TextNew = TextNew + ii + "\n"
TextNew += words_list[-1]
self.draw.text((0, 10), str(TextNew), font=self.font, fill=255)
self.led.image(self.image)
self.led.display()
time.sleep(5)
#Clean shutdown device
subprocess.Popen(['shutdown', '-h', 'now'])
def displayMenuItem(self, menuItem):
print menuItem.name
self.led.clear()
self.draw.rectangle((0, 0, self.screen_width, self.screen_height),
outline=0,
fill=0)
words_list = WRAPPER.wrap(text=menuItem.name)
MenuItemNew = ''
for ii in words_list[:-1]:
MenuItemNew = MenuItemNew + ii + "\n"
MenuItemNew += words_list[-1]
self.draw.text((0, 10), str(MenuItemNew), font=self.font, fill=255)
self.led.image(self.image)
self.led.display()
def cycleLights(self):
t = threading.currentThread()
head = 0 # Index of first 'on' pixel
tail = -10 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
while getattr(t, "do_run", True):
self.strip.setPixelColor(head, color) # Turn on 'head' pixel
self.strip.setPixelColor(tail, 0) # Turn off 'tail'
self.strip.show() # Refresh strip
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
head += 1 # Advance head position
if (head >= self.numpixels): # Off end of strip?
head = 0 # Reset to start
color >>= 8 # Red->green->blue->black
if (color == 0): color = 0xFF0000 # If black, reset to red
tail += 1 # Advance tail position
if (tail >= self.numpixels): tail = 0 # Off end? Reset
def lightsEndingSequence(self):
# make lights green
for i in range(0, self.numpixels):
self.strip.setPixelColor(i, 0xFF0000)
self.strip.show()
time.sleep(5)
# turn lights off
for i in range(0, self.numpixels):
self.strip.setPixelColor(i, 0)
self.strip.show()
def pour(self, pin, waitTime):
GPIO.output(pin, GPIO.LOW)
time.sleep(waitTime)
GPIO.output(pin, GPIO.HIGH)
def progressBar(self, waitTime):
interval = waitTime / 100.0
for x in range(1, 101):
self.led.clear()
self.draw.rectangle((0, 0, self.screen_width, self.screen_height),
outline=0,
fill=0)
self.updateProgressBar(x, y=35)
self.led.image(self.image)
self.led.display()
time.sleep(interval)
def makeDrink(self, drink, ingredients):
# cancel any button presses while the drink is being made
# self.stopInterrupts()
self.running = True
# launch a thread to control lighting
lightsThread = threading.Thread(target=self.cycleLights)
lightsThread.start()
# Parse the drink ingredients and spawn threads for pumps
maxTime = 0
pumpThreads = []
for ing in ingredients.keys():
for pump in self.pump_configuration.keys():
if ing == self.pump_configuration[pump]["value"]:
waitTime = ingredients[ing] * FLOW_RATE
if (waitTime > maxTime):
maxTime = waitTime
pump_t = threading.Thread(
target=self.pour,
args=(self.pump_configuration[pump]["pin"], waitTime))
pumpThreads.append(pump_t)
# start the pump threads
for thread in pumpThreads:
thread.start()
# start the progress bar
self.progressBar(maxTime)
# wait for threads to finish
for thread in pumpThreads:
thread.join()
# show the main menu
self.menuContext.showMenu()
# stop the light thread
lightsThread.do_run = False
lightsThread.join()
# show the ending sequence lights
self.lightsEndingSequence()
# sleep for a couple seconds to make sure the interrupts don't get triggered
time.sleep(2)
# reenable interrupts
# self.startInterrupts()
self.running = False
def left_btn(self, ctx):
print("LEFT_BTN pressed")
if not self.running:
self.running = True
self.menuContext.advance()
print("Finished processing button press")
self.running = False
def right_btn(self, ctx):
print("RIGHT_BTN pressed")
if not self.running:
self.running = True
self.menuContext.select()
print("Finished processing button press")
self.running = 2
print("Starting button timeout")
def updateProgressBar(self, percent, x=15, y=15):
height = 10
width = self.screen_width - 2 * x
for w in range(0, width):
self.draw.point((w + x, y), fill=255)
self.draw.point((w + x, y + height), fill=255)
for h in range(0, height):
self.draw.point((x, h + y), fill=255)
self.draw.point((self.screen_width - x, h + y), fill=255)
for p in range(0, percent):
p_loc = int(p / 100.0 * width)
self.draw.point((x + p_loc, h + y), fill=255)
def run(self):
self.startInterrupts()
# main loop
try:
try:
while True:
letter = raw_input(">")
if letter == "l":
self.left_btn(False)
if letter == "r":
self.right_btn(False)
except EOFError:
while True:
time.sleep(0.1)
if self.running not in (True, False):
self.running -= 0.1
if self.running == 0:
self.running = False
print("Finished button timeout")
except KeyboardInterrupt:
GPIO.cleanup() # clean up GPIO on CTRL+C exit
GPIO.cleanup() # clean up GPIO on normal exit
traceback.print_exc()
import os
import serial
import random
import png
import struct
from time import sleep, time
from struct import pack, unpack
from dotstar import Adafruit_DotStar
numpixels = 144
gamma_value = 1.1
gamma = bytearray(256)
for i in range(256):
gamma[i] = int(pow(float(i) / 255.0, gamma_value) * 255.0 + 0.5)
strip = Adafruit_DotStar(numpixels, order='bgr')
strip.begin() # Initialize pins for output
strip.setBrightness(128) # Limit brightness to ~1/4 duty cycle
for row in xrange(144):
strip.setPixelColor(row, 0)
strip.show()
# FF FF F0
for row in xrange(50):
strip.setPixelColor(row, 0xaaaaa0)
strip.show()
numpixels = 72 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 23
clockpin = 24
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
strip.begin() # Initialize pins for output
strip.setBrightness(128) # Limit brightness to ~1/4 duty cycle
#First, turn all black
offspot = 1
offcolor = 0x000000
while offspot >= 1:
strip.setPixelColor(offspot, offcolor)
offspot += 1
if offspot == 72:
break
#set initial spots and colors of Jupiter and moons
jupspot = 36 #jupiter position
jupcolor = 0xFF8801 #jupiter color
iospot = iopos #Io position
iocolor = 0x9932cc #Io color
eurspot = eurpos #Europa position
eurcolor = 0x9932cc #Europa color
numpixels = 72 # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = 23
clockpin = 24
strip = Adafruit_DotStar(numpixels, datapin, clockpin)
strip.begin() # Initialize pins for output
strip.setBrightness(32) # Limit brightness to ~1/4 duty cycle
#turn all black
offspot = 1
offcolor = 0x000000
while offspot >= 1:
strip.setPixelColor(offspot, offcolor)
offspot += 1
if offspot == 72:
break
jupspot = 36 #jupiter position
iospot = 1 #Io position ------------->trying for just one moon
jupcolor = 0xFF8801 #jupiter color
iocolor = 0x9932cc #Io color
lastiocolor = 0x000000
#lastiospot = (iospot - 1)
while True: # Loop forever
findmoons()
strip.setPixelColor(jupspot, jupcolor) # Turn on jupiter to orange
# See image-pov.py for explanation of no-pixel-buffer use.
# Append "order='gbr'" to declaration for proper colors w/older DotStar strips)
strip.begin() # Initialize pins for output
strip.setBrightness(255) # Limit brightness to ~1/4 duty cycle
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
head = begin # Index of first 'on' pixel
tail = -15 # Index of last 'off' pixel
color = 0xFFFFFF # 'On' color (starts red)
b = 0
while b < 400:
strip.setPixelColor(b, 0)
b = b + 1
print(strip.getPixelColor(b))
strip.show()
while True: # Loop forever
strip.setPixelColor(head, color) # Turn on 'head' pixel
strip.setPixelColor(tail, 0) # Turn off 'tail'
strip.show() # Refresh strip
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
head += 1 # Advance head position
if (head >= px + begin): # Off end of strip?
head = begin # Reset to start
#color >>= 8 # Red->green->blue->black
#!/usr/bin/python from dotstar import Adafruit_DotStar LED_COUNT = 7 datapin = 10 clockpin = 11 strip = Adafruit_DotStar(LED_COUNT, datapin, clockpin) strip.begin() for num in range(1, LED_COUNT): strip.setPixelColor(num, 0, 0, 0) strip.show()
colorScooter = 1
rainbowCounter1 = 4
rainbowCounter2 = 3
rainbowCounter3 = 2
rainbowCounter4 = 1
rainbowCounter5 = 0
oldDataValue = "none"
adaIoCheckerCounter = 0
data = aio.receive(FEED_ID)
while True: # Loop forever
if (data.value != oldDataValue):
i = 0
for i in range(0, 45):
strip.setPixelColor(i, black)
++i
strip.show() # Refresh strip
oldDataValue = data.value
if (oldDataValue == "Off"):
for i in range(0, 45):
strip.setPixelColor(i, black)
++i
strip.show()
elif (oldDataValue == "Christmas"):
i = 0
for i in range(0, 45):
if (i >= 0 and i < 10): color = red
elif (i >= 10 and i < 20): color = green
elif (i >= 20 and i < 30): color = red
elif (i >= 30 and i < 40): color = green
tail = -10 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
pixels = 50
delay = .001
def makeColor(r, g, b):
return (r << 16) + (g << 8) + b
def colorWheel(wheelPos):
if wheelPos < 85:
return makeColor(wheelPos * 3, 255 - wheelPos * 3, 0)
elif wheelPos < 170:
wheelPos -= 85
return makeColor(0, wheelPos * 3, 255 - wheelPos * 3)
else:
wheelPos -= 170
return makeColor(255 - wheelPos * 3, 0, wheelPos * 3)
while True:
for j in reversed(range(pixels)):
for i in range(j):
strip.setPixelColor(i, 0xFF0000)
strip.show()
strip.setPixelColor(i, 0)
time.sleep(delay)
strip.setPixelColor(i, 0xFF0000)
strip.begin() # Initialize pins for output
strip.setBrightness(32) # Limit brightness to ~1/4 duty cycle
# 3-color totalistic cellular automaton
# colors are 0, 1, 2 (we usually show 0 as black)
colors = (0x000000, 0xFF0000, 0x007F7F)
ca = [0,1,2,1,0,0,1] # code 777 CA
# see http://mathworld.wolfram.com/TotalisticCellularAutomaton.html
# Initialize CA, for now with 1 pixel
cells = array.array('B',(0,)*numpixels)
cells[int(numpixels/2)] = 2
sum = array.array('B',(0,)*numpixels)
while True: # Loop forever
# Set strip colors and display them
for i in range(numpixels):
strip.setPixelColor(i, colors[cells[i]])
strip.show() # Refresh strip
# Update CA
for i in range(numpixels):
# Sum up cell and its neighbors (with wraparound)
sum[i] = cells[(i+numpixels-1)%numpixels] + cells[i] + cells[(i+1)%numpixels]
for i in range(numpixels):
cells[i] = ca[sum[i]]
time.sleep(1.0 / fps)
# Append "order='gbr'" to declaration for proper colors w/older DotStar strips)
strip.begin() # Initialize pins for output
strip.setBrightness(65) # Limit brightness to ~1/4 duty cycle
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
head = 10 # Index of first 'on' pixel
tail = 0 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
step = -0x010000
while True: # Loop forever
for i in range(31):
strip.setPixelColor(i, color) # Turn on 'head' pixel
strip.show() # Refresh strip
time.sleep(1.0 / 400) # Pause 20 milliseconds (~50 fps)
# head += 1 # Advance head position
# if(head >= numpixels): # Off end of strip?
# head = 0 # Reset to start
# color >>= 8 # Red->green->blue->black
# if(color == 0): color = 0xFF0000 # If black, reset to red
#
# tail += 1 # Advance tail position
# if(tail >= numpixels): tail = 0 # Off end? Reset
# color = (0.99*color)
if (color>=0xFF0000): step = -0x010000
# strip = Adafruit_DotStar() # SPI, No pixel buffer # strip = Adafruit_DotStar(32000000) # 32 MHz SPI, no pixel buf # See image-pov.py for explanation of no-pixel-buffer use. # Append "order='gbr'" to declaration for proper colors w/older DotStar strips) strip.begin() # Initialize pins for output strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle # Runs 10 LEDs at a time along strip, cycling through red, green and blue. # This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel. head = 0 # Index of first 'on' pixel tail = -20 # Index of last 'off' pixel color = 0xFF0000 # 'On' color (starts red) while True: # Loop forever strip.setPixelColor(head, color) # Turn on 'head' pixel strip.setPixelColor(tail, 0) # Turn off 'tail' strip.show() # Refresh strip time.sleep(1.0 / 100) # Pause 20 milliseconds (~50 fps) head += 1 # Advance head position if(head >= numpixels): # Off end of strip? head = 0 # Reset to start color >>= 8 # Red->green->blue->black if(color == 0): color = 0xFF0000 # If black, reset to red tail += 1 # Advance tail position if(tail >= numpixels): tail = 0 # Off end? Reset
class Bartender(MenuDelegate):
def __init__(self):
self.running = False
# set the oled screen height
self.screen_width = SCREEN_WIDTH
self.screen_height = SCREEN_HEIGHT
self.make_drink = MAKE_DRINK
self.btn1Pin = LEFT_BTN_PIN
self.btn2Pin = RIGHT_BTN_PIN
self.clk = CLK_PIN
self.dt = DT_PIN
# configure interrupts for buttons
#GPIO.setup(self.btn1Pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(self.btn2Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# configure interrupts for encoder
GPIO.setup(self.clk, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(self.dt, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
#Pi config
RST = 21
DC = 20
SPI_PORT = 0
SPI_DEVICE = 0
# configure screen
self.disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
self.disp.begin()
self.disp.clear()
self.disp.display()
#draw
self.image = Image.new('1', (SCREEN_WIDTH, SCREEN_HEIGHT))
self.draw = ImageDraw.Draw(self.image)
self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
outline=0,
fill=0)
self.font = ImageFont.load_default()
# Very important... This lets py-gaugette 'know' what pins to use in order to reset the display
# Change rows & cols values depending on your display dimensions.
# load the pump configuration from file
self.pump_configuration = Bartender.readJson(
'/home/pi/Documents/PiDrink/static/json/pump_config.json')
for pump in self.pump_configuration.keys():
GPIO.setup(self.pump_configuration[pump]["pin"],
GPIO.OUT,
initial=GPIO.HIGH)
# load the current drink list
self.drink_list = Bartender.readJson(
'/home/pi/Documents/PiDrink/static/json/drink_list.json')
self.drink_list = self.drink_list["drink_list"]
# load the current drink options
self.drink_options = Bartender.readJson(
'/home/pi/Documents/PiDrink/static/json/drink_options.json')
self.drink_options = self.drink_options["drink_options"]
# setup pixels:
self.numpixels = NUMBER_NEOPIXELS # Number of LEDs in strip
# Here's how to control the strip from any two GPIO pins:
datapin = NEOPIXEL_DATA_PIN
clockpin = NEOPIXEL_CLOCK_PIN
self.strip = Adafruit_DotStar(self.numpixels, datapin, clockpin)
self.strip.begin() # Initialize pins for output
self.strip.setBrightness(
NEOPIXEL_BRIGHTNESS) # Limit brightness to ~1/4 duty cycle
# turn everything off
for i in range(0, self.numpixels):
self.strip.setPixelColor(i, 0)
self.strip.show()
print('Done initializing')
# def check_email(self):
# status, email_ids = self.imap_server.search(None, '(UNSEEN)')
# if email_ids == ['']:
# mail_list = []
# else:
# mail_list = self.get_subjects(email_ids) #FYI when calling the get_subjects function, the email is marked as 'read'
# self.imap_server.close()
# return mail_list
# def get_subjects(self, email_ids):
# subjects_list = []
# for e_id in email_ids[0].split():
# resp, data = self.imap_server.fetch(e_id, '(RFC822)')
# perf = HeaderParser().parsestr(data[0][1])
# subjects_list.append(perf['Subject'])
# return subjects_list
def voice_command(self, mail_list):
for mail in mail_list:
found = False
while (found == False):
currmen = self.menuContext.currentMenu.getSelection()
if (currmen.name == mail):
self.makeDrink(currmen.name,
currmen.attributes["ingredients"])
self.make_drink = False
found = True
else:
self.menuContext.currentMenu.nextSelection()
found = False
@staticmethod
def readJson(file):
return json.load(open(file))
@staticmethod
def writePumpConfiguration(configuration):
with open("/home/pi/Documents/PiDrink/static/json/pump_config.json",
"w") as jsonFile:
json.dump(configuration, jsonFile)
def startInterrupts(self):
#GPIO.add_event_detect(self.btn1Pin, GPIO.FALLING, callback=self.left_btn, bouncetime=LEFT_PIN_BOUNCE)
GPIO.add_event_detect(self.btn2Pin,
GPIO.FALLING,
callback=self.right_btn,
bouncetime=RIGHT_PIN_BOUNCE)
GPIO.add_event_detect(self.clk,
GPIO.BOTH,
callback=self.rotary_on_change,
bouncetime=1000)
def stopInterrupts(self):
#GPIO.remove_event_detect(self.btn1Pin)
GPIO.remove_event_detect(self.btn2Pin)
GPIO.remove_event_detect(self.clk)
def buildMenu(self):
# create a new main menu
m = Menu("Main Menu")
# add drink options
drink_opts = []
for d in self.drink_list:
drink_opts.append(
MenuItem('drink', d["name"],
{"ingredients": d["ingredients"]}))
configuration_menu = Menu("Configure")
# add pump configuration options
pump_opts = []
for p in sorted(self.pump_configuration.keys()):
config = Menu(self.pump_configuration[p]["name"])
# add fluid options for each pump
for opt in self.drink_options:
# star the selected option
selected = "*" if opt["value"] == self.pump_configuration[p][
"value"] else ""
config.addOption(
MenuItem('pump_selection', opt["name"], {
"key": p,
"value": opt["value"],
"name": opt["name"]
}))
# add a back button so the user can return without modifying
config.addOption(Back("Back"))
config.setParent(configuration_menu)
pump_opts.append(config)
# add pump menus to the configuration menu
configuration_menu.addOptions(pump_opts)
# add a back button to the configuration menu
configuration_menu.addOption(Back("Back"))
# adds an option that cleans all pumps to the configuration menu
configuration_menu.addOption(MenuItem('clean', 'Clean'))
configuration_menu.setParent(m)
m.addOptions(drink_opts)
m.addOption(configuration_menu)
# create a menu context
self.menuContext = MenuContext(m, self)
def filterDrinks(self, menu):
"""
Removes any drinks that can't be handled by the pump configuration
"""
for i in menu.options:
if (i.type == "drink"):
i.visible = False
ingredients = i.attributes["ingredients"]
presentIng = 0
for ing in ingredients.keys():
for p in self.pump_configuration.keys():
if (ing == self.pump_configuration[p]["value"]):
presentIng += 1
if (presentIng == len(ingredients.keys())):
i.visible = True
elif (i.type == "menu"):
self.filterDrinks(i)
def selectConfigurations(self, menu):
"""
Adds a selection star to the pump configuration option
"""
for i in menu.options:
if (i.type == "pump_selection"):
key = i.attributes["key"]
if (self.pump_configuration[key]["value"] ==
i.attributes["value"]):
i.name = "%s %s" % (i.attributes["name"], "*")
else:
i.name = i.attributes["name"]
elif (i.type == "menu"):
self.selectConfigurations(i)
def prepareForRender(self, menu):
self.filterDrinks(menu)
self.selectConfigurations(menu)
return True
def menuItemClicked(self, menuItem):
if (menuItem.type == "drink"):
if self.make_drink:
self.makeDrink(menuItem.name,
menuItem.attributes["ingredients"])
self.make_drink = False
return True
elif (menuItem.type == "pump_selection"):
self.pump_configuration[menuItem.attributes["key"]][
"value"] = menuItem.attributes["value"]
Bartender.writePumpConfiguration(self.pump_configuration)
return True
elif (menuItem.type == "clean"):
if self.make_drink:
self.clean()
self.make_drink = False
return True
return False
def changeConfiguration(self, pumps):
# Change configuration of every pump
for i in range(1, 7):
self.pump_configuration["pump_" + str(i)]["value"] = pumps[i - 1]
Bartender.writePumpConfiguration(self.pump_configuration)
def clean(self):
waitTime = 30
pumpProcesses = []
# cancel any button presses while the drink is being made
# self.stopInterrupts()
self.running = True
for pump in self.pump_configuration.keys():
pump_p = threading.Thread(target=self.pour,
args=(
self.pump_configuration[pump]["pin"],
waitTime,
))
pumpProcesses.append(pump_p)
disp_process = threading.Thread(target=self.progressBar,
args=(waitTime, ))
pumpProcesses.append(disp_process)
# start the pump threads
for process in pumpProcesses:
process.start()
# wait for threads to finish
for process in pumpProcesses:
process.join()
# sleep for a couple seconds to make sure the interrupts don't get triggered
time.sleep(2)
# reenable interrupts
# self.startInterrupts()
self.running = False
self.make_drink = True
self.menuContext.showMenu()
def displayMenuItem(self, menuItem):
#Clear display
self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
outline=0,
fill=0)
self.draw.text((20, 10), menuItem.name, font=self.font, fill=255)
self.disp.image(self.image)
self.disp.display()
def cycleLights(self):
t = threading.currentThread()
head = 0 # Index of first 'on' pixel
tail = -10 # Index of last 'off' pixel
color = 0xFF0000 # 'On' color (starts red)
while getattr(t, "do_run", True):
self.strip.setPixelColor(head, color) # Turn on 'head' pixel
self.strip.setPixelColor(tail, 0) # Turn off 'tail'
self.strip.show() # Refresh strip
time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
head += 1 # Advance head position
if (head >= self.numpixels): # Off end of strip?
head = 0 # Reset to start
color >>= 8 # Red->green->blue->black
if (color == 0): color = 0xFF0000 # If black, reset to red
tail += 1 # Advance tail position
if (tail >= self.numpixels): tail = 0 # Off end? Reset
def lightsEndingSequence(self):
# make lights green
for i in range(0, self.numpixels):
self.strip.setPixelColor(i, 0xFF0000)
self.strip.show()
time.sleep(5)
# turn lights off
for i in range(0, self.numpixels):
self.strip.setPixelColor(i, 0)
self.strip.show()
def pour(self, pin, waitTime):
GPIO.output(pin, GPIO.LOW)
time.sleep(waitTime)
GPIO.output(pin, GPIO.HIGH)
def progressBar(self, waitTime):
interval = waitTime / 116.3
for x in range(1, 101):
# Clear display
self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
outline=0,
fill=0)
#self.draw.text((55,20), str(x) + '%', font = self.font, fill=255)
self.updateProgressBar(x, y=10)
self.disp.image(self.image)
self.disp.display()
time.sleep(interval)
# # self.disp.clear()
# # self.disp.display()
# self.image = Image.open('happycat_oled_32.ppm').convert('1')
# self.disp.image(self.image)
# self.disp.display()
def makeDrink(self, drink, ingredients):
if self.running:
return
# cancel any button presses while the drink is being made
# self.stopInterrupts()
print('Making a ' + drink)
self.running = True
# launch a thread to control lighting
lightsThread = threading.Thread(target=self.cycleLights)
lightsThread.start()
# Make a list for each potential time
maxTime = 0
pumpProcesses = []
for ing in ingredients.keys():
for pump in self.pump_configuration.keys():
if ing == self.pump_configuration[pump]["value"]:
waitTime = ingredients[ing] * FLOW_RATE
if (waitTime > maxTime):
maxTime = waitTime
pump_p = threading.Thread(
target=self.pour,
args=(self.pump_configuration[pump]["pin"], waitTime))
pumpProcesses.append(pump_p)
disp_process = threading.Thread(target=self.progressBar,
args=(maxTime, ))
pumpProcesses.append(disp_process)
# start the pump threads
for process in pumpProcesses:
process.start()
# wait for threads to finish
for process in pumpProcesses:
process.join()
# stop the light thread
lightsThread.do_run = False
lightsThread.join()
# show the ending sequence lights
self.lightsEndingSequence()
# reenable interrupts
# sleep for a couple seconds to make sure the interrupts don't get triggered
time.sleep(2)
# self.startInterrupts()
self.running = False
print('Finished making ' + drink)
self.make_drink = True
# show the main menu
self.menuContext.showMenu()
def left_btn(self, ctx):
if not self.running:
self.menuContext.advance()
def right_btn(self, ctx):
if not self.running:
self.menuContext.select()
def rotary_on_change(self, ctx):
if not self.running:
if GPIO.input(self.dt):
self.menuContext.retreat()
else:
self.menuContext.advance()
def get_ingredients_time(self, drink):
# Get the ingredients for the specified drink
found = False
while (found == False):
currmen = self.menuContext.currentMenu.getSelection()
if (currmen.name == drink):
ingredients = currmen.attributes["ingredients"]
self.make_drink = False
found = True
else:
self.menuContext.currentMenu.nextSelection()
# Get the drink making time
maxTime = 0
for ing in ingredients.keys():
for pump in self.pump_configuration.keys():
if ing == self.pump_configuration[pump]["value"]:
waitTime = ingredients[ing] * FLOW_RATE
if (waitTime > maxTime):
maxTime = waitTime
# Return making time and ingredients for drink
return ingredients, maxTime
def updateProgressBar(self, percent, x=15, y=10):
height = 10
width = self.screen_width - 2 * x
for w in range(0, width):
self.draw.point((w + x, y), fill=255)
self.draw.point((w + x, y + height), fill=255)
for h in range(0, height):
self.draw.point((x, h + y), fill=255)
self.draw.point((self.screen_width - x, h + y), fill=255)
for p in range(0, percent):
p_loc = int(p / 100.0 * width)
self.draw.point((x + p_loc, h + y), fill=255)
self.draw.text((55, 20),
str(percent) + '%',
font=self.font,
fill=255)
#self.disp.image(self.image)
#self.disp.display()
def endprogram(self):
global stopprogram
stopprogram = True
# Goodbye message
self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
outline=0,
fill=0)
self.draw.text((25, 10), "Goodbye...", font=self.font, fill=255)
self.disp.image(self.image)
self.disp.display()
time.sleep(3)
self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
outline=0,
fill=0)
self.draw.text((15, 10), "Have a great day!", font=self.font, fill=255)
self.disp.image(self.image)
self.disp.display()
time.sleep(3)
self.disp.clear()
self.disp.display()
def run(self):
self.startInterrupts()
# main loop
try:
while True:
if stopprogram:
return
# self.imap_server = imaplib.IMAP4_SSL("imap.gmail.com",993)
# self.imap_server.login(USERNAME, PASSWORD)
# self.imap_server.select('INBOX')
# mail_list = self.check_email()
# if mail_list and not self.running:
# self.voice_command(mail_list)
time.sleep(0.1)
except KeyboardInterrupt:
GPIO.cleanup() # clean up GPIO on CTRL+C exit
sys.exit(0)
GPIO.cleanup() # clean up GPIO on normal exit
traceback.print_exc()
while True: # Loop forever # rotate color through rainbow if (color & 0xFF0000) and not (color & 0x0000FF): color = color - 0x010000 # decrement red color = color + 0x000100 # increment green elif(color & 0x00FF00): color = color - 0x000100 # decrement green color = color + 0x000001 # increment blue elif(color & 0x0000FF): color = color - 0x000001 # decrement blue color = color + 0x010000 # increment red # Turn off old dot strip.setPixelColor(dot, 0) # Calculate wave based on time now = time.time() angle = angle_mult * (now - start) amplitude = math.cos(now/mod_period) wave = amplitude * math.cos(angle) #dot = int(math.floor(((wave + 1.0)*(numpixels-1) + 1.0)/2.0)) #dot = int(((wave + 1.0)*(numpixels-1)/2.0 + 1.0)//2.0 + numpixels/2) dot = int(((wave + 1.0)*(numpixels-1) + 1.0)//2.0) # Turn on new dot strip.setPixelColor(dot, color) strip.show() # Refresh strip #time.sleep(1.0 / 50) # Pause 20 milliseconds (~50 fps)
strip.begin() # Initialize pins for output
# Load image in RGB format and get dimensions:
print "Loading..."
img = Image.open(filename).convert("RGB")
pixels = img.load()
width = img.size[0]
height = img.size[1]
print "%dx%d pixels" % img.size
if (height > strip.numPixels()): height = strip.numPixels()
# Calculate gamma correction table, makes mid-range colors look 'right':
gamma = bytearray(256)
for i in range(256):
gamma[i] = int(pow(float(i) / 255.0, 2.7) * 255.0 + 0.5)
print "Displaying..."
while True: # Loop forever
for x in range(width): # For each column of image...
for y in range(height): # For each pixel in column...
value = pixels[x, y] # Read pixel in image
strip.setPixelColor(
y, # Set pixel in strip
gamma[value[0]], # Gamma-corrected red
gamma[value[1]], # Gamma-corrected green
gamma[value[2]]) # Gamma-corrected blue
strip.show() # Refresh LED strip
# Runs 10 LEDs at a time along strip, cycling through red, green and blue.
# This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.
head = 10 # Index of first 'on' pixel
tail = 0 # Index of last 'off' pixel
r = 0xFF
g = 0x00
b = 0x00
color = r * 0x010000 + g * 0x000100 + b * 0x000001
# 'On' color (starts red)
step = -0x01
while True: # Loop forever
for i in range(31):
strip.setPixelColor(i, color) # Turn on 'head' pixel
strip.show() # Refresh strip
time.sleep(1.0 / 100) # Pause 20 milliseconds (~50 fps)
# head += 1 # Advance head position
# if(head >= numpixels): # Off end of strip?
# head = 0 # Reset to start
# color >>= 8 # Red->green->blue->black
# if(color == 0): color = 0xFF0000 # If black, reset to red
#
# tail += 1 # Advance tail position
# if(tail >= numpixels): tail = 0 # Off end? Reset
r = r + step
g = g - step
color = r * 0x010000 + g * 0x000100 + b * 0x000001
pos = abs(mousepos) * scale if pos > 1.0: break lightpaint.dither(ledBuf, pos) strip.show(ledBuf) if btn() != pin_go: # Button released? strip.show(clearBuf) elif b == 2: # Decrease paint duration if speed_pixel > 0: speed_pixel -= 1 duration = (min_time + time_range * speed_pixel / (num_leds - 1)) strip.setPixelColor(speed_pixel, 0x000080) strip.show() startTime = time.time() while (btn() == 2 and ((time.time() - startTime) < rep_time)): continue strip.clear() strip.show() elif b == 3: # Increase paint duration (up to 10 sec maximum) if speed_pixel < num_leds - 1: speed_pixel += 1 duration = (min_time + time_range * speed_pixel / (num_leds - 1)) strip.setPixelColor(speed_pixel, 0x000080) strip.show() startTime = time.time()
print hue print sat print val print "" h = scale(hue, 0, 255, 0, 1) s = scale(sat, 0, 255, 0, 1) v = scale(val, 0, 255, 0, 1) r,g,b = colorsys.hsv_to_rgb(h,s,v) print r print g print b print "" r = int(scale(r, 0, 1, 0, 255)) g = int(scale(g, 0, 1, 0, 255)) b = int(scale(b, 0, 1, 0, 255)) print r print g print b color = strip.Color(g,r,b) for i in range(numpixels): strip.setPixelColor(i, color) strip.show()
#The following is an example LED program that flashes the LEDs in
#random colors.
import time
from dotstar import Adafruit_DotStar
import random
numpixels = 2 # Number of LEDs in strip
strip = Adafruit_DotStar(numpixels, 12000000)
strip.begin() # Initialize pins for output
strip.setBrightness(64) # Limit brightness to ~1/4 duty cycle
head = 0 # First LED in the ball
tail = 1 # Second LED int the ball
head_color = 0xFF0000 # Color of first LED
tail_color = 0x00FF00 # Color of second LED
while True:
strip.setPixelColor(head, head_color)
strip.setPixelColor(tail, tail_color)
strip.show()
#Delay for a time before the colors switch
time.sleep(0.4)
#scroll the color across the two leds in the ball
#generate a new random color each time (from red to white)
tail_color = head_color
head_color = random.randint(255, 16777215)
else: # Time to switch completely to the new kaleidoscope ks_map = ks_new_map ks_old_n = ks_new_n ks_old_map = ks_new_map ks_new_n = random.randrange(len(ks.maps)) ks_new_map = ks.maps[ks_new_n] ks_fade_start = now + ks.HoldTime ks_fade_end = ks_fade_start + ks.FadeTime print "ks =", ks.names[ks_old_n], " -> ", ks.names[ks_new_n] # Apply the Kaleidoscope. ks_screen = [screen[ks_map[p]] for p in range(n_pixels)] # Set up all pixels for draw at beginning of next cycle. for p in range(n_pixels): strip.setPixelColor(p, cm_interp(cm_map,ks_screen[p])) # Strobe. # Fade to black if volume is low. #st_brightness = min(brightness,(osc_max-osc_min)//2) st_brightness = min(brightness,(osc_max-osc_min)*brightness//MAX_BRIGHTNESS) #print 'st_brightness =', st_brightness now = time.time() # Turn strobing on or off? if (st_enabled): if (now > st_end): # Turn strobing off. st_enabled = False print 'st = off' st_start = now + st_DownTime else:
# Load image in RGB format and get dimensions:
print "Loading..."
img = Image.open(filename).convert("RGB")
pixels = img.load()
width = img.size[0]
height = img.size[1]
print "%dx%d pixels" % img.size
if height > strip.numPixels():
height = strip.numPixels()
# Calculate gamma correction table, makes mid-range colors look 'right':
gamma = bytearray(256)
for i in range(256):
gamma[i] = int(pow(float(i) / 255.0, 2.7) * 255.0 + 0.5)
print "Displaying..."
while True: # Loop forever
for x in range(width): # For each column of image...
for y in range(height): # For each pixel in column...
value = pixels[x, y] # Read pixel in image
strip.setPixelColor(
y, # Set pixel in strip
gamma[value[0]], # Gamma-corrected red
gamma[value[1]], # Gamma-corrected green
gamma[value[2]],
) # Gamma-corrected blue
strip.show() # Refresh LED strip
