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())
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")
import time
from mote import Mote
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()
def clamp16(n):
return max(min(16, n), 0)
def moteset(n, r, g, b):
# strip 1 (increasing pixels)
r1 = clamp16(n) # values between 1 and 16
for pixel in range(r1):
mote.set_pixel(1, pixel, r, g, b)
# strip 2 (inc.)
r2 = clamp16(n - 16) # values between 17 and 32
for pixel in range(r2):
mote.set_pixel(2, pixel, r, g, b)
# strip 3 (decreasing pixels)
r3 = clamp16(n - 32) # values between 33 and 48
for pixel in range(15, 15 - r3, -1):
mote.set_pixel(3, pixel, r, g, b)
# strip 4 (dec.)
r4 = clamp16(n - 48) # values betwene 47 and 64
for pixel in range(15, 15 - r4, -1):
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()
ubit_speed = Characteristic(
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()
var1 = 2
elif var1 == 2:
mote2 = Mote(port_name=element.device)
#Configure the 16 LED's, clear channels on both hubs
mote1.configure_channel(1, 16, False)
mote1.configure_channel(2, 16, False)
mote1.configure_channel(3, 16, False)
mote1.configure_channel(4, 16, False)
mote2.configure_channel(1, 16, False)
mote2.configure_channel(2, 16, False)
mote2.configure_channel(3, 16, False)
mote2.configure_channel(4, 16, False)
mote1.clear()
mote2.clear()
try:
while True:
r = requests.get('http://api.thingspeak.com/channels/1417/feed.json')
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']
#calculate the count for each
for idx in range(0,3):
channels_colour_delta[channel - 1][idx] = (channels_colour[channel - 1][idx] - old_channels_colour[channel - 1][idx]) / float(transition_step)
channel += 1
print(channels_colour_rgb)
if old_channels_colour != channels_colour:
# Do the transition
for step in range(0, transition_step):
for channel in range(1, 5):
for idx in range(0,3):
old_channels_colour[channel - 1][idx] += channels_colour_delta[channel - 1][idx]
r,g,b = hsv_to_rgb(old_channels_colour[channel - 1][0],
old_channels_colour[channel - 1][1],
old_channels_colour[channel - 1][2]);
for pixel in range(mote.get_pixel_count(channel)):
mote.set_pixel(channel, pixel, int(r), int(g), int(b))
mote.show()
time.sleep(transition_time / transition_step)
for channel in range(0, 4):
for idx in range(0,3):
old_channels_colour[channel][idx] = channels_colour[channel][idx]
time.sleep(5)
except KeyboardInterrupt:
mote.clear()
mote.show()
time.sleep(0.1)
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()
from mote import Mote
import random
import time
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)
