Compare commits
35 Commits
dthomas_me
...
6d6c2030a9
| Author | SHA1 | Date | |
|---|---|---|---|
| 6d6c2030a9 | |||
| 9893222335 | |||
| 82a52dea5a | |||
| 77fdc43fce | |||
| 3de59f5985 | |||
| 6887fa943b | |||
| 2ec7906ee4 | |||
| 069d2175d9 | |||
| 9b1b92e21d | |||
| ee0f8f4250 | |||
| 9c9435570b | |||
| 1bf10f7349 | |||
| 3c8d6c7ad3 | |||
| cbe7225fc9 | |||
| 44efc4006e | |||
| 218303e92b | |||
| e5d3f87b5c | |||
| 2ab1d0dbb3 | |||
| 1338c3f440 | |||
| 83b077b4df | |||
| f16242f5be | |||
| 2f28a01b7c | |||
| fb85a56d47 | |||
| bec0c63763 | |||
| 4ae30b82a0 | |||
| 4bc3e30116 | |||
| 6053d1b4ec | |||
| f43f9cda2f | |||
| 992040e812 | |||
| 5502a5069d | |||
| fc2af34450 | |||
| 39723ec442 | |||
| 25ceb6c133 | |||
| 56451d3e5c | |||
53638f72e1
|
6
.gitignore
vendored
6
.gitignore
vendored
@ -15,4 +15,8 @@ output.mp4
|
||||
# log files
|
||||
output.log
|
||||
# images
|
||||
*.png
|
||||
map*.png
|
||||
# Built app
|
||||
build
|
||||
# Generated label images
|
||||
labels
|
||||
|
||||
@ -1,7 +1,9 @@
|
||||
FROM python:latest
|
||||
FROM python:3.11-slim
|
||||
|
||||
RUN apt-get update && apt-get install -y libgl1-mesa-glx ghostscript && apt-get clean && rm -rf /var/lib/apt/lists
|
||||
COPY . .
|
||||
# Get runtime dependencies
|
||||
# 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
|
||||
COPY *.py *.yml *.sh *.txt *.html static templates ./
|
||||
#COPY config-server.yml config.yml
|
||||
RUN pip3 install -r requirements.txt
|
||||
|
||||
|
||||
BIN
GothamCond-Medium.otf
Normal file
BIN
GothamCond-Medium.otf
Normal file
Binary file not shown.
BIN
belden-logo-superhires.png
Normal file
BIN
belden-logo-superhires.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 448 KiB |
41
belden-logo.svg
Normal file
41
belden-logo.svg
Normal file
@ -0,0 +1,41 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 25.2.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
|
||||
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
|
||||
viewBox="0 0 446.6 151.4" style="enable-background:new 0 0 446.6 151.4;" xml:space="preserve">
|
||||
<style type="text/css">
|
||||
.st0{fill:#004990;}
|
||||
</style>
|
||||
<g>
|
||||
<g>
|
||||
<path class="st0" d="M21.2,32.1h-1.4v87.2H55c20.3,0,32-9.1,32-24.9c0-12.3-5.6-19.7-15.8-22.1c5.1-3.6,7.8-9.1,7.8-16.9
|
||||
c0-15.5-8.9-23.3-26.5-23.3H21.2z M44.7,51.6c7.4,0,11.4,1.1,11.4,6.8c0,4.8-3.1,6.8-10.5,6.8c0,0-0.6,0-1.1,0
|
||||
c0-2.1,0-11.5,0-13.6C44.5,51.6,44.7,51.6,44.7,51.6z M45.4,84.4l1.8,0c4.6,0,10.3-0.1,13,2.6c1.2,1.2,1.8,2.9,1.8,5.2
|
||||
c0,2-0.6,3.5-1.7,4.7c-3,3-9.2,2.9-13.8,2.9c0,0-1.4,0-2.1,0c0-2.1,0-13.3,0-15.4C44.9,84.4,45.4,84.4,45.4,84.4z"/>
|
||||
<g>
|
||||
<path class="st0" d="M139.8,32.1H90.4v87.2h50.8V98c0,0-23.7,0-26.1,0c0-2,0-9.8,0-11.8c2.4,0,24.8,0,24.8,0V64.8
|
||||
c0,0-22.3,0-24.8,0c0-2,0-9.4,0-11.4c2.5,0,26.1,0,26.1,0V32.1H139.8z"/>
|
||||
</g>
|
||||
<g>
|
||||
<path class="st0" d="M169.3,32.1H146v87.2h51V98c0,0-23.9,0-26.3,0c0-2.6,0-65.9,0-65.9H169.3z"/>
|
||||
</g>
|
||||
<g>
|
||||
<path class="st0" d="M332.4,32.1H283v87.2h50.8V98c0,0-23.7,0-26.1,0c0-2,0-9.8,0-11.8c2.4,0,24.8,0,24.8,0V64.8
|
||||
c0,0-22.3,0-24.8,0c0-2,0-9.4,0-11.4c2.5,0,26.1,0,26.1,0V32.1H332.4z"/>
|
||||
</g>
|
||||
<g>
|
||||
<path class="st0" d="M424.6,32.1h-23.3c0,0,0,43,0,49.3c-4-5.1-38.4-49.3-38.4-49.3h-24v87.2h24.7c0,0,0-43.1,0-49.5
|
||||
c4,5.1,38.4,49.5,38.4,49.5h24V32.1H424.6z"/>
|
||||
</g>
|
||||
<g>
|
||||
<g>
|
||||
<path class="st0" d="M233.8,32.1h-32.5v87.2h32.5c24.4,0,44.3-19.6,44.3-43.6C278.1,51.7,258.2,32.1,233.8,32.1z M226,53.5
|
||||
c13.6,0.3,22,8.7,22,22.2c0,13.6-8.2,21.9-22,22.2V53.5z M231.5,101.3c12.5-3,20.7-10.7,20.8-25.7c-0.2-15-8.3-22.7-20.8-25.7
|
||||
c14,2.1,25,9.5,25,25.6v0.1C256.5,91.8,245.5,99.2,231.5,101.3z M260.2,75.6c-0.2-18-10-29.8-24.9-33.3
|
||||
c16.7,2.5,29.6,14,29.6,33.3c0,0,0,0,0,0.1h0c0,19.3-13,30.7-29.7,33.2C250.1,105.3,260,93.6,260.2,75.6z M240.3,115.7
|
||||
c16.7-4.7,28.3-19.2,28.5-39.9v-0.3c-0.2-20.7-11.9-35.1-28.5-39.8c19,3.9,33.5,17.7,33.6,39.7v0.4
|
||||
C273.9,97.9,259.4,111.8,240.3,115.7z"/>
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
11
config.yml
11
config.yml
@ -6,6 +6,17 @@ core:
|
||||
|
||||
arm:
|
||||
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:
|
||||
cameras:
|
||||
|
||||
164
get_specs.py
164
get_specs.py
@ -27,6 +27,7 @@ def check_internet(url='https://belden.com', timeout=5):
|
||||
|
||||
|
||||
def query_search(partnum, source):
|
||||
fprint("Searching for " + partnum)
|
||||
if source == "Belden":
|
||||
token_url = "https://www.belden.com/coveo/rest/token?t=" + str(int(time.time()))
|
||||
with requests.get(token_url) as r:
|
||||
@ -52,15 +53,15 @@ def query_search(partnum, source):
|
||||
a = json.loads(a)
|
||||
idx = -1
|
||||
name = ""
|
||||
for partid in range(len(a["results"])):
|
||||
for partid in range(len(a["results"])-1, -1, -1):
|
||||
name = a["results"][partid]["title"]
|
||||
if name != partnum:
|
||||
if name.find(partnum) >= 0:
|
||||
idx = partid
|
||||
break
|
||||
#break
|
||||
elif partnum.find(name) >= 0:
|
||||
idx = partid
|
||||
break
|
||||
#break
|
||||
|
||||
else:
|
||||
idx = partid
|
||||
@ -69,7 +70,9 @@ def query_search(partnum, source):
|
||||
if idx < 0:
|
||||
fprint("Could not find part in API: " + partnum)
|
||||
return False
|
||||
fprint("Search result found: result " + str(idx) + ", for ID " + name)
|
||||
|
||||
name = a["results"][idx]["title"]
|
||||
#fprint("Search result found: result " + str(idx) + ", for ID " + name)
|
||||
#urlname = a["results"][0]["raw"]["catalogitemurlname"]
|
||||
img = a["results"][idx]["raw"]["catalogitemimageurl"]
|
||||
img = img[0:img.index("?")]
|
||||
@ -92,7 +95,7 @@ def query_search(partnum, source):
|
||||
#print(out)
|
||||
return out
|
||||
except:
|
||||
print("falied to search with API. Falling back to datasheet lookup.")
|
||||
print("Failed to search with API. Falling back to datasheet lookup.")
|
||||
return False
|
||||
|
||||
|
||||
@ -112,12 +115,14 @@ def query_search(partnum, source):
|
||||
r = requests.get(url=alphaurl)
|
||||
data = r.json()
|
||||
output = dict()
|
||||
#print(data)
|
||||
#print(data["Results"])
|
||||
|
||||
try:
|
||||
if data["Count"] > 0:
|
||||
#print(data["Results"][0]["Url"])
|
||||
for result in data["Results"]:
|
||||
if result["Url"].split("/")[-1] == partnum:
|
||||
#print(result["Url"])
|
||||
if result["Url"].split("/")[-1] == partnum.replace("-", "").replace("/", "_"):
|
||||
#print(partnum)
|
||||
#print(result["Html"])
|
||||
try:
|
||||
@ -133,14 +138,18 @@ def query_search(partnum, source):
|
||||
dsidx = result["Html"].index("<a href=\"/disteAPI/") + 9
|
||||
dsidx2 = result["Html"].index(partnum, dsidx) + len(partnum)
|
||||
output["datasheet"] = "https://www.alphawire.com" + result["Html"][dsidx:dsidx2]
|
||||
output["partnum"] = partnum
|
||||
#"test".index()
|
||||
output["partnum"] = partnum.replace("/", "_") #.replace("-", "").replace("/", "_")
|
||||
#
|
||||
# "test".index()
|
||||
#print(output)
|
||||
return output
|
||||
|
||||
|
||||
except:
|
||||
print("Failed to search with API. Falling back to datasheet lookup.")
|
||||
return False
|
||||
|
||||
print("Failed to search with API. Falling back to datasheet lookup.")
|
||||
return False
|
||||
|
||||
|
||||
@ -150,14 +159,19 @@ def touch(path):
|
||||
|
||||
|
||||
|
||||
def get_multi(partnums, delay=0.25):
|
||||
with alive_bar(len(partnums) * 2, dual_line=True, calibrate=30, bar="classic2", spinner="classic") as bar:
|
||||
|
||||
def _try_download_datasheet(partnum, output_dir): # Guess datasheet URL
|
||||
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", disable=True, file=sys.stdout) as bar:
|
||||
failed = list()
|
||||
actualpartnums = list()
|
||||
def _try_download_datasheet(partnum, output_dir, dstype): # Guess datasheet URL
|
||||
global bartext
|
||||
|
||||
if dstype == "Belden":
|
||||
sanitized_name = partnum.replace(" ", "")
|
||||
url = "https://catalog.belden.com/techdata/EN/" + sanitized_name + "_techdata.pdf"
|
||||
elif dstype == "Alphawire":
|
||||
# Alphawire Datasheet URLs do not use a sanitized part number (but product pages do)
|
||||
url = "https://www.alphawire.com/disteAPI/SpecPDF/DownloadProductSpecPdf?productPartNumber=" + partnum
|
||||
#fprint(url)
|
||||
try:
|
||||
with requests.get(url, stream=True) as r:
|
||||
@ -167,13 +181,14 @@ def get_multi(partnums, delay=0.25):
|
||||
if r.status_code == 404:
|
||||
return False
|
||||
os.makedirs(output_dir, exist_ok=True)
|
||||
bartext = ""
|
||||
with open(output_dir + "/datasheet.pdf", 'wb') as f:
|
||||
for chunk in r.iter_content(chunk_size=131072):
|
||||
for chunk in r.iter_content(chunk_size=65536):
|
||||
# If you have chunk encoded response uncomment if
|
||||
# and set chunk_size parameter to None.
|
||||
#if chunk:
|
||||
bartext = bartext + "."
|
||||
bar.text = bartext
|
||||
# bar.text = bartext
|
||||
f.write(chunk)
|
||||
#fprint("")
|
||||
return output_dir + "/datasheet.pdf"
|
||||
@ -195,13 +210,14 @@ def get_multi(partnums, delay=0.25):
|
||||
if r.status_code == 404:
|
||||
return False
|
||||
os.makedirs(output_dir, exist_ok=True)
|
||||
bartext = ""
|
||||
with open(output_dir + "/datasheet.pdf", 'wb') as f:
|
||||
for chunk in r.iter_content(chunk_size=131072):
|
||||
for chunk in r.iter_content(chunk_size=65536):
|
||||
# If you have chunk encoded response uncomment if
|
||||
# and set chunk_size parameter to None.
|
||||
#if chunk:
|
||||
bartext = bartext + "."
|
||||
bar.text = bartext
|
||||
# bar.text = bartext
|
||||
f.write(chunk)
|
||||
#fprint("")
|
||||
return output_dir + "/datasheet.pdf"
|
||||
@ -221,13 +237,14 @@ def get_multi(partnums, delay=0.25):
|
||||
if r.status_code == 404:
|
||||
return False
|
||||
os.makedirs(output_dir, exist_ok=True)
|
||||
bartext = ""
|
||||
with open(output_dir + "/part-hires." + url.split(".")[-1], 'wb') as f:
|
||||
for chunk in r.iter_content(chunk_size=131072):
|
||||
for chunk in r.iter_content(chunk_size=65536):
|
||||
# If you have chunk encoded response uncomment if
|
||||
# and set chunk_size parameter to None.
|
||||
#if chunk:
|
||||
bartext = bartext + "."
|
||||
bar.text = bartext
|
||||
# bar.text = bartext
|
||||
f.write(chunk)
|
||||
#fprint("")
|
||||
return output_dir + "/part-hires." + url.split(".")[-1]
|
||||
@ -238,77 +255,95 @@ def get_multi(partnums, delay=0.25):
|
||||
|
||||
def __use_cached_datasheet(partnum, path, output_dir, dstype):
|
||||
fprint("Using cached datasheet for " + partnum)
|
||||
bar.text = "Using cached datasheet for " + partnum
|
||||
bar(skipped=True)
|
||||
# bar.text = "Using cached datasheet for " + partnum
|
||||
# bar(skipped=True)
|
||||
if not os.path.exists(output_dir + "/parsed"):
|
||||
|
||||
fprint("Parsing Datasheet contents of " + partnum)
|
||||
bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
|
||||
# bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
|
||||
|
||||
read_datasheet.parse(path, output_dir, partnum, dstype)
|
||||
bar(skipped=False)
|
||||
out = read_datasheet.parse(path, output_dir, partnum, dstype)
|
||||
# bar(skipped=False)
|
||||
return out
|
||||
else:
|
||||
fprint("Datasheet already parsed for " + partnum)
|
||||
bar.text = "Datasheet already parsed for " + partnum + ".pdf"
|
||||
bar(skipped=True)
|
||||
# bar.text = "Datasheet already parsed for " + partnum + ".pdf"
|
||||
# bar(skipped=True)
|
||||
|
||||
def __downloaded_datasheet(partnum, path, output_dir, dstype):
|
||||
fprint("Downloaded " + path)
|
||||
bar.text = "Downloaded " + path
|
||||
bar(skipped=False)
|
||||
# bar.text = "Downloaded " + path
|
||||
# bar(skipped=False)
|
||||
fprint("Parsing Datasheet contents of " + partnum)
|
||||
bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
|
||||
read_datasheet.parse(path, output_dir, partnum, dstype)
|
||||
bar(skipped=False)
|
||||
# bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
|
||||
out = read_datasheet.parse(path, output_dir, partnum, dstype)
|
||||
# bar(skipped=False)
|
||||
return out
|
||||
|
||||
def run_search(partnum):
|
||||
output_dir = "cables/" + partnum
|
||||
partnum = partnum.replace("%20", " ") # undo URL encoding
|
||||
oldpartnum = partnum
|
||||
if dstype == "Alphawire":
|
||||
# For alphawire, sanitize the part number for only the final result check, because their API is very wierd
|
||||
# For the actual search, it must be un-sanitized
|
||||
partnum = partnum.replace("/","_")
|
||||
output_dir = dir + partnum
|
||||
path = output_dir + "/datasheet.pdf"
|
||||
bartext = "Downloading files for part " + partnum
|
||||
bar.text = bartext
|
||||
#
|
||||
if (not os.path.exists(output_dir + "/found_part_hires")) or not (os.path.exists(path) and os.path.getsize(path) > 1):
|
||||
# bar.text = bartext
|
||||
partnum = oldpartnum.replace("_","/")
|
||||
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:
|
||||
# Use query
|
||||
search_result = query_search(partnum, dstype)
|
||||
# Try to use belden.com search
|
||||
if search_result is not False:
|
||||
# Download high resolution part image if available and needed
|
||||
#oldpartnum = partnum
|
||||
partnum = search_result["partnum"]
|
||||
output_dir = "cables/" + partnum
|
||||
returnval = [partnum, dstype, False, False]
|
||||
output_dir = dir + partnum
|
||||
path = output_dir + "/datasheet.pdf"
|
||||
bartext = "Downloading files for part " + partnum
|
||||
bar.text = bartext
|
||||
# bar.text = bartext
|
||||
|
||||
if not os.path.exists(output_dir + "/found_part_hires"):
|
||||
if not os.path.exists(output_dir + "/found_part_hires") or not cache:
|
||||
if _download_image(search_result["image"], output_dir):
|
||||
fprint("Downloaded hi-res part image for " + partnum)
|
||||
returnval = [partnum, dstype, True, False]
|
||||
touch(output_dir + "/found_part_hires")
|
||||
else:
|
||||
fprint("Using cached hi-res part image for " + partnum)
|
||||
|
||||
# Download datasheet from provided URL if needed
|
||||
if os.path.exists(path) and os.path.getsize(path) > 1:
|
||||
__use_cached_datasheet(partnum, path, output_dir, dstype)
|
||||
if os.path.exists(path) and os.path.getsize(path) > 1 and cache:
|
||||
out = __use_cached_datasheet(partnum, path, output_dir, dstype)
|
||||
returnval = [partnum, dstype, True, out]
|
||||
|
||||
elif _download_datasheet(search_result["datasheet"], output_dir) is not False:
|
||||
__downloaded_datasheet(partnum, path, output_dir, dstype)
|
||||
out = __downloaded_datasheet(partnum, path, output_dir, dstype)
|
||||
returnval = [partnum, dstype, True, out]
|
||||
|
||||
elif os.path.exists(path) and os.path.getsize(path) > 1:
|
||||
__use_cached_datasheet(partnum, path, output_dir, dstype)
|
||||
elif os.path.exists(path) and os.path.getsize(path) > 1 and cache:
|
||||
out = __use_cached_datasheet(partnum, path, output_dir, dstype)
|
||||
returnval = [partnum, dstype, True, out]
|
||||
|
||||
# If search fails, and we don't already have the datasheet, guess datasheet URL and skip the hires image download
|
||||
elif _try_download_datasheet(partnum, output_dir) is not False:
|
||||
__downloaded_datasheet(partnum, path, output_dir, dstype)
|
||||
elif _try_download_datasheet(partnum, output_dir, dstype) is not False:
|
||||
out = __downloaded_datasheet(partnum, path, output_dir, dstype)
|
||||
returnval = [partnum, dstype, False, out]
|
||||
|
||||
# Failed to download with search or guess :(
|
||||
else:
|
||||
return False
|
||||
return True
|
||||
actualpartnums.append(returnval)
|
||||
return returnval
|
||||
|
||||
# We already have a hi-res image and the datasheet - perfect!
|
||||
else:
|
||||
fprint("Using cached hi-res part image for " + partnum)
|
||||
__use_cached_datasheet(partnum, path, output_dir, dstype)
|
||||
out = __use_cached_datasheet(partnum, path, output_dir, dstype)
|
||||
returnval = [partnum, dstype, False, out]
|
||||
return True
|
||||
|
||||
for fullpartnum in partnums:
|
||||
@ -338,19 +373,19 @@ def get_multi(partnums, delay=0.25):
|
||||
time.sleep(delay)
|
||||
if not success:
|
||||
fprint("Failed to download datasheet for part " + partnum)
|
||||
bar.text = "Failed to download datasheet for part " + partnum
|
||||
failed.append(partnum)
|
||||
bar(skipped=True)
|
||||
bar(skipped=True)
|
||||
# bar.text = "Failed to download datasheet for part " + partnum
|
||||
failed.append((partnum, dstype))
|
||||
# bar(skipped=True)
|
||||
# bar(skipped=True)
|
||||
time.sleep(delay)
|
||||
|
||||
if len(failed) > 0:
|
||||
fprint("Failed to download:")
|
||||
for partnum in failed:
|
||||
fprint(partnum)
|
||||
return False # Go to manual review upload page
|
||||
fprint(partnum[1] + " " + partnum[0])
|
||||
return False, actualpartnums # Go to manual review upload page
|
||||
else:
|
||||
return True # All cables downloaded; we are good to go
|
||||
return True, actualpartnums # All cables downloaded; we are good to go
|
||||
|
||||
|
||||
|
||||
@ -373,11 +408,12 @@ if __name__ == "__main__":
|
||||
# ]
|
||||
partnums = [
|
||||
# Actual cables in Jukebox
|
||||
"BL3092A",
|
||||
"AW86104CY",
|
||||
"AW3050",
|
||||
"AW6714",
|
||||
"AW1172C",
|
||||
"AW2211/4",
|
||||
"AWFIT-221-1/4",
|
||||
|
||||
"BLTF-1LF-006-RS5N",
|
||||
"BLTF-SD9-006-RI5N",
|
||||
@ -402,10 +438,11 @@ if __name__ == "__main__":
|
||||
"BL6300FE 009Q",
|
||||
"BLRA500P 006Q",
|
||||
|
||||
|
||||
]
|
||||
# Some ones I picked, including some invalid ones
|
||||
a = [
|
||||
"BL10GXS12",
|
||||
"BLRST 5L-RKT 5L-949",
|
||||
"BLRST%205L-RKT%205L-949",
|
||||
"BL10GXS13",
|
||||
"BL10GXW12",
|
||||
"BL10GXW13",
|
||||
@ -416,12 +453,17 @@ if __name__ == "__main__":
|
||||
"BLFISD012R9",
|
||||
"BLFDSD012A9",
|
||||
"BLFSSL024NG",
|
||||
"BLFISX006W0",
|
||||
"BLFISX00103",
|
||||
"BLC6D1100007"
|
||||
"BLFISX006W0", # datasheet only
|
||||
"BLFISX00103", # invalid
|
||||
"BLC6D1100007" # invalid
|
||||
|
||||
]
|
||||
#query_search("86104CY", "Alphawire")
|
||||
#print(query_search("TT-SLG-024-HTNN", "Belden"))
|
||||
from label_generator import gen_label
|
||||
gen_label("BLTF-SD9-006-RI5")
|
||||
gen_label("BLRA500P")
|
||||
gen_label("AWFIT-221-1_4")
|
||||
gen_label("BLRST 5L-RKT 5L-949")
|
||||
get_multi(partnums, 0.25)
|
||||
#query_search("10GXS13", "Belden")
|
||||
|
||||
|
||||
BIN
gs10030w64.exe
Normal file
BIN
gs10030w64.exe
Normal file
Binary file not shown.
@ -1 +0,0 @@
|
||||
<html> <head> <title>RGB Controller Configuration</title> <style> body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; } </style> </head> <body> <h1>RGB Controller Configuration</h1><br> <h2>Set IP address</h2> Needs reboot to apply<br> Set to 0.0.0.0 for DHCP <form method="post" enctype="application/x-www-form-urlencoded" action="/postform/"> <input type="text" name="ipa" value="0" size="3">. <input type="text" name="ipb" value="0" size="3">. <input type="text" name="ipc" value="0" size="3">. <input type="text" name="ipd" value="0" size="3"> <input type="submit" value="Set"> </form><br> <h2>Set Hostname</h2> Needs reboot to apply<br> Max 64 characters <form method="post" enctype="application/x-www-form-urlencoded" action="/postform/"> <input type="text" name="hostname" value="RGBController" size="20"> <input type="submit" value="Set"> </form><br> <h2>DMX512 Start Universe</h2> Applies immediately<br> Between (inclusive) 1-65000 <form method="post" enctype="application/x-www-form-urlencoded" action="/postform/"> <input type="text" name="universe" value="1" size="5"> <input type="submit" value="Set"> </form><br> <form method="post" enctype="application/x-www-form-urlencoded" action="/postform/"> <input type="submit" name="reboot" value="Reboot"> </form><br> </body></html>
|
||||
File diff suppressed because one or more lines are too long
106
label_generator.py
Executable file
106
label_generator.py
Executable file
@ -0,0 +1,106 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
|
||||
|
||||
from get_specs import get_multi
|
||||
import sys
|
||||
import uuid
|
||||
import os
|
||||
import signal
|
||||
from PIL import Image
|
||||
from label_image import generate_code
|
||||
|
||||
|
||||
def input_cable():
|
||||
print("")
|
||||
print("Use the full part number. Spaces, special characters are allowed. Do not specify the brand.")
|
||||
print("")
|
||||
print("Please enter a part number and press enter:")
|
||||
inputnum = input("").strip()
|
||||
if len(inputnum) < 2:
|
||||
killall_signal(0, 0)
|
||||
print("Input part number:", inputnum)
|
||||
print("Searching databases for cables...")
|
||||
# Search both AW and BL sites
|
||||
status, output = get_multi(["BL"+inputnum, "AW"+inputnum], delay=0.1, dir="temp/" + str(uuid.uuid4()) + "/", cache=False)
|
||||
print("")
|
||||
if len(output) > 1:
|
||||
for i in output:
|
||||
print(i[1], i[0])
|
||||
print("Multiple brands with the same part number! Please type \"b\" for the Belden part number or \"a\" for the Alphawire cable")
|
||||
inputbrand = input()
|
||||
if inputbrand == "b":
|
||||
output = [output[0]]
|
||||
elif inputbrand == "a":
|
||||
output = [output[1]]
|
||||
elif len(output) == 0:
|
||||
print("No results found for part number", inputnum + ". Please try again with a different part number.")
|
||||
return
|
||||
|
||||
output = output[0]
|
||||
print("")
|
||||
if output[2] and output[3]:
|
||||
print("Cable result found -",output[1], output[0], "with high-quality image and full specs")
|
||||
elif output[2]:
|
||||
print("Cable result found -",output[1], output[0], "with high-quality image and no specs")
|
||||
elif output[3]:
|
||||
print("Cable result found -",output[1], output[0], "with no/low quality image and full specs")
|
||||
else:
|
||||
print("Cable result found -",output[1], output[0], "with no/low quality image and no specs")
|
||||
print("")
|
||||
if not output[3]:
|
||||
print("Unable to decode cable specs. Please try again with a different part number.")
|
||||
return False
|
||||
else:
|
||||
print("")
|
||||
print("*** Cable details confirmed. Creating label...")
|
||||
print("")
|
||||
img = None
|
||||
imgstr = ""
|
||||
if output[1] == "Belden":
|
||||
imgstr = "BL"
|
||||
elif output[1] == "Alphawire":
|
||||
imgstr = "AW"
|
||||
gen_label(imgstr + output[0])
|
||||
#img = generate_code(imgstr + output[0])
|
||||
#os.makedirs("labels", exist_ok=True)
|
||||
#img.save("labels/" + imgstr + output[0] + ".png")
|
||||
|
||||
def gen_label(partnum, path="labels"):
|
||||
img = generate_code(partnum)
|
||||
os.makedirs(path, exist_ok=True)
|
||||
img.save(path + "/" + partnum + ".png")
|
||||
|
||||
def delete_folder(path):
|
||||
# Check if the path is a directory
|
||||
if not os.path.isdir(path):
|
||||
return
|
||||
|
||||
# List all files and directories in the path
|
||||
for filename in os.listdir(path):
|
||||
file_path = os.path.join(path, filename)
|
||||
# If it's a directory, recursively call this function
|
||||
if os.path.isdir(file_path):
|
||||
delete_folder(file_path)
|
||||
else:
|
||||
# If it's a file, remove it
|
||||
os.remove(file_path)
|
||||
|
||||
# After removing all contents, remove the directory itself
|
||||
os.rmdir(path)
|
||||
|
||||
def killall_signal(a,b):
|
||||
delete_folder("temp")
|
||||
os.kill(os.getpid(), 9) # dirty kill of self
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
signal.signal(signal.SIGINT, killall_signal)
|
||||
signal.signal(signal.SIGTERM, killall_signal)
|
||||
print("Welcome to the Jukebox cable utility. This tool will allow you to verify Belden & Alphawire cable part numbers and create labels for samples in the Jukebox.")
|
||||
print("This tool requires internet access to download cable specifications and verify part numbers.")
|
||||
#print("Use Ctrl+C to exit.")
|
||||
while True:
|
||||
delete_folder("temp")
|
||||
input_cable()
|
||||
|
||||
319
label_image.py
Executable file
319
label_image.py
Executable file
@ -0,0 +1,319 @@
|
||||
#!/usr/bin/env python3
|
||||
from util import fprint
|
||||
|
||||
from PIL import Image
|
||||
from PIL import ImageDraw
|
||||
from PIL import ImageFont
|
||||
#import cv2
|
||||
import numpy as np
|
||||
from util import find_data_file
|
||||
import segno
|
||||
import io
|
||||
#import cairosvg
|
||||
#import math
|
||||
|
||||
|
||||
|
||||
# Copied from http://en.wikipedia.org/wiki/Code_128
|
||||
# Value Weights 128A 128B 128C
|
||||
CODE128_CHART = """
|
||||
0 212222 space space 00
|
||||
1 222122 ! ! 01
|
||||
2 222221 " " 02
|
||||
3 121223 # # 03
|
||||
4 121322 $ $ 04
|
||||
5 131222 % % 05
|
||||
6 122213 & & 06
|
||||
7 122312 ' ' 07
|
||||
8 132212 ( ( 08
|
||||
9 221213 ) ) 09
|
||||
10 221312 * * 10
|
||||
11 231212 + + 11
|
||||
12 112232 , , 12
|
||||
13 122132 - - 13
|
||||
14 122231 . . 14
|
||||
15 113222 / / 15
|
||||
16 123122 0 0 16
|
||||
17 123221 1 1 17
|
||||
18 223211 2 2 18
|
||||
19 221132 3 3 19
|
||||
20 221231 4 4 20
|
||||
21 213212 5 5 21
|
||||
22 223112 6 6 22
|
||||
23 312131 7 7 23
|
||||
24 311222 8 8 24
|
||||
25 321122 9 9 25
|
||||
26 321221 : : 26
|
||||
27 312212 ; ; 27
|
||||
28 322112 < < 28
|
||||
29 322211 = = 29
|
||||
30 212123 > > 30
|
||||
31 212321 ? ? 31
|
||||
32 232121 @ @ 32
|
||||
33 111323 A A 33
|
||||
34 131123 B B 34
|
||||
35 131321 C C 35
|
||||
36 112313 D D 36
|
||||
37 132113 E E 37
|
||||
38 132311 F F 38
|
||||
39 211313 G G 39
|
||||
40 231113 H H 40
|
||||
41 231311 I I 41
|
||||
42 112133 J J 42
|
||||
43 112331 K K 43
|
||||
44 132131 L L 44
|
||||
45 113123 M M 45
|
||||
46 113321 N N 46
|
||||
47 133121 O O 47
|
||||
48 313121 P P 48
|
||||
49 211331 Q Q 49
|
||||
50 231131 R R 50
|
||||
51 213113 S S 51
|
||||
52 213311 T T 52
|
||||
53 213131 U U 53
|
||||
54 311123 V V 54
|
||||
55 311321 W W 55
|
||||
56 331121 X X 56
|
||||
57 312113 Y Y 57
|
||||
58 312311 Z Z 58
|
||||
59 332111 [ [ 59
|
||||
60 314111 \ \ 60
|
||||
61 221411 ] ] 61
|
||||
62 431111 ^ ^ 62
|
||||
63 111224 _ _ 63
|
||||
64 111422 NUL ` 64
|
||||
65 121124 SOH a 65
|
||||
66 121421 STX b 66
|
||||
67 141122 ETX c 67
|
||||
68 141221 EOT d 68
|
||||
69 112214 ENQ e 69
|
||||
70 112412 ACK f 70
|
||||
71 122114 BEL g 71
|
||||
72 122411 BS h 72
|
||||
73 142112 HT i 73
|
||||
74 142211 LF j 74
|
||||
75 241211 VT k 75
|
||||
76 221114 FF l 76
|
||||
77 413111 CR m 77
|
||||
78 241112 SO n 78
|
||||
79 134111 SI o 79
|
||||
80 111242 DLE p 80
|
||||
81 121142 DC1 q 81
|
||||
82 121241 DC2 r 82
|
||||
83 114212 DC3 s 83
|
||||
84 124112 DC4 t 84
|
||||
85 124211 NAK u 85
|
||||
86 411212 SYN v 86
|
||||
87 421112 ETB w 87
|
||||
88 421211 CAN x 88
|
||||
89 212141 EM y 89
|
||||
90 214121 SUB z 90
|
||||
91 412121 ESC { 91
|
||||
92 111143 FS | 92
|
||||
93 111341 GS } 93
|
||||
94 131141 RS ~ 94
|
||||
95 114113 US DEL 95
|
||||
96 114311 FNC3 FNC3 96
|
||||
97 411113 FNC2 FNC2 97
|
||||
98 411311 ShiftB ShiftA 98
|
||||
99 113141 CodeC CodeC 99
|
||||
100 114131 CodeB FNC4 CodeB
|
||||
101 311141 FNC4 CodeA CodeA
|
||||
102 411131 FNC1 FNC1 FNC1
|
||||
103 211412 StartA StartA StartA
|
||||
104 211214 StartB StartB StartB
|
||||
105 211232 StartC StartC StartC
|
||||
106 2331112 Stop Stop Stop
|
||||
""".split()
|
||||
|
||||
VALUES = [int(value) for value in CODE128_CHART[0::5]]
|
||||
WEIGHTS = dict(zip(VALUES, CODE128_CHART[1::5]))
|
||||
CODE128A = dict(zip(CODE128_CHART[2::5], VALUES))
|
||||
CODE128B = dict(zip(CODE128_CHART[3::5], VALUES))
|
||||
CODE128C = dict(zip(CODE128_CHART[4::5], VALUES))
|
||||
|
||||
for charset in (CODE128A, CODE128B):
|
||||
charset[' '] = charset.pop('space')
|
||||
|
||||
|
||||
|
||||
def generate_code(data, show=False, check=False):
|
||||
|
||||
#img = code128_image(data)
|
||||
img = qr_image(data)
|
||||
if show:
|
||||
img.show()
|
||||
#img.show()
|
||||
#print(data)
|
||||
|
||||
if(check):
|
||||
from pyzbar.pyzbar import decode
|
||||
from pyzbar.pyzbar import ZBarSymbol
|
||||
print(decode(img, symbols=[ZBarSymbol.CODE128])[0].data.decode('ascii'))
|
||||
|
||||
#if(decode(img, symbols=[ZBarSymbol.CODE128])[0].data.decode('ascii') == data):
|
||||
# return True
|
||||
#else:
|
||||
# return False
|
||||
return img
|
||||
|
||||
def code128_format(data):
|
||||
"""
|
||||
Generate an optimal barcode from ASCII text
|
||||
"""
|
||||
text = str(data)
|
||||
pos = 0
|
||||
length = len(text)
|
||||
|
||||
# Start Code
|
||||
if text[:2].isdigit():
|
||||
charset = CODE128C
|
||||
codes = [charset['StartC']]
|
||||
else:
|
||||
charset = CODE128B
|
||||
codes = [charset['StartB']]
|
||||
|
||||
# Data
|
||||
while pos < length:
|
||||
if charset is CODE128C:
|
||||
if text[pos:pos+2].isdigit() and length - pos > 1:
|
||||
# Encode Code C two characters at a time
|
||||
codes.append(int(text[pos:pos+2]))
|
||||
pos += 2
|
||||
else:
|
||||
# Switch to Code B
|
||||
codes.append(charset['CodeB'])
|
||||
charset = CODE128B
|
||||
elif text[pos:pos+4].isdigit() and length - pos >= 4:
|
||||
# Switch to Code C
|
||||
codes.append(charset['CodeC'])
|
||||
charset = CODE128C
|
||||
else:
|
||||
# Encode Code B one character at a time
|
||||
codes.append(charset[text[pos]])
|
||||
pos += 1
|
||||
|
||||
# Checksum
|
||||
checksum = 0
|
||||
for weight, code in enumerate(codes):
|
||||
checksum += max(weight, 1) * code
|
||||
codes.append(checksum % 103)
|
||||
|
||||
# Stop Code
|
||||
codes.append(charset['Stop'])
|
||||
return codes
|
||||
|
||||
def code128_image(data, height=100, thickness=3, quiet_zone=False):
|
||||
partnum = data
|
||||
if not data[-1] == CODE128B['Stop']:
|
||||
data = code128_format(data)
|
||||
|
||||
|
||||
barcode_widths = []
|
||||
for code in data:
|
||||
for weight in WEIGHTS[code]:
|
||||
barcode_widths.append(int(weight) * thickness)
|
||||
width = sum(barcode_widths)
|
||||
x = 0
|
||||
|
||||
|
||||
if quiet_zone:
|
||||
width += 20 * thickness
|
||||
x = 10 * thickness
|
||||
|
||||
# Monochrome Image
|
||||
img = Image.new('RGB', (int(width * 10), int(width * 10)), 'white')
|
||||
draw = ImageDraw.Draw(img)
|
||||
draw_bar = True
|
||||
for bwidth in barcode_widths:
|
||||
bwidth *= 4
|
||||
if draw_bar:
|
||||
draw.rectangle(((x + int(width * 3), width*6.25), (x + int(width * 3) + bwidth - 1, width*7)), fill='black')
|
||||
draw_bar = not draw_bar
|
||||
x += bwidth
|
||||
|
||||
#draw.arc(((width - width/5, width - width/5), (width*9 + width/5, width*9 + width/5)),0,360,fill='blue', width = int(width/8))
|
||||
draw.arc(((width+int(width / 1.4), width+int(width / 1.4)), (width*9-int(width / 1.4), width*9-int(width / 1.4))),0,360,fill='blue', width = int(width/8))
|
||||
font_path = find_data_file("OCRAEXT.TTF")
|
||||
font_size = width/2
|
||||
font = ImageFont.truetype(font_path, font_size)
|
||||
text_width = font.getlength(partnum)
|
||||
while text_width > width*4:
|
||||
font_size -= 1
|
||||
font = ImageFont.truetype(font_path, font_size)
|
||||
text_width = font.getlength(partnum)
|
||||
|
||||
txtx = (int(width * 10) - text_width) / 2
|
||||
txty = (int(width * 10)) / 2 + width / 2
|
||||
|
||||
draw.text((txtx,txty),partnum, "black", font)
|
||||
return img
|
||||
|
||||
def qr_image(data, width=600):
|
||||
partnum = data
|
||||
|
||||
|
||||
|
||||
# Monochrome Image
|
||||
img = Image.new('RGB', (int(width * 10), int(width * 10)), 'white')
|
||||
draw = ImageDraw.Draw(img)
|
||||
|
||||
|
||||
|
||||
#svg_path = find_data_file("belden-logo.svg")
|
||||
#with open(svg_path, 'rb') as svg_file:
|
||||
# png_image = cairosvg.svg2png(file_obj=svg_file,dpi=width*30, scale=30, background_color="white")
|
||||
#with open("output.png", 'wb') as file:
|
||||
# file.write(png_image)
|
||||
|
||||
png_image_io = "belden-logo-superhires.png"
|
||||
png_image_pillow = Image.open(png_image_io)
|
||||
png_width, png_height = png_image_pillow.size
|
||||
png_image_pillow = png_image_pillow.resize((int(width*5.2), int(width*5.2/png_width*png_height)))
|
||||
png_width, png_height = png_image_pillow.size
|
||||
# paste belden logo first because it has a big border that would cover stuff up
|
||||
img.paste(png_image_pillow, (int(width*5-png_width/2), int(width*4.25 - png_height/2)))
|
||||
|
||||
# draw circle border
|
||||
#draw.arc(((width - width/5, width - width/5), (width*9 + width/5, width*9 + width/5)),0,360,fill='blue', width = int(width/8))
|
||||
draw.arc(((width+int(width / 1.4), width+int(width / 1.4)), (width*9-int(width / 1.4), width*9-int(width / 1.4))),0,360,fill=(0, 73,144), width = int(width/8))
|
||||
|
||||
font_path = find_data_file("GothamCond-Medium.otf")
|
||||
font_size = width/2
|
||||
font = ImageFont.truetype(font_path, font_size)
|
||||
text_width = font.getlength(partnum[2:])
|
||||
# shrink font dynamically if it's too long of a name
|
||||
while text_width > width*4:
|
||||
font_size -= 1
|
||||
font = ImageFont.truetype(font_path, font_size)
|
||||
text_width = font.getlength(partnum[2:])
|
||||
|
||||
txtx = (int(width * 10) - text_width) / 2
|
||||
txty = (int(width * 10)) / 2
|
||||
# draw part number text
|
||||
draw.text((txtx,txty),partnum[2:], "black", font)
|
||||
|
||||
# Draw QR code
|
||||
partnum = partnum.replace(" ", "%20")
|
||||
qrcode = segno.make('HTTPS://BLDN.APP/' + partnum,micro=False,boost_error=False,error="L",mask=3)
|
||||
out = io.BytesIO()
|
||||
qrx, _ = qrcode.symbol_size(1,0)
|
||||
qrcode.save(out, scale=width*2/qrx, kind="PNG", border=0)
|
||||
qrimg = Image.open(out)
|
||||
img.paste(qrimg, box=(int(width*4),int(width*5.75)))
|
||||
|
||||
|
||||
return img
|
||||
|
||||
if __name__ == "__main__":
|
||||
#print(generate_code("BL10GXS13"))
|
||||
#print(generate_code("BL10GXgd35j35S13"))
|
||||
#print(generate_code("BL10GX54hS13"))
|
||||
#print(generate_code("BL10Gj34qXS13", False, False))
|
||||
#print(generate_code("BL104w5545dp7bfwp43643534/4563G-XS13"))
|
||||
#adjust_image(cv2.imread('test_skew.jpg'))
|
||||
path = "labels"
|
||||
img = generate_code("BL10GXS13")
|
||||
import os
|
||||
os.makedirs(path, exist_ok=True)
|
||||
img.save(path + "/" + "BL10GXS13" + ".png")
|
||||
578
led_control.py
578
led_control.py
@ -14,24 +14,32 @@ import cv2
|
||||
import numpy as np
|
||||
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.
|
||||
|
||||
# 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
|
||||
|
||||
def map():
|
||||
global config
|
||||
global leds
|
||||
global leds_size
|
||||
global leds_normalized
|
||||
global controllers
|
||||
global rings
|
||||
global ringstatus
|
||||
global animation_time
|
||||
|
||||
def map(self):
|
||||
|
||||
with open('config.yml', 'r') as fileread:
|
||||
#global config
|
||||
config = yaml.safe_load(fileread)
|
||||
self.config = yaml.safe_load(fileread)
|
||||
|
||||
animation_time = config["animation_time"]
|
||||
leds = list()
|
||||
leds_size = list()
|
||||
controllers = list()
|
||||
rings = list(range(len(config["position_map"])))
|
||||
ringstatus = list(range(len(config["position_map"])))
|
||||
self.animation_time = self.config["animation_time"]
|
||||
self.leds = list()
|
||||
self.leds_size = list()
|
||||
self.controllers = list()
|
||||
self.rings = list(range(len(self.config["position_map"])))
|
||||
self.ringstatus = list(range(len(self.config["position_map"])))
|
||||
#print(rings)
|
||||
#fprint(config["led"]["map"])
|
||||
generate_map = False
|
||||
map = list()
|
||||
for shape in config["led"]["map"]:
|
||||
for shape in self.config["led"]["map"]:
|
||||
if shape["type"] == "circle":
|
||||
|
||||
if generate_map:
|
||||
@ -84,22 +83,22 @@ def map():
|
||||
angle = 0
|
||||
radius = shape["diameter"] / 2
|
||||
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
|
||||
#print(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
|
||||
ringstatus[item["index"]] = [None, None]
|
||||
self.rings[item["index"]] = (shape["pos"][1],shape["pos"][0],lednum,lednum+shape["size"]) # rings[index] = x, y, startpos, endpos
|
||||
self.ringstatus[item["index"]] = [None, None]
|
||||
break
|
||||
if len(leds) < lednum + shape["size"]:
|
||||
for x in range(lednum + shape["size"] - len(leds)):
|
||||
leds.append(None)
|
||||
leds_size.append(None)
|
||||
if len(self.leds) < lednum + shape["size"]:
|
||||
for x in range(lednum + shape["size"] - len(self.leds)):
|
||||
self.leds.append(None)
|
||||
self.leds_size.append(None)
|
||||
while angle < 359.999:
|
||||
tmpangle = angle + shape["angle"]
|
||||
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]
|
||||
leds[lednum] = (x,y)
|
||||
self.leds[lednum] = (x,y)
|
||||
lednum = lednum + 1
|
||||
angle = angle + anglediv
|
||||
|
||||
@ -112,13 +111,13 @@ def map():
|
||||
xmov = math.cos(angle * (math.pi / 180.0)) * distdiv
|
||||
ymov = math.sin(angle * (math.pi / 180.0)) * distdiv
|
||||
pos = shape["pos"]
|
||||
if len(leds) < lednum + shape["size"]:
|
||||
for x in range(lednum + shape["size"] - len(leds)):
|
||||
leds.append(None)
|
||||
leds_size.append(None)
|
||||
if len(self.leds) < lednum + shape["size"]:
|
||||
for x in range(lednum + shape["size"] - len(self.leds)):
|
||||
self.leds.append(None)
|
||||
self.leds_size.append(None)
|
||||
|
||||
while dist < length:
|
||||
leds[lednum] = (pos[0], pos[1])
|
||||
self.leds[lednum] = (pos[0], pos[1])
|
||||
pos[0] += xmov
|
||||
pos[1] += ymov
|
||||
dist += distdiv
|
||||
@ -140,276 +139,262 @@ def map():
|
||||
yaml_str = yaml.dump(data, default_flow_style=False)
|
||||
print(yaml_str)
|
||||
|
||||
print(rings)
|
||||
print(self.rings)
|
||||
flag = 0
|
||||
for x in leds:
|
||||
for x in self.leds:
|
||||
if x is None:
|
||||
flag = flag + 1
|
||||
if flag > 0:
|
||||
fprint("Warning: Imperfect LED map ordering. Hiding undefined lights.")
|
||||
for x in range(len(leds)):
|
||||
if leds[x] is None:
|
||||
leds[x] = (0, 0)
|
||||
for x in range(len(self.leds)):
|
||||
if self.leds[x] is None:
|
||||
self.leds[x] = (0, 0)
|
||||
|
||||
|
||||
#leds = tmpleds.reverse()
|
||||
#fprint(leds)
|
||||
|
||||
# controller mapping
|
||||
for ctrl in config["led"]["controllers"]:
|
||||
if len(controllers) < ctrl["universe"]+1:
|
||||
for x in range(ctrl["universe"]+1 - len(controllers)):
|
||||
controllers.append(None)
|
||||
for ctrl in self.config["led"]["controllers"]:
|
||||
if len(self.controllers) < ctrl["universe"]+1:
|
||||
for x in range(ctrl["universe"]+1 - len(self.controllers)):
|
||||
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):
|
||||
leds_size[x] = len(ctrl["mode"])
|
||||
self.leds_size[x] = len(ctrl["mode"])
|
||||
#fprint(controllers)
|
||||
|
||||
if(debug):
|
||||
if(self.debug):
|
||||
import matplotlib.pyplot as plt
|
||||
plt.axis('equal')
|
||||
for ctrl in controllers:
|
||||
plt.scatter(*zip(*leds[ctrl[0]:ctrl[1]]), s=2)
|
||||
for ctrl in self.controllers:
|
||||
plt.scatter(*zip(*self.leds[ctrl[0]:ctrl[1]]), s=2)
|
||||
#plt.scatter(*zip(*leds), s=3)
|
||||
plt.savefig("map.png", dpi=600, bbox_inches="tight")
|
||||
|
||||
leds_adj = [(x-min([led[0] for led in leds]), # push to zero start
|
||||
y-min([led[1] for led in leds]) )
|
||||
for x, y in leds]
|
||||
leds_adj = [(x-min([led[0] for led in self.leds]), # push to zero start
|
||||
y-min([led[1] for led in self.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]))
|
||||
for x, y in leds_adj]
|
||||
#return leds, controllers
|
||||
|
||||
def init():
|
||||
map()
|
||||
global sender
|
||||
global config
|
||||
global leds
|
||||
global leds_size
|
||||
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="")
|
||||
def init(self):
|
||||
self.map()
|
||||
self.sender = sacn.sACNsender(fps=self.config["led"]["fps"], universeDiscovery=False)
|
||||
self.sender.start() # start the sending thread
|
||||
"""for x in range(len(self.controllers)):
|
||||
print("Waiting for the controller at", self.controllers[x][2], "to be online...", end="")
|
||||
count = 0
|
||||
while not ping(controllers[x][2]):
|
||||
while not ping(self.controllers[x][2]):
|
||||
count = count + 1
|
||||
if count >= config["led"]["timeout"]:
|
||||
if count >= self.config["led"]["timeout"]:
|
||||
fprint(" ERROR: controller still offline after " + str(count) + " seconds, continuing...")
|
||||
break
|
||||
if count < config["led"]["timeout"]:
|
||||
if count < self.config["led"]["timeout"]:
|
||||
fprint(" done")"""
|
||||
for x in range(len(controllers)):
|
||||
print("Activating controller", x, "at", controllers[x][2], "with", controllers[x][1]-controllers[x][0], "LEDs.")
|
||||
sender.activate_output(x+1) # start sending out data
|
||||
sender[x+1].destination = controllers[x][2]
|
||||
sender.manual_flush = True
|
||||
for x in range(len(self.controllers)):
|
||||
print("Activating controller", x, "at", self.controllers[x][2], "with", self.controllers[x][1]-self.controllers[x][0], "LEDs.")
|
||||
self.sender.activate_output(x+1) # start sending out data
|
||||
self.sender[x+1].destination = self.controllers[x][2]
|
||||
self.sender.manual_flush = True
|
||||
|
||||
# initialize global pixel data list
|
||||
data = list()
|
||||
exactdata = list()
|
||||
for x in range(len(leds)):
|
||||
if leds_size[x] == 3:
|
||||
exactdata.append(None)
|
||||
data.append((20,20,127))
|
||||
elif leds_size[x] == 4:
|
||||
exactdata.append(None)
|
||||
data.append((50,50,255,0))
|
||||
self.data = list()
|
||||
self.exactdata = list()
|
||||
for x in range(len(self.leds)):
|
||||
if self.leds_size[x] == 3:
|
||||
self.exactdata.append(None)
|
||||
self.data.append((20,20,127))
|
||||
elif self.leds_size[x] == 4:
|
||||
self.exactdata.append(None)
|
||||
self.data.append((50,50,255,0))
|
||||
else:
|
||||
exactdata.append(None)
|
||||
data.append((0,0,0))
|
||||
sendall(data)
|
||||
self.exactdata.append(None)
|
||||
self.data.append((0,0,0))
|
||||
self.sendall(self.data)
|
||||
#time.sleep(50000)
|
||||
fprint("Running start-up test sequence...")
|
||||
for y in range(1):
|
||||
for x in range(len(leds)):
|
||||
setpixel(0,60,144,x)
|
||||
sendall(data)
|
||||
for x in range(len(self.leds)):
|
||||
self.setpixel(0,60,144,x)
|
||||
self.sendall(self.data)
|
||||
#time.sleep(2)
|
||||
alloffsmooth()
|
||||
self.alloffsmooth()
|
||||
|
||||
def sendall(datain):
|
||||
def sendall(self, datain):
|
||||
# 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
|
||||
global controllers
|
||||
global sender
|
||||
sender.manual_flush = True
|
||||
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
|
||||
self.sender.manual_flush = True
|
||||
for x in range(len(self.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
|
||||
|
||||
sender.flush()
|
||||
self.sender.flush()
|
||||
time.sleep(0.002)
|
||||
#sender.flush() # 100% reliable with 2 flushes, often fails with 1
|
||||
#time.sleep(0.002)
|
||||
#sender.flush()
|
||||
|
||||
def fastsendall(datain):
|
||||
def fastsendall(self, datain):
|
||||
# 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
|
||||
global controllers
|
||||
global sender
|
||||
sender.manual_flush = False
|
||||
print(datain[controllers[0][0]:controllers[0][1]])
|
||||
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
|
||||
self.sender.manual_flush = False
|
||||
print(datain[self.controllers[0][0]:self.controllers[0][1]])
|
||||
for x in range(len(self.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
|
||||
|
||||
sender.flush()
|
||||
self.sender.flush()
|
||||
|
||||
def senduniverse(datain, lednum):
|
||||
def senduniverse(self, datain, lednum):
|
||||
# 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
|
||||
global controllers
|
||||
global sender
|
||||
for x in range(len(controllers)):
|
||||
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
|
||||
for x in range(len(self.controllers)):
|
||||
if lednum >= self.controllers[x][0] and lednum < self.controllers[x][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
|
||||
|
||||
sender.flush()
|
||||
self.sender.flush()
|
||||
time.sleep(0.004)
|
||||
#sender.flush() # 100% reliable with 2 flushes, often fails with 1
|
||||
#time.sleep(0.002)
|
||||
#sender.flush()
|
||||
|
||||
def alloff():
|
||||
def alloff(self):
|
||||
tmpdata = list()
|
||||
for x in range(len(leds)):
|
||||
if leds_size[x] == 3:
|
||||
for x in range(len(self.leds)):
|
||||
if self.leds_size[x] == 3:
|
||||
tmpdata.append((0,0,0))
|
||||
elif leds_size[x] == 4:
|
||||
elif self.leds_size[x] == 4:
|
||||
tmpdata.append((0,0,0,0))
|
||||
else:
|
||||
tmpdata.append((0,0,0))
|
||||
sendall(tmpdata)
|
||||
self.sendall(tmpdata)
|
||||
#sendall(tmpdata)
|
||||
#sendall(tmpdata) #definitely make sure it's off
|
||||
return self
|
||||
|
||||
def allon():
|
||||
global data
|
||||
sendall(data)
|
||||
def allon(self):
|
||||
self.sendall(self.data)
|
||||
return self
|
||||
|
||||
def alloffsmooth():
|
||||
tmpdata = data
|
||||
def alloffsmooth(self):
|
||||
tmpdata = self.data
|
||||
for x in range(256):
|
||||
for x in range(len(data)):
|
||||
setpixel(tmpdata[x][0]-1,tmpdata[x][1]-1,tmpdata[x][2]-1, x)
|
||||
sendall(tmpdata)
|
||||
for x in range(len(self.data)):
|
||||
self.setpixel(tmpdata[x][0]-1,tmpdata[x][1]-1,tmpdata[x][2]-1, x)
|
||||
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
|
||||
# unfortunately no way to manual flush data packets to only 1 controller with this sACN library
|
||||
global data
|
||||
setpixel(r,g,b,num)
|
||||
senduniverse(data, num)
|
||||
self.setpixel(r,g,b,num)
|
||||
self.senduniverse(self.data, num)
|
||||
return self
|
||||
|
||||
def setmode(stmode, r=0,g=0,b=0):
|
||||
global mode
|
||||
global firstrun
|
||||
def setmode(self, stmode, r=0,g=0,b=0):
|
||||
if stmode is not None:
|
||||
if mode != stmode:
|
||||
firstrun = True
|
||||
if self.mode != stmode:
|
||||
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]):
|
||||
setpixel(r,g,b,pixel)
|
||||
self.setpixel(r,g,b,pixel)
|
||||
#global data
|
||||
#senduniverse(data, ring[2])
|
||||
return self
|
||||
|
||||
def runmodes(ring = -1, speed = 1):
|
||||
global mode
|
||||
global firstrun
|
||||
global changecount
|
||||
fprint("Mode: " + str(mode))
|
||||
if mode == "Startup":
|
||||
def runmodes(self, ring = -1, speed = 1):
|
||||
fprint("Mode: " + str(self.mode))
|
||||
if self.mode == "Startup":
|
||||
# loading animation. cable check
|
||||
if firstrun:
|
||||
changecount = animation_time * 3
|
||||
if self.firstrun:
|
||||
self.changecount = self.animation_time * 3
|
||||
firstrun = False
|
||||
for x in range(len(ringstatus)):
|
||||
ringstatus[x] = [True, animation_time]
|
||||
for x in range(len(self.ringstatus)):
|
||||
self.ringstatus[x] = [True, self.animation_time]
|
||||
|
||||
if changecount > 0:
|
||||
fprint(changecount)
|
||||
changecount = fadeorder(0,len(leds), changecount, 0,50,100)
|
||||
if self.changecount > 0:
|
||||
fprint(self.changecount)
|
||||
self.changecount = self.fadeorder(0,len(self.leds), self.changecount, 0,50,100)
|
||||
else:
|
||||
setmode("Startup2")
|
||||
self.setmode("Startup2")
|
||||
|
||||
|
||||
elif mode == "Startup2":
|
||||
if firstrun:
|
||||
firstrun = False
|
||||
elif self.mode == "Startup2":
|
||||
if self.firstrun:
|
||||
self.firstrun = False
|
||||
|
||||
else:
|
||||
for x in range(len(ringstatus)):
|
||||
if ringstatus[x][0]:
|
||||
setring(0, 50, 100, x)
|
||||
for x in range(len(self.ringstatus)):
|
||||
if self.ringstatus[x][0]:
|
||||
self.setring(0, 50, 100, x)
|
||||
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":
|
||||
if firstrun:
|
||||
firstrun = False
|
||||
for x in range(len(ringstatus)):
|
||||
ringstatus[x] = [False, animation_time]
|
||||
elif self.mode == "StartupCheck":
|
||||
if self.firstrun:
|
||||
self.firstrun = False
|
||||
for x in range(len(self.ringstatus)):
|
||||
self.ringstatus[x] = [False, self.animation_time]
|
||||
else:
|
||||
for x in range(len(ringstatus)):
|
||||
if ringstatus[x][0]:
|
||||
ringstatus[x][1] = fadeall(rings[x][2],rings[x][3], ringstatus[x][1], 0,50,100) # ready
|
||||
for x in range(len(self.ringstatus)):
|
||||
if self.ringstatus[x][0]:
|
||||
self.ringstatus[x][1] = self.fadeall(self.rings[x][2],self.rings[x][3], self.ringstatus[x][1], 0,50,100) # ready
|
||||
else:
|
||||
setring(100, 0, 0, x)
|
||||
self.setring(100, 0, 0, x)
|
||||
|
||||
elif mode == "GrabA":
|
||||
if firstrun:
|
||||
firstrun = False
|
||||
changecount = animation_time # 100hz
|
||||
if changecount > 0:
|
||||
changecount = fadeall(rings[ring][2],rings[ring][3], changecount, 100,0,0)
|
||||
elif self.mode == "GrabA":
|
||||
if self.firstrun:
|
||||
self.firstrun = False
|
||||
self.changecount = self.animation_time # 100hz
|
||||
if self.changecount > 0:
|
||||
self.changecount = self.fadeall(self.rings[ring][2],self.rings[ring][3], self.changecount, 100,0,0)
|
||||
else:
|
||||
setring(100,0,0,ring)
|
||||
setmode("GrabB")
|
||||
elif mode == "GrabB":
|
||||
if firstrun:
|
||||
firstrun = False
|
||||
changecount = animation_time # 100hz
|
||||
if changecount > 0:
|
||||
changecount = fadeorder(rings[ring][2],rings[ring][3], changecount, 0,100,0)
|
||||
self.setring(100,0,0,ring)
|
||||
self.setmode("GrabB")
|
||||
elif self.mode == "GrabB":
|
||||
if self.firstrun:
|
||||
self.firstrun = False
|
||||
self.changecount = self.animation_time # 100hz
|
||||
if self.changecount > 0:
|
||||
self.changecount = self.fadeorder(self.rings[ring][2],self.rings[ring][3], self.changecount, 0,100,0)
|
||||
else:
|
||||
setring(0,100,0,ring)
|
||||
setmode("idle")
|
||||
elif mode == "GrabC":
|
||||
if firstrun:
|
||||
firstrun = False
|
||||
changecount = animation_time # 100hz
|
||||
if changecount > 0:
|
||||
changecount = fadeall(rings[ring][2],rings[ring][3], changecount, 0,50,100)
|
||||
self.setring(0,100,0,ring)
|
||||
self.setmode("idle")
|
||||
elif self.mode == "GrabC":
|
||||
if self.firstrun:
|
||||
self.firstrun = False
|
||||
self.changecount = self.animation_time # 100hz
|
||||
if self.changecount > 0:
|
||||
self.changecount = self.fadeall(self.rings[ring][2],self.rings[ring][3], self.changecount, 0,50,100)
|
||||
else:
|
||||
setring(0,50,100,ring)
|
||||
setmode("idle")
|
||||
elif mode == "idle":
|
||||
self.setring(0,50,100,ring)
|
||||
self.setmode("idle")
|
||||
elif self.mode == "idle":
|
||||
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:
|
||||
return 0
|
||||
global exactdata
|
||||
sum = 0
|
||||
for x in range(idxa,idxb):
|
||||
if exactdata[x] is None:
|
||||
exactdata[x] = data[x]
|
||||
old = exactdata[x]
|
||||
if self.exactdata[x] is None:
|
||||
self.exactdata[x] = self.data[x]
|
||||
old = self.exactdata[x]
|
||||
dr = (r - old[0])/sizerem
|
||||
sum += abs(dr)
|
||||
dr += old[0]
|
||||
@ -419,27 +404,26 @@ def fadeall(idxa,idxb,sizerem,r,g,b):
|
||||
db = (b - old[2])/sizerem
|
||||
db += old[2]
|
||||
sum += abs(db)
|
||||
exactdata[x] = (dr, dg, db)
|
||||
self.exactdata[x] = (dr, dg, db)
|
||||
#print(new)
|
||||
setpixel(dr, dg, db, x)
|
||||
self.setpixel(dr, dg, db, x)
|
||||
if sizerem == 1:
|
||||
exactdata[x] = None
|
||||
self.exactdata[x] = None
|
||||
if sum == 0 and sizerem > 2:
|
||||
sizerem = 2
|
||||
return sizerem - 1
|
||||
|
||||
def fadeorder(idxa,idxb,sizerem,r,g,b):
|
||||
def fadeorder(self, idxa,idxb,sizerem,r,g,b):
|
||||
if sizerem < 1:
|
||||
return 0
|
||||
global exactdata
|
||||
drs = 0
|
||||
dgs = 0
|
||||
dbs = 0
|
||||
sum = 0
|
||||
for x in range(idxa,idxb):
|
||||
if exactdata[x] is None:
|
||||
exactdata[x] = data[x]
|
||||
old = exactdata[x]
|
||||
if self.exactdata[x] is None:
|
||||
self.exactdata[x] = self.data[x]
|
||||
old = self.exactdata[x]
|
||||
dr = (r - old[0])
|
||||
dg = (g - old[1])
|
||||
db = (b - old[2])
|
||||
@ -453,7 +437,7 @@ def fadeorder(idxa,idxb,sizerem,r,g,b):
|
||||
sum += abs(drs) + abs(dgs) + abs(dbs)
|
||||
print(drs,dgs,dbs)
|
||||
for x in range(idxa,idxb):
|
||||
old = exactdata[x]
|
||||
old = self.exactdata[x]
|
||||
new = list(old)
|
||||
if drs > 0:
|
||||
if old[0] + drs > r:
|
||||
@ -500,20 +484,18 @@ def fadeorder(idxa,idxb,sizerem,r,g,b):
|
||||
dbs = 0
|
||||
|
||||
if drs != 0 or dgs != 0 or dbs != 0:
|
||||
exactdata[x] = new
|
||||
setpixel(new[0],new[1],new[2],x)
|
||||
self.exactdata[x] = new
|
||||
self.setpixel(new[0],new[1],new[2],x)
|
||||
|
||||
if sizerem == 1:
|
||||
exactdata[x] = None
|
||||
self.exactdata[x] = None
|
||||
|
||||
if sum == 0 and sizerem > 2:
|
||||
sizerem = 2
|
||||
return sizerem - 1
|
||||
|
||||
|
||||
def setpixel(r, g, b, num):
|
||||
global data
|
||||
global leds_size
|
||||
def setpixel(self, r, g, b, num):
|
||||
# constrain values
|
||||
if r < 0:
|
||||
r = 0
|
||||
@ -528,29 +510,28 @@ def setpixel(r, g, b, num):
|
||||
elif b > 255:
|
||||
b = 255
|
||||
|
||||
if leds_size[num] == 3:
|
||||
data[num] = (int(r), int(g), int(b))
|
||||
elif 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))) )
|
||||
if self.leds_size[num] == 3:
|
||||
self.data[num] = (int(r), int(g), int(b))
|
||||
elif self.leds_size[num] == 4: # cut out matching white and turn on white pixel instead
|
||||
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:
|
||||
data[num] = (int(r), int(g), int(b))
|
||||
self.data[num] = (int(r), int(g), int(b))
|
||||
return self
|
||||
|
||||
|
||||
def close():
|
||||
global sender
|
||||
def close(self):
|
||||
time.sleep(0.5)
|
||||
sender.stop()
|
||||
self.sender.stop()
|
||||
return self
|
||||
|
||||
def mapimage(image, fps=90):
|
||||
global start
|
||||
while uptime() - start < 1/fps:
|
||||
def mapimage(self, image, fps=90):
|
||||
while uptime() - self.start < 1/fps:
|
||||
time.sleep(0.00001)
|
||||
fprint(1 / (uptime() - start))
|
||||
start = uptime()
|
||||
fprint(1 / (uptime() - self.start))
|
||||
self.start = uptime()
|
||||
minsize = min(image.shape[0:2])
|
||||
leds_normalized2 = [(x * minsize,
|
||||
y * minsize)
|
||||
for x, y in leds_normalized]
|
||||
for x, y in self.leds_normalized]
|
||||
|
||||
cv2.imshow("video", image)
|
||||
cv2.waitKey(1)
|
||||
@ -567,39 +548,39 @@ def mapimage(image, fps=90):
|
||||
#avgx += x
|
||||
#avgy += y
|
||||
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)
|
||||
else:
|
||||
#avgx += x
|
||||
#avgy += y
|
||||
setpixel(0,0,0,xx)
|
||||
self.setpixel(0,0,0,xx)
|
||||
#avgx /= 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]) ))
|
||||
global data
|
||||
fastsendall(data)
|
||||
self.fastsendall(self.data)
|
||||
return self
|
||||
|
||||
def mainloop(stmode, ring = -1, fps = 100, preview = False):
|
||||
global start
|
||||
while uptime() - start < 1/fps:
|
||||
def mainloop(self, stmode, ring = -1, fps = 100, preview = False):
|
||||
while uptime() - self.start < 1/fps:
|
||||
time.sleep(0.00001)
|
||||
fprint(1 / (uptime() - start))
|
||||
start = uptime()
|
||||
if mode is not None:
|
||||
setmode(stmode)
|
||||
runmodes(ring)
|
||||
fprint(1 / (uptime() - self.start))
|
||||
self.start = uptime()
|
||||
if self.mode is not None:
|
||||
self.setmode(stmode)
|
||||
self.runmodes(ring)
|
||||
if preview:
|
||||
drawdata()
|
||||
self.drawdata()
|
||||
return self
|
||||
|
||||
def drawdata():
|
||||
def drawdata(self):
|
||||
#tmp = list()
|
||||
#for x in len(leds):
|
||||
# led = leds[x]
|
||||
# tmp.append((led[0], led[1], data[x]))
|
||||
|
||||
x = [led[0] for led in leds]
|
||||
y = [led[1] for led in leds]
|
||||
colors = data
|
||||
x = [led[0] for led in self.leds]
|
||||
y = [led[1] for led in self.leds]
|
||||
colors = self.data
|
||||
colors_normalized = [(x[0]/255, x[1]/255, x[2]/255) for x in colors]
|
||||
# Plot the points
|
||||
plt.scatter(x, y, c=colors_normalized)
|
||||
@ -612,42 +593,48 @@ def drawdata():
|
||||
plt.show()
|
||||
plt.savefig("map3.png", dpi=50, bbox_inches="tight")
|
||||
plt.clf()
|
||||
return self
|
||||
|
||||
def startup_animation(show):
|
||||
def startup_animation(self, show):
|
||||
|
||||
|
||||
stmode = "Startup"
|
||||
mainloop(stmode, preview=show)
|
||||
while mode == "Startup":
|
||||
mainloop(None, preview=show)
|
||||
self.mainloop(stmode, preview=show)
|
||||
while self.mode == "Startup":
|
||||
self.mainloop(None, preview=show)
|
||||
for x in range(54):
|
||||
ringstatus[x][0] = False
|
||||
mainloop(None, preview=show)
|
||||
self.ringstatus[x][0] = False
|
||||
self.mainloop(None, preview=show)
|
||||
|
||||
for x in range(animation_time):
|
||||
mainloop(None, preview=show)
|
||||
clear_animations()
|
||||
for x in range(self.animation_time):
|
||||
self.mainloop(None, preview=show)
|
||||
self.clear_animations()
|
||||
stmode = "StartupCheck"
|
||||
mainloop(stmode, preview=show)
|
||||
clear_animations()
|
||||
self.mainloop(stmode, preview=show)
|
||||
self.clear_animations()
|
||||
return self
|
||||
|
||||
def clear_animations():
|
||||
for x in range(len(leds)):
|
||||
exactdata[x] = None
|
||||
def clear_animations(self):
|
||||
for x in range(len(self.leds)):
|
||||
self.exactdata[x] = None
|
||||
return self
|
||||
|
||||
def do_animation(stmode, ring=-1):
|
||||
mainloop(stmode, ring, preview=show)
|
||||
wait_for_animation(ring)
|
||||
def do_animation(self, stmode, ring=-1):
|
||||
self.mainloop(stmode, ring, preview=show)
|
||||
self.wait_for_animation(ring)
|
||||
return self
|
||||
|
||||
def start_animation(stmode, ring=-1):
|
||||
mainloop(stmode, ring, preview=show)
|
||||
def start_animation(self, stmode, ring=-1):
|
||||
self.mainloop(stmode, ring, preview=show)
|
||||
return self
|
||||
|
||||
def wait_for_animation(ring=-1):
|
||||
while mode != "idle":
|
||||
mainloop(None, ring, preview=show)
|
||||
def wait_for_animation(self, ring=-1):
|
||||
while self.mode != "idle":
|
||||
self.mainloop(None, ring, preview=show)
|
||||
return self
|
||||
|
||||
if __name__ == "__main__":
|
||||
init()
|
||||
|
||||
import matplotlib.pyplot as plt
|
||||
"""cap = cv2.VideoCapture('badapple.mp4')
|
||||
while cap.isOpened():
|
||||
@ -655,24 +642,25 @@ if __name__ == "__main__":
|
||||
if not ret:
|
||||
break
|
||||
mapimage(frame, fps=30)"""
|
||||
show = True
|
||||
show = False
|
||||
ring = 1
|
||||
startup_animation(show)
|
||||
ledsys = LEDSystem()
|
||||
ledsys.startup_animation(show)
|
||||
for x in range(54):
|
||||
ringstatus[x][0] = True
|
||||
mainloop(None, preview=show)
|
||||
for x in range(animation_time):
|
||||
mainloop(None, preview=show)
|
||||
ledsys.ringstatus[x][0] = True
|
||||
ledsys.mainloop(None, preview=show)
|
||||
for x in range(ledsys.animation_time):
|
||||
ledsys.mainloop(None, preview=show)
|
||||
|
||||
do_animation("GrabA", 1)
|
||||
ledsys.do_animation("GrabA", 1)
|
||||
|
||||
do_animation("GrabA", 5)
|
||||
start_animation("GrabC", 1)
|
||||
ledsys.do_animation("GrabA", 5)
|
||||
ledsys.start_animation("GrabC", 1)
|
||||
|
||||
wait_for_animation(1)
|
||||
do_animation("GrabC", 5)
|
||||
ledsys.wait_for_animation(1)
|
||||
ledsys.do_animation("GrabC", 5)
|
||||
|
||||
close()
|
||||
ledsys.close()
|
||||
#sys.exit(0)
|
||||
|
||||
|
||||
|
||||
BIN
map3.png
BIN
map3.png
Binary file not shown.
|
Before Width: | Height: | Size: 44 KiB After Width: | Height: | Size: 41 KiB |
@ -1,9 +1,8 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# Parse Belden catalog techdata datasheets
|
||||
# Parse Belden (100%) & Alphawire (75%) catalog techdata datasheets
|
||||
|
||||
import pandas as pd
|
||||
pd.set_option('future.no_silent_downcasting', True)
|
||||
from PyPDF2 import PdfReader
|
||||
import camelot
|
||||
import numpy as np
|
||||
@ -13,55 +12,94 @@ import json
|
||||
from util import fprint
|
||||
import uuid
|
||||
from util import run_cmd
|
||||
from util import win32
|
||||
import os
|
||||
import glob
|
||||
import sys
|
||||
|
||||
def touch(path):
|
||||
with open(path, 'a'):
|
||||
os.utime(path, None)
|
||||
|
||||
def find_data_file(filename):
|
||||
if getattr(sys, "frozen", False):
|
||||
# The application is frozen
|
||||
datadir = os.path.dirname(sys.executable)
|
||||
else:
|
||||
# The application is not frozen
|
||||
# Change this bit to match where you store your data files:
|
||||
datadir = os.path.dirname(__file__)
|
||||
return os.path.join(datadir, filename)
|
||||
|
||||
def extract_table_name(table_start, searchpage, reader, dstype, fallbackname):
|
||||
if dstype == "Belden":
|
||||
ymin = table_start
|
||||
ymax = table_start + 10
|
||||
elif dstype == "Alphawire":
|
||||
ymin = table_start - 5
|
||||
ymax = table_start + 10
|
||||
page = reader.pages[searchpage - 1]
|
||||
parts = []
|
||||
def visitor_body(text, cm, tm, fontDict, fontSize):
|
||||
y = tm[5]
|
||||
if y > ymin and y < ymax:
|
||||
parts.append(text)
|
||||
page.extract_text(visitor_text=visitor_body)
|
||||
text_body = "".join(parts).strip('\n')
|
||||
if len(text_body) == 0:
|
||||
text_body = str(fallbackname)
|
||||
|
||||
return text_body
|
||||
#fprint(text_body)
|
||||
|
||||
def parse(filename, output_dir, partnum, dstype):
|
||||
|
||||
tables = []
|
||||
# Extract table data
|
||||
|
||||
tables = camelot.read_pdf(filename, pages="1-end", flavor='lattice', backend="poppler", split_text=False, line_scale=100, process_background=True, resolution=600, interations=1, layout_kwargs={'detect_vertical': False, 'char_margin': 0.5}, shift_text=['r', 't'])
|
||||
try:
|
||||
if dstype == "Belden":
|
||||
tables = camelot.read_pdf(filename, pages="1-end", flavor='lattice', backend="ghostscript", split_text=False, line_scale=100, process_background=True, resolution=600, interations=1, layout_kwargs={'detect_vertical': False, 'char_margin': 0.5}, shift_text=['r', 't'])
|
||||
elif dstype == "Alphawire":
|
||||
tables = camelot.read_pdf(filename, pages="1-end", flavor='lattice', backend="ghostscript", split_text=False, line_scale=50, process_background=True, resolution=600, interations=1, layout_kwargs={'detect_vertical': True, 'char_margin': 0.5}, shift_text=['l', 't'])
|
||||
except (OSError, RuntimeError) as e:
|
||||
print(e)
|
||||
if win32:
|
||||
print("Ghostscript is not installed! Launching installer...")
|
||||
#subprocess.run([r".\\gs10030w64.exe"])
|
||||
os.system(r'''Powershell -Command "& { Start-Process \"''' + find_data_file("gs10030w64.exe") + r'''\" -Verb RunAs } " ''')
|
||||
# Will return once file launched...
|
||||
print("Once the install is completed, try again.")
|
||||
return False
|
||||
else:
|
||||
print("Ghostscript is not installed. You can install it with e.g. apt install ghostscript for Debian-based systems.")
|
||||
return False
|
||||
#fprint("Total tables extracted:", tables.n)
|
||||
n = 0
|
||||
pagenum = 0
|
||||
#pagenum = 0
|
||||
reader = PdfReader(filename)
|
||||
page = reader.pages[0]
|
||||
table_list = {}
|
||||
|
||||
table_list_raw = {}
|
||||
pd.set_option('future.no_silent_downcasting', True)
|
||||
for table in tables:
|
||||
#with pd.options.context("future.no_silent_downcasting", True):
|
||||
table.df.infer_objects(copy=False)
|
||||
table.df.replace('', np.nan, inplace=True)
|
||||
table.df = table.df.replace('', np.nan).infer_objects(copy=False)
|
||||
table.df.dropna(inplace=True, how="all")
|
||||
table.df.dropna(inplace=True, axis="columns", how="all")
|
||||
table.df.replace(np.nan, '', inplace=True)
|
||||
table.df = table.df.replace(np.nan, '').infer_objects(copy=False)
|
||||
|
||||
if not table.df.empty:
|
||||
#fprint("\nTable " + str(n))
|
||||
# Extract table names
|
||||
table_start = table.cells[0][0].lt[1] # Read top-left cell's top-left coordinate
|
||||
#fprint(table_start)
|
||||
ymin = table_start
|
||||
ymax = table_start + 10
|
||||
if pagenum != table.page - 1:
|
||||
pagenum = table.page - 1
|
||||
page = reader.pages[table.page - 1]
|
||||
parts = []
|
||||
def visitor_body(text, cm, tm, fontDict, fontSize):
|
||||
y = tm[5]
|
||||
if y > ymin and y < ymax:
|
||||
parts.append(text)
|
||||
|
||||
page.extract_text(visitor_text=visitor_body)
|
||||
text_body = "".join(parts).strip('\n')
|
||||
if len(text_body) == 0:
|
||||
text_body = str(n)
|
||||
#fprint(text_body)
|
||||
|
||||
text_body = extract_table_name(table_start, table.page, reader, dstype, n)
|
||||
|
||||
table_list[text_body] = table.df
|
||||
if dstype == "Alphawire":
|
||||
table_list_raw[text_body] = table
|
||||
|
||||
#table.to_html("table" + str(n) + ".html")
|
||||
|
||||
#fprint(table.df)
|
||||
@ -71,7 +109,7 @@ def parse(filename, output_dir, partnum, dstype):
|
||||
|
||||
#tables.export(output_dir + '/techdata.json', f='json')
|
||||
|
||||
# fprint(table_list)
|
||||
#fprint(table_list)
|
||||
# Extract Basic details - part name & description, image, etc
|
||||
|
||||
reader = PdfReader(filename)
|
||||
@ -100,24 +138,32 @@ def parse(filename, output_dir, partnum, dstype):
|
||||
tables = dict()
|
||||
torename = dict()
|
||||
previous_table = ""
|
||||
#print(table_list.keys())
|
||||
for table_name in table_list.keys():
|
||||
# determine shape: horizontal or vertical
|
||||
table = table_list[table_name]
|
||||
rows = table.shape[0]
|
||||
cols = table.shape[1]
|
||||
vertical = None
|
||||
#print(rows, cols, table_name)
|
||||
if rows > 2 and cols == 2:
|
||||
vertical = True
|
||||
elif cols == 1:
|
||||
elif cols == 1 and rows > 1:
|
||||
vertical = False
|
||||
elif rows == 1:
|
||||
vertical = True
|
||||
elif cols == 2: # and rows <= 2
|
||||
# inconsistent
|
||||
if dstype == "Belden":
|
||||
if table.iloc[0, 0].find(":") == len(table.iloc[0, 0]) - 1: # check if last character is ":" indicating a vertical table
|
||||
vertical = True
|
||||
else:
|
||||
vertical = False
|
||||
elif dstype == "Alphawire":
|
||||
if table.iloc[0, 0].find(")") == 1 or table.iloc[0, 0].find(")") == 2 or table.iloc[0, 0].find(":") == len(table.iloc[0, 0]) - 1: # check if last character is ":" indicating a vertical table
|
||||
vertical = True
|
||||
else:
|
||||
vertical = False
|
||||
|
||||
elif cols > 2: # and rows <= 2
|
||||
vertical = False
|
||||
@ -125,10 +171,13 @@ def parse(filename, output_dir, partnum, dstype):
|
||||
vertical = False
|
||||
else: # 1 column, <= 2 rows
|
||||
vertical = False
|
||||
|
||||
#print(vertical)
|
||||
# missing name check
|
||||
for table_name_2 in table_list.keys():
|
||||
if table_name_2.find(table.iloc[-1, 0]) >= 0:
|
||||
if dstype == "Alphawire" and table_name_2.find("\n") >= 0:
|
||||
torename[table_name_2] = table_name_2[0:table_name_2.find("\n")]
|
||||
|
||||
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
|
||||
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
|
||||
@ -136,8 +185,12 @@ def parse(filename, output_dir, partnum, dstype):
|
||||
|
||||
if vertical:
|
||||
out = dict()
|
||||
if rows > 1:
|
||||
for row in table.itertuples(index=False, name=None):
|
||||
out[row[0].replace("\n", " ").replace(":", "")] = row[1]
|
||||
else:
|
||||
for row in table.itertuples(index=False, name=None):
|
||||
out[row[0].replace("\n", " ").replace(":", "")] = ""
|
||||
|
||||
else: # horizontal
|
||||
out = dict()
|
||||
@ -147,17 +200,57 @@ def parse(filename, output_dir, partnum, dstype):
|
||||
|
||||
tables[table_name] = out
|
||||
|
||||
# multi-page table check, Alphawire
|
||||
if dstype == "Alphawire" and table_name.isdigit():
|
||||
# table continues from previous page or has name on previous page
|
||||
thistbl = table_list_raw[table_name]
|
||||
prevtbl = table_list_raw[previous_table]
|
||||
|
||||
if prevtbl.cells[-1][0].lb[1] < 50 and thistbl.cells[0][0].lt[1] > 600:
|
||||
# wraparound
|
||||
#print("WRAP")
|
||||
#print("PREV TABLE", prevtbl.df)
|
||||
#print("THIS TABLE", thistbl.df)
|
||||
#print("PREV TABLE CORNER", prevtbl.cells[-1][0].lb[1])
|
||||
#print("THIS TABLE CORNER", thistbl.cells[0][0].lt[1])
|
||||
main_key = previous_table
|
||||
cont_key = table_name
|
||||
#print(vertical)
|
||||
if vertical == False:
|
||||
main_keys = list(tables[main_key].keys())
|
||||
for i, (cont_key, cont_values) in enumerate(tables[cont_key].items()):
|
||||
if i < len(main_keys):
|
||||
#print(tables[main_key][main_keys[i]])
|
||||
tables[main_key][main_keys[i]] = (tuple(tables[main_key][main_keys[i]]) + (cont_key,) + cont_values)
|
||||
|
||||
del tables[table_name]
|
||||
|
||||
else:
|
||||
#print(tables[cont_key].keys())
|
||||
for key in tables[cont_key].keys():
|
||||
#print(main_key, key, cont_key, key)
|
||||
tables[main_key][key] = tables[cont_key][key]
|
||||
del tables[table_name]
|
||||
|
||||
elif thistbl.cells[0][0].lt[1] > 600:
|
||||
# name on previous page (grrrr)
|
||||
#print("NAMEABOVE")
|
||||
#print("PREV TABLE", prevtbl.df)
|
||||
#print("THIS TABLE", thistbl.df)
|
||||
#print("PREV TABLE CORNER", prevtbl.cells[-1][0].lb[1])
|
||||
#print("THIS TABLE CORNER", thistbl.cells[0][0].lt[1])
|
||||
name = extract_table_name(50, prevtbl.page,reader,dstype,table_name).strip("\n").strip()
|
||||
#print("FOUND NAME:", name)
|
||||
torename[table_name] = name
|
||||
|
||||
|
||||
# multi-page table check
|
||||
|
||||
# multi-page table check, Belden
|
||||
if dstype == "Belden":
|
||||
if table_name.isdigit() and len(tables) > 1:
|
||||
#fprint(table_name)
|
||||
#fprint(previous_table)
|
||||
|
||||
|
||||
|
||||
|
||||
main_key = previous_table
|
||||
cont_key = table_name
|
||||
#fprint(tables)
|
||||
@ -171,15 +264,21 @@ def parse(filename, output_dir, partnum, dstype):
|
||||
del tables[table_name]
|
||||
|
||||
else:
|
||||
#print(tables)
|
||||
#print(main_key)
|
||||
#print(cont_key)
|
||||
for key in tables[cont_key].keys():
|
||||
tables[main_key][key] = tables[cont_key][key]
|
||||
del tables[table_name]
|
||||
|
||||
else:
|
||||
previous_table = table_name
|
||||
else:
|
||||
previous_table = table_name
|
||||
|
||||
# remove renamed tables
|
||||
# remove & rename tables
|
||||
#print(torename)
|
||||
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]
|
||||
# remove multi-line values that occasionally squeak through
|
||||
def replace_newlines_in_dict(d):
|
||||
@ -211,11 +310,20 @@ def parse(filename, output_dir, partnum, dstype):
|
||||
|
||||
#print(output_table)
|
||||
|
||||
run_cmd("rm \"" + output_dir + "\"/*.json") # not reliable!
|
||||
with open(output_dir + "/" + output_table["searchspecs"]["id"] + ".json", 'w') as json_file:
|
||||
#run_cmd("rm \"" + output_dir + "\"/*.json") # not reliable!
|
||||
pattern = os.path.join(output_dir, '*.json')
|
||||
json_files = glob.glob(pattern)
|
||||
for file_path in json_files:
|
||||
os.remove(file_path)
|
||||
#print(f"Deleted {file_path}")
|
||||
with open(output_dir + "/search.json", 'w') as json_file:
|
||||
json.dump(output_table["searchspecs"], json_file)
|
||||
touch(output_dir + "/parsed")
|
||||
return output_table
|
||||
with open(output_dir + "/specs.json", 'w') as json_file:
|
||||
json.dump(output_table["fullspecs"], json_file)
|
||||
|
||||
#print(json.dumps(output_table, indent=2))
|
||||
touch(output_dir + "/parsed") # mark as parsed
|
||||
return True
|
||||
|
||||
|
||||
def flatten(tables):
|
||||
@ -241,13 +349,20 @@ def flatten(tables):
|
||||
|
||||
fullkeyname = (table + ": " + keyname).replace(".","")
|
||||
if type(tables[table][key]) is not tuple:
|
||||
if len(tables[table][key]) > 0:
|
||||
out[fullkeyname] = convert_to_number(tables[table][key])
|
||||
#print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
|
||||
elif len(tables[table][key]) == 1:
|
||||
if len(tables[table][key][0]) > 0:
|
||||
out[fullkeyname] = convert_to_number(tables[table][key][0])
|
||||
|
||||
#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 tables[table][key].count(',') > 0:
|
||||
out[fullkeyname] = list(map(lambda x: x.strip(), tables[table][key].split(",")))
|
||||
@ -256,7 +371,7 @@ def flatten(tables):
|
||||
# if the item has at least two commas in it, split it
|
||||
if tables[table][key].count(',') > 0:
|
||||
out[fullkeyname] = list(map(lambda x: x.strip(), tables[table][key].split(",")))
|
||||
print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
|
||||
#print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
|
||||
|
||||
|
||||
#print("}")
|
||||
@ -265,4 +380,4 @@ def flatten(tables):
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parse("test2.pdf", "cables/10GXS13", "10GXS13")
|
||||
print(parse("cables/3050/datasheet.pdf", "cables/3050", "3050", "Alphawire"))
|
||||
@ -1,5 +1,5 @@
|
||||
# Runtime
|
||||
camelot-py[base]
|
||||
camelot-py
|
||||
opencv-python
|
||||
pypdf2==2.12.1
|
||||
alive-progress
|
||||
@ -15,6 +15,13 @@ websockets
|
||||
numpy
|
||||
scipy
|
||||
ipywidgets
|
||||
pandas
|
||||
pyarrow
|
||||
ghostscript
|
||||
pyzbar
|
||||
segno
|
||||
|
||||
# Development
|
||||
matplotlib
|
||||
#cx_Freeze # uncomment if building label generator app
|
||||
# requires windows 10 SDK, visual C++, etc
|
||||
183
run.py
183
run.py
@ -1,5 +1,6 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
from alive_progress import alive_bar
|
||||
import get_specs
|
||||
import traceback
|
||||
#import logging
|
||||
@ -12,16 +13,19 @@ from util import fprint
|
||||
from util import run_cmd
|
||||
import sys
|
||||
import ur5_control
|
||||
from ur5_control import Rob
|
||||
import os
|
||||
import signal
|
||||
import socket
|
||||
from flask import Flask, render_template, request
|
||||
import requests
|
||||
import led_control
|
||||
from led_control import LEDSystem
|
||||
import server
|
||||
import asyncio
|
||||
import json
|
||||
import process_video
|
||||
import search
|
||||
from search import JukeboxSearch
|
||||
|
||||
|
||||
|
||||
@ -32,13 +36,22 @@ led_ready = False
|
||||
camera_ready = False
|
||||
sensor_ready = False
|
||||
vm_ready = False
|
||||
cable_search_ready = False
|
||||
killme = None
|
||||
#pool = None
|
||||
serverproc = None
|
||||
camera = None
|
||||
|
||||
ledsys = None
|
||||
arm = None
|
||||
to_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):
|
||||
global arm_ready
|
||||
@ -47,10 +60,14 @@ def arm_start_callback(res):
|
||||
def led_start_callback(res):
|
||||
global led_ready
|
||||
led_ready = True
|
||||
global ledsys
|
||||
ledsys = res
|
||||
|
||||
def camera_start_callback(res):
|
||||
global camera_ready
|
||||
camera_ready = True
|
||||
global scan_value
|
||||
scan_value = res
|
||||
|
||||
def sensor_start_callback(res):
|
||||
global sensor_ready
|
||||
@ -60,6 +77,12 @@ def vm_start_callback(res):
|
||||
global vm_ready
|
||||
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):
|
||||
#global val
|
||||
if val is False:
|
||||
@ -231,13 +254,18 @@ def setup_server(pool):
|
||||
global arm_ready
|
||||
global serverproc
|
||||
global camera
|
||||
|
||||
pool.apply_async(ur5_control.init, (config["arm"]["ip"],), callback=arm_start_callback)
|
||||
pool.apply_async(led_control.init, callback=led_start_callback)
|
||||
global arm
|
||||
global jbs
|
||||
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)
|
||||
serverproc = Process(target=start_server_socket)
|
||||
serverproc.start()
|
||||
|
||||
|
||||
if led_ready is False:
|
||||
fprint("waiting for " + "LED controller initialization" + " to complete...", sendqueue=to_server_queue)
|
||||
while led_ready is False:
|
||||
@ -253,7 +281,7 @@ def setup_server(pool):
|
||||
|
||||
if camera_ready is False:
|
||||
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)
|
||||
|
||||
@ -265,23 +293,156 @@ def setup_server(pool):
|
||||
fprint("Arm initialized.", sendqueue=to_server_queue)
|
||||
|
||||
|
||||
|
||||
|
||||
jbs = JukeboxSearch()
|
||||
return True
|
||||
|
||||
|
||||
|
||||
def mainloop_server(pool):
|
||||
# NON-blocking loop
|
||||
global config
|
||||
global counter
|
||||
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:
|
||||
killall()
|
||||
counter = counter + 1
|
||||
|
||||
# fprint("Looking for QR code...")
|
||||
# print(camera.read_qr(30))
|
||||
if mode == "Startup":
|
||||
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.find("bldn.app/") > -1:
|
||||
scan_value = scan_value[scan_value.find("bldn.app/")+9:]
|
||||
cable_list.append((counter, 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 = list()
|
||||
for cable in cable_list:
|
||||
tmp.append(cable[1])
|
||||
|
||||
tmp = [
|
||||
# Actual cables in Jukebox
|
||||
|
||||
"AW86104CY",
|
||||
"AW3050",
|
||||
"AW6714",
|
||||
"AW1172C",
|
||||
"AWFIT-221-1_4",
|
||||
|
||||
"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"
|
||||
]
|
||||
cable_list = tmp
|
||||
pool.apply_async(get_specs.get_multi, (tmp, 0.5), 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
|
||||
#partnums = list()
|
||||
# debug
|
||||
#success = True
|
||||
|
||||
#cable_list = list(range(len(partnums)))
|
||||
if success:
|
||||
# easy mode
|
||||
fprint("All cables inventoried and parsed.")
|
||||
for x in range(len(cable_list)):
|
||||
#cable_list[x] = (cable_list[x][0], partnums[x])
|
||||
cable_list[x] = (x, cable_list[x])
|
||||
fprint("Adding to database...")
|
||||
for idx,partnum in cable_list:
|
||||
with open("cables/" + partnum[2:] + "/search.json", "rb") as f:
|
||||
searchdata = json.load(f)
|
||||
searchdata["position"] = idx
|
||||
with open("cables/" + partnum[2:] + "/specs.json", "rb") as f:
|
||||
specs = json.load(f)
|
||||
searchdata["fullspecs"] = specs
|
||||
jbs.add_document(searchdata)
|
||||
|
||||
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():
|
||||
|
||||
|
||||
@ -1,8 +1,10 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
"""Interactions with the Meilisearch API for adding and searching cables."""
|
||||
from meilisearch import Client
|
||||
from meilisearch.task import TaskInfo
|
||||
from meilisearch.errors import MeilisearchApiError
|
||||
import json
|
||||
import time
|
||||
|
||||
DEFAULT_URL = "http://localhost:7700"
|
||||
DEFAULT_APIKEY = "fluffybunnyrabbit" # I WOULD RECOMMEND SOMETHING MORE SECURE
|
||||
@ -34,12 +36,15 @@ class JukeboxSearch:
|
||||
# create the index if it does not exist already
|
||||
try:
|
||||
self.client.get_index(self.index)
|
||||
self.client.delete_index(self.index)
|
||||
self.client.create_index(self.index)
|
||||
except MeilisearchApiError as _:
|
||||
self.client.create_index(self.index)
|
||||
# make a variable to easily reference the index
|
||||
self.idxref = self.client.index(self.index)
|
||||
|
||||
time.sleep(0.05)
|
||||
# update filterable attributes if needed
|
||||
self.idxref.update_distinct_attribute('partnum')
|
||||
self.update_filterables(filterable_attrs)
|
||||
|
||||
def add_document(self, document: dict) -> TaskInfo:
|
||||
|
||||
31
setup-label-generator.py
Normal file
31
setup-label-generator.py
Normal file
@ -0,0 +1,31 @@
|
||||
import sys
|
||||
from cx_Freeze import setup, Executable
|
||||
|
||||
debug = True
|
||||
debug = not debug
|
||||
# Dependencies are automatically detected, but it might need fine tuning.
|
||||
# "packages": ["os"] is used as example only
|
||||
|
||||
import opcode
|
||||
import os
|
||||
import distutils
|
||||
#distutils_path = os.path.join(os.path.dirname(opcode.__file__), 'distutils')
|
||||
build_exe_options = {"include_msvcr": True, "packages": ["camelot", "setuptools", "segno"], "optimize": 0, "silent": True, "include_files": ["gs10030w64.exe", "GothamCond-Medium.otf", "belden-logo-superhires.png"], "excludes": ["scipy", "torch"]}
|
||||
|
||||
# base="Win32GUI" should be used only for Windows GUI app
|
||||
base = "console"
|
||||
#if sys.platform == "win32" and not debug:
|
||||
# base = "Win32GUI"
|
||||
|
||||
if sys.platform == "linux" or sys.platform == "linux2" or sys.platform == "darwin":
|
||||
name = "jukebox-labelgen"
|
||||
else:
|
||||
name = "jukebox-labelgen.exe"
|
||||
|
||||
setup(
|
||||
name="IP Pigeon",
|
||||
version="0.2.4",
|
||||
description="IP Pigeon client application",
|
||||
options={"build_exe": build_exe_options},
|
||||
executables=[Executable("label_generator.py", base=base, uac_admin=False, target_name=name)],
|
||||
)
|
||||
351
ur5_control.py
351
ur5_control.py
@ -6,6 +6,7 @@ import numpy as np
|
||||
import time
|
||||
import os
|
||||
import logging
|
||||
import yaml
|
||||
from urx.robotiq_two_finger_gripper import Robotiq_Two_Finger_Gripper
|
||||
import sys
|
||||
from util import fprint
|
||||
@ -13,11 +14,26 @@ from util import fprint
|
||||
|
||||
|
||||
|
||||
rob = None
|
||||
|
||||
class 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(ip):
|
||||
global rob
|
||||
def init_arm(self):
|
||||
#sys.stdout = Logger()
|
||||
fprint("Starting UR5 power up...")
|
||||
|
||||
@ -29,29 +45,28 @@ def init(ip):
|
||||
# trigger auto-initialize
|
||||
|
||||
# wait for auto-initialize
|
||||
|
||||
ip = self.ip
|
||||
# init urx
|
||||
fprint("Connecting to arm at " + ip)
|
||||
trying = True
|
||||
while trying:
|
||||
try:
|
||||
rob = urx.Robot(ip)
|
||||
self.robot = urx.Robot(ip)
|
||||
trying = False
|
||||
except:
|
||||
time.sleep(1)
|
||||
robotiqgrip = Robotiq_Two_Finger_Gripper(rob)
|
||||
|
||||
# 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
|
||||
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))
|
||||
time.sleep(0.2)
|
||||
fprint("UR5 ready.")
|
||||
|
||||
def set_pos_abs(x, y, z, xb, yb, zb, threshold=None):
|
||||
global rob
|
||||
def set_pos_abs(robot, x, y, z, xb, yb, zb, threshold=None):
|
||||
rob = robot.robot
|
||||
new_orientation = m3d.Transform()
|
||||
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
|
||||
@ -67,8 +82,8 @@ def set_pos_abs(x, y, z, xb, yb, zb, threshold=None):
|
||||
#rob.speedj(0.2, 0.5, 99999)
|
||||
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):
|
||||
global rob
|
||||
def set_pos_rel_rot_abs(robot, x, y, z, xb, yb, zb):
|
||||
rob = robot.robot
|
||||
new_orientation = m3d.Transform()
|
||||
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
|
||||
@ -85,8 +100,8 @@ def set_pos_rel_rot_abs(x, y, z, xb, yb, zb):
|
||||
#rob.speedj(0.2, 0.5, 99999)
|
||||
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):
|
||||
global rob
|
||||
def set_pos_abs_rot_rel(robot, x, y, z, xb, yb, zb):
|
||||
rob = robot.robot
|
||||
new_orientation = m3d.Transform()
|
||||
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
|
||||
@ -132,8 +147,8 @@ def polar_to_cartesian(r, theta):
|
||||
return x, y
|
||||
|
||||
|
||||
def move_to_polar(start_pos, end_pos):
|
||||
global rob
|
||||
def move_to_polar(robot, start_pos, end_pos):
|
||||
rob = robot.robot
|
||||
|
||||
# Convert to polar coordinates
|
||||
start_r, start_theta = cartesian_to_polar(start_pos[0], start_pos[1])
|
||||
@ -190,8 +205,8 @@ def move_to_polar(start_pos, end_pos):
|
||||
|
||||
return rx_intermediate
|
||||
|
||||
def move_to_home():
|
||||
global rob
|
||||
def move_to_home(robot):
|
||||
rob = robot.robot
|
||||
|
||||
# Home position in degrees
|
||||
home_pos = [0.10421807948612624,
|
||||
@ -216,53 +231,254 @@ def normalize_degree(theta):
|
||||
# Return angle
|
||||
return normalized_theta
|
||||
|
||||
def get_joints_from_xyz_rel(x, y, z, initial_guess = (math.pi/2, math.pi/2, 0), limbs=(.422864, .359041, .092124)):
|
||||
# Get polar coordinates of x,y pair
|
||||
r, theta = cartesian_to_polar(x, y)
|
||||
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):
|
||||
# Get limbs and offsets
|
||||
#l3=0.15
|
||||
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
|
||||
offset_x = robot.offset_x
|
||||
offset_y = robot.offset_y
|
||||
offset_z = robot.offset_z
|
||||
# Calculate base angle and r relative to shoulder joint
|
||||
def calculate_theta(x, y, a):
|
||||
# Calculate if we need the + or - in our equations
|
||||
if (x>-a and y>=0) or (x>a and y<0):
|
||||
flip = 1
|
||||
elif (x<-a and y>=0) or (x<a and y<0):
|
||||
flip = -1
|
||||
else:
|
||||
# Critical section (x=a, or x=-a). Infinite slope
|
||||
# Return 0 or 180 depending on sign
|
||||
return math.atan2(y, 0)
|
||||
|
||||
# Calculate tangent line y = mx + b
|
||||
m = (x*y - math.sqrt(x*x*y*y-(x*x-a*a)*(y*y-a*a)))/(x*x-a*a)
|
||||
b = flip * a * math.sqrt(1+m*m)
|
||||
# Calculate equivalent tangent point on circle
|
||||
cx = (-flip*m*b)/(1+m*m)
|
||||
cy = m*cx + flip*b
|
||||
# Calculate base angle, make angle negative if flip=1
|
||||
theta = math.atan2(cy, cx) + (-math.pi if flip==1 else 0)
|
||||
return theta
|
||||
|
||||
base_theta = calculate_theta(x, y, l_bs)
|
||||
cx, cy = l_bs*math.cos(base_theta), l_bs*math.sin(base_theta)
|
||||
r = math.sqrt((x+offset_x+cx)**2 + (y+offset_y+cy)**2)
|
||||
|
||||
# Get length of each limb
|
||||
l1, l2, l3 = limbs
|
||||
|
||||
# Formulas to find out joint positions for (r, z)
|
||||
def inv_kin_r_z(p):
|
||||
a, b, c = p
|
||||
|
||||
return (l1*math.cos(a) + l2*math.cos(a-b) + l3*math.cos(a-b-c) - r, # r
|
||||
l1*math.sin(a) + l2*math.sin(a-b) - l3*math.sin(a-b-c) - z, # z
|
||||
l1*math.sin(a) + l2*math.sin(a-b) - l3*math.sin(a-b-c) - (l3*math.sin(a-b-c)) - (z + offset_z), # z
|
||||
a-b-c) # wrist angle
|
||||
|
||||
|
||||
# Normalize angles
|
||||
base, shoulder, elbow, wrist = [normalize_degree(deg) for deg in [theta, *fsolve(inv_kin_r_z, initial_guess)]]
|
||||
|
||||
base, shoulder, elbow, wrist1 = [normalize_degree(deg) for deg in [base_theta, *fsolve(inv_kin_r_z, initial_guess)]]
|
||||
wrist1 += rx
|
||||
# Return result
|
||||
return base, shoulder, elbow, wrist
|
||||
return base, shoulder, elbow, wrist1, ry, rz
|
||||
|
||||
def get_joints_from_xyz_abs(x, y, z):
|
||||
joints = get_joints_from_xyz_rel(x, y, z)
|
||||
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):
|
||||
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
|
||||
# Base, Shoulder, Elbow, Wrist
|
||||
inverse = [1, -1, 1, 1]
|
||||
offsets = [0, 0, 0, -math.pi/2]
|
||||
inverse = [1, -1, 1, 1, 1, 1]
|
||||
offsets = [-math.pi/2, 0, 0, -math.pi/2, 0, 0]
|
||||
|
||||
if math.degrees(joints[1]) > 137:
|
||||
print("CRASH! Shoulder at", joints[1] * 180/math.pi)
|
||||
#else:
|
||||
#print("Shoulder at", joints[1] * 180/math.pi)
|
||||
|
||||
# Get adjusted joint positions
|
||||
adjusted_joints = [o+j*i for j, o, i in zip(joints, offsets, inverse)]
|
||||
|
||||
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:
|
||||
rz = - math.pi / 2
|
||||
else:
|
||||
rz = math.pi / 2
|
||||
|
||||
if flip:
|
||||
gripperangle = -math.radians(gripperangle)
|
||||
grippery = gripperlength - math.cos(gripperangle) * gripperlength
|
||||
grippery += math.sin(gripperangle) * limb3
|
||||
gripperx = math.sin(gripperangle) * gripperlength + limb3 * 2
|
||||
gripperx -= (1-math.cos(gripperangle)) * limb3
|
||||
rz = math.pi / 2
|
||||
# flip the whole wrist
|
||||
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:
|
||||
gripperangle = math.radians(gripperangle)
|
||||
grippery = gripperlength - math.cos(gripperangle) * gripperlength
|
||||
grippery -= math.sin(gripperangle) * limb3
|
||||
gripperx = math.sin(gripperangle) * gripperlength
|
||||
gripperx += (1-math.cos(gripperangle)) * limb3
|
||||
|
||||
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]
|
||||
|
||||
if verbose:
|
||||
print("Going to cable holder index", joint["index"], "at position", joint["pos"])
|
||||
|
||||
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)
|
||||
#return angles
|
||||
#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)
|
||||
|
||||
# Return adjusted joint positions
|
||||
return [o+j*i for j, o, i in zip(joints, offsets, inverse)]
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
#rob.movej((0, 0, 0, 0, 0, 0), 0.1, 0.2)
|
||||
#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())
|
||||
move_to_home()
|
||||
move_to_home(robot)
|
||||
|
||||
home_pose = [-0.4999999077032916,
|
||||
-0.2000072960336574,
|
||||
0.40002172976662786,
|
||||
0,
|
||||
-3.14152741295329,
|
||||
0]
|
||||
math.radians(62)]
|
||||
|
||||
# time.sleep(.5)
|
||||
|
||||
@ -282,38 +498,57 @@ if __name__ == "__main__":
|
||||
0.0510]
|
||||
|
||||
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.3, 0.3, 0.3)
|
||||
rob.movej([*angles, *rob.getj()[4:]], acc=1, vel=1)
|
||||
config = None
|
||||
joints = []
|
||||
for i in np.linspace(-0.2, -0.7, 10):
|
||||
joints.append(get_joints_from_xyz_abs(robot, i, 0, 0))
|
||||
# rob.movejs(joints, acc=2, vel=2, radius=0.1)
|
||||
|
||||
angles = get_joints_from_xyz_abs(-0.3, -0.3, 0.7)
|
||||
rob.movej([*angles, *rob.getj()[4:]], acc=1, vel=1)
|
||||
# rob.movej(offset_gripper_angle(robot, -0.15, -0.15, 0.3, gripperangle=90, flip=is_flipped(robot)), vel=2, acc=2)
|
||||
|
||||
angles = get_joints_from_xyz_abs(-0.3, 0.4, 0.2)
|
||||
rob.movej([*angles, *rob.getj()[4:]], acc=1, vel=1)
|
||||
# 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)
|
||||
|
||||
|
||||
# set_pos_abs(*p1)
|
||||
# move = move_to_polar(p1, p2)
|
||||
|
||||
# goto_holder_index(robot, 7, 0.0)
|
||||
|
||||
# pick_up_routine(robot, 8)
|
||||
|
||||
|
||||
# for p in move:
|
||||
# print(math.degrees(p))
|
||||
# print("Safe? :", is_safe_move(p1, p2))
|
||||
# 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 = []
|
||||
|
||||
|
||||
# angle = 30
|
||||
# goto_holder_index(robot, 26, 0.1, angle)
|
||||
# time.sleep(1)
|
||||
# goto_holder_index(robot, 25, 0.1, angle)
|
||||
# time.sleep(1)
|
||||
# goto_holder_index(robot, 24, 0.1, angle)
|
||||
|
||||
|
||||
|
||||
|
||||
#rob.movej(angles, acc=2, vel=2)
|
||||
#time.sleep(10)
|
||||
#rob.movejs(joints, acc=2, vel=2)
|
||||
# joints = []
|
||||
# for i in np.linspace(-0.3, -0.7, 50):
|
||||
# joints.append(get_joints_from_xyz_abs(i, 0, 0))
|
||||
# rob.movejs(joints, acc=2, vel=2)
|
||||
|
||||
# time.sleep(5)
|
||||
|
||||
|
||||
# #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("getj(): ", rob.getj())
|
||||
|
||||
Reference in New Issue
Block a user