def step(self, amt = 1):
t = time.localtime()
hex = "#{0:0>2}{1:0>2}{2:0>2}".format(t.tm_hour, t.tm_min, t.tm_sec)
log.info(hex)
c = colors.hex2rgb(hex)
self._led.fill(c)
self._step = 0
def step(self, amt=1):
t = time.localtime()
hex = "#{0:0>2}{1:0>2}{2:0>2}".format(t.tm_hour, t.tm_min, t.tm_sec)
log.info(hex)
c = colors.hex2rgb(hex)
self._led.fill(c)
self._step = 0
def next_draw_obj(self):
self.cur_vis += 1
if self.cur_vis >= len(self.vis_list):
self.cur_vis = 0
if self.draw_obj:
del self.draw_obj
name = self.vis_list[self.cur_vis]
log.info("Loading {}".format(name))
self.draw_obj = self.vis_dict[name]
def next_draw_obj(self):
self.cur_vis += 1
if self.cur_vis >= len(self.vis_list):
self.cur_vis = 0
if self.draw_obj:
del self.draw_obj
name = self.vis_list[self.cur_vis]
log.info("Loading {}".format(name))
self.draw_obj = self.vis_dict[name]
def wrapped(self, *args, **kwargs):
if self.internal_delay != beam_state.delay:
log.info('delay changing from {} to {}'.format(
self.internal_delay, beam_state.delay))
self.set_delay(beam_state.delay)
self.set_brightness(beam_state.brightness)
if self._step > 10000000:
self._step = 0
return fn(self, *args, **kwargs)
def main_loop(led):
t = threading.Thread(target=app.run, kwargs={'port': 5555}, daemon=True)
t.start()
while True:
animation_class = get_new_input_class(beam_state.animation)
anim = animation_class(led)
anim.set_runner(None)
log.info('starting {} sequence'.format(anim.__class__.__name__))
try:
anim.run_all_frames()
except Interrupt:
pass
def _printError(error):
fatal = True
msg = "Unknown error occured."
if error == RETURN_CODES.ERROR_SIZE:
msg = "Data packet size incorrect."
fatal = False
elif error == RETURN_CODES.ERROR_UNSUPPORTED:
msg = "Unsupported configuration attempted."
elif error == RETURN_CODES.ERROR_PIXEL_COUNT:
msg = "Too many pixels specified for device."
elif error == RETURN_CODES.ERROR_BAD_CMD:
msg = "Unsupported protocol command. Check your device version."
if not fatal:
log.info("%s: %s", error, msg)
return
log.error("%s: %s", error, msg)
raise BiblioSerialError(msg)
def change_beam_state():
request_dict = flask.request.get_json()
input_delay = request_dict.get('delay')
if input_delay is not None and 0.0001 <= input_delay <= 100:
beam_state.delay = input_delay
input_brightness = request_dict.get('brightness')
if input_brightness is not None and 0 <= input_brightness <= 255:
beam_state.brightness = math.floor(input_brightness *
(config.max_brightness / 255.))
input_animation = request_dict.get('animation')
if input_animation in animation_dict.keys():
beam_state.animation = input_animation
log.info('setting beam_state.animation to {}'.format(input_animation))
else:
log.info('unknown animation: {}'.format(input_animation))
input_colors = request_dict.get('colors', [])
if input_colors:
try:
input_colors = list(map(color_util.hex2rgb, input_colors))
beam_state.colors = input_colors
except KeyError:
log.info('invalid color passed')
if flask.request.data:
response_dict = _get_state()
return flask.Response(json.dumps(response_dict), 200)
else:
return flask.redirect('/')
def __init__(self,
type,
num,
dev="",
c_order=ChannelOrder.RGB,
SPISpeed=2,
gamma=None,
restart_timeout=3,
deviceID=None,
hardwareID="1D50:60AB",
baud_rate=1000000):
super(DriverSerial, self).__init__(num, c_order=c_order, gamma=gamma)
if SPISpeed < 1 or SPISpeed > 24 or not (type in SPIChipsets):
SPISpeed = 1
self.set_baud_rate(baud_rate)
self._hardwareID = hardwareID
self._SPISpeed = SPISpeed
self._com = None
self._type = type
self._bufPad = 0
self.dev = dev
self.devVer = 0
self.deviceID = deviceID
if self.deviceID is not None and (self.deviceID < 0
or self.deviceID > 255):
raise ValueError("deviceID must be between 0 and 255")
resp = self._connect()
if resp == RETURN_CODES.REBOOT: # reboot needed
log.info(
"Reconfigure and reboot needed, waiting for controller to restart..."
)
self._com.close()
time.sleep(restart_timeout)
resp = self._connect()
if resp != RETURN_CODES.SUCCESS:
DriverSerial._printError(resp)
else:
log.info("Reconfigure success!")
elif resp != RETURN_CODES.SUCCESS:
DriverSerial._printError(resp)
if type in SPIChipsets:
log.info("Using SPI Speed: %sMHz", self._SPISpeed)
parser.add_argument('--delay', '-d', type=float)
parser.add_argument('--brightness', '-b', type=int)
args = parser.parse_args()
if args.animation:
beam_state.animation = args.animation
if args.brightness:
beam_state.brightness = math.floor(args.brightness *
(config.max_brightness / 255.))
if args.delay:
beam_state.delay = args.delay
num_pixels = config.pixels_per_strip * config.num_strips
if config.driver == 'sim':
# simulator on osx
log.info('using sim driver')
driver = SimPixel.SimPixel(num=num_pixels)
else:
# hardware on pi
c_order = getattr(ChannelOrder, config.channel_order)
log.info(
'using neopixel driver with channel order: {}'.format(c_order))
driver = Serial(num=num_pixels,
ledtype=LEDTYPE.WS2811,
c_order=c_order)
led = Matrix(
driver,
width=config.pixels_per_strip,
height=config.num_strips,
brightness=beam_state.brightness,
def nt_grab(bbox=None):
if bbox is None:
img = getScreenAsImage()
else:
img = getRectAsImage(bbox)
return img
grab = nt_grab
except:
pass
if grab is None:
try:
from mss.linux import MSS as mss
from PIL import Image
log.info('Using mss module')
sct = mss()
monitor = sct.enum_display_monitors()[0]
def mss_grab(bbox):
sct.get_pixels(monitor)
img = Image.frombytes('RGB', (sct.width, sct.height),
sct.image).crop(bbox)
return img
grab = mss_grab
except:
try:
from pil import ImageGrab
log.info("Using PIL ImageGrab module")
def test_serial(self):
# Code taken from
# https://gist.github.com/adammhaile/1b43fdde6ae6cbbd35560c68a9b90beb
from bibliopixel import Strip
from bibliopixel.drivers.channel_order import ChannelOrder
from bibliopixel.drivers.serial import Serial, LEDTYPE
from bibliopixel.drivers.serial.devices import Devices
from bibliopixel.animation import StripChannelTest
import bibliopixel.log as log
import time
log.setLogLevel(log.DEBUG)
devs = Devices(hardware_id="1D50:60AB", baudrate=921600)
log.info("Serial devices:")
dev_list = devs.find_serial_devices()
log.info(dev_list)
first_dev = dev_list[list(dev_list.keys())[0]][0]
log.info('Default device:')
log.info(devs.get_device())
log.info('Device ID for: ' + first_dev)
old_id = devs.get_device_id(first_dev)
log.info(old_id)
log.info('Setting device ID to 42')
devs.set_device_id(first_dev, 42, baudrate=921600)
log.info('New Device ID for: ' + first_dev)
log.info(devs.get_device_id(first_dev))
log.info('Restoring device ID to ' + str(old_id))
devs.set_device_id(first_dev, old_id, baudrate=921600)
log.info('Device version for: ' + first_dev)
log.info(devs._get_device_version(first_dev))
driver = Serial(LEDTYPE.APA102,
600,
SPISpeed=4,
c_order=ChannelOrder.RGB)
layout = Strip(driver)
for b in range(7, 256, 8):
log.info('Set brightness ' + str(b))
layout.set_brightness(b)
time.sleep(0.25)
log.info('Run StripChannelTest')
anim = StripChannelTest(layout)
anim.run(amt=1, max_steps=8)
layout.all_off()
layout.update()
print("Test Complete!")
def _connect(self):
try:
if self.dev == "" or self.dev is None:
DriverSerial.findSerialDevices(self._hardwareID)
if self.deviceID is not None:
if self.deviceID in DriverSerial.deviceIDS:
self.dev = DriverSerial.deviceIDS[self.deviceID]
self.devVer = 0
try:
i = DriverSerial.foundDevices.index(self.dev)
self.devVer = DriverSerial.deviceVers[i]
except:
pass
log.info(
"Using COM Port: %s, Device ID: %s, Device Ver: %s",
self.dev, self.deviceID, self.devVer)
if self.dev == "" or self.dev is None:
error = "Unable to find device with ID: {}".format(
self.deviceID)
log.error(error)
raise ValueError(error)
elif len(DriverSerial.foundDevices) > 0:
self.dev = DriverSerial.foundDevices[0]
self.devVer = 0
try:
i = DriverSerial.foundDevices.index(self.dev)
self.devVer = DriverSerial.deviceVers[i]
except:
pass
devID = -1
for id in DriverSerial.deviceIDS:
if DriverSerial.deviceIDS[id] == self.dev:
devID = id
log.info(
"Using COM Port: %s, Device ID: %s, Device Ver: %s",
self.dev, devID, self.devVer)
try:
self._com = serial.Serial(self.dev,
baudrate=DriverSerial.baud_rate,
timeout=5)
except serial.SerialException as e:
ports = DriverSerial.findSerialDevices(self._hardwareID)
error = "Invalid port specified. No COM ports available."
if len(ports) > 0:
error = "Invalid port specified. Try using one of: \n" + \
"\n".join(ports)
log.info(error)
raise BiblioSerialError(error)
packet = DriverSerial._generateHeader(CMDTYPE.SETUP_DATA, 4)
packet.append(self._type) # set strip type
byteCount = self.bufByteCount
if self._type in BufferChipsets:
if self._type == LEDTYPE.APA102 and self.devVer >= 2:
pass
else:
self._bufPad = BufferChipsets[self._type](self.numLEDs) * 3
byteCount += self._bufPad
packet.append(byteCount & 0xFF) # set 1st byte of byteCount
packet.append(byteCount >> 8) # set 2nd byte of byteCount
packet.append(self._SPISpeed)
self._com.write(packet)
resp = self._com.read(1)
if len(resp) == 0:
# Hack I had to add for my Arduinos to correct IOError
# self._com.write(packet)
# resp = self._com.read(1)
# if len(resp) == 0:
DriverSerial._comError()
return ord(resp)
except serial.SerialException as e:
error = "Unable to connect to the device. Please check that it is connected and the correct port is selected."
log.error(traceback.format_exc())
log.error(error)
raise e
def __exit__(self, type, value, traceback):
if self._com is not None:
log.info("Closing connection to: %s", self.dev)
self._com.close()
def test_serial(self):
# Code taken from
# https://gist.github.com/adammhaile/1b43fdde6ae6cbbd35560c68a9b90beb
from bibliopixel import Strip
from bibliopixel.drivers.channel_order import ChannelOrder
from bibliopixel.drivers.serial import Serial, LEDTYPE
from bibliopixel.drivers.serial.devices import Devices
from bibliopixel.animation import StripChannelTest
import bibliopixel.log as log
import time
log.setLogLevel(log.DEBUG)
devs = Devices(hardware_id="1D50:60AB", baudrate=921600)
log.info("Serial devices:")
dev_list = devs.find_serial_devices()
log.info(dev_list)
first_dev = dev_list[list(dev_list.keys())[0]][0]
log.info('Default device:')
log.info(devs.get_device())
log.info('Device ID for: ' + first_dev)
old_id = devs.get_device_id(first_dev)
log.info(old_id)
log.info('Setting device ID to 42')
devs.set_device_id(first_dev, 42, baudrate=921600)
log.info('New Device ID for: ' + first_dev)
log.info(devs.get_device_id(first_dev))
log.info('Restoring device ID to ' + str(old_id))
devs.set_device_id(first_dev, old_id, baudrate=921600)
log.info('Device version for: ' + first_dev)
log.info(devs._get_device_version(first_dev))
driver = Serial(
LEDTYPE.APA102, 600, SPISpeed=4, c_order=ChannelOrder.RGB)
layout = Strip(driver)
for b in range(7, 256, 8):
log.info('Set brightness ' + str(b))
layout.set_brightness(b)
time.sleep(0.25)
log.info('Run StripChannelTest')
anim = StripChannelTest(layout)
anim.run(amt=1, max_steps=8)
layout.all_off()
layout.update()
print("Test Complete!")
def stop(self):
self._stop_event.set()
log.info("Stopping Receiver...")
self.thread_cleanup()
def start(self):
self._t = threading.Thread(target=self._recv_thread_obj)
self._t.setDaemon(True) # don't hang on exit
self._t.start()
log.info("Receiver Listening on %s", self.address)
