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

Compare commits

base: Jukebox:labelgenv0.2
Branches Tags
Jukebox:main Jukebox:dthomas_meilisearch Jukebox:dthomas-db
Jukebox:labelgenv0.2 Jukebox:labelgenv0.1
..
compare: Jukebox:64bb50f055149874d0d4786b8e2574e82bf9a7f4
Branches Tags
Jukebox:main Jukebox:dthomas_meilisearch Jukebox:dthomas-db
Jukebox:labelgenv0.2 Jukebox:labelgenv0.1

13 Commits
labelgenv0 ... 64bb50f055

Author SHA1 Message Date
Cole Deck
64bb50f055 Add setup-alpine-vm.sh 2024-03-28 00:44:57 +00:00
Cole Deck
5016b4e99f Update compose.yml 2024-03-28 00:44:35 +00:00
Cole Deck
efbda23c38 Fix docker runtime support 2024-03-27 18:53:50 -05:00
Cole Deck
19ce328596 Correctly parse results from get_specs 2024-03-27 17:49:02 -05:00
Cole Deck
ad216f21fa Implement cable_details call 2024-03-26 18:42:01 -05:00
BlueOceanWave
6d6c2030a9 Merge branch 'main' of https://git.myitr.org/Jukebox/jukebox-software 2024-03-26 15:24:20 -05:00
BlueOceanWave
9893222335 Pick-up routine 2024-03-26 15:24:18 -05:00
Cole Deck
82a52dea5a Add cables to meilisearch db 2024-03-26 15:09:26 -05:00
Cole Deck
77fdc43fce Add missing robot pass-ins 2024-03-24 15:35:46 -05:00
Cole Deck
3de59f5985 Convert ur5_control to class based (untested) 2024-03-24 15:31:58 -05:00
BlueOceanWave
6887fa943b Merge branch 'main' of https://git.myitr.org/Jukebox/jukebox-software 2024-03-24 13:50:17 -05:00
BlueOceanWave
2ec7906ee4 Basic move restrictions and flip routine 2024-03-23 15:47:10 -05:00
Cole Deck
069d2175d9 Convert led code to class based for multithreading 2024-03-23 15:33:51 -05:00
12 changed files with 1341 additions and 949 deletions
Expand all files Collapse all files

6
Dockerfile
View File

@ -3,11 +3,11 @@ FROM python:3.11-slim
# Get runtime dependencies # Get runtime dependencies
# glx for OpenCV, ghostscript for datasheet PDF rendering, zbar for barcode scanning, git for cloning repos # glx for OpenCV, ghostscript for datasheet PDF rendering, zbar for barcode scanning, git for cloning repos
RUN apt-get update && apt-get install -y libgl1-mesa-glx ghostscript libzbar0 git && apt-get clean && rm -rf /var/lib/apt/lists RUN apt-get update && apt-get install -y libgl1-mesa-glx ghostscript libzbar0 git && apt-get clean && rm -rf /var/lib/apt/lists
COPY *.py *.yml *.sh *.txt *.html static templates ./ COPY requirements.txt ./
#COPY config-server.yml config.yml #COPY config-server.yml config.yml
RUN pip3 install -r requirements.txt RUN pip3 install -r requirements.txt
COPY *.py *.yml *.sh *.txt *.html static templates ./
CMD ["python3", "run.py"] CMD ["sh", "-c", "python3 run.py"]
EXPOSE 5000 EXPOSE 5000
EXPOSE 8000 EXPOSE 8000
EXPOSE 9000 EXPOSE 9000

17
compose.yml
View File

@ -9,5 +9,22 @@ services:
volumes: volumes:
- "meili_data:/meili_data" - "meili_data:/meili_data"
jukebox-software:
build: .
init: true
ports:
- "5000:5000"
- "8000:8000"
- "9000:9000"
environment:
- PYTHONUNBUFFERED=1
depends_on:
- meilisearch
jukebox-web:
build: jukebox-web
ports:
- "3000:3000"
volumes: volumes:
meili_data: meili_data:

11
config.yml
View File

@ -6,6 +6,17 @@ core:
arm: arm:
ip: 192.168.1.145 ip: 192.168.1.145
tool:
offset_x: 0
offset_y: 0
offset_z: 0.14
limbs:
limb_base: 0.105
limb1: 0.425
limb2: 0.39225
limb3: 0.1
limb_wrist: 0.0997
#cable_map: #cable_map:
cameras: cameras:

49
get_specs.py
View File

@ -159,8 +159,8 @@ def touch(path):
def get_multi(partnums, delay=0.25, dir="cables/", cache=True): def get_multi(partnums, delay=0.25, dir="cables/", cache=True, bar=None):
with alive_bar(len(partnums) * 2, dual_line=True, calibrate=30, bar="classic2", spinner="classic") as bar: #with alive_bar(len(partnums) * 2, dual_line=True, calibrate=30, bar="classic2", spinner="classic", disable=True, file=sys.stdout) as bar:
failed = list() failed = list()
actualpartnums = list() actualpartnums = list()
def _try_download_datasheet(partnum, output_dir, dstype): # Guess datasheet URL def _try_download_datasheet(partnum, output_dir, dstype): # Guess datasheet URL
@ -188,7 +188,7 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
# and set chunk_size parameter to None. # and set chunk_size parameter to None.
#if chunk: #if chunk:
bartext = bartext + "." bartext = bartext + "."
bar.text = bartext # bar.text = bartext
f.write(chunk) f.write(chunk)
#fprint("") #fprint("")
return output_dir + "/datasheet.pdf" return output_dir + "/datasheet.pdf"
@ -217,7 +217,7 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
# and set chunk_size parameter to None. # and set chunk_size parameter to None.
#if chunk: #if chunk:
bartext = bartext + "." bartext = bartext + "."
bar.text = bartext # bar.text = bartext
f.write(chunk) f.write(chunk)
#fprint("") #fprint("")
return output_dir + "/datasheet.pdf" return output_dir + "/datasheet.pdf"
@ -244,7 +244,7 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
# and set chunk_size parameter to None. # and set chunk_size parameter to None.
#if chunk: #if chunk:
bartext = bartext + "." bartext = bartext + "."
bar.text = bartext # bar.text = bartext
f.write(chunk) f.write(chunk)
#fprint("") #fprint("")
return output_dir + "/part-hires." + url.split(".")[-1] return output_dir + "/part-hires." + url.split(".")[-1]
@ -255,29 +255,29 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
def __use_cached_datasheet(partnum, path, output_dir, dstype): def __use_cached_datasheet(partnum, path, output_dir, dstype):
fprint("Using cached datasheet for " + partnum) fprint("Using cached datasheet for " + partnum)
bar.text = "Using cached datasheet for " + partnum # bar.text = "Using cached datasheet for " + partnum
bar(skipped=True) # bar(skipped=True)
if not os.path.exists(output_dir + "/parsed"): if not os.path.exists(output_dir + "/parsed"):
fprint("Parsing Datasheet contents of " + partnum) fprint("Parsing Datasheet contents of " + partnum)
bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..." # bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
out = read_datasheet.parse(path, output_dir, partnum, dstype) out = read_datasheet.parse(path, output_dir, partnum, dstype)
bar(skipped=False) # bar(skipped=False)
return out return out
else: else:
fprint("Datasheet already parsed for " + partnum) fprint("Datasheet already parsed for " + partnum)
bar.text = "Datasheet already parsed for " + partnum + ".pdf" # bar.text = "Datasheet already parsed for " + partnum + ".pdf"
bar(skipped=True) # bar(skipped=True)
def __downloaded_datasheet(partnum, path, output_dir, dstype): def __downloaded_datasheet(partnum, path, output_dir, dstype):
fprint("Downloaded " + path) fprint("Downloaded " + path)
bar.text = "Downloaded " + path # bar.text = "Downloaded " + path
bar(skipped=False) # bar(skipped=False)
fprint("Parsing Datasheet contents of " + partnum) fprint("Parsing Datasheet contents of " + partnum)
bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..." # bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
out = read_datasheet.parse(path, output_dir, partnum, dstype) out = read_datasheet.parse(path, output_dir, partnum, dstype)
bar(skipped=False) # bar(skipped=False)
return out return out
def run_search(partnum): def run_search(partnum):
@ -290,7 +290,7 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
output_dir = dir + partnum output_dir = dir + partnum
path = output_dir + "/datasheet.pdf" path = output_dir + "/datasheet.pdf"
bartext = "Downloading files for part " + partnum bartext = "Downloading files for part " + partnum
bar.text = bartext # bar.text = bartext
partnum = oldpartnum.replace("_","/") partnum = oldpartnum.replace("_","/")
returnval = [partnum, dstype, False, False] returnval = [partnum, dstype, False, False]
if (not os.path.exists(output_dir + "/found_part_hires")) or not (os.path.exists(path) and os.path.getsize(path) > 1) or not cache: if (not os.path.exists(output_dir + "/found_part_hires")) or not (os.path.exists(path) and os.path.getsize(path) > 1) or not cache:
@ -305,7 +305,7 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
output_dir = dir + partnum output_dir = dir + partnum
path = output_dir + "/datasheet.pdf" path = output_dir + "/datasheet.pdf"
bartext = "Downloading files for part " + partnum bartext = "Downloading files for part " + partnum
bar.text = bartext # bar.text = bartext
if not os.path.exists(output_dir + "/found_part_hires") or not cache: if not os.path.exists(output_dir + "/found_part_hires") or not cache:
if _download_image(search_result["image"], output_dir): if _download_image(search_result["image"], output_dir):
@ -344,9 +344,13 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
fprint("Using cached hi-res part image for " + partnum) fprint("Using cached hi-res part image for " + partnum)
out = __use_cached_datasheet(partnum, path, output_dir, dstype) out = __use_cached_datasheet(partnum, path, output_dir, dstype)
returnval = [partnum, dstype, False, out] returnval = [partnum, dstype, False, out]
actualpartnums.append(returnval)
return True return True
for fullpartnum in partnums: for fullpartnum in partnums:
if fullpartnum is False:
actualpartnums.append(False)
continue
if fullpartnum[0:2] == "BL": # catalog.belden.com entry if fullpartnum[0:2] == "BL": # catalog.belden.com entry
partnum = fullpartnum[2:] partnum = fullpartnum[2:]
dstype = "Belden" dstype = "Belden"
@ -373,10 +377,10 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
time.sleep(delay) time.sleep(delay)
if not success: if not success:
fprint("Failed to download datasheet for part " + partnum) fprint("Failed to download datasheet for part " + partnum)
bar.text = "Failed to download datasheet for part " + partnum # bar.text = "Failed to download datasheet for part " + partnum
failed.append((partnum, dstype)) failed.append((partnum, dstype))
bar(skipped=True) # bar(skipped=True)
bar(skipped=True) # bar(skipped=True)
time.sleep(delay) time.sleep(delay)
if len(failed) > 0: if len(failed) > 0:
@ -408,7 +412,7 @@ if __name__ == "__main__":
# ] # ]
partnums = [ partnums = [
# Actual cables in Jukebox # Actual cables in Jukebox
"BL3092A",
"AW86104CY", "AW86104CY",
"AW3050", "AW3050",
"AW6714", "AW6714",
@ -438,8 +442,9 @@ if __name__ == "__main__":
"BL6300FE 009Q", "BL6300FE 009Q",
"BLRA500P 006Q", "BLRA500P 006Q",
]
# Some ones I picked, including some invalid ones # Some ones I picked, including some invalid ones
a = [
"BL10GXS12", "BL10GXS12",
"BLRST%205L-RKT%205L-949", "BLRST%205L-RKT%205L-949",
"BL10GXS13", "BL10GXS13",

125
inv_kin_testing.ipynb
View File

File diff suppressed because one or more lines are too long

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)

31
read_datasheet.py
View File

@ -177,7 +177,7 @@ def parse(filename, output_dir, partnum, dstype):
if dstype == "Alphawire" and table_name_2.find("\n") >= 0: if dstype == "Alphawire" and table_name_2.find("\n") >= 0:
torename[table_name_2] = table_name_2[0:table_name_2.find("\n")] torename[table_name_2] = table_name_2[0:table_name_2.find("\n")]
if table_name_2.find(table.iloc[-1, 0]) >= 0: if dstype == "Alphawire" and table_name_2.find(table.iloc[-1, 0]) >= 0:
# Name taken from table directly above - this table does not have a name # Name taken from table directly above - this table does not have a name
torename[table_name_2] = "Specs " + str(len(tables)) torename[table_name_2] = "Specs " + str(len(tables))
#table_list["Specs " + str(len(tables))] = table_list[table_name_2] # rename table to arbitrary altername name #table_list["Specs " + str(len(tables))] = table_list[table_name_2] # rename table to arbitrary altername name
@ -251,9 +251,6 @@ def parse(filename, output_dir, partnum, dstype):
#fprint(table_name) #fprint(table_name)
#fprint(previous_table) #fprint(previous_table)
main_key = previous_table main_key = previous_table
cont_key = table_name cont_key = table_name
#fprint(tables) #fprint(tables)
@ -267,15 +264,21 @@ def parse(filename, output_dir, partnum, dstype):
del tables[table_name] del tables[table_name]
else: else:
#print(tables)
#print(main_key)
#print(cont_key)
for key in tables[cont_key].keys(): for key in tables[cont_key].keys():
tables[main_key][key] = tables[cont_key][key] tables[main_key][key] = tables[cont_key][key]
del tables[table_name] del tables[table_name]
else:
previous_table = table_name
else:
previous_table = table_name previous_table = table_name
# remove & rename tables # remove & rename tables
#print(torename)
for table_name in torename.keys(): for table_name in torename.keys():
tables[torename[table_name]] = tables[table_name] tables[torename[str(table_name)]] = tables[str(table_name)]
del tables[table_name] del tables[table_name]
# remove multi-line values that occasionally squeak through # remove multi-line values that occasionally squeak through
def replace_newlines_in_dict(d): def replace_newlines_in_dict(d):
@ -298,7 +301,7 @@ def parse(filename, output_dir, partnum, dstype):
output_table["id"] = id output_table["id"] = id
#output_table["position"] = id #output_table["position"] = id
#output_table["brand"] = brand #output_table["brand"] = brand
output_table["fullspecs"] = tables output_table["fullspecs"] = {"partnum": partnum, "id": id, **tables}
output_table["searchspecs"] = {"partnum": partnum, **flatten(tables)} output_table["searchspecs"] = {"partnum": partnum, **flatten(tables)}
output_table["searchspecs"]["id"] = id output_table["searchspecs"]["id"] = id
@ -313,9 +316,9 @@ def parse(filename, output_dir, partnum, dstype):
for file_path in json_files: for file_path in json_files:
os.remove(file_path) os.remove(file_path)
#print(f"Deleted {file_path}") #print(f"Deleted {file_path}")
with open(output_dir + "/search_" + output_table["searchspecs"]["id"] + ".json", 'w') as json_file: with open(output_dir + "/search.json", 'w') as json_file:
json.dump(output_table["searchspecs"], json_file) json.dump(output_table["searchspecs"], json_file)
with open(output_dir + "/specs_" + output_table["partnum"] + ".json", 'w') as json_file: with open(output_dir + "/specs.json", 'w') as json_file:
json.dump(output_table["fullspecs"], json_file) json.dump(output_table["fullspecs"], json_file)
#print(json.dumps(output_table, indent=2)) #print(json.dumps(output_table, indent=2))
@ -346,12 +349,20 @@ def flatten(tables):
fullkeyname = (table + ": " + keyname).replace(".","") fullkeyname = (table + ": " + keyname).replace(".","")
if type(tables[table][key]) is not tuple: if type(tables[table][key]) is not tuple:
if len(tables[table][key]) > 0:
out[fullkeyname] = convert_to_number(tables[table][key]) out[fullkeyname] = convert_to_number(tables[table][key])
#print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",") #print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
elif len(tables[table][key]) == 1: elif len(tables[table][key]) == 1:
if len(tables[table][key][0]) > 0:
out[fullkeyname] = convert_to_number(tables[table][key][0]) out[fullkeyname] = convert_to_number(tables[table][key][0])
#print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",") #print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
else:
tmp = []
for x in range(len(tables[table][key])):
if len(tables[table][key][x]) > 0:
tmp.append(tables[table][key][x].strip())
#out[fullkeyname + " " + str(x+1)] = convert_to_number(tables[table][key][x])
out[fullkeyname] = tmp
# if the item has at least two commas in it, split it # if the item has at least two commas in it, split it
if tables[table][key].count(',') > 0: if tables[table][key].count(',') > 0:
out[fullkeyname] = list(map(lambda x: x.strip(), tables[table][key].split(","))) out[fullkeyname] = list(map(lambda x: x.strip(), tables[table][key].split(",")))

235
run.py
View File

@ -1,5 +1,6 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
from alive_progress import alive_bar
import get_specs import get_specs
import traceback import traceback
#import logging #import logging
@ -12,17 +13,20 @@ from util import fprint
from util import run_cmd from util import run_cmd
import sys import sys
import ur5_control import ur5_control
from ur5_control import Rob
import os import os
import signal 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
import process_video import process_video
import search
from search import JukeboxSearch
#multiprocessing.set_start_method('spawn', True)
config = None config = None
@ -32,13 +36,22 @@ led_ready = False
camera_ready = False camera_ready = False
sensor_ready = False sensor_ready = False
vm_ready = False vm_ready = False
cable_search_ready = False
killme = None killme = None
#pool = None #pool = None
serverproc = None serverproc = None
camera = None camera = None
ledsys = None
arm = None
to_server_queue = Queue() to_server_queue = Queue()
from_server_queue = Queue() from_server_queue = Queue()
mode = "Startup"
counter = 0
jbs = None
scan_value = None
arm_state = None
cable_list = list()
parse_res = None
def arm_start_callback(res): def arm_start_callback(res):
global arm_ready global arm_ready
@ -47,10 +60,14 @@ 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
camera_ready = True camera_ready = True
global scan_value
scan_value = res
def sensor_start_callback(res): def sensor_start_callback(res):
global sensor_ready global sensor_ready
@ -60,6 +77,12 @@ def vm_start_callback(res):
global vm_ready global vm_ready
vm_ready = True vm_ready = True
def cable_search_callback(res):
global cable_search_ready
cable_search_ready = True
global parse_res
parse_res = res
def wait_for(val, name): def wait_for(val, name):
#global val #global val
if val is False: if val is False:
@ -67,7 +90,15 @@ def wait_for(val, name):
while val is False: while val is False:
sleep(0.1) sleep(0.1)
def send_data(type, call, data, client_id="*"):
out = dict()
out["type"] = type
out["call"] = call
out["data"] = data
to_server_queue.put((client_id, json.dumps(out)))
def start_server_socket(): def start_server_socket():
global jbs
"""app = Flask(__name__) """app = Flask(__name__)
@app.route('/report_ip', methods=['POST']) @app.route('/report_ip', methods=['POST'])
@ -99,6 +130,10 @@ def start_server_socket():
# Message handler # Message handler
try: try:
decoded = json.loads(message) decoded = json.loads(message)
except:
fprint("Non-JSON message recieved")
continue
if "type" not in decoded: if "type" not in decoded:
fprint("Missing \"type\" field.") fprint("Missing \"type\" field.")
continue continue
@ -108,7 +143,6 @@ def start_server_socket():
if "data" not in decoded: if "data" not in decoded:
fprint("Missing \"data\" field.") fprint("Missing \"data\" field.")
continue continue
# if we get here, we have a "valid" data packet # if we get here, we have a "valid" data packet
data = decoded["data"] data = decoded["data"]
call = decoded["call"] call = decoded["call"]
@ -119,24 +153,19 @@ def start_server_socket():
fprint("webapp: " + str(data), sendqueue=to_server_queue) fprint("webapp: " + str(data), sendqueue=to_server_queue)
elif call == "request": elif call == "request":
fprint("") fprint("")
case "cable_map": case "cable_map":
fprint("cable_map message") fprint("cable_map message")
if call == "send": if call == "send":
fprint("") fprint("")
elif call == "request": elif call == "request":
fprint("") fprint("")
case "ping": case "ping":
fprint("Pong!!!") fprint("Pong!!!")
# Lucas' notes # Lucas' notes
# Add a ping pong :) response/handler # Add a ping pong :) response/handler
# Add a get cable response/handler # Add a get cable response/handler
# this will tell the robot arm to move # this will tell the robot arm to move
# Call for turning off everything # Call for turning off everything
# TODO Helper for converting Python Dictionaries to JSON # TODO Helper for converting Python Dictionaries to JSON
# make function: pythonData --> { { "type": "...", "call": "...", "data": pythonData } } # make function: pythonData --> { { "type": "...", "call": "...", "data": pythonData } }
@ -148,6 +177,20 @@ def start_server_socket():
fprint("") fprint("")
elif call == "request": elif call == "request":
fprint("") fprint("")
dataout = dict()
dataout["cables"] = list()
print(data)
if "part_number" in data:
for part in data["part_number"]:
#print(part)
#print(jbs.get_partnum(part))
dataout["cables"].append(jbs.get_partnum(part)["fullspecs"])
if "position" in data:
for pos in data["position"]:
#print(pos)
#print(jbs.get_position(str(pos)))
dataout["cables"].append(jbs.get_position(str(pos))["fullspecs"])
send_data(decoded["type"], "send", dataout, client_id)
case "cable_search": case "cable_search":
fprint("cable_search message") fprint("cable_search message")
@ -155,7 +198,6 @@ def start_server_socket():
fprint("") fprint("")
elif call == "request": elif call == "request":
fprint("") fprint("")
case "keyboard": case "keyboard":
fprint("keyboard message") fprint("keyboard message")
if call == "send": if call == "send":
@ -169,21 +211,17 @@ def start_server_socket():
elif data["enabled"] == False: elif data["enabled"] == False:
p = Process(target=run_cmd, args=("./keyboard-down.ps1",)) p = Process(target=run_cmd, args=("./keyboard-down.ps1",))
p.start() p.start()
case "machine_settings": case "machine_settings":
fprint("machine_settings message") fprint("machine_settings message")
if call == "send": if call == "send":
fprint("") fprint("")
elif call == "request": elif call == "request":
fprint("") fprint("")
case _: case _:
fprint("Unknown/unimplemented data type: " + decoded["type"]) fprint("Unknown/unimplemented data type: " + decoded["type"])
except:
fprint("Non-JSON message recieved")
continue
sleep(0.001) # Sleep to prevent tight loop sleep(0.001) # Sleep to prevent tight loop
@ -231,13 +269,19 @@ def setup_server(pool):
global arm_ready global arm_ready
global serverproc global serverproc
global camera global camera
global arm
pool.apply_async(ur5_control.init, (config["arm"]["ip"],), callback=arm_start_callback) global jbs
pool.apply_async(led_control.init, callback=led_start_callback) arm = Rob(config)
pool.apply_async(arm.init_arm, callback=arm_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)
jbs = JukeboxSearch()
serverproc = Process(target=start_server_socket) serverproc = Process(target=start_server_socket)
serverproc.start() serverproc.start()
if led_ready is False: if led_ready is False:
fprint("waiting for " + "LED controller initialization" + " to complete...", sendqueue=to_server_queue) fprint("waiting for " + "LED controller initialization" + " to complete...", sendqueue=to_server_queue)
while led_ready is False: while led_ready is False:
@ -253,7 +297,7 @@ def setup_server(pool):
if camera_ready is False: if camera_ready is False:
fprint("waiting for " + "Camera initilization" + " to complete...", sendqueue=to_server_queue) fprint("waiting for " + "Camera initilization" + " to complete...", sendqueue=to_server_queue)
# camera = process_video.qr_reader(config["cameras"]["banner"]["ip"], config["cameras"]["banner"]["port"]) camera = process_video.qr_reader(config["cameras"]["banner"]["ip"], config["cameras"]["banner"]["port"])
fprint("Camera initialized.", sendqueue=to_server_queue) fprint("Camera initialized.", sendqueue=to_server_queue)
@ -266,22 +310,158 @@ def setup_server(pool):
return True return True
def mainloop_server(pool): def mainloop_server(pool):
# NON-blocking loop
global config global config
global counter global counter
global killme global killme
global mode
global jbs
global arm
global ledsys
global camera
global arm_ready
global arm_state
global camera_ready
global cable_search_ready
global cable_list
if killme.value > 0: if killme.value > 0:
killall() killall()
counter = counter + 1
# fprint("Looking for QR code...") if mode == "Startup":
# print(camera.read_qr(30)) counter = 54
if counter < 54:
# scanning cables
if arm_state is None:
#pool.apply_async(arm.get cable to camera, callback=arm_start_callback)
#ur5_control.goto_holder_index(arm)
#ur5 get item
# ur5 bring to camera
fprint("Getting cable index " + str(counter) + " and scanning...")
arm_state = "GET"
elif arm_ready and arm_state == "GET":
fprint("Looking for QR code...")
pool.apply_async(camera.read_qr, (30,), callback=camera_start_callback)
arm_ready = False
elif camera_ready:
fprint("Adding cable to list...")
global scan_value
if scan_value is False:
cable_list.append(scan_value)
elif scan_value.find("bldn.app/") > -1:
scan_value = scan_value[scan_value.find("bldn.app/")+9:]
else:
cable_list.append(scan_value)
fprint(scan_value)
#pool.apply_async(arm.return cable, callback=arm_start_callback)
arm_state = "RETURN"
camera_ready = False
elif arm_ready and arm_state == "RETURN":
counter += 1
arm_state = None
else:
# just wait til arm/camera is ready
pass
else:
# scanned everything
tmp = [
# Actual cables in Jukebox
"BLTF-1LF-006-RS5",
"BLTF-SD9-006-RI5",
"BLTT-SLG-024-HTN",
"BLFISX012W0",
"BLFI4X012W0",
"BLSPE101",
"BLSPE102",
"BL7922A",
"BL7958A",
"BLIOP6U",
"BL10GXW13",
"BL10GXW53",
"BL29501F",
"BL29512",
"BL3106A",
"BL9841",
"BL3105A",
"BL3092A",
"BL8760",
"BL6300UE",
"BL6300FE",
"BLRA500P",
"AW86104CY",
"AW3050",
"AW6714",
"AW1172C",
"AWFIT-221-1_4"
]
while len(tmp) < 54:
tmp.append(False) # must have 54 entries
cable_list = tmp # remove for real demo
pool.apply_async(get_specs.get_multi, (tmp, 0.3), callback=cable_search_callback)
mode = "Parsing"
fprint("All cables scanned. Finding & parsing datasheets...")
if mode == "Parsing":
# waiting for search & parse to complete
#cable_search_ready = True
if cable_search_ready is False:
pass
else:
# done
global parse_res
success, partnums = parse_res
for idx in range(len(partnums)):
if partnums[idx] is not False:
cable_list[idx] = partnums[idx][0].replace("/", "_")
else:
cable_list[idx] = False
print(partnums)
if success:
# easy mode
fprint("All cables inventoried and parsed.")
fprint("Adding to database...")
for idx in range(len(cable_list)):
partnum = cable_list[idx]
if partnum is not False:
with open("cables/" + partnum + "/search.json", "rb") as f:
searchdata = json.load(f)
searchdata["position"] = idx
with open("cables/" + partnum + "/specs.json", "rb") as f:
specs = json.load(f)
searchdata["fullspecs"] = specs
searchdata["fullspecs"]["position"] = idx
jbs.add_document(searchdata)
#sleep(0.5)
#print(jbs.get_position("1"))
fprint("All cables added to database.")
mode = "Idle"
else:
# TODO: manual input
pass
if mode == "Idle":
# do nothing
if arm_ready is False:
pool.apply_async(ur5_control.move_to_home, (arm,), callback=arm_start_callback)
arm_ready = True
else:
# LED idle anim
pass
def run_loading_app(): def run_loading_app():
@ -401,7 +581,7 @@ if __name__ == "__main__":
with open('config.yml', 'r') as fileread: with open('config.yml', 'r') as fileread:
#global config #global config
config = yaml.safe_load(fileread) config = yaml.safe_load(fileread)
fprint("Config loaded.")
with Manager() as manager: with Manager() as manager:
fprint("Spawning threads...") fprint("Spawning threads...")
pool = LoggingPool(processes=10) pool = LoggingPool(processes=10)
@ -422,5 +602,12 @@ if __name__ == "__main__":
fprint("Entering main loop...") fprint("Entering main loop...")
while(keeprunning): while(keeprunning):
mainloop_server(pool) mainloop_server(pool)
else:
fprint("Mode unspecified - assuming server")
fprint("Starting in server mode.")
if setup_server(pool):
fprint("Entering main loop...")
while(keeprunning):
mainloop_server(pool)

20
search.py
View File

@ -1,10 +1,12 @@
#!/usr/bin/env python3
"""Interactions with the Meilisearch API for adding and searching cables.""" """Interactions with the Meilisearch API for adding and searching cables."""
from meilisearch import Client from meilisearch import Client
from meilisearch.task import TaskInfo from meilisearch.task import TaskInfo
from meilisearch.errors import MeilisearchApiError from meilisearch.errors import MeilisearchApiError
import json import time
DEFAULT_URL = "http://localhost:7700" DEFAULT_URL = "http://meilisearch:7700"
DEFAULT_APIKEY = "fluffybunnyrabbit" # I WOULD RECOMMEND SOMETHING MORE SECURE DEFAULT_APIKEY = "fluffybunnyrabbit" # I WOULD RECOMMEND SOMETHING MORE SECURE
DEFAULT_INDEX = "cables" DEFAULT_INDEX = "cables"
DEFAULT_FILTERABLE_ATTRS = ["partnum", "uuid", "position"] # default filterable attributes DEFAULT_FILTERABLE_ATTRS = ["partnum", "uuid", "position"] # default filterable attributes
@ -34,12 +36,15 @@ class JukeboxSearch:
# create the index if it does not exist already # create the index if it does not exist already
try: try:
self.client.get_index(self.index) self.client.get_index(self.index)
self.client.delete_index(self.index)
self.client.create_index(self.index)
except MeilisearchApiError as _: except MeilisearchApiError as _:
self.client.create_index(self.index) self.client.create_index(self.index)
# make a variable to easily reference the index # make a variable to easily reference the index
self.idxref = self.client.index(self.index) self.idxref = self.client.index(self.index)
time.sleep(0.05)
# update filterable attributes if needed # update filterable attributes if needed
self.idxref.update_distinct_attribute('partnum')
self.update_filterables(filterable_attrs) self.update_filterables(filterable_attrs)
def add_document(self, document: dict) -> TaskInfo: def add_document(self, document: dict) -> TaskInfo:
@ -65,11 +70,10 @@ class JukeboxSearch:
:param filterables: List of all filterable attributes""" :param filterables: List of all filterable attributes"""
existing_filterables = self.idxref.get_filterable_attributes() #existing_filterables = self.idxref.get_filterable_attributes()
if len(set(existing_filterables).difference(set(filterables))) > 0: #if len(set(existing_filterables).difference(set(filterables))) > 0:
taskref = self.idxref.update_filterable_attributes(filterables) taskref = self.idxref.update_filterable_attributes(filterables)
#self.client.wait_for_task(taskref.index_uid)
self.client.wait_for_task(taskref.index_uid)
def search(self, query: str, filters: str = None): def search(self, query: str, filters: str = None):
"""Execute a search query on the Meilisearch index. """Execute a search query on the Meilisearch index.
@ -90,7 +94,7 @@ class JukeboxSearch:
:returns: A dict containing the results; If no results found, an empty dict.""" :returns: A dict containing the results; If no results found, an empty dict."""
q = self.search("", filter) q = self.search("", filter)
if q["estimatedTotalHits"] != 0: if q["estimatedTotalHits"] != 0:
return ["hits"][0] return q["hits"][0]
else: else:
return dict() return dict()

17
setup-alpine-vm.sh Normal file
View File

@ -0,0 +1,17 @@
#!/bin/sh
# This script must run as root!
echo "https://dl-cdn.alpinelinux.org/alpine/latest-stable/main
https://dl-cdn.alpinelinux.org/alpine/latest-stable/community" > /etc/apk/repositories
apk upgrade
apk add git docker docker-cli-compose
rc-update add docker
service docker start
git clone https://git.myitr.org/Jukebox/jukebox-software
cd jukebox-software
git submodule init
git submodule update

359
ur5_control.py
View File

@ -6,6 +6,7 @@ import numpy as np
import time import time
import os import os
import logging import logging
import yaml
from urx.robotiq_two_finger_gripper import Robotiq_Two_Finger_Gripper from urx.robotiq_two_finger_gripper import Robotiq_Two_Finger_Gripper
import sys import sys
from util import fprint from util import fprint
@ -13,12 +14,26 @@ from util import fprint
rob = None
offset_x, offset_y, offset_z = (0, 0, 0.14) # Tool offset
limb_base, limb1, limb2, limb3, limb_wrist = (0.105, .425, .39225, .1, .0997) # Limb lengths
def init(ip): class Rob():
global rob robot = None
#offset_x, offset_y, offset_z = (0, 0, 0.14) # Tool offset
#
def __init__(self, config):
self.config = config
armc = config["arm"]
self.ip = armc["ip"]
tool = armc["tool"]
limbs = armc["limbs"]
self.offset_x, self.offset_y, self.offset_z = (tool["offset_x"], tool["offset_y"], tool["offset_z"])
self.limb_base = limbs["limb_base"]
self.limb1 = limbs["limb1"]
self.limb2 = limbs["limb2"]
self.limb3 = limbs["limb3"]
self.limb_wrist = limbs["limb_wrist"]
#self.init_arm()
def init_arm(self):
#sys.stdout = Logger() #sys.stdout = Logger()
fprint("Starting UR5 power up...") fprint("Starting UR5 power up...")
@ -30,29 +45,28 @@ def init(ip):
# trigger auto-initialize # trigger auto-initialize
# wait for auto-initialize # wait for auto-initialize
ip = self.ip
# init urx # init urx
fprint("Connecting to arm at " + ip) fprint("Connecting to arm at " + ip)
trying = True trying = True
while trying: while trying:
try: try:
rob = urx.Robot(ip) self.robot = urx.Robot(ip)
trying = False trying = False
except: except:
time.sleep(1) time.sleep(1)
robotiqgrip = Robotiq_Two_Finger_Gripper(rob)
# Sets robot arm endpoint offset (x,y,z,rx,ry,rz) # Sets robot arm endpoint offset (x,y,z,rx,ry,rz)
rob.set_tcp((0, 0, 0.15, 0, 0, 0)) self.robot.set_tcp((self.offset_x, self.offset_y, self.offset_z, 0, 0, 0))
# Set weight # Set weight
rob.set_payload(2, (0, 0, 0.1)) self.robot.set_payload(2, (0, 0, 0.1))
#rob.set_payload(2, (0, 0, 0.1)) #rob.set_payload(2, (0, 0, 0.1))
time.sleep(0.2) time.sleep(0.2)
fprint("UR5 ready.") fprint("UR5 ready.")
def set_pos_abs(x, y, z, xb, yb, zb, threshold=None): def set_pos_abs(robot, x, y, z, xb, yb, zb, threshold=None):
global rob rob = robot.robot
new_orientation = m3d.Transform() new_orientation = m3d.Transform()
new_orientation.orient.rotate_xb(xb) # Replace rx with the desired rotation around X-axis new_orientation.orient.rotate_xb(xb) # Replace rx with the desired rotation around X-axis
new_orientation.orient.rotate_yb(yb) # Replace ry with the desired rotation around Y-axis new_orientation.orient.rotate_yb(yb) # Replace ry with the desired rotation around Y-axis
@ -68,8 +82,8 @@ def set_pos_abs(x, y, z, xb, yb, zb, threshold=None):
#rob.speedj(0.2, 0.5, 99999) #rob.speedj(0.2, 0.5, 99999)
rob.set_pose(new_trans, acc=2, vel=2, command="movej", threshold=threshold) # apply the new pose rob.set_pose(new_trans, acc=2, vel=2, command="movej", threshold=threshold) # apply the new pose
def set_pos_rel_rot_abs(x, y, z, xb, yb, zb): def set_pos_rel_rot_abs(robot, x, y, z, xb, yb, zb):
global rob rob = robot.robot
new_orientation = m3d.Transform() new_orientation = m3d.Transform()
new_orientation.orient.rotate_xb(xb) # Replace rx with the desired rotation around X-axis new_orientation.orient.rotate_xb(xb) # Replace rx with the desired rotation around X-axis
new_orientation.orient.rotate_yb(yb) # Replace ry with the desired rotation around Y-axis new_orientation.orient.rotate_yb(yb) # Replace ry with the desired rotation around Y-axis
@ -86,8 +100,8 @@ def set_pos_rel_rot_abs(x, y, z, xb, yb, zb):
#rob.speedj(0.2, 0.5, 99999) #rob.speedj(0.2, 0.5, 99999)
rob.set_pose(new_trans, acc=0.1, vel=0.4, command="movej") # apply the new pose rob.set_pose(new_trans, acc=0.1, vel=0.4, command="movej") # apply the new pose
def set_pos_abs_rot_rel(x, y, z, xb, yb, zb): def set_pos_abs_rot_rel(robot, x, y, z, xb, yb, zb):
global rob rob = robot.robot
new_orientation = m3d.Transform() new_orientation = m3d.Transform()
new_orientation.orient.rotate_xb(xb) # Replace rx with the desired rotation around X-axis new_orientation.orient.rotate_xb(xb) # Replace rx with the desired rotation around X-axis
new_orientation.orient.rotate_yb(yb) # Replace ry with the desired rotation around Y-axis new_orientation.orient.rotate_yb(yb) # Replace ry with the desired rotation around Y-axis
@ -133,8 +147,8 @@ def polar_to_cartesian(r, theta):
return x, y return x, y
def move_to_polar(start_pos, end_pos): def move_to_polar(robot, start_pos, end_pos):
global rob rob = robot.robot
# Convert to polar coordinates # Convert to polar coordinates
start_r, start_theta = cartesian_to_polar(start_pos[0], start_pos[1]) start_r, start_theta = cartesian_to_polar(start_pos[0], start_pos[1])
@ -191,13 +205,8 @@ def move_to_polar(start_pos, end_pos):
return rx_intermediate return rx_intermediate
def degtorad(angle): def move_to_home(robot):
return angle/180.0 * math.pi rob = robot.robot
def radtodeg(angle):
return angle*180.0 / math.pi
def move_to_home():
global rob
# Home position in degrees # Home position in degrees
home_pos = [0.10421807948612624, home_pos = [0.10421807948612624,
@ -222,15 +231,14 @@ def normalize_degree(theta):
# Return angle # Return angle
return normalized_theta return normalized_theta
def get_joints_from_xyz_rel(robot, x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess = (math.pi/2, math.pi/2, 0), l3offset=0):
def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess = (math.pi/2, math.pi/2, 0), l3offset=0):
# Get limbs and offsets # Get limbs and offsets
#l3=0.15 #l3=0.15
l_bs, l1, l2, l3, l_wt = (limb_base, limb1, limb2, limb3, limb_wrist) # Limb lengths l_bs, l1, l2, l3, l_wt = (robot.limb_base, robot.limb1, robot.limb2, robot.limb3, robot.limb_wrist) # Limb lengths
l3 += l3offset # add wrist offset, used for gripper angle calculations l3 += l3offset # add wrist offset, used for gripper angle calculations
offset_x = robot.offset_x
offset_y = robot.offset_y
offset_z = robot.offset_z
# Calculate base angle and r relative to shoulder joint # Calculate base angle and r relative to shoulder joint
def calculate_theta(x, y, a): def calculate_theta(x, y, a):
# Calculate if we need the + or - in our equations # Calculate if we need the + or - in our equations
@ -273,63 +281,197 @@ def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess =
# Return result # Return result
return base, shoulder, elbow, wrist1, ry, rz return base, shoulder, elbow, wrist1, ry, rz
def get_joints_from_xyz_abs(x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2, l3offset=0): def get_joints_from_xyz_abs(robot, x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2, l3offset=0, use_closest_path=True):
joints = get_joints_from_xyz_rel(x, y, z, rx, ry, rz, l3offset=l3offset) rob = robot.robot
joints = get_joints_from_xyz_rel(robot, x, y, z, rx, ry, rz, l3offset=l3offset)
# Return current positions if coordinates don't make sense
if z<0:
return rob.getj()
# Joint offsets # Joint offsets
# Base, Shoulder, Elbow, Wrist # Base, Shoulder, Elbow, Wrist
inverse = [1, -1, 1, 1, 1, 1] inverse = [1, -1, 1, 1, 1, 1]
offsets = [-math.pi/2, 0, 0, -math.pi/2, 0, 0] offsets = [-math.pi/2, 0, 0, -math.pi/2, 0, 0]
if radtodeg(joints[1]) > 137:
if math.degrees(joints[1]) > 137:
print("CRASH! Shoulder at", joints[1] * 180/math.pi) print("CRASH! Shoulder at", joints[1] * 180/math.pi)
#else: #else:
#print("Shoulder at", joints[1] * 180/math.pi) #print("Shoulder at", joints[1] * 180/math.pi)
# Return adjusted joint positions
return [o+j*i for j, o, i in zip(joints, offsets, inverse)]
# gripper angle: from vertical # Get adjusted joint positions
# gripper length: from joint to start of grip adjusted_joints = [o+j*i for j, o, i in zip(joints, offsets, inverse)]
# to flip, you can use flip=True or make gripper angle negative
def offset_gripper_angle(x, y, z, gripperangle=35, gripperlength=0.20+0.018, flip=False): curr_joints = rob.getj()
def get_complimentary_angle(joint_angle):
if joint_angle<0:
new_angle = joint_angle + 2*math.pi
else:
new_angle = joint_angle - 2*math.pi
if abs(new_angle) > math.radians(350):
return joint_angle
else:
return new_angle
# Use closest path (potentially going beyond 180 degrees)
if use_closest_path:
if abs(get_complimentary_angle(adjusted_joints[0])-curr_joints[0]) < abs(adjusted_joints[0]-curr_joints[0]):
adjusted_joints[0] = get_complimentary_angle(adjusted_joints[0])
# final_joint_positions = []
# for curr_joint, adjusted_joint in zip(curr_joints, adjusted_joints):
# if abs(curr_joint - adjusted_joint) < abs(curr_joint - get_complimentary_angle(adjusted_joint)):
# final_joint_positions.append(adjusted_joint)
# else:
# final_joint_positions.append(get_complimentary_angle(adjusted_joint))
# return final_joint_positions
return adjusted_joints
def move_arc(robot, x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2):
rob = robot.robot
start_joints = rob.getj()
end_joint = get_joints_from_xyz_abs(robot, x, y, z, rx, ry, rz)
n_points = 50
intermediate_joints = []
for i in range(0, 6):
intermediate_joints.append(np.linspace(start_joints[i], end_joint[i], n_points))
joints = [joint_position for joint_position in zip(*intermediate_joints)]
rob.movejs(joints, acc=2, vel=2, radius=0.1)
def offset_gripper_angle(robot, x, y, z, gripperangle=30, gripperlength=0.20+0.018, flip=False, use_closest_path=True):
# gripper angle: from vertical
# gripper length: from joint to start of grip
# to flip, you can use flip=True or make gripper angle negative
limb3 = robot.limb3
# Determine tool rotation depending on gripper angle
if gripperangle < 0: if gripperangle < 0:
rz = - math.pi / 2 rz = - math.pi / 2
else: else:
rz = math.pi / 2 rz = math.pi / 2
if flip: if flip:
gripperangle = -degtorad(gripperangle) gripperangle = -math.radians(gripperangle)
grippery = gripperlength - math.cos(gripperangle) * gripperlength grippery = gripperlength - math.cos(gripperangle) * gripperlength
grippery += math.sin(gripperangle) * limb3 grippery += math.sin(gripperangle) * limb3
gripperx = math.sin(gripperangle) * gripperlength + limb3 * 2 gripperx = math.sin(gripperangle) * gripperlength + limb3 * 2
gripperx -= (1-math.cos(gripperangle)) * limb3 gripperx -= (1-math.cos(gripperangle)) * limb3
rz = math.pi / 2 rz = math.pi / 2
# flip the whole wrist # flip the whole wrist
return get_joints_from_xyz_abs(x, y, z-grippery, rx=gripperangle + degtorad(180), l3offset=-gripperx, ry=math.pi/2, rz=rz) return get_joints_from_xyz_abs(robot, x, y, z-grippery, rx=gripperangle + math.radians(180), l3offset=-gripperx, ry=math.pi/2, rz=rz, use_closest_path=use_closest_path)
else: else:
gripperangle = degtorad(gripperangle) gripperangle = math.radians(gripperangle)
grippery = gripperlength - math.cos(gripperangle) * gripperlength grippery = gripperlength - math.cos(gripperangle) * gripperlength
grippery -= math.sin(gripperangle) * limb3 grippery -= math.sin(gripperangle) * limb3
gripperx = math.sin(gripperangle) * gripperlength gripperx = math.sin(gripperangle) * gripperlength
gripperx += (1-math.cos(gripperangle)) * limb3 gripperx += (1-math.cos(gripperangle)) * limb3
return get_joints_from_xyz_abs(x, y, z-grippery, rx=gripperangle, l3offset=-gripperx, rz=rz) return get_joints_from_xyz_abs(robot, x, y, z-grippery, rx=gripperangle, l3offset=-gripperx, rz=rz, use_closest_path=use_closest_path)
def goto_holder_index(robot, idx, z=0.05, gripperangle=30, flip=False, verbose=False):
joint = robot.config["position_map"][idx]
def goto_holder_index(idx, z=0.05, gripperangle=35, flip=False): if verbose:
joint = config["position_map"][idx]
print("Going to cable holder index", joint["index"], "at position", joint["pos"]) print("Going to cable holder index", joint["index"], "at position", joint["pos"])
angles = offset_gripper_angle(joint["pos"][1]/1000, joint["pos"][0]/1000, z, gripperangle=gripperangle, flip=flip)
safe_move(robot, joint["pos"][1]/1000, joint["pos"][0]/1000, z)
#angles = offset_gripper_angle(joint["pos"][1]/1000, joint["pos"][0]/1000, z, gripperangle=gripperangle, flip=flip)
#rob.movej(angles, acc=2, vel=2) #rob.movej(angles, acc=2, vel=2)
return angles #return angles
#angles = get_joints_from_xyz_abs(joint["pos"][1]/1000, joint["pos"][0]/1000, 0.05, ) #angles = get_joints_from_xyz_abs(joint["pos"][1]/1000, joint["pos"][0]/1000, 0.05, )
def is_flipped(robot):
rob = robot.robot
wrist2 = rob.getj()[4]
if wrist2>0:
return True
else:
return False
def flip(robot):
rob = robot.robot
# A list of safe positions to flip
safe_positions = [(-0.18, -0.108, 0.35),
(0.18, -0.108, 0.35)]
# Find the closest safe position
curr_pos = rob.getl()[:3]
def dist_from_robot(pos):
x, y, z = pos
rx, ry, rz = curr_pos
return math.sqrt((rx-x)**2+(ry-y)**2+(rz-z)**2)
pos_dist_pairs = zip(safe_positions, [dist_from_robot(pos) for pos in safe_positions])
safe_pos = min(pos_dist_pairs, key=lambda x:x[1])[0]
# Flip at safe position
rob.movej(offset_gripper_angle(robot, *safe_pos, flip=is_flipped(robot)), vel=2, acc=2) # Move to safe position
rob.movej(offset_gripper_angle(robot, *safe_pos, flip=(not is_flipped(robot))), vel=2, acc=2) # Flip gripper
def safe_move(robot, x, y, z):
rob = robot.robot
flip_radius = 0.22 # Min radius on which to flip
r = math.sqrt(x**2 + y**2) # Get position radius
# Flip gripper if needed
if (r <= flip_radius and is_flipped(robot)) or (r > flip_radius and not is_flipped(robot)):
flip(robot)
rob.movej(offset_gripper_angle(robot, x, y, z, flip=is_flipped(robot)), vel=2, acc=2)
def pick_up_routine(robot, holder_index, verbose=False):
rob = robot.robot
if verbose:
print('Pickup routine for index', holder_index)
goto_holder_index(robot, holder_index, 0.2)
curr_pos = rob.getl()
new_pos = curr_pos
new_pos[2] = 0
rob.movel(new_pos, vel=0.3, acc=1)
# goto_holder_index(robot, holder_index, 0.0)
# Close Gripper code
time.sleep(0.5)
new_pos[2] = 0.2
rob.movel(new_pos, vel=0.3, acc=1)
was_flipped = is_flipped(robot)
# Tray position 1
rob.movej(offset_gripper_angle(robot, -0.15, -0.15, 0.3, flip=is_flipped(robot), use_closest_path=False), vel=2, acc=2)
rob.movej(get_joints_from_xyz_abs(robot, -0.35, -0.15, 0.0, math.pi/2, 0.1), vel=2, acc=2)
time.sleep(0.5)
# Back to safe position
rob.movej(offset_gripper_angle(robot, -0.205, -0.108, 0.3, flip=True), vel=2, acc=2)
if __name__ == "__main__": if __name__ == "__main__":
#rob.movej((0, 0, 0, 0, 0, 0), 0.1, 0.2) #rob.movej((0, 0, 0, 0, 0, 0), 0.1, 0.2)
#rob.movel((x, y, z, rx, ry, rz), a, v) #rob.movel((x, y, z, rx, ry, rz), a, v)
init("192.168.1.145") #init("192.168.1.145")
with open('config.yml', 'r') as fileread:
#global config
config = yaml.safe_load(fileread)
robot = Rob(config) # robot of type Rob is the custom class above
robot.init_arm()
rob = robot.robot # rob is robot.robot is the urx robot class, what we've been using previously
print("Current tool pose is: ", rob.getl()) print("Current tool pose is: ", rob.getl())
move_to_home() move_to_home(robot)
home_pose = [-0.4999999077032916, home_pose = [-0.4999999077032916,
-0.2000072960336574, -0.2000072960336574,
@ -356,81 +498,45 @@ if __name__ == "__main__":
0.0510] 0.0510]
curr_pos = rob.getl() curr_pos = rob.getl()
# up/down,
# tool rotation
# tool angle (shouldn't need)
# rob.set_pos(p1[0:3], acc=0.5, vel=0.5)
# set_pos_abs(*home_pose)
# angles = get_joints_from_xyz_abs(-0.2, 0, 0)
# rob.movej(angles, acc=2, vel=2)
# angles = get_joints_from_xyz_abs(-0.2, -0.2, 0)
# rob.movej(angles, acc=2, vel=2)
# angles = get_joints_from_xyz_abs(0, -0.6, 0)
# rob.movej(angles, acc=2, vel=2)
# angles = get_joints_from_xyz_abs(0, -0.5, 0)
# rob.movej(angles, acc=2, vel=2)
# angles = get_joints_from_xyz_abs(0, -0.4, 0)
# rob.movej(angles, acc=2, vel=2)
# angles = get_joints_from_xyz_abs(0, -0.3, 0)
# rob.movej(angles, acc=2, vel=2)
# angles = get_joints_from_xyz_abs(0, -0.2, 0)
# rob.movej(angles, acc=2, vel=2)
# angles = get_joints_from_xyz_abs(0, -0.13, 0)
# rob.movej(angles, acc=2, vel=2)
config = None config = None
joints = [] joints = []
for i in np.linspace(-0.2, -0.7, 50): for i in np.linspace(-0.2, -0.7, 10):
joints.append(get_joints_from_xyz_abs(i, 0, 0)) joints.append(get_joints_from_xyz_abs(robot, i, 0, 0))
#rob.movejs(joints, acc=2, vel=2) # rob.movejs(joints, acc=2, vel=2, radius=0.1)
import yaml
with open('config.yml', 'r') as fileread:
#global config
config = yaml.safe_load(fileread)
#rob.movej(goto_holder_index(24, 0.2, 0), acc=2, vel=2) # rob.movej(offset_gripper_angle(robot, -0.15, -0.15, 0.3, gripperangle=90, flip=is_flipped(robot)), vel=2, acc=2)
# move_arc(0, 0.3, 0.1)
# move_arc(0, -0.3, 0.3)
for i in range(20, 25):
pick_up_routine(robot, i, verbose=True)
# goto_holder_index(robot, 7, 0.0)
# pick_up_routine(robot, 8)
# rob.movej(get_joints_from_xyz_abs(robot, -0.35, -0.15, 0.0, math.pi/2, 0.1), vel=2, acc=2)
#rob.movej(goto_holder_index(24, 0.2, 0), acc=2, vel=2).
#joints = [] #joints = []
#for i in np.linspace(0, 340, 340):
# joints.append(goto_holder_index(24, 0.5, i))
#rob.movejs(joints, acc=1, vel=3)
angle = 30
rob.movej(goto_holder_index(26, 0.1, angle), acc=2, vel=2)
time.sleep(1)
rob.movej(goto_holder_index(25, 0.1, angle), acc=2, vel=2)
time.sleep(1)
rob.movej(goto_holder_index(24, 0.1, angle, flip=True), acc=2, vel=2)
#rob.movej(goto_holder_index(32, 0.2, angle), acc=2, vel=2)
#rob.movej(goto_holder_index(38, 0.2, angle), acc=2, vel=2)
#rob.movej(goto_holder_index(25, 0.1, angle, flip=True), acc=2, vel=2)
#rob.movej(goto_holder_index(25, 0.2, angle, flip=True), acc=2, vel=2) # angle = 30
#rob.movej(goto_holder_index(24, 0.1, angle, flip=True), acc=2, vel=2) # goto_holder_index(robot, 26, 0.1, angle)
#time.sleep(1) # time.sleep(1)
#rob.movej(goto_holder_index(25, 0.1, angle, flip=True), acc=2, vel=2) # goto_holder_index(robot, 25, 0.1, angle)
#rob.movej(goto_holder_index(49, 0.1, angle), acc=2, vel=2) # time.sleep(1)
#rob.movej(goto_holder_index(49, 0.1, angle, flip=True), acc=2, vel=2) # goto_holder_index(robot, 24, 0.1, angle)
# rob.movej(goto_holder_index(50, 0.1, angle, flip=True), acc=2, vel=2)
# rob.movej(goto_holder_index(51, 0.1, angle, flip=True), acc=2, vel=2)
# rob.movej(goto_holder_index(52, 0.1, angle, flip=True), acc=2, vel=2)
# rob.movej(goto_holder_index(53, 0.1, angle, flip=True), acc=2, vel=2)
#time.sleep(2)
#rob.movej(goto_holder_index(24, 0.15, 35, flip=True), acc=2, vel=2)
#time.sleep(10)
# time.sleep(4)
# goto_holder_index(26, 0.1, 20)
# time.sleep(4)
# goto_holder_index(26, 0.1, 30)
# time.sleep(4)
# goto_holder_index(26, 0.1, 40)
# for joint in config["position_map"]:
#joint = config["position_map"][26]
#print("Going to cable holder index", joint["index"], "at position", joint["pos"])
#angles = get_joints_from_xyz_abs(joint["pos"][1]/1000, joint["pos"][0]/1000, 0.05, )# rx=math.pi / 5)
#joints.append(angles)
#rob.movej(angles, acc=2, vel=2) #rob.movej(angles, acc=2, vel=2)
#time.sleep(10) #time.sleep(10)
@ -443,25 +549,6 @@ if __name__ == "__main__":
# time.sleep(5) # time.sleep(5)
# angles = get_joints_from_xyz_abs(0, -0.6, 0)
# rob.movej(angles, acc=2, vel=2)
# set_pos_abs(*p1)
# move = move_to_polar(p1, p2)
# for p in move:
# print(math.degrees(p))
# print("Safe? :", is_safe_move(p1, p2))
# #set_pos_rel_rot_abs(0, 0, -0.2, math.pi, 0, -math.pi)
# set_pos_abs(0.3, -0.2, 0.5, math.pi, 0, -math.pi)
# set_pos_abs(0, 0.2, 0.6, math.pi, 0, -math.pi)
# set_pos_abs(-0.5, -0.2, 0.4, math.pi, 0, -math.pi)
# #set_pos_rel_rot_abs(0, 0, 0, math.pi, 0, -math.pi)
# print("Current tool pose is: ", rob.getl()) # print("Current tool pose is: ", rob.getl())
# print("getj(): ", rob.getj()) # print("getj(): ", rob.getj())

2
websocket_test.html
View File

@ -81,7 +81,7 @@
socket.send(message); socket.send(message);
console.log('Message sent', message); console.log('Message sent', message);
} }
setInterval(ping, 1500); //setInterval(ping, 1500);
// setInterval(() => { // setInterval(() => {
// updateServiceStatus('serviceA', 'down'); // updateServiceStatus('serviceA', 'down');