XYtestMovesFunction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "29014bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "38d9c68a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#assumptions: clockwise is actually clockwise about the origin"
   ]
  },
  {
   "cell_type": "raw",
   "id": "de0075fe",
   "metadata": {},
   "source": [
    "UNITS\n",
    "H (deg)\n",
    "R1, R2, x0, y0 (mm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2128952b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#try out the function\n",
    "H = 20 #angle of hard limit relative to x-axis\n",
    "R1 = 3\n",
    "R2 = 3\n",
    "x0 = 1\n",
    "y0 = 1\n",
    "x = -1.8\n",
    "y = 1.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2e950ab1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform(H,R_theta,R_phi,x,y): #function to output theta and phi angles based on coordinates relative to center \n",
    "    \n",
    "    if x==0 and y==0:\n",
    "        theta = 0\n",
    "        phi = 0\n",
    "    \n",
    "    H = H*np.pi/180\n",
    "    d = np.sqrt(x**2 + y**2)\n",
    "    a = d*np.cos(H)\n",
    "    b = d*np.sin(H)\n",
    "    r = np.sqrt((x-a)**2 + (y-b)**2)\n",
    "    alpha = 2*np.arcsin(r/(2*d))\n",
    "    #print(alpha*180/np.pi)\n",
    "    phi = np.arccos((R_phi**2 + R_theta**2 - d**2)/(2*R_theta*R_phi))\n",
    "    d_theta = np.arcsin(R_theta*np.sin(phi)/d)\n",
    "\n",
    "    \n",
    "    if abs(H) > np.pi/2:\n",
    "        if y>(b/a)*x:\n",
    "            theta = alpha + d_theta\n",
    "        if y<=(b/a)*x:\n",
    "            theta = ((2*np.pi)-alpha) + d_theta\n",
    "    else:\n",
    "        if y>(b/a)*x:\n",
    "            theta = ((2*np.pi)-alpha) + d_theta\n",
    "        if y<=(b/a)*x:\n",
    "            theta = alpha + d_theta \n",
    "    \n",
    "    theta = theta*180/np.pi\n",
    "    phi = phi*180/np.pi\n",
    "    \n",
    "    if theta>360:\n",
    "        theta = theta - 360\n",
    "    \n",
    "    return theta,phi\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "28880420",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "304.1183318654216 43.43864217771347\n"
     ]
    }
   ],
   "source": [
    "theta,phi = transform(H,R1,R2,x,y)\n",
    "print(theta,phi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "50e45cfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#version of the function to give moves\n",
    "def calc_moves(H,R_theta,R_phi,x0,y0,x,y): #function to output moves in theta and phi \n",
    "\n",
    "    #where you are\n",
    "    theta0,phi0 = transform(H,R_theta,R_phi,x0,y0)\n",
    "    #where you want to be \n",
    "    theta,phi = transform(H,R_theta,R_phi,x,y)\n",
    "    #difference\n",
    "    delta_theta = theta-theta0\n",
    "    delta_phi = phi-phi0\n",
    "    #logic\n",
    "    if delta_theta >= 0:\n",
    "        theta_cw = abs(delta_theta)\n",
    "        theta_ccw = 0\n",
    "    elif delta_theta < 0:\n",
    "        theta_cw = 0\n",
    "        theta_ccw = abs(delta_theta)\n",
    "    if delta_phi >= 0:\n",
    "        phi_cw = abs(delta_phi)\n",
    "        phi_ccw = 0\n",
    "    elif delta_phi < 0:\n",
    "        phi_cw = abs(delta_phi)\n",
    "        phi_ccw = 0\n",
    "    \n",
    "    return theta_cw,theta_ccw,phi_cw,phi_ccw\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6bbb811e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CW theta move: 252.75135409078797\n",
      "CCW theta move: 0\n",
      "CW phi move: 16.17259772698064\n",
      "CCW phi move: 0\n"
     ]
    }
   ],
   "source": [
    "theta_cw,theta_ccw,phi_cw,phi_ccw = calc_moves(H,R1,R2,x0,y0,x,y)\n",
    "print('CW theta move:', theta_cw)\n",
    "print('CCW theta move:', theta_ccw)\n",
    "print('CW phi move:', phi_cw)\n",
    "print('CCW phi move:', phi_ccw)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04a37703",
   "metadata": {},
   "source": [
    "***\n",
    "---\n",
    "***\n",
    "<a id='thomas'><Thomas>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "502f0c17",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-15-5b95789bbd8e>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-15-5b95789bbd8e>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    <a id='another_cell'></thomas>\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def get_angles(target, len1=3.0, len2=3.0):\n",
    "    \"\"\"\n",
    "    NOTE: This code was adapted from \"https://courses.ideate.cmu.edu/16-375/f2020/text/code/lecture-samples/two-link-ik.html\"\n",
    "    The angles \"alpha\" wrt the arm attached to the origin was given wrt the -Y axis, and the angle \"beta\" wrt the second arm was given wrt\n",
    "    the first arm, so the elbow angle was being calculated. The angles returned now are both wrt the positive X axis.\n",
    "    I also have plotted the results as a visual confirmation that the task was successful.\n",
    "    \n",
    "    Compute two inverse kinematics solutions for a target end position.  The\n",
    "    target is a Cartesian position vector (two-element ndarray) in world\n",
    "    coordinates, and the result vectors are joint angles as ndarrays [q0, q1].\n",
    "    If the target is out of reach, returns the closest pose.\n",
    "\n",
    "    :param target: two-element list or ndarray with [x1, y] target position\n",
    "    :param len1: optional proximal link length\n",
    "    :param len2: optional distal link length\n",
    "    :return: tuple (solution1, solution2) of two-element ndarrays with q1, q2 angles\n",
    "    \"\"\"\n",
    "\n",
    "    # find the position of the point in polar coordinates\n",
    "    radiussq = np.dot(target, target)\n",
    "    radius   = math.sqrt(radiussq)\n",
    "\n",
    "    # theta is the angle of target point w.r.t. -Y axis, same origin as arm\n",
    "    theta    = math.atan2(target[0], -target[1]) \n",
    "    \n",
    "\n",
    "    # use the law of cosines to compute the elbow angle\n",
    "    #   R**2 = l1**2 + l2**2 - 2*l1*l2*cos(pi - elbow)\n",
    "    #   both elbow and -elbow are valid solutions\n",
    "    acosarg = (radiussq - len1**2 - len2**2) / (-2 * len1 * len2)\n",
    "    if acosarg < -1.0:  elbow_supplement = math.pi\n",
    "    elif acosarg > 1.0: elbow_supplement = 0.0\n",
    "    else:               elbow_supplement = math.acos(acosarg)\n",
    "\n",
    "    # use the law of sines to find the angle at the bottom vertex of the triangle defined by the links\n",
    "    #  radius / sin(elbow_supplement)  = l2 / sin(alpha)\n",
    "    if radius > 0.0:\n",
    "        alpha = math.asin(len2 * math.sin(elbow_supplement) / radius)\n",
    "    else:\n",
    "        alpha = 0.0\n",
    "\n",
    "    #  compute the two solutions with opposite elbow sign\n",
    "    soln1 = np.array((theta - alpha, math.pi - elbow_supplement))\n",
    "    soln2 = np.array((theta + alpha, elbow_supplement - math.pi))\n",
    "    \n",
    "    # I think here I'm trying to ensure the angle is positive/negative when it should be, although it doesn't matter\n",
    "    if (-np.pi < theta - alpha) & (theta - alpha < -np.pi/2):\n",
    "        sol = np.array((theta - alpha + 3*np.pi/2, math.pi - elbow_supplement))\n",
    "        sol2 = np.array((theta + alpha + 3*np.pi/2, elbow_supplement - math.pi))\n",
    "    else:\n",
    "        sol = np.array((theta - alpha - np.pi/2, math.pi - elbow_supplement))\n",
    "        sol2 = np.array((theta + alpha - np.pi/2, elbow_supplement - math.pi))\n",
    "    \n",
    "    # See if we can plot our results, first plot the target\n",
    "    plt.figure(figsize = (8,8))\n",
    "    plt.scatter(target[0],target[1], s = 500, marker = '*', color = 'red')\n",
    "    plt.axvline(0, linestyle = '--', linewidth = 1, color = 'k')\n",
    "    plt.axhline(0, linestyle = '--', linewidth = 1, color = 'k')\n",
    "    plt.xlim((-6,6))\n",
    "    plt.ylim((-6,6))\n",
    "    \n",
    "    origin = [0,0]\n",
    "\n",
    "    # Find the location of the first solution joint geometrically \n",
    "    joint1 = [len1 * np.cos(sol[0]), len1 * np.sin(sol[0])]\n",
    "\n",
    "    x_values1_0 = [origin[0], joint1[0]]\n",
    "    y_values1_0 = [origin[1], joint1[1]]\n",
    "\n",
    "    \n",
    "    # End point of the second arm geometrically using the calculated angles \n",
    "    end1 = [x_values1_0[1] + len2 * np.cos(soln1[1] + sol[0]), y_values1_0[1] + len2 * np.sin(soln1[1] + sol[0])]\n",
    "   \n",
    "    x_values2 = [joint1[0], end1[0]]\n",
    "    y_values2 = [joint1[1], end1[1]]\n",
    "    \n",
    "    plt.plot(x_values1_0, y_values1_0, 'bo', linestyle=\"--\", markersize = 5)\n",
    "    plt.plot(x_values2, y_values2, 'bo', linestyle=\"--\", markersize = 5)\n",
    "    \n",
    "    # Now, see if we can do the same thing for the second solution\n",
    "    \n",
    "    joint2 = [len1 * np.cos(sol2[0]), len1 * np.sin(sol2[0])]\n",
    "    \n",
    "    x_values1_1 = [origin[0], joint2[0]]\n",
    "    y_values1_1 = [origin[1], joint2[1]]\n",
    "    \n",
    "    end2 = [x_values1_1[1] + len2 * np.cos(soln2[1] + sol2[0]), y_values1_1[1] + len2 * np.sin(soln2[1] + sol2[0])]\n",
    "    \n",
    "    x_values2_1 = [joint2[0], end2[0]]\n",
    "    y_values2_1 = [joint2[1], end2[1]]\n",
    "    \n",
    "    \n",
    "    plt.plot(x_values1_1, y_values1_1, 'yo', linestyle=\"--\", markersize = 5)\n",
    "    plt.plot(x_values2_1, y_values2_1, 'yo', linestyle=\"--\", markersize = 5)\n",
    "    \n",
    "    \n",
    "    # If the figure looks like the arms are in the correct location, then the angles are correct...\n",
    "    \n",
    "    #OK, so what are my actual angles???\n",
    "    angles1 = [sol[0], soln1[1] + sol[0]]\n",
    "    angles2 = [sol2[0], soln2[1] + sol2[0]]\n",
    "    \n",
    "    angles1 = [i - 2*np.pi if i > np.pi else i for i in angles1]\n",
    "    angles2 = [i - 2*np.pi if i > np.pi else i for i in angles2]\n",
    "    \n",
    "    print ('Angles for solution 1: {}, {}'.format(math.degrees(angles1[0]), math.degrees(angles1[1])))\n",
    "    print ('Angles for solution 2: {}, {}'.format(math.degrees(angles2[0]), math.degrees(angles2[1])))\n",
    "    return angles1, angles2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "88e36cfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Angles for solution 1: -31.366977774633675, 121.3669777746335\n",
      "Angles for solution 2: 121.36697777463367, -31.366977774633497\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([-0.5474570385672415, 2.118253365362135],\n",
       " [2.118253365362138, -0.5474570385672384])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "get_angles((x0,y0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "21ae24e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Angles for solution 1: -284.1183318654215, -147.556974043135\n",
      "Angles for solution 2: -147.55697404313506, -284.11833186542157\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([-4.958800356325528, -2.575355031332515],\n",
       " [-2.575355031332516, -4.958800356325529])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "get_angles((x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86a23b29",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}