Merge branch 'main' of https://git.myitr.org/Jukebox/jukebox-software

.gitignore

@@ -15,7 +15,7 @@ output.mp4
 # log files
 output.log
 # images
-*.png
+map*.png
 # Built app
 build
 # Generated label images

belden-logo.svg

@@ -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>

get_specs.py

@@ -70,6 +70,8 @@ def query_search(partnum, source):
                 if idx < 0:
                     fprint("Could not find part in API: " + partnum)
                     return False
+                
+                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"]
@@ -279,6 +281,7 @@ def get_multi(partnums, delay=0.25, dir="cables/", cache=True):
             return out
 
         def run_search(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
@@ -405,6 +408,7 @@ if __name__ == "__main__":
     # ]
     partnums = [
     # Actual cables in Jukebox
+     
     "AW86104CY",
     "AW3050",
     "AW6714",
@@ -437,7 +441,7 @@ if __name__ == "__main__":
 
     # Some ones I picked, including some invalid ones
     "BL10GXS12", 
-    "BLRST 5L-RKT 5L-949", 
+    "BLRST%205L-RKT%205L-949",
     "BL10GXS13",
     "BL10GXW12",
     "BL10GXW13",
@@ -448,13 +452,18 @@ if __name__ == "__main__":
     "BLFISD012R9",
     "BLFDSD012A9",
     "BLFSSL024NG",
-    "BLFISX006W0",
+    "BLFISX006W0", # datasheet only
-    "BLFISX00103",
+    "BLFISX00103", # invalid
-    "BLC6D1100007"
+    "BLC6D1100007" # invalid
 
     ]
-    print(query_search("74002", "Belden"))
+    #print(query_search("TT-SLG-024-HTNN", "Belden"))
-    #get_multi(partnums, 0.25)
+    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")
 
 

index.html

@@ -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>

inv_kin_testing.ipynb

@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -52,16 +52,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "data": {
-     "output_type": "stream",
+      "text/plain": [
-     "text": [
+       "[82.5301003420473,\n",
-      "flip\n",
+       " -83.54918182551367,\n",
-      "[62.18186071534606, -126.63734509021032, 142.6959710408549, -106.0586259506446]\n"
+       " 111.24503912126411,\n",
-     ]
+       " -117.69585729575046,\n",
+       " -90.0,\n",
+       " 90.0]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -69,7 +76,6 @@
     "    # Normalizes degree theta from -1.5pi to 1.5pi\n",
     "    multiplier = 1.5\n",
     "    normalized_theta = theta % (math.pi * multiplier)\n",
-    "    \n",
     "    # Maintain the negative sign if the original angle is negative\n",
     "    if theta < 0:\n",
     "        normalized_theta -= math.pi * multiplier\n",
@@ -77,28 +83,28 @@
     "    # Return angle\n",
     "    return normalized_theta\n",
     "\n",
-    "def get_joints_from_xyz_rel(x, y, z, rx=0, ry=0, rz=0, tool_offset=(0.145, 0, 0.14), initial_guess = (math.pi/2, math.pi/2, 0)):\n",
+    "def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess = (math.pi/2, math.pi/2, 0)):\n",
     "    # Get limbs and offsets\n",
-    "    offset_x, offset_y, offset_z = tool_offset\n",
+    "    offset_x, offset_y, offset_z = (0, 0, 0.14)     # Tool offset\n",
-    "    l_bs, l1, l2, l3 = (0.14, .422864, .359041, .15)\n",
+    "    l_bs, l1, l2, l3, l_wt = (0.1333, .425, .39225, .1267, .0997)    # Limb lengths\n",
-    "\n",
+    "    \n",
     "    # Calculate base angle and r relative to shoulder joint\n",
     "    def calculate_theta(x, y, a):\n",
     "        # Calculate if we need the + or - in our equations\n",
-    "        if (x>-a and y>=0) or (x>a and y<0):\n",
+    "        if (x>a and y>=0) or (x>-a and y<0):\n",
-    "            print('no flip')\n",
     "            flip = 1\n",
-    "        elif (x<-a and y>=0) or (x<a and y<0):\n",
+    "        elif (x<a and y>=0) or (x<-a and y<0):\n",
-    "            print('flip')\n",
     "            flip = -1\n",
     "        else: \n",
-    "            print('critical')\n",
     "            # Critical section (x=a, or x=-a). Infinite slope\n",
     "            # Return 0 or 180 depending on sign\n",
-    "            return math.atan2(y, 0)\n",
+    "            return math.atan2(y, 0) - math.pi/2\n",
     "        \n",
     "        # Calculate tangent line y = mx + b\n",
-    "        m = (x*y - math.sqrt(x*x*y*y-(x*x-a*a)*(y*y-a*a)))/(x*x-a*a)\n",
+    "        if abs(a) != abs(x): # If there is no division by 0\n",
+    "            m = (x*y + math.sqrt(x*x*y*y-(x*x-a*a)*(y*y-a*a)))/(x*x-a*a)\n",
+    "        else: # Deal with edge case when x^2=a^2\n",
+    "            m = flip*(-a*a+y*y)/(a*y-flip*abs(a*y))\n",
     "        b = flip * a * math.sqrt(1+m*m)\n",
     "\n",
     "        # Calculate equivalent tangent point on circle\n",
@@ -108,11 +114,11 @@
     "        # Calculate base angle, make angle negative if flip=1\n",
     "        theta = math.atan2(cy, cx) + (-math.pi if flip==1 else 0)\n",
     "\n",
-    "        return theta\n",
+    "        return theta \n",
     "    \n",
     "    base_theta = calculate_theta(x, y, l_bs)\n",
-    "    cx, cy = l_bs*math.cos(base_theta), l_bs*math.sin(l_bs)\n",
+    "    cx, cy = l_bs*math.cos(base_theta), l_bs*math.sin(base_theta)\n",
-    "    r = math.sqrt((x-cx)**2 + (y-cy)**2) - 0.1\n",
+    "    r = math.sqrt((x-cx)**2 + (y-cy)**2) \n",
     "\n",
     "\n",
     "    # Formulas to find out joint positions for (r, z)\n",
@@ -120,7 +126,7 @@
     "        a, b, c = p            \n",
     "\n",
     "        return (l1*math.cos(a) + l2*math.cos(a-b) + l3*math.cos(a-b-c) - r, # r\n",
-    "                l1*math.sin(a) + l2*math.sin(a-b) - l3*math.sin(a-b-c) - (z+offset_z),  # z\n",
+    "                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\n",
     "                a-b-c) # wrist angle\n",
     "\n",
     "\n",
@@ -130,125 +136,50 @@
     "    # Return result\n",
     "    return base, shoulder, elbow, wrist1, ry, rz\n",
     "\n",
-    "def get_joints_from_xyz_abs(x, y, z):\n",
+    "def get_joints_from_xyz_abs(x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2):\n",
-    "    joints = get_joints_from_xyz_rel(x, y, z)\n",
+    "    joints = get_joints_from_xyz_rel(x, y, z, rx, ry, rz)\n",
     "\n",
     "    # Joint offsets\n",
     "    # Base, Shoulder, Elbow, Wrist\n",
     "    inverse = [1, -1, 1, 1, 1, 1]\n",
-    "    offsets = [-math.pi/2, 0, 0, -math.pi/2, -math.pi/2, 0]\n",
+    "    offsets = [-math.pi/2, 0, 0, -math.pi/2, 0, 0]\n",
     "\n",
     "    # Return adjusted joint positions\n",
-    "    return [o+j*i for j, o, i in zip(joints, offsets, inverse)]\n",
+    "    robot_angles = [o+j*i for j, o, i in zip(joints, offsets, inverse)]\n",
     "\n",
-    "# print([math.degrees(deg) for deg in get_joints_from_xyz_rel(0.3, 0.3, 0.3)])\n",
+    "    return robot_angles\n",
-    "print([math.degrees(deg) for deg in get_joints_from_xyz_abs(0, -0.3, 0.1)])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 64,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "no flip\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "-126.86989764584402"
-      ]
-     },
-     "execution_count": 64,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "def calculate_theta(x, y, a):\n",
-    "        # Calculate if we need the + or - in our equations\n",
-    "        if (x>a and y>=0) or (x>-a and y<0):\n",
-    "            print('no flip')\n",
-    "            flip = 1\n",
-    "        elif (x<a and y>=0) or (x<-a and y<0):\n",
-    "            print('flip')\n",
-    "            flip = -1\n",
-    "        else: \n",
-    "            print('critical')\n",
-    "            # Critical section (x=a, or x=-a). Infinite slope\n",
-    "            # Return 0 or 180 depending on sign\n",
-    "            return math.atan2(y, 0)\n",
-    "        \n",
-    "        # Calculate tangent line y = mx + b\n",
-    "        m = (x*y + math.sqrt(x*x*y*y-(x*x-a*a)*(y*y-a*a)))/(x*x-a*a)\n",
-    "        b = flip * a * math.sqrt(1+m*m)\n",
     "\n",
-    "        # Calculate equivalent tangent point on circle\n",
+    "# Print degree rotation for each joint (robot angles)\n",
-    "        cx = (-flip*m*b)/(1+m*m)\n",
+    "[math.degrees(deg) for deg in get_joints_from_xyz_abs(-0.2, -0.5, 0.1)]"
-    "        cy = m*cx + flip*b\n",
-    "\n",
-    "        # Calculate base angle\n",
-    "        theta = math.atan2(cy, cx) + (-math.pi if flip==1 else 0)\n",
-    "\n",
-    "        return theta\n",
-    "\n",
-    "calculate_theta(5,-5,1)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Simulate arm and joint angles"
+    "### Simulate Arm and Joint Angles"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [
+   "outputs": [],
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "no flip\n",
-      "Target position (x,y,z): 0.3 0.3 0.3\n",
-      "Angles (base, shoulder, elbow, wrist): [-25.7322, 113.4225, 127.6133, -14.1908]\n",
-      "no flip\n",
-      "Robot Angles: [-115.7322, -113.4225, 127.6133, -104.1908]\n",
-      "elbow (x,y): -0.168 0.388\n",
-      "wrist (x,y): 0.18 0.3\n",
-      "tool  (x,y): 0.33 0.3\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
    "source": [
-    "def draw_arm(x, y, z):\n",
+    "def draw_arm_side_view(x, y, z, details=False):\n",
     "\n",
     "    # Get joint angles\n",
-    "    l1, l2, l3 = (.422864, .359041, .15)\n",
+    "    l1, l2, l3 = .425, .39225, .1267\n",
-    "    offset_x, offset_y, offset_z = (0.145, 0, 0.195)\n",
+    "    offset_x, offset_y, offset_z = (0, 0, 0.14)\n",
     "    r, theta = cartesian_to_polar(x, y)\n",
-    "    base, shoulder, elbow, wrist = get_joints_from_xyz_rel(x, y, z)\n",
+    "    base, shoulder, elbow, wrist, _, _ = get_joints_from_xyz_rel(x, y, z)\n",
     "\n",
     "    # Print angles\n",
-    "    print('Target position (x,y,z):', x, y, z)\n",
+    "    if details:\n",
-    "    print('Angles (base, shoulder, elbow, wrist):', [round(math.degrees(i), 4) for i in [base, shoulder, elbow, wrist]])\n",
+    "        print('Target position (x,y,z):', x, y, z)\n",
-    "    print('Robot Angles:', [round(math.degrees(i), 4) for i in get_joints_from_xyz_abs(x, y, z)])\n",
+    "        print('R: ', round(math.sqrt(x**2+y**2),4))\n",
+    "        print('Angles (base, shoulder, elbow, wrist):', [round(math.degrees(i), 4) for i in [base, shoulder, elbow, wrist]])\n",
+    "        print('Robot Angles:', [round(math.degrees(i), 4) for i in get_joints_from_xyz_abs(x, y, z)])\n",
     "\n",
     "    # Calculate each joint's endpoint position\n",
     "    x1, y1 = polar_to_cartesian(l1, shoulder)\n",
@@ -263,9 +194,10 @@
     "    ty = y3 - offset_z\n",
     "\n",
     "    # Print each joint's endpoint position\n",
-    "    print('elbow (x,y):', round(x1,3), round(y1,3))\n",
+    "    if details:\n",
-    "    print('wrist (x,y):', round(x2,3), round(y2,3))\n",
+    "        print('elbow (x,y):', round(x1,3), round(y1,3))\n",
-    "    print('tool  (x,y):', round(x3,3), round(y3,3))\n",
+    "        print('wrist (x,y):', round(x2,3), round(y2,3))\n",
+    "        print('tool  (x,y):', round(x3,3), round(y3,3))\n",
     "\n",
     "    # Draw limbs\n",
     "    plt.plot([0, x1], [0, y1], color='cyan', linewidth=7)\n",
@@ -287,37 +219,126 @@
     "\n",
     "    # Display z arrow\n",
     "    plt.annotate(f'', xy=(x3, 0), xycoords='data', xytext=(tx, ty), textcoords='data', arrowprops={'arrowstyle': '<->'})\n",
-    "    plt.annotate(f'z={round(ty,4)}', xy=(x3+0.01, y2/2), xycoords='data', xytext=(x3/2, 0), textcoords='offset points')\n",
+    "    plt.annotate(f'z={round(ty,4)}', xy=(tx+0.01, ty/2), xycoords='data', xytext=(x3/2, 0), textcoords='offset points')\n",
     "   \n",
     "    # Display plot\n",
     "    ax = plt.subplot(111)\n",
     "    ax.spines[['right', 'top']].set_visible(False)\n",
     "    plt.axis('equal')\n",
-    "    plt.show()\n",
+    "    plt.show()"
-    "\n",
-    "draw_arm(0.3, 0.3, 0.3)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_arm_top_view(x, y, z, details=False):\n",
+    "    # Get joint and position information\n",
+    "    angles = get_joints_from_xyz_rel(x, y, z)\n",
+    "    offset_x, offset_y, offset_z = (0, 0, 0.14)     # Tool offset\n",
+    "    l_bs, l1, l2, l3, l_wt = (0.1333, .425, .39225, .1267, .0997)    # Limb lengths\n",
+    "    cx, cy = l_bs*math.cos(angles[0]), l_bs*math.sin(angles[0]) # Base tangent point\n",
+    "    line_angle = math.pi/2+angles[0]\n",
+    "\n",
+    "    if details:\n",
+    "        print('Angles:', [round(math.degrees(angle),3) for angle in angles])\n",
+    "        print(f'Circle position (cx, cy): ({round(cx, 3)}, {round(cy, 3)})')\n",
+    "\n",
+    "\n",
+    "    # Plot coordinate system\n",
+    "    fig = plt.figure()\n",
+    "    ax = fig.add_subplot(1, 1, 1)\n",
+    "    ax.spines['left'].set_position('center')\n",
+    "    ax.spines['bottom'].set_position('center')\n",
+    "    ax.spines['right'].set_color('none')\n",
+    "    ax.spines['top'].set_color('none')\n",
+    "    ax.set_yticklabels([])\n",
+    "    ax.set_xticklabels([])\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "\n",
+    "    # Target point\n",
+    "    # plt.plot(x, y, 'go')\n",
+    "\n",
+    "    # Circle\n",
+    "    circle = plt.Circle((0, 0), l_bs, color='b', fill=False, linewidth=1)\n",
+    "    plt.plot([0, cx], [0, cy], color='b', linewidth=1)\n",
+    "    ax.add_patch(circle)\n",
+    "\n",
+    "    # Draw limbs\n",
+    "    # Shoulder\n",
+    "    x1, y1 = polar_to_cartesian(l1*math.cos(angles[1]), line_angle)\n",
+    "    x1, y1 = cx+x1, cy+y1\n",
+    "    z1 = l1*math.sin(angles[1])\n",
+    "    plt.plot([cx, x1], [cy, y1], color='cyan', linewidth=3)\n",
+    "\n",
+    "    # Elbow\n",
+    "    x2, y2 = polar_to_cartesian(l2*math.cos(angles[1]-angles[2]), line_angle)\n",
+    "    x2 += x1\n",
+    "    y2 += y1\n",
+    "    z2 = z1 + l2*math.sin(angles[1]-angles[2])\n",
+    "    plt.plot([x1, x2], [y1, y2], color='orange', linewidth=2)\n",
+    "\n",
+    "    # Wrist\n",
+    "    x3, y3 = polar_to_cartesian(l3*math.cos(angles[1]-angles[2]-angles[3]), line_angle)\n",
+    "    x3 += x2\n",
+    "    y3 += y2\n",
+    "    z3 = z2 + l3*math.sin(angles[1]-angles[2]-angles[3]) \n",
+    "    plt.plot([x2, x3], [y2, y3], color='red', linewidth=2)\n",
+    "\n",
+    "    # Print joint positions\n",
+    "    if details:\n",
+    "        print(f'Shoulder (x, y, z): ({round(x1,3)}, {round(y1,3)}, {round(z1,3)})')\n",
+    "        print(f'Elbow    (x, y, z): ({round(x2,3)}, {round(y2,3)}, {round(z2,3)})')\n",
+    "        print(f'Wrist    (x, y, z): ({round(x3,3)}, {round(y3,3)}, {round(z3,3)})')\n",
+    "\n",
+    "    # Display angle\n",
+    "    plt.text(0.01, -0.01-cy/abs(cy+0.00001)*0.02, f'{round(math.degrees(angles[0]), 2)}°', fontsize=7)\n",
+    "\n",
+    "    # Display x arrow\n",
+    "    sign = x3/abs(x3)\n",
+    "    plt.annotate(f'', xy=(0, y3), xycoords='data', xytext=(x3, y3), textcoords='data', arrowprops={'arrowstyle': '<->'})\n",
+    "    plt.annotate(f'x={round(x3,3)}', xy=(-0.1-sign*0.13, y3-0.015), xycoords='data', xytext=(x2/2, 0), textcoords='offset points')\n",
+    "\n",
+    "    # Display y arrow\n",
+    "    sign = y3/abs(y3)\n",
+    "    plt.annotate(f'', xy=(x3, 0), xycoords='data', xytext=(x3, y3), textcoords='data', arrowprops={'arrowstyle': '<->'})\n",
+    "    plt.annotate(f'y={round(y3,3)}', xy=((x3-0.1), -0.015-sign*0.03), xycoords='data', xytext=(x3/2, 0), textcoords='offset points')\n",
+    "\n",
+    "\n",
+    "    # Set axis limits and labels\n",
+    "    axis_limit = math.hypot(x, y)+.1\n",
+    "    plt.axis('square')\n",
+    "    plt.xlim(-axis_limit, axis_limit)\n",
+    "    plt.ylim(-axis_limit, axis_limit)\n",
+    "\n",
+    "    # Adjust the position of axis labels\n",
+    "    plt.xlabel('+x', horizontalalignment='right', x=1.05)\n",
+    "    plt.ylabel('+y', verticalalignment='top', rotation=0, y=1.05)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Target position (x,y,z): 0.3 0.3 0.3\n",
+      "Angles: [-53.867, 89.583, 87.39, 2.193, -90.0, 0.0]\n",
-      "Angles (base, shoulder, elbow, wrist): [33.9862, 85.2162, 73.3858, 11.8304]\n",
+      "Circle position (cx, cy): (0.079, -0.108)\n",
-      "Robot Angles: [33.9862, -85.2162, 73.3858, -78.1696]\n",
+      "Shoulder (x, y, z): (0.081, -0.106, 0.425)\n",
-      "elbow (x,y): 0.035 0.421\n",
+      "Elbow    (x, y, z): (0.398, 0.125, 0.44)\n",
-      "wrist (x,y): 0.387 0.495\n",
+      "Wrist    (x, y, z): (0.5, 0.2, 0.44)\n"
-      "tool  (x,y): 0.537 0.495\n"
      ]
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -329,48 +350,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Target position (x,y,z): -0.3 -0.3 0.7\n",
+      "Target position (x,y,z): 0.5 0.2 0.3\n",
-      "Angles (base, shoulder, elbow, wrist): [-117.3239, 78.0693, 0.0255, 79.0945]\n",
+      "R:  0.5385\n",
-      "Robot Angles: [-117.3239, -78.0693, 0.0255, -10.9055]\n",
+      "Angles (base, shoulder, elbow, wrist): [-53.8671, 89.5827, 87.3895, 2.1932]\n",
-      "elbow (x,y): 0.087 0.414\n",
+      "Robot Angles: [-143.8671, -89.5827, 87.3895, -87.8068, -90.0, 90.0]\n",
-      "wrist (x,y): 0.162 0.765\n",
+      "elbow (x,y): 0.003 0.425\n",
-      "tool  (x,y): 0.312 0.762\n"
+      "wrist (x,y): 0.395 0.44\n",
-     ]
+      "tool  (x,y): 0.522 0.44\n"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\nadee\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\scipy\\optimize\\_minpack_py.py:178: RuntimeWarning: The iteration is not making good progress, as measured by the \n",
-      "  improvement from the last ten iterations.\n",
-      "  warnings.warn(msg, RuntimeWarning)\n"
      ]
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Target position (x,y,z): -0.3 0.4 0.2\n",
-      "Angles (base, shoulder, elbow, wrist): [111.1813, 100.8341, 104.0795, -3.2455]\n",
-      "Robot Angles: [111.1813, -100.8341, 104.0795, -93.2455]\n",
-      "elbow (x,y): -0.079 0.415\n",
-      "wrist (x,y): 0.279 0.395\n",
-      "tool  (x,y): 0.429 0.395\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -380,63 +371,76 @@
     }
    ],
    "source": [
-    "draw_arm(0.3, 0.3, 0.3)\n",
+    "def draw_arm(x, y, z, details=False):\n",
-    "draw_arm(-0.3, -0.3, 0.7)\n",
+    "    draw_arm_top_view(x,y,z, details=details)\n",
-    "draw_arm(-0.3, 0.4, 0.2)"
+    "    draw_arm_side_view(x,y,z, details=details)\n",
-   ]
+    "\n",
-  },
+    "draw_arm(0.5,0.2,0.3, details=True)"
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Interactive Arm"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "30dd696bcdc14aec9a1d4c17fb4787d4",
-       "version_major": 2,
-       "version_minor": 0
-      },
       "text/plain": [
-       "interactive(children=(FloatSlider(value=0.3, description='x', max=1.0, step=0.01), FloatSlider(value=0.3, desc…"
+       "{'elbow': (0.06441407671759522, -0.08297834710053949, 0.42498873000714044),\n",
+       " 'wrist': (0.3809831975755794, 0.14814654552767514, 0.44000000000002354),\n",
+       " 'wrist2': (0.4617483203289997, 0.20711259462904327, 0.44000000000002354),\n",
+       " 'tool': (0.4617483203289997, 0.20711259462904327, 0.5800000000000236)}"
       ]
      },
-     "metadata": {},
+     "execution_count": 10,
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<function __main__.draw_arm(x, y, z)>"
-      ]
-     },
-     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "from ipywidgets import interact, FloatSlider\n",
+    "def joint_positions(x, y, z):\n",
+    "    # Get joint and position information\n",
+    "    angles = get_joints_from_xyz_abs(x, y, z)\n",
+    "    offset_x, offset_y, offset_z = (0, 0, 0.14)     # Tool offset\n",
+    "    l_bs, l1, l2, l3, l_wt = (0.1333, .425, .39225, .1267, .0997)    # Limb lengths\n",
+    "    cx, cy = l_bs*math.cos(angles[0]), l_bs*math.sin(angles[0]) # Base tangent point\n",
+    "    line_angle = math.pi/2+angles[0]\n",
     "\n",
-    "# Interactive slider for z coordinate\n",
+    "    # Elbow\n",
-    "interact(draw_arm,  x=FloatSlider(min=0, max=1, step=0.01, value=0.3),\n",
+    "    x1, y1 = polar_to_cartesian(l1*math.cos(angles[1]), line_angle)\n",
-    "                    y=FloatSlider(min=0, max=1, step=0.01, value=0.3),\n",
+    "    x1, y1 = cx+x1, cy+y1\n",
-    "                    z=FloatSlider(min=0, max=1, step=0.01, value=0.3))\n"
+    "    z1 = l1*math.sin(angles[1])\n",
+    "\n",
+    "    # Wrist\n",
+    "    x2, y2 = polar_to_cartesian(l2*math.cos(angles[1]-angles[2]), line_angle)\n",
+    "    x2 += x1\n",
+    "    y2 += y1\n",
+    "    z2 = z1 + l2*math.sin(angles[1]-angles[2])\n",
+    "\n",
+    "    # Wrist 2\n",
+    "    x3, y3 = polar_to_cartesian(l3*math.cos(angles[1]-angles[2]-angles[3]), line_angle)\n",
+    "    x3 += x2\n",
+    "    y3 += y2\n",
+    "    z3 = z2 + l3*math.sin(angles[1]-angles[2]-angles[3]) \n",
+    "\n",
+    "    # Tool\n",
+    "    x4, y4 = polar_to_cartesian(offset_z*math.cos(angles[1]-angles[2]-angles[3]-angles[4]), line_angle)\n",
+    "    x4 += x3\n",
+    "    y4 += y3\n",
+    "    z4 = z3 + offset_z*math.sin(angles[1]-angles[2]-angles[3]-angles[4])\n",
+    "\n",
+    "\n",
+    "    positions = {\n",
+    "        'elbow': (x1, y1, z1),\n",
+    "        'wrist': (x2, y2, z2),\n",
+    "        'wrist2': (x3, y3, z3),\n",
+    "        'tool': (x4, y4, z4)\n",
+    "    }\n",
+    "\n",
+    "    return positions\n",
+    "\n",
+    "joint_positions(0.5,0.2,0.3)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

label_generator.py

@@ -61,9 +61,15 @@ def input_cable():
             imgstr = "BL"
         elif output[1] == "Alphawire":
             imgstr = "AW"
-        img = generate_code(imgstr + output[0])
+        gen_label(imgstr + output[0])
-        os.makedirs("labels", exist_ok=True)
+        #img = generate_code(imgstr + output[0])
-        img.save("labels/" + imgstr + output[0] + ".png")
+        #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

label_image.py

@@ -3,8 +3,13 @@ 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
 
 
@@ -134,7 +139,8 @@ for charset in (CODE128A, CODE128B):
 
 def generate_code(data, show=False, check=False):
 
-    img = code128_image(data)
+    #img = code128_image(data)
+    img = qr_image(data)
     if show:
         img.show()
     #img.show()
@@ -198,6 +204,7 @@ def code128_format(data):
     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)
         
@@ -227,12 +234,86 @@ def code128_image(data, height=100, thickness=3, quiet_zone=False):
 
     #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("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")

requirements.txt

@@ -19,7 +19,7 @@ pandas
 pyarrow
 ghostscript
 pyzbar
-
+segno
 
 # Development
 matplotlib

run.py

@@ -17,7 +17,7 @@ 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
@@ -36,7 +36,7 @@ killme = None
 #pool = None
 serverproc = None
 camera = None
-
+ledsys = None
 to_server_queue = Queue()
 from_server_queue = Queue()
 
@@ -47,6 +47,8 @@ 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
@@ -233,7 +235,9 @@ def setup_server(pool):
     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 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()

setup-label-generator.py

@@ -10,7 +10,7 @@ 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"], "optimize": 0, "silent": True, "include_files": ["gs10030w64.exe"], "excludes": ["scipy", "torch"]}
+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"

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
@@ -14,7 +15,8 @@ from util import fprint
 
 
 rob = None
-
+offset_x, offset_y, offset_z = (0, 0, 0.14)     # Tool offset
+limb_base, limb1, limb2, limb3, limb_wrist = (0.105, .425, .39225, .1, .0997)    # Limb lengths
 
 def init(ip):
     global rob
@@ -216,12 +218,12 @@ def normalize_degree(theta):
     # Return angle
     return normalized_theta
 
-
+def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess = (math.pi/2, math.pi/2, 0), l3offset=0):
-def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess = (math.pi/2, math.pi/2, 0)):
     # Get limbs and offsets
-    offset_x, offset_y, offset_z = (0, 0, 0.14)     # Tool offset
+    
-    l_bs, l1, l2, l3, l_wt = (0.1333, .425, .39225, .1267, .0997)    # Limb lengths
     #l3=0.15
+    l_bs, l1, l2, l3, l_wt = (limb_base, limb1, limb2, limb3, limb_wrist)    # Limb lengths
+    l3 += l3offset # add wrist offset, used for gripper angle calculations
     
     # Calculate base angle and r relative to shoulder joint
     def calculate_theta(x, y, a):
@@ -238,19 +240,16 @@ def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess =
         # 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(l_bs)
+    cx, cy = l_bs*math.cos(base_theta), l_bs*math.sin(base_theta)
-    r = math.sqrt((x-cx)**2 + (y-cy)**2) 
+    r = math.sqrt((x+offset_x+cx)**2 + (y+offset_y+cy)**2) 
 
 
     # Formulas to find out joint positions for (r, z)
@@ -264,21 +263,128 @@ def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess =
 
     # Normalize angles
     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, wrist1, ry, rz
 
-def get_joints_from_xyz_abs(x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2):
+def get_joints_from_xyz_abs(x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2, l3offset=0):
-    joints = get_joints_from_xyz_rel(x, y, z, rx, ry, rz)
+    joints = get_joints_from_xyz_rel(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, 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)
+
     # Return adjusted joint positions
     return [o+j*i for j, o, i in zip(joints, offsets, inverse)]
 
+def move_arc(x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2):
+    
+    global rob
+    start_joints = rob.getj()
+    end_joint = get_joints_from_xyz_abs(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(x, y, z, gripperangle=35, gripperlength=0.20+0.018, flip=False):
+    # gripper angle: from vertical
+    # gripper length: from joint to start of grip
+    # to flip, you can use flip=True or make gripper angle negative
+
+    # 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(x, y, z-grippery, rx=gripperangle + math.radians(180), l3offset=-gripperx, ry=math.pi/2, rz=-rz)
+
+    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(x, y, z-grippery, rx=gripperangle, l3offset=-gripperx, rz=rz)
+    
+def goto_holder_index(idx, z=0.05, gripperangle=35, flip=False):
+    joint = config["position_map"][idx]
+    print("Going to cable holder index", joint["index"], "at position", joint["pos"])   
+    
+    safe_move(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():
+    global rob
+    wrist2 = rob.getj()[4]
+
+    if wrist2>0:
+        return True
+    else:
+        return False
+
+def flip():
+    global rob
+
+    # A list of safe positions to flip
+    safe_positions = [(-0.205, -0.108, 0.3),
+                      (0.205, -0.108, 0.3)]
+
+    # 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(*safe_pos, flip=is_flipped()), vel=2, acc=2) # Move to safe position
+    rob.movej(offset_gripper_angle(*safe_pos, flip=(not is_flipped())), vel=2, acc=2) # Flip gripper
+
+def safe_move(x, y, z):
+    flip_radius = 0.17 # 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()) or (r > flip_radius and not is_flipped()):
+        flip()
+
+    global rob
+    rob.movej(offset_gripper_angle(x, y, z, flip=is_flipped()), vel=2, acc=2)
+
+
+
 if __name__ == "__main__":
     
     #rob.movej((0, 0, 0, 0, 0, 0), 0.1, 0.2)
@@ -312,18 +418,72 @@ 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)
 
     
+    config = None
+    joints = []
+    for i in np.linspace(-0.2, -0.7, 10):
+         joints.append(get_joints_from_xyz_abs(i, 0, 0))
+    # rob.movejs(joints, acc=2, vel=2, radius=0.1)
 
-    angles = get_joints_from_xyz_abs(-0.7, 0, 0)
+    with open('config.yml', 'r') as fileread:
-    rob.movej(angles, acc=2, vel=2)
+        #global config
+        config = yaml.safe_load(fileread)
 
+    # move_arc(0, 0.3, 0.1)
+    # move_arc(0, -0.3, 0.3)
+
+
+    # for i in range(20):
+    #     goto_holder_index(i, 0.1)
+
+    flip()
+    flip()
+
+    #rob.movej(goto_holder_index(24, 0.2, 0), acc=2, vel=2)
+    #joints = []
+    
+    #for i in np.linspace(0, 340, 340):
+    #    joints.append(goto_holder_index(24, 0.5, i))
+    #rob.movejs(joints, acc=1, vel=3)
+    angle = 30
+    rob.movej(goto_holder_index(26, 0.1, angle), acc=2, vel=2)
+    time.sleep(1)
+    rob.movej(goto_holder_index(25, 0.1, angle), acc=2, vel=2)
+    time.sleep(1)
+    rob.movej(goto_holder_index(24, 0.1, angle, flip=True), acc=2, vel=2)
+    #rob.movej(goto_holder_index(32, 0.2, angle), acc=2, vel=2)
+    #rob.movej(goto_holder_index(38, 0.2, angle), acc=2, vel=2)
+    #rob.movej(goto_holder_index(25, 0.1, angle, flip=True), acc=2, vel=2)
+
+    #rob.movej(goto_holder_index(25, 0.2, angle, flip=True), acc=2, vel=2)
+    #rob.movej(goto_holder_index(24, 0.1, angle, flip=True), acc=2, vel=2)
+    #time.sleep(1)
+    #rob.movej(goto_holder_index(25, 0.1, angle, flip=True), acc=2, vel=2)
+    #rob.movej(goto_holder_index(49, 0.1, angle), acc=2, vel=2)
+    #rob.movej(goto_holder_index(49, 0.1, angle, flip=True), acc=2, vel=2)
+    # rob.movej(goto_holder_index(50, 0.1, angle, flip=True), acc=2, vel=2)
+    # rob.movej(goto_holder_index(51, 0.1, angle, flip=True), acc=2, vel=2)
+    # rob.movej(goto_holder_index(52, 0.1, angle, flip=True), acc=2, vel=2)
+    # rob.movej(goto_holder_index(53, 0.1, angle, flip=True), acc=2, vel=2)
+    #time.sleep(2)
+    #rob.movej(goto_holder_index(24, 0.15, 35, flip=True), acc=2, vel=2)
+    #time.sleep(10)
+    # time.sleep(4)
+    # goto_holder_index(26, 0.1, 20)
+    # time.sleep(4)
+    # goto_holder_index(26, 0.1, 30)
+    # time.sleep(4)
+    # goto_holder_index(26, 0.1, 40)
+    # for joint in config["position_map"]:
+    #joint = config["position_map"][26]
+    #print("Going to cable holder index", joint["index"], "at position", joint["pos"])   
+    #angles = get_joints_from_xyz_abs(joint["pos"][1]/1000, joint["pos"][0]/1000, 0.05, )# rx=math.pi / 5)
+    #joints.append(angles)
+
+    #rob.movej(angles, acc=2, vel=2)
+    #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))