def main(): try: mote = None try: mote = Mote() mote.configure_channel(1, 16, False) mote.configure_channel(2, 16, False) mote.configure_channel(3, 16, False) mote.configure_channel(4, 16, False) mote.clear() except: pass puzzled = Puzzled(mote) puzzled.start() if mote != None: for channel in range(1, 5): for pixel in range(16): mote.set_pixel(channel, pixel, 0, 0, 0) mote.show() curses.nocbreak() screen.keypad(False) curses.echo() curses.endwin() quit() except: curses.nocbreak() screen.keypad(False) curses.echo() curses.endwin() print(sys.exc_info())
def run(): """let's goooo""" mote = Mote() mote.configure_channel(1, 16, False) mote.configure_channel(2, 16, False) mote.configure_channel(3, 16, False) mote.configure_channel(4, 16, False) rand_cols = ColorRandom() patterns = [ pattern_floodfill, pattern_scatter, pattern_race, pattern_horizflood, pattern_horizsnakeflood, pattern_snakeflood, ] black = lambda: ColorConstant([0, 0, 0]) colors = [ ColorRandom, lambda: ColorConstant(rand_cols.get(None)), lambda: ColorChannelConstant(rand_cols), lambda: ColorChannelFade(rand_cols.get(None), rand_cols.get(None)), lambda: ColorGlobalFade(rand_cols.get(None), rand_cols.get(None)), lambda: ColorPixelFade(rand_cols.get(None), rand_cols.get(None)), lambda: ColorHorizCenterFade(rand_cols.get(None), rand_cols.get(None)), lambda: ColorRadialFade(rand_cols.get(None), rand_cols.get(None)), lambda: ColorChequerboard(rand_cols), ] last_col_template = None last_pattern_template = None while True: pattern_template = choice(patterns) if pattern_template == last_pattern_template: continue pattern = pattern_template() if random() < 0.5 else pattern_reverse( pattern_template()) color_template = black if (random() < 0.33 and last_col_template is not None) \ else choice(colors) if color_template == last_col_template: continue color = color_template() for update in pattern: c = color.get(update) prev_c = mote.get_pixel(update[0], update[1]) for step in range(8): step_c = lerp_cols(step / 7.0, prev_c, c) mote.set_pixel(update[0], update[1], step_c[0], step_c[1], step_c[2]) mote.show() time.sleep(0.03) last_col_template = color_template last_pattern_template = pattern_template
def setstick(s, r, g, b): mote = Mote() # new instance of the Mote class, will do all the USB init state = getmotestate() for m in range(1, 4 + 1): mote.configure_channel(m, 16, False) # configure for use the Mote sticks setpixels(m, state[m - 1][0], state[m - 1][1], state[m - 1][2], mote) if s == 0: for st in range(1, 4 + 1): setpixels(st, r, g, b, mote) setmotestate(state, st, r, g, b) else: setpixels(s, r, g, b, mote) setmotestate(state, s, r, g, b) mote.show()
def setstick(s, b, i): mote = Mote() # new instance of the Mote class, will do all the USB init state = getmotestate() if i != 0: b = getbrightness(state, s) + i if b < 0: b = 0 elif b > 9: b = 9 state = setbrightness(state, s, b, i) for m in range(1, 4 + 1): mote.configure_channel(m, 16, False) # configure for use the Mote sticks setpixels(m, state[m - 1][0], state[m - 1][1], state[m - 1][2], mote) mote.show() setmotestate(state, s, state[s - 1][0], state[s - 1][1], state[s - 1][2])
class MoteLamp(BaseLamp): def __init__(self, channels=4, correction=[1., 1., 1.]): self.mote = Mote() for c in range(channels): self.mote.configure_channel(c + 1, 16, False) BaseLamp.__init__(self, correction=correction) self.channels = channels self.pixels = 16 for channel in range(self.channels): self.mote.configure_channel(channel + 1, self.pixels, False) self.width = self.channels self.height = self.pixels # Clear all pixels def clear(self): self.mote.clear() self.mote.show() def show(self): self.mote.show() # Set a single pixel def set_pixel(self, x, y, r, g, b): r, g, b = self.apply_correction(r, g, b) self.mote.set_pixel(x + 1, y, r, g, b) # Set all pixels to RGB def set_all(self, r, g, b): self.color = (r, g, b) r, g, b = self.apply_correction(r, g, b) self.mote.set_all(r, g, b) # Set maximum global brightness def set_brightness(self, val): val = int(val) if 0 <= val <= 255: self.mote.set_brightness( val / 255) # Set brightness through unicornhat library self.brightness = val # Log user-selected brightness to a variable self.mote.show() else: logging.error("Brightness must be between 0 and 255")
from mote import Mote import time mote = Mote() mote.configure_channel(1, 16, False) mote.configure_channel(2, 16, False) mote.configure_channel(3, 16, False) mote.configure_channel(4, 16, False) mote.clear() mote.show() # colours = ['red', 'orange', 'yellow', 'green', 'blue', 'purple'] # iteration = 0 red = 255 green = 0 blue = 0 try: while True: if red > 0 and blue == 0: red -= 1 green += 1 if green > 0 and red == 0: green -= 1 blue += 1 if blue > 0 and green == 0: blue -= 1 red += 1 mote.set_all(red, green, blue, 0.5) mote.show()
print('power adapter') dongle = adapter.Adapter('/org/bluez/hci0') if not dongle.powered(): dongle.powered(True) print('discovery') dongle.nearby_discovery() ubit = device.Device( tools.device_dbus_path(constants.DEVICE_INTERFACE, 'puteg')[0]) while True: print('connect...') while not ubit.connected(): ubit.connect() while not ubit.services_resolved(): lights.set_pixel(1, 1, 255, 0, 0) sleep(0.1) lights.show() lights.clear() sleep(0.1) print('set up characteristics') ubit_btn_b = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'E95DDA90-251D-470A-A062-FA1922DFA9A8')[0]) ubit_btn_b.add_characteristic_cb(on_button_b) ubit_btn_b.start_notify() ubit_btn_a = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'E95DDA91-251D-470A-A062-FA1922DFA9A8')[0]) ubit_btn_a.add_characteristic_cb(on_button_a) ubit_btn_a.start_notify()
from mote import Mote import sys motes = Mote() motes.configure_channel(1, 16, False) r = int(sys.argv[1]) g = int(sys.argv[2]) b = int(sys.argv[3]) motes.clear() motes.set_pixel(1, 0, r, g, b) motes.set_pixel(1, 1, r, g, b) motes.set_pixel(1, 2, r, g, b) motes.set_pixel(1, 3, r, g, b) motes.set_pixel(1, 4, r, g, b) motes.set_pixel(1, 5, r, g, b) motes.set_pixel(1, 6, r, g, b) motes.set_pixel(1, 7, r, g, b) motes.set_pixel(1, 8, r, g, b) motes.set_pixel(1, 9, r, g, b) motes.set_pixel(1, 10, r, g, b) motes.set_pixel(1, 11, r, g, b) motes.set_pixel(1, 12, r, g, b) motes.set_pixel(1, 13, r, g, b) motes.set_pixel(1, 14, r, g, b) motes.set_pixel(1, 15, r, g, b) motes.show()
j = r.json() f = j['feeds'][-8:] f = [element for index, element in enumerate(f) if index % 2 == 0] print(f) channel = 1 for col in f: col = col['field2'] ## Older versions of Python may need this line ##r, g, b = tuple(ord(c) for c in col[1:].lower().decode('hex')) r, g, b = tuple(c for c in bytes.fromhex(col[1:])) for pixel in range(mote1.get_pixel_count(channel)): mote1.set_pixel(channel, pixel, r, g, b) mote2.set_pixel(channel, pixel, r, g, b) channel += 1 mote1.show() mote2.show() time.sleep(5) except KeyboardInterrupt: mote1.clear() mote2.clear() mote1.show() mote2.show() time.sleep(0.1)
mote.configure_channel(2, 16, False) mote.configure_channel(3, 16, False) mote.configure_channel(4, 16, False) def usage(): print("Usage: {} <r> <g> <b>".format(sys.argv[0])) sys.exit(1) if len(sys.argv) != 4: usage() # Exit if non integer value. int() will raise a ValueError try: r, g, b = [int(x) for x in sys.argv[1:]] except ValueError: usage() # Exit if any of r, g, b are greater than 255 if max(r,g,b) > 255: usage() print("Setting Mote to {r},{g},{b}".format(r=r,g=g,b=b)) for channel in range(4): for pixel in range(16): mote.set_pixel(channel + 1, pixel, r, g, b) time.sleep(0.01) mote.show()
height = img.size[1] print "%dx%d pixels" % img.size if (height > mote.get_pixel_count(1)): height = 15 # 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..." try: 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 mote.set_pixel( 1, y, # Set pixel in strip gamma[value[0]], # Gamma-corrected red gamma[value[1]], # Gamma-corrected green gamma[value[2]]) # Gamma-corrected blue mote.show() # Refresh LED strip except KeyboardInterrupt: mote.clear() mote.show() quit()
class MyApplication: def __init__(self): #1: Create a builder self.builder = builder = pygubu.Builder() self.doQuick = False self.timeSlices = 320 self.motePixelInSceenPixels = 1 self.graphWidth = self.timeSlices self.cameraLag = 3 self.currentColumn = 0 self.simulate = False self.animate = False self.completeRepeats = 0 self.motePixelInCm = 1 self.mode = MODE_IMAGE self.color = (255, 0, 0) self.colorend = (0, 0, 255) self.bCameraBusy = False self.bControlCamera = False self.bPaintFromLeft = True self.bFacingScreen = True self.bReverseImage = False self.bFlipVertical = False self.bGradient = False self.bPaintWhite = False self.bPaintBlack = False self.bTween = False self.bLines = False self.bSpeckles = False self.bRandomAcrossRange = False self.iDuration = 5 self.iRepeats = 1 self.iDelay = 0 screen_width = gtk.gdk.screen_width() screen_height = gtk.gdk.screen_height() #2: Load an ui file builder.add_from_file(os.path.join(CURRENT_DIR, 'main_repeats.ui')) self.motePixelInSceenPixels = 2 #3: Create the toplevel widget. self.mainwindow = builder.get_object('mainwindow') self.canPreview = builder.get_object('canPreview') self.msgMessage = builder.get_object('msgMessage') self.scaDelay = builder.get_object('scaDelay') self.scaDuration = builder.get_object('scaDuration') self.connectToMote() self.iPixels = len(self.yToStick) self.aColourGrid = [] self.aRandomGrid = [] self.updateControls() self.filename = "images/Spectrum Vertical.png" self.loadImage() self.makeRandom() builder.connect_callbacks(self) def beep(self, duration=0.1): freq = 440 # Hz os.system( 'play --no-show-progress --null --channels 1 synth %s sine %f' % (duration, freq)) def addStick(self, channel, up=True, length=16, gammacorrect=True): #from top if not self.simulate: self.mote.configure_channel(channel, length, gammacorrect) for i in range(length): if up: offset = length - 1 - i else: offset = i self.yToStick.append((channel, offset)) def connectToMote(self): self.showMessage("Connecting") try: from mote import Mote self.mote = Mote() self.simulate = False self.showMessage("Connected") if not self.simulate: self.mote.clear() self.mote.show() except IOError: self.simulate = True self.showMessage("Simulating") self.yToStick = [] self.addStick(1) self.addStick(2) self.addStick(3) self.addStick(4) def takePhoto2(self): self.bCameraBusy = True os.system(gphoto2_command) self.bCameraBusy = False return 0 def takePhoto(self): return self.takePhoto2() logging.basicConfig(format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) self.bCameraBusy = True gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) print('Capturing image') file_path = gp.check_result( gp.gp_camera_capture(camera, gp.GP_CAPTURE_IMAGE)) print('Camera file path: {0}/{1}'.format(file_path.folder, file_path.name)) target = os.path.join('~/tmp', file_path.name) target = os.path.join(CURRENT_DIR, '..', 'LightPaintings', file_path.name) print('Copying image to', target) camera_file = gp.check_result( gp.gp_camera_file_get(camera, file_path.folder, file_path.name, gp.GP_FILE_TYPE_NORMAL)) gp.check_result(gp.gp_file_save(camera_file, target)) if (self.completeRepeats == self.iRepeats): subprocess.call(['xdg-open', target]) gp.check_result(gp.gp_camera_exit(camera)) self.bCameraBusy = False return 0 def quit(self, event=None): if not self.simulate: self.mote.clear() self.mote.show() self.mainwindow.quit() def reloadImage(self): self.mode = MODE_IMAGE self.loadImage() def loadImage(self): filename = self.filename self.im = Image.open(filename) iOriginalWidth, iOriginalHeight = self.im.size fAspect = float(iOriginalWidth) / float(iOriginalHeight) #targetWidth = int(fAspect * len(self.yToStick) * self.motePixelInCm) targetWidth = int(fAspect * self.iPixels * self.motePixelInCm) message = "Opened \"" + os.path.basename(filename) + "\" " + str( targetWidth) + "cm wide" self.showMessage(message) self.rgb_im = self.im.convert('RGB').resize( (self.timeSlices, self.iPixels), Image.NEAREST) self.width, self.height = self.rgb_im.size self.aImageValues = [[ self.rgb_im.getpixel((x, y)) for x in range(self.width) ] for y in range(self.height)] self.aRandomGrid = [[1 for x in range(self.width)] for y in range(self.height)] if (self.mode == MODE_IMAGE): self.drawPreview() def onFileChoose(self, event=None): self.filename = askopenfilename( initialdir="images/", title="Select file", filetypes=(("gif files", "*.gif"), ("png files", "*.png"), ("jpeg files", "*.jpg"), ("all files", "*.*"))) self.mode = MODE_IMAGE self.loadImage() def getColor(self, event=None): color = askcolor(self.color) if (color[0] == None): return if self.bPaintBlack == False: self.mode = MODE_COLOR self.color = color[0] self.drawPreview() def gradientChanged(self, event=None): self.mode = MODE_COLOR self.drawPreview() def getColorEnd(self, event=None): color = askcolor(self.colorend) if (color[0] == None): return self.bGradient = True self.updateControls() self.mode = MODE_COLOR self.colorend = color[0] self.drawPreview() def getImageX(self, processX): direction = (1 if self.bPaintFromLeft else -1) x = (0 if (direction == 1) else (self.timeSlices - 1)) + (direction * processX) return x def getPreviewX(self, processX): direction = (1 if self.bPaintFromLeft else -1) * (1 if self.bFacingScreen else -1) x = (0 if (direction == 1) else (self.timeSlices - 1)) + (direction * processX) return x def showColumn(self, x): iImageX = self.getImageX(x) if not self.simulate: try: for y in range(0, self.iPixels): try: if (self.bFlipVertical): colour = self.aPixels[(self.iPixels - y) - 1][iImageX] else: colour = self.aPixels[y][iImageX] except: colour = (0, 0, 0) channel, pixel = self.yToStick[y % len(self.yToStick)] if colour != (0, 0, 0): r, g, b = colour self.mote.set_pixel(channel, pixel, r, g, b) else: self.mote.set_pixel(channel, pixel, 0, 0, 0) self.mote.show() except IOError: self.simulate = True self.showMessage("Connection Failed. Simulating") def updateControls(self): self.builder.tkvariables.__getitem__('bGradient').set(self.bGradient) self.builder.tkvariables.__getitem__('bReverseImage').set( self.bReverseImage) self.builder.tkvariables.__getitem__('bFacingScreen').set( self.bFacingScreen) self.builder.tkvariables.__getitem__('bPaintFromLeft').set( self.bPaintFromLeft) self.builder.tkvariables.__getitem__('bPaintWhite').set( self.bPaintWhite) self.builder.tkvariables.__getitem__('iPixels').set(self.iPixels) self.builder.tkvariables.__getitem__('iDuration').set(self.iDuration) self.builder.tkvariables.__getitem__('iRepeats').set(self.iRepeats) self.builder.tkvariables.__getitem__('bControlCamera').set( self.bControlCamera) self.builder.tkvariables.__getitem__('bPaintBlack').set( self.bPaintBlack) self.builder.tkvariables.__getitem__('bTween').set(self.bTween) self.builder.tkvariables.__getitem__('bLines').set(self.bLines) self.builder.tkvariables.__getitem__('bSpeckles').set(self.bSpeckles) self.builder.tkvariables.__getitem__('bRandomAcrossRange').set( self.bRandomAcrossRange) self.builder.tkvariables.__getitem__('bFlipVertical').set( self.bFlipVertical) self.scaDelay.set(self.iDelay) def updateParams(self): self.bGradient = self.builder.tkvariables.__getitem__( 'bGradient').get() self.bReverseImage = self.builder.tkvariables.__getitem__( 'bReverseImage').get() self.bFacingScreen = self.builder.tkvariables.__getitem__( 'bFacingScreen').get() self.bPaintFromLeft = self.builder.tkvariables.__getitem__( 'bPaintFromLeft').get() self.bPaintWhite = self.builder.tkvariables.__getitem__( 'bPaintWhite').get() self.iPixels = self.builder.tkvariables.__getitem__('iPixels').get() self.iDuration = self.builder.tkvariables.__getitem__( 'iDuration').get() self.iRepeats = self.builder.tkvariables.__getitem__('iRepeats').get() self.bControlCamera = self.builder.tkvariables.__getitem__( 'bControlCamera').get() self.bPaintBlack = self.builder.tkvariables.__getitem__( 'bPaintBlack').get() self.bTween = self.builder.tkvariables.__getitem__('bTween').get() self.bLines = self.builder.tkvariables.__getitem__('bLines').get() self.bSpeckles = self.builder.tkvariables.__getitem__( 'bSpeckles').get() self.bRandomAcrossRange = self.builder.tkvariables.__getitem__( 'bRandomAcrossRange').get() self.bFlipVertical = self.builder.tkvariables.__getitem__( 'bFlipVertical').get() self.iDelay = self.scaDelay.get() def getColColour(self, px): if (self.bGradient): r = int( round(self.color[0] + float(self.colorend[0] - self.color[0]) * (float(px) / float(self.graphWidth)))) g = int( round(self.color[1] + float(self.colorend[1] - self.color[1]) * (float(px) / float(self.graphWidth)))) b = int( round(self.color[2] + float(self.colorend[2] - self.color[2]) * (float(px) / float(self.graphWidth)))) return (r, g, b) return self.color def getFrameColour(self): if (self.iRepeats > 1): j = self.completeRepeats r = int( round(self.color[0] + float(self.colorend[0] - self.color[0]) * (float(j) / float(self.iRepeats - 1)))) g = int( round(self.color[1] + float(self.colorend[1] - self.color[1]) * (float(j) / float(self.iRepeats - 1)))) b = int( round(self.color[2] + float(self.colorend[2] - self.color[2]) * (float(j) / float(self.iRepeats - 1)))) return (r, g, b) return self.color def transformThroughRandom(self, color, x, y, base=(0, 0, 0)): try: fMultiply = self.aRandomGrid[y][x] except: fMultiply == False if (fMultiply == False): return (0, 0, 0) else: return (int(round(fMultiply * float(color[0] - base[0]))) + base[0], int(round(fMultiply * float(color[1] - base[1]))) + base[1], int(round(fMultiply * float(color[2] - base[2]))) + base[2]) def dontPaintWhite(self, colour): if colour == (255, 255, 255): return (0, 0, 0) return colour def makeInvertedPixel( self, color, x, y, ): if color == (0, 0, 0): return self.aColorPixels[y][x] else: return (0, 0, 0) def makePixels(self): if self.bTween: self.aColorPixels = [[ self.getFrameColour() for x in range(self.width) ] for y in range(self.height)] else: if self.bRandomAcrossRange: self.aColorPixels = [[ self.transformThroughRandom(self.colorend, x, y, self.color) for x in range(self.width) ] for y in range(self.height)] else: self.aColorPixels = [[ self.getColColour(x) for x in range(self.width) ] for y in range(self.height)] if (self.mode == MODE_IMAGE): if self.bPaintBlack: self.aPixels = [[ self.makeInvertedPixel(self.aImageValues[y][x], x, y) for x in range(self.width) ] for y in range(self.height)] else: self.aRawPixels = self.aImageValues else: self.aRawPixels = self.aColorPixels if self.bPaintBlack == False: self.aPixels = [[ self.transformThroughRandom(self.aRawPixels[y][x], x, y) for x in range(self.width) ] for y in range(self.height)] if self.bPaintWhite == False: self.aPixels = [[ self.dontPaintWhite(self.aPixels[y][x]) for x in range(self.width) ] for y in range(self.height)] if self.bReverseImage == True: try: self.aPixels = [[ self.aPixels[y][(self.width - x) - 1] for x in range(self.width) ] for y in range(self.height)] except: print("failing", len(self.aPixels), self.width, x) def drawColumn(self, x): iImageX = self.getImageX(x) iPreviewX = self.getPreviewX(x) iPreviewXend = self.getPreviewX(x + 1) for y in range(0, self.iPixels): try: colour = self.aPixels[y][iImageX] except: colour = (0, 0, 0) if colour != (0, 0, 0): color = str(webcolors.rgb_to_hex(colour)) self.canPreview.create_rectangle( iPreviewX, (y * self.motePixelInSceenPixels), iPreviewXend, (y * self.motePixelInSceenPixels) + self.motePixelInSceenPixels, width=0, fill=color) if self.bPaintBlack & (self.currentColumn > 0 and self.currentColumn < self.graphWidth): self.canPreview.create_rectangle(iPreviewX, (0), iPreviewXend, self.motePixelInSceenPixels * 5, width=0, fill="#0F0") def doPreview(self, event=None): self.drawPreview() def changeRandom(self): self.updateParams() self.makeRandom() self.makePixels() self.drawPreview() def drawPreview(self): self.updateParams() self.makePixels() self.canPreview.create_rectangle( 0, 0, self.graphWidth, (len(self.yToStick) * self.motePixelInSceenPixels), fill="black") for x in range(0, self.graphWidth): self.drawColumn(x) def makeRandom(self): self.aRandomGrid = [[False for x in range(self.width)] for y in range(self.height)] for y in range(self.iPixels): if (self.bLines): line = [ random.randint(0, self.timeSlices), random.randint(0, self.timeSlices) ] line.sort() start = line[0] end = line[1] else: start = 0 end = self.timeSlices for x in range(0, self.timeSlices): if (x >= start and x <= end): if (self.bSpeckles or self.bRandomAcrossRange): level = random.random() else: level = 1 self.aRandomGrid[y][x] = level def refreshPixels(self): self.aImageValues = [[ self.rgb_im.getpixel((x, y)) for x in range(self.width) ] for y in range(self.height)] self.makePixels() def onShowEnd(self): if not self.simulate: self.mote.clear() self.mote.show() self.showMessage("Lights Finished") self.completeRepeats += 1 if self.bControlCamera: while self.bCameraBusy: pass message = "Show " + str(self.completeRepeats) + "/" + str( self.iRepeats) + " Complete in " + str(time.time() - self.startTime) + "s" self.showMessage(message) try: self.im.seek(self.im.tell() + 1) self.rgb_im = self.im.convert('RGB').resize( (self.timeSlices, self.iPixels)) self.refreshPixels() self.showMessage("Loaded next frame") self.drawPreview() except EOFError: try: if (self.im.tell() > 0): self.im.seek(0) self.rgb_im = self.im.convert('RGB').resize( (self.timeSlices, self.iPixels)) self.refreshPixels() print("Animation Looped") except: if (self.im.tell() > 0): self.im = Image.open(self.filename) self.rgb_im = self.im.convert('RGB').resize( (self.timeSlices, self.iPixels)) self.refreshPixels() print("Could not loop - Reloaded") if (self.completeRepeats < self.iRepeats): self.singleShow() else: self.completeRepeats = 0 self.makeRandom() self.drawPreview() def startPhoto(self): if self.bControlCamera: thread.start_new_thread(self.takePhoto, ()) def show(self): self.canPreview.create_rectangle( 0, 0, self.graphWidth, (len(self.yToStick) * self.motePixelInSceenPixels), fill="#000") if self.simulate: message = "Simulating" else: message = "Show " + str(self.completeRepeats + 1) + "/" + str( self.iRepeats) + " started" self.showMessage(message) duration = float(self.scaDuration.get()) self.stepTime = int(1000 * duration / float(self.timeSlices)) self.stepTimeS = duration / float(self.timeSlices) self.currentColumn = 0 self.startTime = time.time() self.targetTime = time.time() + self.stepTimeS self.doColumn() def doColumn(self): if time.time() < self.targetTime: self.timer = self.mainwindow.after(1, self.doColumn) return thisColumn = self.currentColumn if self.currentColumn < self.graphWidth: self.targetTime += self.stepTimeS self.timer = self.mainwindow.after(1, self.doColumn) self.drawColumn(thisColumn) self.showColumn(thisColumn) else: self.onShowEnd() self.currentColumn += 1 def showMessage(self, message): self.builder.tkvariables.__getitem__('messageText').set(message) def on_btnDraw_clicked(self, event=None): if (self.currentColumn > 0 and self.currentColumn < self.graphWidth) or self.bCameraBusy: self.showMessage("Cannot start now, still running") return False self.updateParams() self.completeRepeats = 0 self.singleShow() def drawCountdown(self): i = 1 + self.iFullDelay - self.delayRemaining width = self.graphWidth if self.iFullDelay > 0: width = i * self.graphWidth / self.iFullDelay self.canPreview.create_rectangle( 0, 0, width, (len(self.yToStick) * self.motePixelInSceenPixels), fill="#000") message = "Show " + str(self.completeRepeats + 1) + "/" + str( self.iRepeats) + " starts in " + str(self.delayRemaining) self.canPreview.itemconfigure(self.countdown_id, text=message) self.showMessage(message) if self.delayRemaining <= 4 and self.delayRemaining > 1: self.beep(0.1) self.delayRemaining -= 1 if self.delayRemaining > 0: self.mainwindow.after(1000, self.drawCountdown) else: self.beep(0.3) def singleShow(self): if self.simulate: self.connectToMote() self.canPreview.create_rectangle( 0, 0, self.graphWidth, (len(self.yToStick) * self.motePixelInSceenPixels), fill="#AAA") self.countdown_id = self.canPreview.create_text(100, self.graphWidth - 100, fill="#F00", text=".....") delayTime = self.scaDelay.get() lag = 0 if self.bControlCamera: lag = self.cameraLag #Start the countdown including the lag self.iFullDelay = delayTime + lag self.delayRemaining = self.iFullDelay self.drawCountdown() #start the camera shot after the delay without the lag self.mainwindow.after(delayTime * 1000, self.startPhoto) #start the show after waiting for delay & lag self.mainwindow.after((delayTime + lag) * 1000, self.show) def run(self): self.mainwindow.mainloop()
def handle_key(index, state): global brightlist if state and brightlist == off: brightlist = quarter keybow.set_led(index, brightlist[0], brightlist[1], brightlist[2]) elif state and brightlist == quarter: brightlist = half keybow.set_led(index, brightlist[0], brightlist[1], brightlist[2]) elif state and brightlist == half: brightlist = threequarter keybow.set_led(index, brightlist[0], brightlist[1], brightlist[2]) elif state and brightlist == threequarter: brightlist = full keybow.set_led(index, brightlist[0], brightlist[1], brightlist[2]) elif state and brightlist == full: brightlist = off keybow.set_led(index, brightlist[0], brightlist[1], brightlist[2]) return brightlist # main loop -- TODO function that takes current state + dictionary and returns next state while True: mote.clear() mote2.clear() mote.set_all(rgblist[0], rgblist[1], rgblist[2]) mote2.set_all(brightlist[0], brightlist[1], brightlist[2]) mote.show() mote2.show() keybow.show() time.sleep(0.2)
m = Mote() m.set_clear_on_exit(True) m.configure_channel(1, 16, False) m.configure_channel(2, 16, False) m.configure_channel(3, 16, False) m.configure_channel(4, 16, False) m.clear() try: while True: clear = random.randint(0, 9) if clear == 0: m.clear() for channel in range(1, 5): pixel = random.randint(0, 15) red = random.randint(0, 255) green = random.randint(0, 255) blue = random.randint(0, 255) delay = random.randint(2, 20) m.set_pixel(channel, pixel, red, green, blue, 0.5) m.show() time.sleep(delay / 1000) except KeyboardInterrupt: m.clear() m.show()