def __init__(self, ip='127.0.0.1:7890', debug=False):
threading.Thread.__init__(self)
self.fc = opc.Client(ip)
self.debug = debug
self.state = 0
self.direction = True
self.position = 0
self.initialized = False
self.timetillon = datetime.now().time()
self.timetilloff = datetime.now().time()
self.specialdays = {}
self.is_special_day = False
self.special_day_colors = None
self.last_initialized_date = datetime.min.date()
self.initspecialdays()
self.check_special_day()
self.offsets = [randint(0, 1023) for x in range(150)]
self.halloween_states = [0] * GRG_LEN
#One-off events
self.manual_show_test = False
self.g_open = False
self.g_close = False
self.w = Weather()
self.w.daemon = True
self.w.start()
if self.fc.can_connect():
print('Connected to Fadecandy')
else:
print('WARNING: could not connect to fadecandy')
def start(self):
logger.info("Starting Tryptofan...")
self.opc_client = opc.Client('localhost:7890')
apps = [
(r'/ws', handlers.ControllerHandler, {
'tryptofan': self
}),
(r'/(.*)', handlers.IndexStaticFileHandler, {
'path': settings.WEBROOT
}),
]
application = Application(apps)
self.http_server = HTTPServer(application)
self.updater = PeriodicCallback(self.update, 1000 / settings.FRAMERATE)
for i in range(settings.BLADES):
blade = Blade(self.pixels, i * settings.BLADE_PIXELS,
self.state[i][0], self.state[i][1], self.state[i][2])
self.blades.append(blade)
self.http_server.listen(settings.HTTP_PORT)
self.updater.start()
IOLoop.instance().start()
def __init__(self, input_recorder=None, fullShell=False, framerate=15, path='../'):
#set path
self.path = path
#open fadecandy client connection
self.client = opc.Client('localhost:7890')
#load default video files
self.framerate = framerate
self.reactframerate = 1000
self.show = 'Hearts'
self.switch = 0
self.loadVideoFile(shell=True, back=True, snout=True)
self.video = True
self.z = 0
self.totmax = 0
#load audio recorder
self.input_recorder = input_recorder
#load strip lens
self.stripLens = np.loadtxt(self.path+"LoveBug/StripLens.csv",delimiter=',').astype(int)
#load 2d point mapping
self.shellPoints2d = np.loadtxt(self.path+"LoveBug/LED2DPoints.csv",delimiter=',').astype(int)
self.shellPoints2d2 = np.loadtxt(self.path+"LoveBug/LED2DPoints2.csv",delimiter=',').astype(int)
self.backflap2d = np.loadtxt(self.path+"LoveBug/BackFlap2D.csv",delimiter=',').astype(int)
self.snout2d = np.loadtxt(self.path+"LoveBug/Snout2D.csv",delimiter=',').astype(int)
self.fullShell = fullShell
def fc_connect(self):
"""Attempt to connect to our fadecandy server"""
self.fc_conn = opc.Client(self.fc_host)
if (not self.fc_conn.can_connect()):
print "Could not connect to server:", self.fc_host
return self.fc_conn
def __init__(self, parent, initial_display):
QtCore.QThread.__init__(self, parent)
self.__exiting = False
self.__display = initial_display
self.__opc_client = opc.Client(self.OPC_ADDRESS)
self.__lepton_frame = None
self.__movement = None
self.__color_adjustment_enabled = False
def createAndPlayStrip(frames):
client = opc.Client('localhost:7890')
strip = []
createStrip(strip)
#strip[3*60+0] = (255,255,255) i = 60r + l
client.put_pixels(strip, channel=255)
run(strip, frames)
return strip
def run(strip, j):
client = opc.Client('localhost:7890')
i = 0
while i < j:
#client.put_pixels(strip,channel=255)
moveStrip(strip)
client.put_pixels(strip, channel=255)
time.sleep(0.025)
i += 1
def get_led_controller():
global led_controller
if led_controller is None:
world = LEDWorldBuilder().add_octa_circle().build()
client = opc.Client(FC_SERVER)
led_controller = LEDController(world, client)
led_controller.start()
led_controller.off()
return led_controller
def start_opc(server):
client = opc.Client(server)
if client.can_connect():
print ' connected to %s' % server
else:
# can't connect, but keep running in case the server appears later
print ' WARNING: could not connect to %s' % server
print
return client
def __init__(self):
self.numLEDs = 512
self.columns = 16
self.rows = 16
self.client = opc.Client('192.168.17.64:7890')
self.start_col = -1
self.start_row = -1
self.end_col = -1
self.end_row = -1
self.clearMaze()
def __init__(self):
""" Connect to Fadecandy server, then turn off all cup lights and set cups "hit" status to False """
self.address = config['defaults']['fadecandy_address']
self.cup_light = [colors.Black] * 10 # blackout all cup LEDs
self.cup_hit = [False] * 10 # reset all cups "hit" status to False
self.balls_thrown = 0
self.key_name = '' # clear hit-switch variable
self.fadecandy = opc.Client(
self.address, verbose=config['defaults'].getboolean('verbose'))
self._initialize()
def __init__(self, eventQueue, opcIP_PORT='127.0.0.1:7890'):
self.eventQueue = eventQueue
self.IP_PORT = opcIP_PORT
self.client = opc.Client(self.IP_PORT)
if self.client.can_connect():
print ' connected to %s' % self.IP_PORT
else:
# can't connect, but keep running in case the server appears later
print ' WARNING: could not connect to ' + self.IP_PORT
def __init__(self):
self.fc = opc.Client('localhost:7890')
self.nfaces = 19
self.ins = ''
# lookup list of face names by index
self.facemap = [chr(i + ord('a')) for i in range(self.nfaces)]
#print str(self.facemap)
self.numLEDs = 80
# array of pixels
self.px = [[0, 0, 0]] * self.numLEDs
def __init__(self, server_addr='localhost:7890', mock=False):
self.mock = mock
if mock:
pygame.init()
self.screen = pygame.display.set_mode((self.width * self.size,
self.height * self.size))
else:
self.client = opc.Client(server_addr)
self.leds = [(0, 0, 0)] * self.num_leds
self.led_map = self.map
def _connect(address):
client = opc.Client(address)
if client.can_connect():
print(' connected to %s' % address)
else:
# can't connect, but keep running in case the server appears later
print(' WARNING: could not connect to %s' % address)
print('')
return client
def __init__(self, use_websockets=False):
"""
Setup the GUI, setup the Websockets Connection,
provide timer and button callback updates, and display info
"""
super(Hub, self).__init__()
self.use_websockets = use_websockets
# set access ctl
self.access = 0
self.window_state = None
self.logged_in_user = ""
self.start_armed = True
# set windows
self.lockscreen = None
self.ledscreen = None
self.statsscreen = None
self.hub_voice = None
# connection variables
self.first_time = True
self.red = 0
self.green = 0
self.blue = 0
# LED vars
self.num_pixels = 60
self.led_addr = 'localhost:7890'
self.led_client = opc.Client(self.led_addr)
self.fast_transition = True
# initalize the GUI
self.initUI()
self.rootCAPath = "/home/pi/Desktop/root-CA.crt"
self.privateKeyPath = "/home/pi/Desktop/Access01.private.key"
self.certificatePath = "/home/pi/Desktop/Access01.cert.pem"
self.host = "a1qhmcyp5eh8yq.iot.us-west-2.amazonaws.com"
self.setupAWS()
self.WORK_PERIOD = 2000
self.myTimer = QTimer()
self.myTimer.timeout.connect(self.processSQS)
self.myTimer.start(self.WORK_PERIOD)
if self.led_client.can_connect():
print('Connected to: ' + self.led_addr)
else:
print('NOT Connected to: ' + self.led_addr)
self.window_state = WindowState.LOCK_WINDOW
self.set_window_to_state()
def main():
"""
Find out which pattern they want to run and go with it..
"""
client = opc.Client(ADDRESS)
if client.can_connect():
print('connected to %s' % ADDRESS)
else:
print('WARNING: could not connect to %s' % ADDRESS)
return
return
def main():
#mixer.init()
#mixer.music.load('/home/maayand/Downloads/Wonderland_background.mp3')
#mixer.music.play(-1)
ADDRESS = 'localhost:7890'
# Create a client object
client = opc.Client(ADDRESS)
# Test if it can connect
if client.can_connect():
print
'connected to %s' % ADDRESS
else:
# We could exit here, but instead let's just print a warning
# and then keep trying to send pixels in case the server
# appears later
print
'WARNING: could not connect to %s' % ADDRESS
i=255
# Send pixels forever
print(' sending pixels forever (control-c to exit)...')
print('')
while True:
in_pixel = input("Enter pixel number?")
my_pixels = [(i, i, i), (i, i, i), (i, i, i), (i, i, i), (i, i, i),
(i, i, i), (i, i, i), (i, i, i), (i, i, i), (i, i, i),
(i, i, i), (i, i, i), (i, i, i), (i, i, i), (i, i, i),
(i, i, i), (i, i, i), (i, i, i), (i, i, i), (i, i, i),
(i, i, i), (i, i, i), (i, i, i), (i, i, i), (i, i, i)]
#i=i+1
#if i>=255:
# i=0
for x in range(num_nodes):
all_nodes.setNodeColor(x, i, i, i)
my_pixels[x] = (i, i, i)
my_pixels[int(in_pixel)] = (255, 0, 0)
all_nodes.setNodeColor(int(in_pixel), 255, 0, 0)
# random.shuffle(my_pixels)
if client.put_pixels(my_pixels, channel=0):
print
'sent'
else:
print
'not connected'
time.sleep(0.01)
def __init__(self, bot, address):
self.bot = bot
self.opcClient = opc.Client(address)
if self.opcClient.can_connect():
print('connected to %s' % address)
else:
# We could exit here, but instead let's just print a warning
# and then keep trying to send pixels in case the server
# appears later
print('WARNING: could not connect to %s' % address)
def strobe():
""" strobe effect """
num_leds = 512
client = opc.Client("localhost:7890")
black = [(0, 0, 0)] * num_leds
white = [(255, 255, 255)] * num_leds
while True:
client.put_pixels(white)
client.put_pixels(black)
time.sleep(0.05)
def __init__(self):
Thread.__init__(self)
seed()
self._end = False
self.state = False
self.brightness = 128
self.effect_list = []
self.current_effect = None
self.client = opc.Client('localhost:7890')
self.pixels = [(0, 0, 0)
] * self.NUM_STRIPS_FC * self.NUM_LED_PER_STRIP_FC
def fade():
""" fade effect """
client = opc.Client("localhost:7890")
black = [(0, 0, 0)] * config.NUM_LEDS
white = [(255, 255, 255)] * config.NUM_LEDS
while True:
client.put_pixels(white)
time.sleep(0.05)
client.put_pixels(black)
time.sleep(0.05)
def __init__(self):
self.client = opc.Client('localhost:7890')
self.topw = [(0, 0, 0)]*3
self.topb = [(0, 0, 0)]*4
self.middlew = [(0, 0, 0)] *4
self.middleb = [(0, 0, 0)]*4
self.bottomw = [(0, 0, 0)]*4
self.bottomb = [(0, 0, 0)] *3
self.outv = self.topw + self.topb + self.middlew + self.middleb + self.bottomw + self.bottomb
def __init__(self,
server_ip_port="localhost:7890",
debug=False,
max_pixels=512):
print "Connecting to OPC server %s, max_pixels=%d" % (server_ip_port,
max_pixels)
self.opc = opc.Client(server_ip_port, True)
# Load a pixel mapping from "panel name" format to channel & ix
with open("data/opc_mapping.json") as f:
self.panel_map = json.load(f)
self.pixels = [(0, 0, 0)] * max_pixels
def __init__(self):
self.client = opc.Client('localhost:7890')
#make an intensity array for the whole fadecandy addressable pixels.
self.intensity = [(0,0,0)] * 512
#inital ppower level is 100 (out of 255)
self.power = 100
self.outerLEDs=outerLEDs
self.innerLEDs=innerLEDs
self.totalLEDs=(outerLEDs+innerLEDs)
self.ringStart=ringStart
self.cabinetStart=cabinetStart
self.cabinetLEDs=cabinetLEDs
self.progress=0
self.savedProgress=(0,0,0)
def handle(self, *args, **options):
self.tree = opc.Client('%s:%d' %
(settings.TREE_HOST, settings.TREE_PORT))
x = 0
while True:
drawings = self.get_drawings()
if drawings:
self.draw(drawings)
else:
x += 1
self.update_sequence()
self.spiral(x, 255, 255, 255)
time.sleep(0.05)
def tpm2():
global frames
pixel_data = None
port = 0xFFE2
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('127.0.0.1', port))
client = opc.Client('localhost:7890')
if client.can_connect():
print 'connected'
else:
print 'cant connect'
my = 30
mx = 12
max = mx * my
last = 0
data_size = 3 * 4 * 30
while True:
data, addr = sock.recvfrom(2000)
head, t, size, pn, seq = struct.unpack(">BBHBB", data[0:6])
# print hex(head),hex(t),size,pn,seq
if last + 1 != pn:
continue
last = pn
if pn == 1:
pixel_data = data[6:6 + data_size]
else:
pixel_data = pixel_data + data[6:6 + data_size]
if pn < seq:
continue
last = 0
pixels = [[
ord(pixel_data[i * 3]),
ord(pixel_data[i * 3 + 1]),
ord(pixel_data[i * 3 + 2])
] for i in range(max)]
if record:
frames.append(pixel_data)
if client.put_pixels(pixels, channel=0):
pass
else:
print 'not connected'
def __init__(self):
self.pixels = np.zeros((512, 3), dtype='float32')
self.diff = np.zeros((512, 3), dtype='float32')
self.endVals = np.zeros((512, 3), dtype='float32')
self.remaining = np.zeros((512), dtype='uint32')
self.clockerActive = threading.Event()
self.commands = queue.Queue(maxsize=100)
self.frameRate = 15
self.FCclient = opc.Client('localhost:7890')
self.arbitration = [False, '127.0.0.1']
bootMsg = 'Server booted at ' + str(datetime.datetime.now()) + '\n'
self.logError(bootMsg)
def init_fcclient(self, ADDRESS_1='localhost:7890', ADDRESS_2=''):
# Create a client object
self.client = opc.Client(ADDRESS_1)
# Test if it can connect
if self.client.can_connect():
print('connected to %s') % ADDRESS_1
else:
# We could exit here, but instead let's just print a warning
# and then keep trying to send pixels in case the server
# appears later
print('''WARNING: could not connect to %s... Is fcserver
running?\nClient will retry connection each time a pixel update is
sent' % ADDRESS_1''')
self.clients = [self.client]
def __init__(self, settings):
self.settings = settings
self.server = opc.Client('localhost:7890')
json_data = open('./opc/playfield.json')
self.led_map = json.load(json_data)
self.number_of_leds = len(self.led_map)
self.center_x = int(self.settings['Screen']['X'] / 2)
self.center_y = int(self.settings['Screen']['Y'] / 2)
self.multiplier = self.settings['Screen']['Y'] / 5.5
self.circle_diameter = int(self.settings['Screen']['Y'] / 60)
self.circle_outline_width = int(self.circle_diameter / 2)
