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 open_mote():
m = Mote()
for channel in range(1, 5):
m.configure_channel(channel, 16, False)
return m
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
class MoteController:
def __init__(self):
self.mote = Mote()
gammaCorrection = False
self.mote.configure_channel(1, 16, gammaCorrection)
self.mote.configure_channel(2, 16, gammaCorrection)
self.mote.configure_channel(3, 16, gammaCorrection)
self.mote.configure_channel(4, 16, gammaCorrection)
def run(self, programs):
while True:
for program in programs:
program.run(self.mote)
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 init_motes(colour, brightness):
print("initialising Motes")
#set
mote = Mote() # new instance of the Mote class, will do all the USB init
for m in range(1, 4 + 1):
mote.configure_channel(m, 16,
False) # configure for use the Mote sticks
#calculate colour for brightness
# just first stick at the moment
h, s, v = colorsys.rgb_to_hsv(colour[0][0], colour[0][1], colour[0][2])
colour_new = [[0] * 3 for i in range(4)]
colour_new[0][0], colour_new[0][1], colour_new[0][2] = rgb_to_decimal(
colorsys.hsv_to_rgb(h, s, brightness))
set_mote_sticks(mote, colour_new)
return mote
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")
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])
from time import sleep
from mote import Mote
from bluezero import constants
from bluezero import tools
from bluezero import adapter
from bluezero import device
from bluezero.GATT import Characteristic
display_on = False
lights = Mote()
mote_pixels = 16
lights.configure_channel(1, mote_pixels, False)
def on_accel_change(iface, changed_props, invalidated_props):
print('Accel!')
global display_on
if iface != constants.GATT_CHRC_IFACE:
return
if not len(changed_props):
return
accel_val = changed_props.get('Value', None)
if not accel_val:
return
# Read button value
x = abs(int.from_bytes(accel_val[0:1], byteorder='little', signed=True))
#!/usr/bin/env python
import sys
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)
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:
import pygame
from mote import Mote
import time
from random import randint
file_rocket = 'rocket.mp3'
file_firecrackers = 'with-firecrackers.mp3'
pygame.init()
pygame.mixer.init()
pygame.mixer.music.load(file_rocket)
mote = Mote()
for i in range(1, 5):
mote.configure_channel(i, 16, False)
def twinkle(channel, pixel):
pygame.mixer.music.play()
print("Bang!")
for i in range(0, 100):
r = randint(10, 255)
g = randint(10, 255)
b = randint(10, 255)
mote.set_pixel(channel, pixel, r, g, b)
mote.show()
time.sleep(0.005)
pygame.mixer.fadeout(1)
time.sleep(1)
import requests
except ImportError:
exit(
"This script requires the requests module\nInstall with: sudo pip install requests"
)
from mote import Mote
mote = Mote()
num_pixels = 16
transition_time = 1 # seconds
transition_step = 100
mote.configure_channel(1, num_pixels, False)
mote.configure_channel(2, num_pixels, False)
mote.configure_channel(3, num_pixels, False)
mote.configure_channel(4, num_pixels, False)
try:
channels_colour_rgb = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
channels_colour = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
channels_colour_delta = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
old_channels_colour = [[0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0]]
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]
#!/usr/bin/env python3
"""AmbiMote UDP Server."""
import argparse
import sys
import asyncio
import struct
from base64 import b16encode
from mote import Mote
mote = Mote()
mote.configure_channel(1, 16, True)
mote.configure_channel(2, 16, True)
mote.configure_channel(3, 16, True)
mote.configure_channel(4, 16, True)
try:
import signal
except ImportError:
signal = None
class UdpAmbiMoteProtocol:
pix_no = 0
def connection_made(self, transport):
print('start', transport)
self.transport = transport
@staticmethod
def parse_rgb(i):
from mote import Mote
if __name__ == "__main__":
mote = Mote()
gammaCorrection = False
mote.configure_channel(1, 16, gammaCorrection)
mote.configure_channel(2, 16, gammaCorrection)
mote.configure_channel(3, 16, gammaCorrection)
mote.configure_channel(4, 16, gammaCorrection)
mote.clear()
mote.show()
#!/usr/bin/env python
import colorsys
import math
import signal
import time
from random import randint, sample
import argparse
import sys
if sys.platform == 'darwin':
from mote import Mote
motephat = Mote()
motephat.configure_channel(1, 16, False)
motephat.configure_channel(2, 16, False)
else:
import motephat
motephat.set_brightness(1)
parser = argparse.ArgumentParser()
parser.add_argument("sequence",
choices=['sparkle', 'flash'],
help="Type of mote sequence to play.")
parser.add_argument("-i",
"--interval",
default=0.1,
type=float,
help="Interval between sparkles in seconds (default=0.1).")
parser.add_argument(
"-d",
"--density",
from mote import Mote
import time
import random
m = Mote()
m.configure_channel(1, 16, True)
m.configure_channel(2, 16, False)
m.configure_channel(3, 16, False)
m.configure_channel(4, 16, False)
m.clear()
last_r = 0
last_g = 0
last_b = 0
while True:
for c in range(1, 5):
for p in range(16):
while True:
r = random.choice([0, 127, 255])
g = random.choice([0, 127, 255])
b = random.choice([0, 127, 255])
if (r != g or r != b
or g != b) and (r != last_r and b != last_b
and g != last_g):
break
m.set_pixel(c, p, r, g, b)
last_r = r
last_g = g
#!/usr/bin/env python
# Adapted from Adafruit's dotstar python example
# https://github.com/adafruit/Adafruit_DotStar_Pi
from PIL import Image
from mote import Mote
mote = Mote()
NUMPIXELS = 16 # Number of LEDs in strip
FILENAME = "hello.png" # Image file to load
mote.configure_channel(1, NUMPIXELS, False)
mote.configure_channel(2, 0, False)
mote.configure_channel(3, 0, False)
mote.configure_channel(4, 0, False)
# Load image in RGB format and get dimensions:
print("Loading...")
img = Image.open(FILENAME).convert("RGB")
pixels = img.load()
width, height = img.size
ratio = width / height
print("Image is {}x{}".format(width, height))
if height > NUMPIXELS:
height = NUMPIXELS
width = int(height * ratio)
img.resize((width, height))
print("Resized to {}x{}".format(width, height))
# Calculate gamma correction table, makes mid-range colors look 'right':
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):
try:
import requests
except ImportError:
exit("This script requires the requests module\nInstall with: sudo pip install requests")
from mote import Mote
mote = Mote()
num_pixels = 16
transition_time = 1 # seconds
transition_step = 100
mote.configure_channel(1, num_pixels, False)
mote.configure_channel(2, num_pixels, False)
mote.configure_channel(3, num_pixels, False)
mote.configure_channel(4, num_pixels, False)
try:
channels_colour_rgb = [[0,0,0], [0,0,0], [0,0,0], [0,0,0]]
channels_colour = [[0,0,0], [0,0,0], [0,0,0], [0,0,0]]
channels_colour_delta = [[0,0,0], [0,0,0], [0,0,0], [0,0,0]]
old_channels_colour = [[0,1,0], [0,1,0], [0,1,0], [0,1,0]]
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]
