Jukebox/jukebox-software
10
0
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases 2 Wiki Activity

Convert led code to class based for multithreading

Browse Source
This commit is contained in:
Cole Deck 2024-03-23 15:33:51 -05:00
parent 9b1b92e21d
commit 069d2175d9
2 changed files with 603 additions and 611 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

576
led_control.py
View File

@ -14,24 +14,32 @@ import cv2
import numpy as np import numpy as np
from uptime import uptime from uptime import uptime
sender = None
debug = True
config = None
leds = None
leds_size = None
leds_normalized = None
controllers = None
data = None
exactdata = None
rings = None
ringstatus = None
mode = "Startup"
firstrun = True
changecount = 0
animation_time = 0
start = uptime()
def ping(host):
class LEDSystem():
sender = None
debug = True
config = None
leds = None
leds_size = None
leds_normalized = None
controllers = None
data = None
exactdata = None
rings = None
ringstatus = None
mode = "Startup"
firstrun = True
changecount = 0
animation_time = 0
start = uptime()
def __init__(self):
self.start = uptime()
#self.init()
#return self
def ping(self, host):
#Returns True if host (str) responds to a ping request. #Returns True if host (str) responds to a ping request.
# Option for the number of packets as a function of # Option for the number of packets as a function of
@ -49,32 +57,23 @@ def ping(host):
return subprocess.call(command, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) == 0 return subprocess.call(command, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) == 0
def map(): def map(self):
global config
global leds
global leds_size
global leds_normalized
global controllers
global rings
global ringstatus
global animation_time
with open('config.yml', 'r') as fileread: with open('config.yml', 'r') as fileread:
#global config #global config
config = yaml.safe_load(fileread) self.config = yaml.safe_load(fileread)
animation_time = config["animation_time"] self.animation_time = self.config["animation_time"]
leds = list() self.leds = list()
leds_size = list() self.leds_size = list()
controllers = list() self.controllers = list()
rings = list(range(len(config["position_map"]))) self.rings = list(range(len(self.config["position_map"])))
ringstatus = list(range(len(config["position_map"]))) self.ringstatus = list(range(len(self.config["position_map"])))
#print(rings) #print(rings)
#fprint(config["led"]["map"]) #fprint(config["led"]["map"])
generate_map = False generate_map = False
map = list() map = list()
for shape in config["led"]["map"]: for shape in self.config["led"]["map"]:
if shape["type"] == "circle": if shape["type"] == "circle":
if generate_map: if generate_map:
@ -84,22 +83,22 @@ def map():
angle = 0 angle = 0
radius = shape["diameter"] / 2 radius = shape["diameter"] / 2
lednum = shape["start"] lednum = shape["start"]
for item in config['position_map']: for item in self.config['position_map']:
# Check if the current item's position matches the target position # Check if the current item's position matches the target position
#print(item['pos'],(shape["pos"][1],shape["pos"][0])) #print(item['pos'],(shape["pos"][1],shape["pos"][0]))
if tuple(item['pos']) == (shape["pos"][1],shape["pos"][0]): if tuple(item['pos']) == (shape["pos"][1],shape["pos"][0]):
rings[item["index"]] = (shape["pos"][1],shape["pos"][0],lednum,lednum+shape["size"]) # rings[index] = x, y, startpos, endpos self.rings[item["index"]] = (shape["pos"][1],shape["pos"][0],lednum,lednum+shape["size"]) # rings[index] = x, y, startpos, endpos
ringstatus[item["index"]] = [None, None] self.ringstatus[item["index"]] = [None, None]
break break
if len(leds) < lednum + shape["size"]: if len(self.leds) < lednum + shape["size"]:
for x in range(lednum + shape["size"] - len(leds)): for x in range(lednum + shape["size"] - len(self.leds)):
leds.append(None) self.leds.append(None)
leds_size.append(None) self.leds_size.append(None)
while angle < 359.999: while angle < 359.999:
tmpangle = angle + shape["angle"] tmpangle = angle + shape["angle"]
x = math.cos(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][1] # flip by 90 degress when we changed layout x = math.cos(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][1] # flip by 90 degress when we changed layout
y = math.sin(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][0] y = math.sin(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][0]
leds[lednum] = (x,y) self.leds[lednum] = (x,y)
lednum = lednum + 1 lednum = lednum + 1
angle = angle + anglediv angle = angle + anglediv
@ -112,13 +111,13 @@ def map():
xmov = math.cos(angle * (math.pi / 180.0)) * distdiv xmov = math.cos(angle * (math.pi / 180.0)) * distdiv
ymov = math.sin(angle * (math.pi / 180.0)) * distdiv ymov = math.sin(angle * (math.pi / 180.0)) * distdiv
pos = shape["pos"] pos = shape["pos"]
if len(leds) < lednum + shape["size"]: if len(self.leds) < lednum + shape["size"]:
for x in range(lednum + shape["size"] - len(leds)): for x in range(lednum + shape["size"] - len(self.leds)):
leds.append(None) self.leds.append(None)
leds_size.append(None) self.leds_size.append(None)
while dist < length: while dist < length:
leds[lednum] = (pos[0], pos[1]) self.leds[lednum] = (pos[0], pos[1])
pos[0] += xmov pos[0] += xmov
pos[1] += ymov pos[1] += ymov
dist += distdiv dist += distdiv
@ -140,276 +139,262 @@ def map():
yaml_str = yaml.dump(data, default_flow_style=False) yaml_str = yaml.dump(data, default_flow_style=False)
print(yaml_str) print(yaml_str)
print(rings) print(self.rings)
flag = 0 flag = 0
for x in leds: for x in self.leds:
if x is None: if x is None:
flag = flag + 1 flag = flag + 1
if flag > 0: if flag > 0:
fprint("Warning: Imperfect LED map ordering. Hiding undefined lights.") fprint("Warning: Imperfect LED map ordering. Hiding undefined lights.")
for x in range(len(leds)): for x in range(len(self.leds)):
if leds[x] is None: if self.leds[x] is None:
leds[x] = (0, 0) self.leds[x] = (0, 0)
#leds = tmpleds.reverse() #leds = tmpleds.reverse()
#fprint(leds) #fprint(leds)
# controller mapping # controller mapping
for ctrl in config["led"]["controllers"]: for ctrl in self.config["led"]["controllers"]:
if len(controllers) < ctrl["universe"]+1: if len(self.controllers) < ctrl["universe"]+1:
for x in range(ctrl["universe"]+1 - len(controllers)): for x in range(ctrl["universe"]+1 - len(self.controllers)):
controllers.append(None) self.controllers.append(None)
controllers[ctrl["universe"]] = (ctrl["ledstart"],ctrl["ledend"]+1,ctrl["ip"]) self.controllers[ctrl["universe"]] = (ctrl["ledstart"],ctrl["ledend"]+1,ctrl["ip"])
for x in range(ctrl["ledstart"],ctrl["ledend"]+1): for x in range(ctrl["ledstart"],ctrl["ledend"]+1):
leds_size[x] = len(ctrl["mode"]) self.leds_size[x] = len(ctrl["mode"])
#fprint(controllers) #fprint(controllers)
if(debug): if(self.debug):
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
plt.axis('equal') plt.axis('equal')
for ctrl in controllers: for ctrl in self.controllers:
plt.scatter(*zip(*leds[ctrl[0]:ctrl[1]]), s=2) plt.scatter(*zip(*self.leds[ctrl[0]:ctrl[1]]), s=2)
#plt.scatter(*zip(*leds), s=3) #plt.scatter(*zip(*leds), s=3)
plt.savefig("map.png", dpi=600, bbox_inches="tight") plt.savefig("map.png", dpi=600, bbox_inches="tight")
leds_adj = [(x-min([led[0] for led in leds]), # push to zero start leds_adj = [(x-min([led[0] for led in self.leds]), # push to zero start
y-min([led[1] for led in leds]) ) y-min([led[1] for led in self.leds]) )
for x, y in leds] for x, y in self.leds]
leds_normalized = [(x / max([led[0] for led in leds_adj]), self.leds_normalized = [(x / max([led[0] for led in leds_adj]),
y / max([led[1] for led in leds_adj])) y / max([led[1] for led in leds_adj]))
for x, y in leds_adj] for x, y in leds_adj]
#return leds, controllers #return leds, controllers
def init(): def init(self):
map() self.map()
global sender self.sender = sacn.sACNsender(fps=self.config["led"]["fps"], universeDiscovery=False)
global config self.sender.start() # start the sending thread
global leds """for x in range(len(self.controllers)):
global leds_size print("Waiting for the controller at", self.controllers[x][2], "to be online...", end="")
global controllers
global data
global exactdata
sender = sacn.sACNsender(fps=config["led"]["fps"], universeDiscovery=False)
sender.start() # start the sending thread
"""for x in range(len(controllers)):
print("Waiting for the controller at", controllers[x][2], "to be online...", end="")
count = 0 count = 0
while not ping(controllers[x][2]): while not ping(self.controllers[x][2]):
count = count + 1 count = count + 1
if count >= config["led"]["timeout"]: if count >= self.config["led"]["timeout"]:
fprint(" ERROR: controller still offline after " + str(count) + " seconds, continuing...") fprint(" ERROR: controller still offline after " + str(count) + " seconds, continuing...")
break break
if count < config["led"]["timeout"]: if count < self.config["led"]["timeout"]:
fprint(" done")""" fprint(" done")"""
for x in range(len(controllers)): for x in range(len(self.controllers)):
print("Activating controller", x, "at", controllers[x][2], "with", controllers[x][1]-controllers[x][0], "LEDs.") print("Activating controller", x, "at", self.controllers[x][2], "with", self.controllers[x][1]-self.controllers[x][0], "LEDs.")
sender.activate_output(x+1) # start sending out data self.sender.activate_output(x+1) # start sending out data
sender[x+1].destination = controllers[x][2] self.sender[x+1].destination = self.controllers[x][2]
sender.manual_flush = True self.sender.manual_flush = True
# initialize global pixel data list # initialize global pixel data list
data = list() self.data = list()
exactdata = list() self.exactdata = list()
for x in range(len(leds)): for x in range(len(self.leds)):
if leds_size[x] == 3: if self.leds_size[x] == 3:
exactdata.append(None) self.exactdata.append(None)
data.append((20,20,127)) self.data.append((20,20,127))
elif leds_size[x] == 4: elif self.leds_size[x] == 4:
exactdata.append(None) self.exactdata.append(None)
data.append((50,50,255,0)) self.data.append((50,50,255,0))
else: else:
exactdata.append(None) self.exactdata.append(None)
data.append((0,0,0)) self.data.append((0,0,0))
sendall(data) self.sendall(self.data)
#time.sleep(50000) #time.sleep(50000)
fprint("Running start-up test sequence...") fprint("Running start-up test sequence...")
for y in range(1): for y in range(1):
for x in range(len(leds)): for x in range(len(self.leds)):
setpixel(0,60,144,x) self.setpixel(0,60,144,x)
sendall(data) self.sendall(self.data)
#time.sleep(2) #time.sleep(2)
alloffsmooth() self.alloffsmooth()
def sendall(datain): def sendall(self, datain):
# send all LED data to all controllers # send all LED data to all controllers
# data must have all LED data in it as [(R,G,B,)] tuples in an array, 1 tuple per pixel # data must have all LED data in it as [(R,G,B,)] tuples in an array, 1 tuple per pixel
global controllers self.sender.manual_flush = True
global sender for x in range(len(self.controllers)):
sender.manual_flush = True self.sender[x+1].dmx_data = list(sum(datain[self.controllers[x][0]:self.controllers[x][1]] , ())) # flatten the subsection of the data array
for x in range(len(controllers)):
sender[x+1].dmx_data = list(sum(datain[controllers[x][0]:controllers[x][1]] , ())) # flatten the subsection of the data array
sender.flush() self.sender.flush()
time.sleep(0.002) time.sleep(0.002)
#sender.flush() # 100% reliable with 2 flushes, often fails with 1 #sender.flush() # 100% reliable with 2 flushes, often fails with 1
#time.sleep(0.002) #time.sleep(0.002)
#sender.flush() #sender.flush()
def fastsendall(datain): def fastsendall(self, datain):
# send all LED data to all controllers # send all LED data to all controllers
# data must have all LED data in it as [(R,G,B,)] tuples in an array, 1 tuple per pixel # data must have all LED data in it as [(R,G,B,)] tuples in an array, 1 tuple per pixel
global controllers self.sender.manual_flush = False
global sender print(datain[self.controllers[0][0]:self.controllers[0][1]])
sender.manual_flush = False for x in range(len(self.controllers)):
print(datain[controllers[0][0]:controllers[0][1]]) self.sender[x+1].dmx_data = list(sum(datain[self.controllers[x][0]:self.controllers[x][1]] , ())) # flatten the subsection of the data array
for x in range(len(controllers)):
sender[x+1].dmx_data = list(sum(datain[controllers[x][0]:controllers[x][1]] , ())) # flatten the subsection of the data array
sender.flush() self.sender.flush()
def senduniverse(datain, lednum): def senduniverse(self, datain, lednum):
# send all LED data for 1 controller/universe # send all LED data for 1 controller/universe
# data must have all LED data in it as [(R,G,B,)] tuples in an array, 1 tuple per pixel # data must have all LED data in it as [(R,G,B,)] tuples in an array, 1 tuple per pixel
global controllers for x in range(len(self.controllers)):
global sender if lednum >= self.controllers[x][0] and lednum < self.controllers[x][1]:
for x in range(len(controllers)): self.sender[x+1].dmx_data = list(sum(datain[self.controllers[x][0]:self.controllers[x][1]] , ())) # flatten the subsection of the data array
if lednum >= controllers[x][0] and lednum < controllers[x][1]:
sender[x+1].dmx_data = list(sum(datain[controllers[x][0]:controllers[x][1]] , ())) # flatten the subsection of the data array
sender.flush() self.sender.flush()
time.sleep(0.004) time.sleep(0.004)
#sender.flush() # 100% reliable with 2 flushes, often fails with 1 #sender.flush() # 100% reliable with 2 flushes, often fails with 1
#time.sleep(0.002) #time.sleep(0.002)
#sender.flush() #sender.flush()
def alloff(): def alloff(self):
tmpdata = list() tmpdata = list()
for x in range(len(leds)): for x in range(len(self.leds)):
if leds_size[x] == 3: if self.leds_size[x] == 3:
tmpdata.append((0,0,0)) tmpdata.append((0,0,0))
elif leds_size[x] == 4: elif self.leds_size[x] == 4:
tmpdata.append((0,0,0,0)) tmpdata.append((0,0,0,0))
else: else:
tmpdata.append((0,0,0)) tmpdata.append((0,0,0))
sendall(tmpdata) self.sendall(tmpdata)
#sendall(tmpdata) #sendall(tmpdata)
#sendall(tmpdata) #definitely make sure it's off #sendall(tmpdata) #definitely make sure it's off
return self
def allon(): def allon(self):
global data self.sendall(self.data)
sendall(data) return self
def alloffsmooth(): def alloffsmooth(self):
tmpdata = data tmpdata = self.data
for x in range(256): for x in range(256):
for x in range(len(data)): for x in range(len(self.data)):
setpixel(tmpdata[x][0]-1,tmpdata[x][1]-1,tmpdata[x][2]-1, x) self.setpixel(tmpdata[x][0]-1,tmpdata[x][1]-1,tmpdata[x][2]-1, x)
sendall(tmpdata) self.sendall(tmpdata)
alloff() self.alloff()
return self
def setpixelnow(r, g, b, num): def setpixelnow(self, r, g, b, num):
# slight optimization: send only changed universe # slight optimization: send only changed universe
# unfortunately no way to manual flush data packets to only 1 controller with this sACN library # unfortunately no way to manual flush data packets to only 1 controller with this sACN library
global data self.setpixel(r,g,b,num)
setpixel(r,g,b,num) self.senduniverse(self.data, num)
senduniverse(data, num) return self
def setmode(stmode, r=0,g=0,b=0): def setmode(self, stmode, r=0,g=0,b=0):
global mode
global firstrun
if stmode is not None: if stmode is not None:
if mode != stmode: if self.mode != stmode:
firstrun = True self.firstrun = True
mode = stmode self.mode = stmode
return self
def setring(r,g,b,idx): def setring(self, r,g,b,idx):
ring = rings[idx] ring = self.rings[idx]
for pixel in range(ring[2],ring[3]): for pixel in range(ring[2],ring[3]):
setpixel(r,g,b,pixel) self.setpixel(r,g,b,pixel)
#global data #global data
#senduniverse(data, ring[2]) #senduniverse(data, ring[2])
return self
def runmodes(ring = -1, speed = 1): def runmodes(self, ring = -1, speed = 1):
global mode fprint("Mode: " + str(self.mode))
global firstrun if self.mode == "Startup":
global changecount
fprint("Mode: " + str(mode))
if mode == "Startup":
# loading animation. cable check # loading animation. cable check
if firstrun: if self.firstrun:
changecount = animation_time * 3 self.changecount = self.animation_time * 3
firstrun = False firstrun = False
for x in range(len(ringstatus)): for x in range(len(self.ringstatus)):
ringstatus[x] = [True, animation_time] self.ringstatus[x] = [True, self.animation_time]
if changecount > 0: if self.changecount > 0:
fprint(changecount) fprint(self.changecount)
changecount = fadeorder(0,len(leds), changecount, 0,50,100) self.changecount = self.fadeorder(0,len(self.leds), self.changecount, 0,50,100)
else: else:
setmode("Startup2") self.setmode("Startup2")
elif mode == "Startup2": elif self.mode == "Startup2":
if firstrun: if self.firstrun:
firstrun = False self.firstrun = False
else: else:
for x in range(len(ringstatus)): for x in range(len(self.ringstatus)):
if ringstatus[x][0]: if self.ringstatus[x][0]:
setring(0, 50, 100, x) self.setring(0, 50, 100, x)
else: else:
ringstatus[x][1] = fadeall(rings[x][2],rings[x][3], ringstatus[x][1], 100,0,0) # not ready self.ringstatus[x][1] = self.fadeall(self.rings[x][2],self.rings[x][3], self.ringstatus[x][1], 100,0,0) # not ready
elif mode == "StartupCheck": elif self.mode == "StartupCheck":
if firstrun: if self.firstrun:
firstrun = False self.firstrun = False
for x in range(len(ringstatus)): for x in range(len(self.ringstatus)):
ringstatus[x] = [False, animation_time] self.ringstatus[x] = [False, self.animation_time]
else: else:
for x in range(len(ringstatus)): for x in range(len(self.ringstatus)):
if ringstatus[x][0]: if self.ringstatus[x][0]:
ringstatus[x][1] = fadeall(rings[x][2],rings[x][3], ringstatus[x][1], 0,50,100) # ready self.ringstatus[x][1] = self.fadeall(self.rings[x][2],self.rings[x][3], self.ringstatus[x][1], 0,50,100) # ready
else: else:
setring(100, 0, 0, x) self.setring(100, 0, 0, x)
elif mode == "GrabA": elif self.mode == "GrabA":
if firstrun: if self.firstrun:
firstrun = False self.firstrun = False
changecount = animation_time # 100hz self.changecount = self.animation_time # 100hz
if changecount > 0: if self.changecount > 0:
changecount = fadeall(rings[ring][2],rings[ring][3], changecount, 100,0,0) self.changecount = self.fadeall(self.rings[ring][2],self.rings[ring][3], self.changecount, 100,0,0)
else: else:
setring(100,0,0,ring) self.setring(100,0,0,ring)
setmode("GrabB") self.setmode("GrabB")
elif mode == "GrabB": elif self.mode == "GrabB":
if firstrun: if self.firstrun:
firstrun = False self.firstrun = False
changecount = animation_time # 100hz self.changecount = self.animation_time # 100hz
if changecount > 0: if self.changecount > 0:
changecount = fadeorder(rings[ring][2],rings[ring][3], changecount, 0,100,0) self.changecount = self.fadeorder(self.rings[ring][2],self.rings[ring][3], self.changecount, 0,100,0)
else: else:
setring(0,100,0,ring) self.setring(0,100,0,ring)
setmode("idle") self.setmode("idle")
elif mode == "GrabC": elif self.mode == "GrabC":
if firstrun: if self.firstrun:
firstrun = False self.firstrun = False
changecount = animation_time # 100hz self.changecount = self.animation_time # 100hz
if changecount > 0: if self.changecount > 0:
changecount = fadeall(rings[ring][2],rings[ring][3], changecount, 0,50,100) self.changecount = self.fadeall(self.rings[ring][2],self.rings[ring][3], self.changecount, 0,50,100)
else: else:
setring(0,50,100,ring) self.setring(0,50,100,ring)
setmode("idle") self.setmode("idle")
elif mode == "idle": elif self.mode == "idle":
time.sleep(0) time.sleep(0)
sendall(data) self.sendall(self.data)
return self
def fadeall(idxa,idxb,sizerem,r,g,b): def fadeall(self, idxa,idxb,sizerem,r,g,b):
if sizerem < 1: if sizerem < 1:
return 0 return 0
global exactdata
sum = 0 sum = 0
for x in range(idxa,idxb): for x in range(idxa,idxb):
if exactdata[x] is None: if self.exactdata[x] is None:
exactdata[x] = data[x] self.exactdata[x] = self.data[x]
old = exactdata[x] old = self.exactdata[x]
dr = (r - old[0])/sizerem dr = (r - old[0])/sizerem
sum += abs(dr) sum += abs(dr)
dr += old[0] dr += old[0]
@ -419,27 +404,26 @@ def fadeall(idxa,idxb,sizerem,r,g,b):
db = (b - old[2])/sizerem db = (b - old[2])/sizerem
db += old[2] db += old[2]
sum += abs(db) sum += abs(db)
exactdata[x] = (dr, dg, db) self.exactdata[x] = (dr, dg, db)
#print(new) #print(new)
setpixel(dr, dg, db, x) self.setpixel(dr, dg, db, x)
if sizerem == 1: if sizerem == 1:
exactdata[x] = None self.exactdata[x] = None
if sum == 0 and sizerem > 2: if sum == 0 and sizerem > 2:
sizerem = 2 sizerem = 2
return sizerem - 1 return sizerem - 1
def fadeorder(idxa,idxb,sizerem,r,g,b): def fadeorder(self, idxa,idxb,sizerem,r,g,b):
if sizerem < 1: if sizerem < 1:
return 0 return 0
global exactdata
drs = 0 drs = 0
dgs = 0 dgs = 0
dbs = 0 dbs = 0
sum = 0 sum = 0
for x in range(idxa,idxb): for x in range(idxa,idxb):
if exactdata[x] is None: if self.exactdata[x] is None:
exactdata[x] = data[x] self.exactdata[x] = self.data[x]
old = exactdata[x] old = self.exactdata[x]
dr = (r - old[0]) dr = (r - old[0])
dg = (g - old[1]) dg = (g - old[1])
db = (b - old[2]) db = (b - old[2])
@ -453,7 +437,7 @@ def fadeorder(idxa,idxb,sizerem,r,g,b):
sum += abs(drs) + abs(dgs) + abs(dbs) sum += abs(drs) + abs(dgs) + abs(dbs)
print(drs,dgs,dbs) print(drs,dgs,dbs)
for x in range(idxa,idxb): for x in range(idxa,idxb):
old = exactdata[x] old = self.exactdata[x]
new = list(old) new = list(old)
if drs > 0: if drs > 0:
if old[0] + drs > r: if old[0] + drs > r:
@ -500,20 +484,18 @@ def fadeorder(idxa,idxb,sizerem,r,g,b):
dbs = 0 dbs = 0
if drs != 0 or dgs != 0 or dbs != 0: if drs != 0 or dgs != 0 or dbs != 0:
exactdata[x] = new self.exactdata[x] = new
setpixel(new[0],new[1],new[2],x) self.setpixel(new[0],new[1],new[2],x)
if sizerem == 1: if sizerem == 1:
exactdata[x] = None self.exactdata[x] = None
if sum == 0 and sizerem > 2: if sum == 0 and sizerem > 2:
sizerem = 2 sizerem = 2
return sizerem - 1 return sizerem - 1
def setpixel(r, g, b, num): def setpixel(self, r, g, b, num):
global data
global leds_size
# constrain values # constrain values
if r < 0: if r < 0:
r = 0 r = 0
@ -528,29 +510,28 @@ def setpixel(r, g, b, num):
elif b > 255: elif b > 255:
b = 255 b = 255
if leds_size[num] == 3: if self.leds_size[num] == 3:
data[num] = (int(r), int(g), int(b)) self.data[num] = (int(r), int(g), int(b))
elif leds_size[num] == 4: # cut out matching white and turn on white pixel instead elif self.leds_size[num] == 4: # cut out matching white and turn on white pixel instead
data[num] = (( int(r) - int(min(r,g,b)), int(g) - int(min(r,g,b)), int(b) - int(min(r,g,b)), int(min(r,g,b))) ) self.data[num] = (( int(r) - int(min(r,g,b)), int(g) - int(min(r,g,b)), int(b) - int(min(r,g,b)), int(min(r,g,b))) )
else: else:
data[num] = (int(r), int(g), int(b)) self.data[num] = (int(r), int(g), int(b))
return self
def close(self):
def close():
global sender
time.sleep(0.5) time.sleep(0.5)
sender.stop() self.sender.stop()
return self
def mapimage(image, fps=90): def mapimage(self, image, fps=90):
global start while uptime() - self.start < 1/fps:
while uptime() - start < 1/fps:
time.sleep(0.00001) time.sleep(0.00001)
fprint(1 / (uptime() - start)) fprint(1 / (uptime() - self.start))
start = uptime() self.start = uptime()
minsize = min(image.shape[0:2]) minsize = min(image.shape[0:2])
leds_normalized2 = [(x * minsize, leds_normalized2 = [(x * minsize,
y * minsize) y * minsize)
for x, y in leds_normalized] for x, y in self.leds_normalized]
cv2.imshow("video", image) cv2.imshow("video", image)
cv2.waitKey(1) cv2.waitKey(1)
@ -567,39 +548,39 @@ def mapimage(image, fps=90):
#avgx += x #avgx += x
#avgy += y #avgy += y
color = tuple(image[y, x]) color = tuple(image[y, x])
setpixel(color[2]/2,color[1]/2,color[0]/2,xx) # swap b & r self.setpixel(color[2]/2,color[1]/2,color[0]/2,xx) # swap b & r
#print(color) #print(color)
else: else:
#avgx += x #avgx += x
#avgy += y #avgy += y
setpixel(0,0,0,xx) self.setpixel(0,0,0,xx)
#avgx /= len(leds) #avgx /= len(leds)
#avgy /= len(leds) #avgy /= len(leds)
#print((avgx,avgy, max([led[0] for led in leds_adj]), max([led[1] for led in leds_adj]) , min(image.shape[0:2]) )) #print((avgx,avgy, max([led[0] for led in leds_adj]), max([led[1] for led in leds_adj]) , min(image.shape[0:2]) ))
global data self.fastsendall(self.data)
fastsendall(data) return self
def mainloop(stmode, ring = -1, fps = 100, preview = False): def mainloop(self, stmode, ring = -1, fps = 100, preview = False):
global start while uptime() - self.start < 1/fps:
while uptime() - start < 1/fps:
time.sleep(0.00001) time.sleep(0.00001)
fprint(1 / (uptime() - start)) fprint(1 / (uptime() - self.start))
start = uptime() self.start = uptime()
if mode is not None: if self.mode is not None:
setmode(stmode) self.setmode(stmode)
runmodes(ring) self.runmodes(ring)
if preview: if preview:
drawdata() self.drawdata()
return self
def drawdata(): def drawdata(self):
#tmp = list() #tmp = list()
#for x in len(leds): #for x in len(leds):
# led = leds[x] # led = leds[x]
# tmp.append((led[0], led[1], data[x])) # tmp.append((led[0], led[1], data[x]))
x = [led[0] for led in leds] x = [led[0] for led in self.leds]
y = [led[1] for led in leds] y = [led[1] for led in self.leds]
colors = data colors = self.data
colors_normalized = [(x[0]/255, x[1]/255, x[2]/255) for x in colors] colors_normalized = [(x[0]/255, x[1]/255, x[2]/255) for x in colors]
# Plot the points # Plot the points
plt.scatter(x, y, c=colors_normalized) plt.scatter(x, y, c=colors_normalized)
@ -612,42 +593,48 @@ def drawdata():
plt.show() plt.show()
plt.savefig("map3.png", dpi=50, bbox_inches="tight") plt.savefig("map3.png", dpi=50, bbox_inches="tight")
plt.clf() plt.clf()
return self
def startup_animation(show): def startup_animation(self, show):
stmode = "Startup" stmode = "Startup"
mainloop(stmode, preview=show) self.mainloop(stmode, preview=show)
while mode == "Startup": while self.mode == "Startup":
mainloop(None, preview=show) self.mainloop(None, preview=show)
for x in range(54): for x in range(54):
ringstatus[x][0] = False self.ringstatus[x][0] = False
mainloop(None, preview=show) self.mainloop(None, preview=show)
for x in range(animation_time): for x in range(self.animation_time):
mainloop(None, preview=show) self.mainloop(None, preview=show)
clear_animations() self.clear_animations()
stmode = "StartupCheck" stmode = "StartupCheck"
mainloop(stmode, preview=show) self.mainloop(stmode, preview=show)
clear_animations() self.clear_animations()
return self
def clear_animations(): def clear_animations(self):
for x in range(len(leds)): for x in range(len(self.leds)):
exactdata[x] = None self.exactdata[x] = None
return self
def do_animation(stmode, ring=-1): def do_animation(self, stmode, ring=-1):
mainloop(stmode, ring, preview=show) self.mainloop(stmode, ring, preview=show)
wait_for_animation(ring) self.wait_for_animation(ring)
return self
def start_animation(stmode, ring=-1): def start_animation(self, stmode, ring=-1):
mainloop(stmode, ring, preview=show) self.mainloop(stmode, ring, preview=show)
return self
def wait_for_animation(ring=-1): def wait_for_animation(self, ring=-1):
while mode != "idle": while self.mode != "idle":
mainloop(None, ring, preview=show) self.mainloop(None, ring, preview=show)
return self
if __name__ == "__main__": if __name__ == "__main__":
init()
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
"""cap = cv2.VideoCapture('badapple.mp4') """cap = cv2.VideoCapture('badapple.mp4')
while cap.isOpened(): while cap.isOpened():
@ -657,22 +644,23 @@ if __name__ == "__main__":
mapimage(frame, fps=30)""" mapimage(frame, fps=30)"""
show = False show = False
ring = 1 ring = 1
startup_animation(show) ledsys = LEDSystem()
ledsys.startup_animation(show)
for x in range(54): for x in range(54):
ringstatus[x][0] = True ledsys.ringstatus[x][0] = True
mainloop(None, preview=show) ledsys.mainloop(None, preview=show)
for x in range(animation_time): for x in range(ledsys.animation_time):
mainloop(None, preview=show) ledsys.mainloop(None, preview=show)
do_animation("GrabA", 1) ledsys.do_animation("GrabA", 1)
do_animation("GrabA", 5) ledsys.do_animation("GrabA", 5)
start_animation("GrabC", 1) ledsys.start_animation("GrabC", 1)
wait_for_animation(1) ledsys.wait_for_animation(1)
do_animation("GrabC", 5) ledsys.do_animation("GrabC", 5)
close() ledsys.close()
#sys.exit(0) #sys.exit(0)

10
run.py
View File

@ -17,7 +17,7 @@ import signal
import socket import socket
from flask import Flask, render_template, request from flask import Flask, render_template, request
import requests import requests
import led_control from led_control import LEDSystem
import server import server
import asyncio import asyncio
import json import json
@ -36,7 +36,7 @@ killme = None
#pool = None #pool = None
serverproc = None serverproc = None
camera = None camera = None
ledsys = None
to_server_queue = Queue() to_server_queue = Queue()
from_server_queue = Queue() from_server_queue = Queue()
@ -47,6 +47,8 @@ def arm_start_callback(res):
def led_start_callback(res): def led_start_callback(res):
global led_ready global led_ready
led_ready = True led_ready = True
global ledsys
ledsys = res
def camera_start_callback(res): def camera_start_callback(res):
global camera_ready global camera_ready
@ -233,7 +235,9 @@ def setup_server(pool):
global camera global camera
pool.apply_async(ur5_control.init, (config["arm"]["ip"],), callback=arm_start_callback) pool.apply_async(ur5_control.init, (config["arm"]["ip"],), callback=arm_start_callback)
pool.apply_async(led_control.init, callback=led_start_callback) global ledsys
ledsys = LEDSystem()
pool.apply_async(ledsys.init, callback=led_start_callback)
#pool.apply_async(sensor_control.init, callback=sensor_start_callback) #pool.apply_async(sensor_control.init, callback=sensor_start_callback)
serverproc = Process(target=start_server_socket) serverproc = Process(target=start_server_socket)
serverproc.start() serverproc.start()