diff --git a/Q8_with_Controller1.slx b/Q8_with_Controller1.slx new file mode 100644 index 0000000..c87e6b0 Binary files /dev/null and b/Q8_with_Controller1.slx differ diff --git a/Q8_with_Controller2.slx b/Q8_with_Controller2.slx new file mode 100644 index 0000000..b205729 Binary files /dev/null and b/Q8_with_Controller2.slx differ diff --git a/Question_3.py b/Question_3.py new file mode 100644 index 0000000..240a4eb --- /dev/null +++ b/Question_3.py @@ -0,0 +1,47 @@ +#DH parameters and endeffector properties for a STANFORD Type manipultor + +import numpy as np +n = 4 #number of links + +#defing Cos and Sin as functions for simplicity. +def c(t): + c= np.cos(t*np.pi/180) + return c + +def s(t): + s= np.sin(t*np.pi/180) + return s + +# DH parameters for SCARA manipulator +DH = np.array([[10, 0, 0 , 0], + [10, 180, 0, 0], + [0, 0, 0, 0,], + [0, 0, 5, 0]]) + +#Initializing the T matrix +T = np.array([[1,0,0,0], + [0,1,0,0], + [0,0,1,0], + [0,0,0,1]]) + +B = np.array([[1],[2],[3],[1]]) #given end effector position +W = np.array([[5],[6],[4],[1]]) +# making the T matrix and matrix multiplying all the H matrices. +for i in range(0,4): + H = np.array([[c(DH[i,3]), -s(DH[i,3])*c(DH[i,1]), s(DH[i,3])*s(DH[i,1]), DH[i,0]*c(DH[i,3])], + [s(DH[i,3]) , c(DH[i,3])*c(DH[i,1]), c(DH[i,3])*s(DH[i,1]), DH[i,0]*s(DH[i,3])], + [0, s(DH[i,1]), c(DH[i,1]), DH[i,1]], + [0, 0, 0, 1]]) + T = np.dot(T,H) + +# T is the Jacobian manipulator. + +print('Manipulator Jacobian is') +print(T) +E = np.dot(T, B) +print('EndEffector position is ', E[0],E[1],E[2] ) +#E gives the end effector postion with respect to base frame. + +V = np.dot(T,W) +print('EndEffector velocity is ', V[0],V[1],V[2] ) +# V gives the end effector velocity with respect to base frame \ No newline at end of file diff --git a/Question_4.py b/Question_4.py new file mode 100644 index 0000000..ebb53dc --- /dev/null +++ b/Question_4.py @@ -0,0 +1,50 @@ +#DH parameters and endeffector properties for a STANFORD Type manipultor + +import numpy as np +n = 6 #number of links + +#defing Cos and Sin as functions for simplicity. +def c(t): + c= np.cos(t*np.pi/180) + return c + +def s(t): + s= np.sin(t*np.pi/180) + return s + +# DH parameters for STANFORD manipulator +DH = np.array([[0, -90, 0 , 0], + [0, 90, 10, 0], + [0, 0, 0, 0,], + [0, -90, 0, 0], + [0, 90, 0, 0], + [0, 0, 10, 0]]) + +#Initializing the T matrix +T = np.array([[1,0,0,0], + [0,1,0,0], + [0,0,1,0], + [0,0,0,1]]) + +B = np.array([[1],[2],[3],[1]]) #given end effector position +W = np.array([[5],[6],[4],[1]]) +# making the T matrix and matrix multiplying all the H matrices. +for i in range(0,4): + H = np.array([[c(DH[i,3]), -s(DH[i,3])*c(DH[i,1]), s(DH[i,3])*s(DH[i,1]), DH[i,0]*c(DH[i,3])], + [s(DH[i,3]) , c(DH[i,3])*c(DH[i,1]), c(DH[i,3])*s(DH[i,1]), DH[i,0]*s(DH[i,3])], + [0, s(DH[i,1]), c(DH[i,1]), DH[i,1]], + [0, 0, 0, 1]]) + T = np.dot(T,H) + +# T is the Jacobian manipulator. + +print('Manipulator Jacobian is') +print(T) + +E = np.dot(T, B) +print('EndEffector position is ', E[0],E[1],E[2] ) +#E gives the end effector postion with respect to base frame. + +V = np.dot(T,W) +print('EndEffector velocity is ', V[0],V[1],V[2] ) +# V gives the end effector velocity with respect to base frame \ No newline at end of file diff --git a/Robotics _Assignment3_Goutham..pdf b/Robotics _Assignment3_Goutham..pdf new file mode 100644 index 0000000..0472a5f Binary files /dev/null and b/Robotics _Assignment3_Goutham..pdf differ diff --git a/Robotics_Assignment_4.ipynb b/Robotics_Assignment_4.ipynb new file mode 100644 index 0000000..34487a9 --- /dev/null +++ b/Robotics_Assignment_4.ipynb @@ -0,0 +1,807 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Question_1" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q_1=1.30588811500363 q_2=-0.547056509455663 Length = 2.00945911277785\n", + "q_4=0 q_5=1.04820946874082 q_6=1.40290061368638\n" + ] + } + ], + "source": [ + "import sympy as sympy\n", + "import numpy as np\n", + "from numpy import cos as c\n", + "from numpy import sin as s\n", + "\n", + "s1,s2,s3,s4,s5,s6 = sympy.symbols('s1,s2,s3,s4,s5,s6')\n", + "c1,c2,c3,c4,c5,c6 = sympy.symbols('c1,c2,c3,c4,c5,c6')\n", + "d2,d3,d6 = 1,1,0.5\n", + "qd_1 = qd_2 = qd_3 = qd_4 = qd_5 = qd_6 = pi/6\n", + "\n", + "r11 = c(qd_1)*(c(qd_2)*(c(qd_4)*c(qd_5)*c(qd_6)-s(qd_4)*s(qd_6))-s(qd_2)*s(qd_5)*c(qd_6))-s(qd_1)*(s(qd_4)*c(qd_5)*c(qd_6)+c(qd_4)*c(qd_6)) \n", + "r21 = s(qd_1)*(c(qd_2)*(c(qd_4)*c(qd_5)*c(qd_6)-s(qd_4)*s(qd_6))-s(qd_2)*s(qd_5)*c(qd_6))+c(qd_1)*(s(qd_4)*c(qd_5)*c(qd_6)+c(qd_4)*c(qd_6))\n", + "r31 = -s(qd_2)*(c(qd_4)*c(qd_5)*c(qd_6)-s(qd_4)*s(qd_6))-c(qd_2)*s(qd_5)*s(qd_6)\n", + "\n", + "r12 = c(qd_1)*(-c(qd_2)*(c(qd_4)*c(qd_5)*s(qd_6)+s(qd_4)*c(qd_6))+s(qd_2)*s(qd_5)*s(qd_6))-s(qd_1)*(-s(qd_4)*c(qd_5)*s(qd_6)+c(qd_4)*c(qd_6))\n", + "r22 = s(qd_1)*(-c(qd_2)*(c(qd_4)*c(qd_5)*s(qd_6)+s(qd_4)*c(qd_6))+s(qd_2)*s(qd_5)*s(qd_6))+c(qd_1)*(-s(qd_4)*c(qd_5)*s(qd_6)+c(qd_4)*c(qd_6))\n", + "r32 = s(qd_2)*(c(qd_4)*c(qd_5)*c(qd_6)+s(qd_4)*s(qd_6))+c(qd_2)*s(qd_5)*s(qd_6)\n", + "\n", + "r13 = c(qd_1)*(c(qd_2)*c(qd_4)*s(qd_5)+s(qd_2)*c(qd_5))-s(qd_1)*s(qd_4)*s(qd_5)\n", + "r23 = s(qd_1)*(c(qd_2)*c(qd_4)*s(qd_5)+s(qd_2)*c(qd_5))+c(qd_1)*s(qd_4)*s(qd_5)\n", + "r33 = -s(qd_2)*c(qd_4)*s(qd_5)+c(qd_2)*c(qd_5)\n", + "\n", + "\n", + "r14 = c(qd_1)*s(qd_2)*d3-s(qd_1)*d2+d6*(c(qd_1)*c(qd_2)*c(qd_4)*s(qd_5)+c(qd_1)*c(qd_5)*s(qd_2)-s(qd_1)*s(qd_4)*s(qd_5))\n", + "r24 = s(qd_1)*s(qd_2)*d3+c(qd_1)*d2+d6*(c(qd_1)*s(qd_4)*s(qd_5)+c(qd_2)*c(qd_4)*s(qd_1)*s(qd_5)+c(qd_5)*s(qd_1)*s(qd_2))\n", + "r34 = c(qd_2)*d3+d6*(c(qd_2)*c(qd_5)-c(qd_4)*s(qd_2)*s(qd_5))\n", + "\n", + "\n", + "MAT = [[r11,r12,r13,r14],\n", + " [r21,r22,r23,r24],\n", + " [r31,r32,r33,r34],\n", + " [ 0 , 0 , 0 , 1 ]]\n", + "#print(MAT)\n", + "\n", + "eqd_1 = sympy.Eq(c1*s2*s3-s1*d2,1.2)\n", + "eqd_2 = sympy.Eq(s1*s2*s3+d2*c1,0.8)\n", + "eqd_3 = sympy.Eq(c2*s3,1.88)\n", + "eqd_4 = sympy.Eq(c1**2+s1**2,0.9)\n", + "eqd_5 = sympy.Eq(c2**2+s2**2,1.2)\n", + "\n", + "Ans = sympy.solve([eqd_1,eqd_2,eqd_3,eqd_4,eqd_5],s1,s2,s3,c1,c2)\n", + "\n", + "(s1,s2,s3,c1,c2)=Ans[0]\n", + "\n", + "print(\"q_1=\"+str(atan(s1/c1))+\" q_2=\"+str(atan(s2/c2))+\" Length = \"+str(s3))\n", + "Rotaion_Matrix = [[c1*c2,-s1,c1*s2,0],[s1*c2,c1,s1*s2,0],[-s2,0,c2,0],[0,0,0,1]]\n", + "\n", + "P = np.transpose(Rotaion_Matrix)*(MAT)\n", + "\n", + "Q_1 = sympy.Eq(c5,P[2][2])\n", + "Q_2 = sympy.Eq(s4,P[1][2]/P[0][2])\n", + "Q_3 = sympy.Eq(s6,-P[2][1]/P[2][0])\n", + "\n", + "Ans1 = sympy.solve([Q_1,Q_2,Q_3],\n", + " [ s4, c5, s6])\n", + "\n", + "print(\"q_4=\"+str(atan(Ans1.get(s4)))+\n", + " \" q_5=\"+str(acos(Ans1.get(c5))) +\n", + " \" q_6=\"+str(atan(Ans1.get(s6))))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Question_2" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q_1=0.643501108793284 q_2=0.927295218001612 Length=0.200000000000000\n", + "q_4=0.343023940420703\n" + ] + } + ], + "source": [ + "import sympy as sympy\n", + "import numpy as np\n", + "\n", + "\n", + "s1,s2,s3,s4,s5,s6 = sympy.symbols('s1,s2,s3,s4,s5,s6')\n", + "c1,c2,c3,c4,c5,c6 = sympy.symbols('c1,c2,c3,c4,c5,c6')\n", + "d2,d3,d6 = 1,1,0.5\n", + "\n", + "eq1 = sympy.Eq(d2*c1+d3*c2,1.4)\n", + "eq2 = sympy.Eq(d2*s1+d3*s2,1.4)\n", + "eq3 = sympy.Eq(s3,0.2)\n", + "eq4 = sympy.Eq(c1**2+s1**2,1)\n", + "eq5 = sympy.Eq(c2**2+s2**2,1)\n", + "\n", + "ans = sympy.solve([eq1,eq2,eq3,eq4,eq5],s1,s2,s3,c1,c2)\n", + "\n", + "(s1,s2,s3,c1,c2)=ans[0]\n", + "print(\"q_1=\"+str(atan(s1/c1))+\" q_2=\"+str(atan(s2/c2))+\" Length=\"+str(s3))\n", + "\n", + "Q_1 = sympy.Eq(s2*c4+c2*s4,0.9)\n", + "Q_2 = sympy.Eq(c2*c4+s2*s4,0.8)\n", + "ans1 = sympy.solve([Q_1,Q_2],[s4,c4])\n", + "\n", + "print(\"q_4=\"+str(atan(ans1.get(s4))))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Question_3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import sympy as sym\n", + "import numpy as np\n", + "from sympy import *\n", + "from numpy import *\n", + "\n", + "jacobian = Matrix([[-20, 5, 1], [-10, 5, 0], [5, 1, 0]])\n", + "\n", + "Jtrans = jacobian*jacobian.transpose()\n", + "#print(Jtrans)\n", + "joint_velocities = jacobian.transpose()*Jtrans.inv()*Matrix([1,1,1]) \n", + "print(joint_velocities)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Question_6" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q_1=-0.337889611165861 q_2=0.785398163397448 q_3=0.785398163397448\n" + ] + } + ], + "source": [ + "import sympy as sympy\n", + "import numpy as np\n", + "\n", + "\n", + "[[r11,r12,r13],[r21,r22,r23],[r31,r32,r33]] = [[0.9,0.9,0.9],[0.9,0.9,0.9],[0.9,0.9,0.9]]\n", + "s1,s2,s3 = sympy.symbols('s1,s2,s3')\n", + "c1,c2,c3 = sympy.symbols('c1,c2,c3')\n", + "\n", + "eq1 = sympy.Eq(c1,r33)\n", + "eq2 = sympy.Eq(c2*s1,r13)\n", + "eq3 = sympy.Eq(s2*s1,r23)\n", + "eq4 = sympy.Eq(-s1*c3,r31)\n", + "eq5 = sympy.Eq(-s1*s3,r32)\n", + "eq6 = sympy.Eq(c1**1+s1**2,1)\n", + "\n", + "Ans = sympy.solve([eq1,eq2,eq3,eq4,eq5,eq6],s1,s2,s3,c1,c2,c3)\n", + "\n", + "(s1,s2,s3,c1,c2,c3)=Ans[0]\n", + "print(\"q_1=\"+str(atan(s1/c1))+\" q_2=\"+str(atan(s2/c2))+\" q_3=\"+str(atan(s3/c3)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Question_9" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-0.999180521256603, -0.715464195021075, 1.76053968998146, -0.0404757450997962, 0.698649401089592)\n", + "(-0.997037356565575, -0.760361703569547, 1.77059312096258, -0.0769188508281979, 0.649499868933641)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "E:\\anaconda\\lib\\site-packages\\control\\timeresp.py:941: UserWarning: Non-zero initial condition given for transfer function system. Internal conversion to state space used; may not be consistent with given X0.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import control as ct\n", + "import sympy as sympy\n", + "import matplotlib.animation as animation\n", + "import mpl_toolkits.mplot3d.axes3d as p3\n", + "\n", + "J_E,B_E,ks = 5,3,1\n", + "kd,kp = 1,0.3\n", + "\n", + "dynamics = ct.tf([1],[J_E,B_E])\n", + "stiff = ct.tf([ks],[1])\n", + "TransF_1 = ct.series(stiff,dynamics)\n", + "f1 = ct.tf([kd],[1])\n", + "TransF_2 = ct.feedback(TransF_1,f1,sign=-1)\n", + "feed_kp = ct.tf([kp],[1])\n", + "feed_s = ct.tf([1],[1,0])\n", + "h3 = ct.series(feed_kp,TransF_2,feed_s)\n", + "\n", + "def inv_kin(ox,oy,oz):\n", + " s1,s2,s3,s4,s5,s6 = sympy.symbols('s1,s2,s3,s4,s5,s6')\n", + " c1,c2,c3,c4,c5,c6 = sympy.symbols('c1,c2,c3,c4,c5,c6')\n", + " d2,d3,d6 = 1.2,0.8,1\n", + " r11,r21,r31,r41 = 0.2,0.5,0.5,ox\n", + " r12,r22,r32,r42 = 1.,1,1,oy\n", + " r13,r23,r33,r43 = 1.6,1.6,1.6,oz\n", + " r14,r24,r34,r44 = 0,0,0,1\n", + " \n", + " Mat = [[r11,r12,r13,r14],\n", + " [r21,r22,r23,r24],\n", + " [r31,r32,r33,r34],\n", + " [r41,r42,r43,r44]]\n", + " \n", + " eq1 = sympy.Eq(c1*s2*s3-s1*d2,r41)\n", + " eq2 = sympy.Eq(s1*s2*s3+d2*c1,r42)\n", + " eq3 = sympy.Eq(c2*s3,r43)\n", + " eq4 = sympy.Eq(c1**2+s1**2,1)\n", + " eq5 = sympy.Eq(c2**2+s2**2,1)\n", + " \n", + " Anslt = sympy.solve([eq1,eq2,eq3,eq4,eq5],s1,s2,s3,c1,c2)\n", + " print(Anslt[0])\n", + " (s1,s2,s3,c1,c2)=Anslt[0] \n", + " return (s1,s2,s3,c1,c2)\n", + "\n", + "def get_angles(p1,p2):\n", + " (p1s1,p1s2,p1s3,p1c1,p1c2) = inv_kin(p1[0],p1[1],p1[2])\n", + " (p2s1,p2s2,p2s3,p2c1,p2c2) = inv_kin(p2[0],p2[1],p2[2])\n", + "# print(p1s1,p1s2,p1s3,p1c1,p1c2)\n", + "# print(p2s1,p2s2,p2s3,p2c1,p2c2)\n", + " p1q1, p1q2 = float(atan(p1s1/p1c1)),float(atan(p1s2/p1c2))\n", + " p2q1, p2q2 = float(atan(p2s1/p2c1)),float(atan(p2s2/p2c2))\n", + " \n", + " u = np.linspace(p1q1,p2q1,nt)\n", + " return (p1q1,p1q2,p2q1,p2q2,float(p1s3),float(p2s3))\n", + "\n", + "\n", + "t0 = 1\n", + "t1 = 20\n", + "dt = 0.1\n", + "nt = int(t1 / dt ) + 1 \n", + "t = np.linspace( t0 , t1 , nt )\n", + "\n", + "p1 = [1.25,1.21,1.23]\n", + "p2 = [1.3,1.25,1.15]\n", + "(p1q1,p1q2,p2q1,p2q2,p1s3,p2s3) = get_angles(p1,p2)\n", + "\n", + "u = np.linspace(p1q1,p2q1,nt)\n", + "v = np.linspace(p1q2,p2q2,nt)\n", + "w = np.linspace(p1s3,p2s3,nt)\n", + "\n", + "(t,x)=ct.forced_response(h3,t,u,X0=p1q1)\n", + "(t,y)=ct.forced_response(h3,t,v,X0=p1q2)\n", + "(t,z)=ct.forced_response(h3,t,w,X0=0)\n", + "plt.close( 'all ')\n", + "fig_width_cm = 24\n", + "fig_height_cm = 18\n", + "plt . figure (1 , figsize =( fig_width_cm /2.54 , fig_height_cm /2.54))\n", + "plt . subplot (3 , 1 , 1)\n", + "plt.plot(t , x , 'blue')\n", + "plt . xlabel ( 't [ s ] ')\n", + "plt.grid()\n", + "plt.legend( labels =( 'q1' ,))\n", + "plt.subplot(3 , 1 , 2)\n", + "plt.plot(t , y , 'blue')\n", + "plt . xlabel ( 't [ s ] ')\n", + "plt.grid()\n", + "plt.legend( labels =( 'q2' ,))\n", + "plt.subplot(3 , 1 , 3)\n", + "plt.plot(t , z , 'blue')\n", + "plt.xlabel( 't [ s ]')\n", + "plt.grid()\n", + "plt.legend( labels =( 'd' ,))\n", + "plt.show()\n", + "\n", + "\n", + "x1_arr,y1_arr = cos(x),-sin(x)\n", + "x2_arr,y2_arr = (cos(x)+cos(y)),-(sin(x)+sin(y))\n", + "x3_arr,y3_arr = np.linspace(p1[0],p2[0],nt),np.linspace(p1[1],p2[1],nt)\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(\n", + " 111, aspect=\"equal\", autoscale_on=True, xlim=(-2, 2), ylim=(-2, 2)\n", + ")\n", + "\n", + "ax.grid(alpha=1)\n", + "ax.set_title(\"Stanford Manipulator\")\n", + "ax.set_xticklabels([])\n", + "ax.set_yticklabels([])\n", + "(line, ) = ax.plot(\n", + " [], [], \".-\", lw=1, color=\"black\"\n", + ") \n", + "(line2, ) = ax.plot(\n", + " [], [], \".-\", lw=1, color='black'\n", + ") \n", + "\n", + "def init():\n", + " line.set_data([], [])\n", + " return (line,)\n", + "\n", + "def animate(i):\n", + " x_points = [0, x1_arr[i], x3_arr[i]]\n", + " y_points = [0, y1_arr[i], y3_arr[i]]\n", + " line.set_data(x_points, y_points)\n", + "\n", + " \n", + " return (line,line2,)\n", + "ani = animation.FuncAnimation(\n", + " fig, animate, init_func=init, frames=len(x1_arr)-1, interval=40, blit=True, repeat=False\n", + ")\n", + "ani.save('stanford1.mp4', fps=30, extra_args=['-vcodec', 'libx264'])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Question_10" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.349972464912089, 0.987541302631866, 1.23000000000000, 0.936759987298431, 0.157360019052354)\n", + "(0.395733180218287, 0.968900229672570, 1.15000000000000, 0.918365531841391, 0.247451702237913)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "E:\\anaconda\\lib\\site-packages\\control\\timeresp.py:941: UserWarning: Non-zero initial condition given for transfer function system. Internal conversion to state space used; may not be consistent with given X0.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import control as ct\n", + "import sympy as sym\n", + "from sympy import *\n", + "from numpy import pi, sin, cos, sqrt, absolute, arccos, arctan, sign\n", + "import matplotlib.animation as animation\n", + "import mpl_toolkits.mplot3d.axes3d as p3\n", + "\n", + "J_E,B_E,ks = 5,3,1\n", + "kd,kp = 1,0.3\n", + "\n", + "dynamics = ct.tf([1],[J_E,B_E])\n", + "stiff = ct.tf([ks],[1])\n", + "TransF_1 = ct.series(stiff,dynamics)\n", + "f1 = ct.tf([kd],[1])\n", + "TransF_2 = ct.feedback(TransF_1,f1,sign=-1)\n", + "feed_kp = ct.tf([kp],[1])\n", + "feed_s = ct.tf([1],[1,0])\n", + "h3 = ct.series(feed_kp,TransF_2,feed_s)\n", + "\n", + "def inv_kin(ox,oy,oz):\n", + " s1,s2,s3,s4,s5,s6 = sym.symbols('s1,s2,s3,s4,s5,s6')\n", + " c1,c2,c3,c4,c5,c6 = sym.symbols('c1,c2,c3,c4,c5,c6')\n", + " d2,d3,d6 = 1.2,0.8,1\n", + " r11,r21,r31,r41 = 0.2,0.5,0.5,ox\n", + " r12,r22,r32,r42 = 1.,1,1,oy\n", + " r13,r23,r33,r43 = 1.6,1.6,1.6,oz\n", + " r14,r24,r34,r44 = 0,0,0,1\n", + " \n", + " Mat = [[r11,r12,r13,r14],\n", + " [r21,r22,r23,r24],\n", + " [r31,r32,r33,r34],\n", + " [r41,r42,r43,r44]]\n", + " \n", + " eq1 = sym.Eq(d2*c1+d3*c2,ox)\n", + " eq2 = sym.Eq(d2*s1+d3*s2,oy)\n", + " eq3 = sym.Eq(s3,oz)\n", + " eq4 = sym.Eq(c1**2+s1**2,1)\n", + " eq5 = sym.Eq(c2**2+s2**2,1)\n", + " \n", + " Anslt = sym.solve([eq1,eq2,eq3,eq4,eq5],s1,s2,s3,c1,c2)\n", + " print(Anslt[0])\n", + " (s1,s2,s3,c1,c2)=Anslt[0] \n", + " return (s1,s2,s3,c1,c2)\n", + "\n", + "def get_angles(p1,p2):\n", + " (p1s1,p1s2,p1s3,p1c1,p1c2) = inv_kin(p1[0],p1[1],p1[2])\n", + " (p2s1,p2s2,p2s3,p2c1,p2c2) = inv_kin(p2[0],p2[1],p2[2])\n", + "# print(p1s1,p1s2,p1s3,p1c1,p1c2)\n", + "# print(p2s1,p2s2,p2s3,p2c1,p2c2)\n", + " p1q1, p1q2 = float(atan(p1s1/p1c1)),float(atan(p1s2/p1c2))\n", + " p2q1, p2q2 = float(atan(p2s1/p2c1)),float(atan(p2s2/p2c2))\n", + " \n", + " u = np.linspace(p1q1,p2q1,nt)\n", + " return (p1q1,p1q2,p2q1,p2q2,float(p1s3),float(p2s3))\n", + "\n", + "\n", + "t0 = 1\n", + "t1 = 20\n", + "dt = 0.1\n", + "nt = int(t1 / dt ) + 1 \n", + "t = np.linspace( t0 , t1 , nt )\n", + "\n", + "p1 = [1.25,1.21,1.23]\n", + "p2 = [1.3,1.25,1.15]\n", + "(p1q1,p1q2,p2q1,p2q2,p1s3,p2s3) = get_angles(p1,p2)\n", + "\n", + "u = np.linspace(p1q1,p2q1,nt)\n", + "v = np.linspace(p1q2,p2q2,nt)\n", + "w = np.linspace(p1s3,p2s3,nt)\n", + "\n", + "(t,x)=ct.forced_response(h3,t,u,X0=p1q1)\n", + "(t,y)=ct.forced_response(h3,t,v,X0=p1q2)\n", + "(t,z)=ct.forced_response(h3,t,w,X0=0)\n", + "plt.close( 'all ')\n", + "fig_width_cm = 24\n", + "fig_height_cm = 18\n", + "plt . figure (1 , figsize =( fig_width_cm /2.54 , fig_height_cm /2.54))\n", + "plt . subplot (3 , 1 , 1)\n", + "plt.plot(t , x , 'blue')\n", + "plt . xlabel ( 't [ s ] ')\n", + "plt.grid()\n", + "plt.legend( labels =( 'q1' ,))\n", + "plt.subplot(3 , 1 , 2)\n", + "plt.plot(t , y , 'blue')\n", + "plt . xlabel ( 't [ s ] ')\n", + "plt.grid()\n", + "plt.legend( labels =( 'q2' ,))\n", + "plt.subplot(3 , 1 , 3)\n", + "plt.plot(t , z , 'blue')\n", + "plt.xlabel( 't [ s ]')\n", + "plt.grid()\n", + "plt.legend( labels =( 'd' ,))\n", + "plt.show()\n", + "\n", + "\n", + "x1_arr,y1_arr = cos(x),-sin(x)\n", + "x2_arr,y2_arr = (cos(x)+cos(y)),-(sin(x)+sin(y))\n", + "x3_arr,y3_arr = np.linspace(p1[0],p2[0],nt),np.linspace(p1[1],p2[1],nt)\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(\n", + " 111, aspect=\"equal\", autoscale_on=True, xlim=(-2, 2), ylim=(-2, 2)\n", + ")\n", + "\n", + "ax.grid(alpha=1)\n", + "ax.set_title(\"Stanford Manipulator\")\n", + "ax.set_xticklabels([])\n", + "ax.set_yticklabels([])\n", + "(line, ) = ax.plot(\n", + " [], [], \".-\", lw=1, color=\"black\"\n", + ") \n", + "(line2, ) = ax.plot(\n", + " [], [], \".-\", lw=1, color='black'\n", + ") \n", + "\n", + "def init():\n", + " line.set_data([], [])\n", + " return (line,)\n", + "\n", + "def animate(i):\n", + " x_points = [0, x1_arr[i], x3_arr[i]]\n", + " y_points = [0, y1_arr[i], y3_arr[i]]\n", + " line.set_data(x_points, y_points)\n", + "\n", + " \n", + " return (line,line2,)\n", + "ani = animation.FuncAnimation(\n", + " fig, animate, init_func=init, frames=len(x1_arr)-1, interval=40, blit=True, repeat=False\n", + ")\n", + "ani.save('stanford.mp4', fps=30, extra_args=['-vcodec', 'libx264'])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Question_11" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-0.474963330849782, -0.887864517260367, -0.936914622305684, 0.880005587680033, 0.460104986921479, -0.349558279132103)\n", + "q_4=atan(4.0/(25.0*c2 + 25.0*s2))\n", + "(-0.932157359915714, -0.983400457462024, -0.779685316451944, 0.362053388818509, 0.181448450705654, -0.626171547827935)\n", + "q_4=atan(4.0/(25.0*c2 + 25.0*s2))\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "E:\\anaconda\\lib\\site-packages\\control\\timeresp.py:941: UserWarning: Non-zero initial condition given for transfer function system. Internal conversion to state space used; may not be consistent with given X0.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import control as ct\n", + "import sympy as sympy\n", + "import matplotlib.animation as animation\n", + "import mpl_toolkits.mplot3d.axes3d as p3\n", + "\n", + "jeff,beff,ks = 5,3,1\n", + "kd,kp = 1,0.3\n", + "dyn = ct.tf([1],[jeff,beff])\n", + "stiff = ct.tf([ks],[1])\n", + "h1 = ct.series(stiff,dyn)\n", + "f1 = ct.tf([kd],[1])\n", + "h2 = ct.feedback(h1,f1,sign=-1)\n", + "feed_kp = ct.tf([kp],[1])\n", + "feed_s = ct.tf([1],[1,0])\n", + "h3 = ct.series(feed_kp,h2,feed_s)\n", + "\n", + "def inv_kin(ox,oy,oz):\n", + " s1,s2,s3,s4,s5,s6 = sympy.symbols('s1,s2,s3,s4,s5,s6')\n", + " c1,c2,c3,c4,c5,c6 = sympy.symbols('c1,c2,c3,c4,c5,c6')\n", + "\n", + " d2,d3,d4 = 1,1,0.5\n", + " q1 = q2 = q3 = q4 = q5 = q6 = pi/6\n", + " r11,r21,r31,r41 = 0.16,0.16,0.16,ox\n", + " r12,r22,r32,r42 = 1.05,1.05,1.05,oy\n", + " r13,r23,r33,r43 = 1.45,1.45,1.45,oz\n", + " r14,r24,r34,r44 = 0,0,0,1\n", + " Mat = [[r11,r12,r13,r14],\n", + " [r21,r22,r23,r24],\n", + " [r31,r32,r33,r34],\n", + " [r41,r42,r43,r44]]\n", + " \n", + "\n", + " eq1 = sympy.Eq(c1*(d2*c2+d3*c3 + d4*s3)-d2*s1,ox)\n", + " eq2 = sympy.Eq(s1*(d2*c2+d3*c3+d4*s3)+d2*c1,oy)\n", + " eq3 = sympy.Eq(d4*c3-d3*s3-d2*s2,oz)\n", + " eq4 = sympy.Eq(c1**2+s1**2,1)\n", + " eq5 = sympy.Eq(c2**2+s2**2,1)\n", + " eq6 = sympy.Eq(c3**2+s3**2,1)\n", + " \n", + " Ans = sympy.solve([eq1,eq2,eq3,eq4,eq5,eq6],s1,s2,s3,c1,c2,c3)\n", + " print(Ans[0])\n", + " iq1 = sympy.Eq(s2*c4+c2*s4,r21)\n", + " iq2 = sympy.Eq(c2*c4+s2*s4,r11)\n", + " Ans1 = sympy.solve([iq1,iq2],[s4,c4])\n", + "\n", + " print(\"q_4=\"+str(atan(Ans1.get(s4))))\n", + " (s1,s2,s3,c1,c2,c3)=Ans[0] \n", + " return (s1,s2,s3,Ans1.get(s4),c1,c2,c3,Ans1.get(c4))\n", + "\n", + "def get_angles(p1,p2):\n", + " (p1s1,p1s2,p1s3,p1s4,p1c1,p1c2,p1c3,p1c4) = inv_kin(p1[0],p1[1],p1[2])\n", + " (p2s1,p2s2,p2s3,p2s4,p2c1,p2c2,p2c3,p2c4) = inv_kin(p2[0],p2[1],p2[2])\n", + " p1q1, p1q2,p1q3 = float(atan(p1s1/p1c1)),float(atan(p1s2/p1c2)), float(atan(p1s3/p1c3))\n", + " p2q1, p2q2,p2q3 = float(atan(p2s1/p2c1)),float(atan(p2s2/p2c2)), float(atan(p2s3/p2c3))\n", + " u = np.linspace(p1q1,p2q1,nt)\n", + " return (p1q1,p1q2,p2q1,p2q2,p1q3,p2q3)\n", + "\n", + "t0 = 1\n", + "t1 = 20\n", + "dt = 0.1\n", + "nt = int(t1 / dt ) + 1 \n", + "t = np.linspace( t0 , t1 , nt )\n", + "\n", + "p1 = [0.16,1.05,1.65]\n", + "p2 = [0.63,1.14,1.45]\n", + "(p1q1,p1q2,p2q1,p2q2,p1s3,p2s3) = get_angles(p1,p2)\n", + "\n", + "u = np.linspace(p1q1,p2q1,nt)\n", + "v = np.linspace(p1q2,p2q2,nt)\n", + "w = np.linspace(p1s3,p2s3,nt)\n", + "\n", + "(t,x)=ct.forced_response(h3,t,u,X0=p1q1)\n", + "(t,y)=ct.forced_response(h3,t,v,X0=p1q2)\n", + "(t,z)=ct.forced_response(h3,t,w,X0=0)\n", + "plt.close( 'all ')\n", + "fig_width_cm = 24\n", + "fig_height_cm = 18\n", + "plt . figure (1 , figsize =( fig_width_cm /2.54 , fig_height_cm /2.54))\n", + "plt . subplot (3 , 1 , 1)\n", + "plt.plot(t , x , 'blue')\n", + "plt . xlabel ( 't [ s ] ')\n", + "plt.grid()\n", + "plt.legend( labels =( 'q1' ,))\n", + "plt.subplot(3 , 1 , 2)\n", + "plt.plot(t , y , 'blue')\n", + "plt . xlabel ( 't [ s ] ')\n", + "plt.grid()\n", + "plt.legend( labels =( 'q2' ,))\n", + "plt.subplot(3 , 1 , 3)\n", + "plt.plot(t , z , 'blue')\n", + "plt.xlabel( 't [ s ]')\n", + "plt.grid()\n", + "plt.legend( labels =( 'd' ,))\n", + "plt.show()\n", + "\n", + "\n", + "x1_arr,y1_arr = cos(x),-sin(x)\n", + "x2_arr,y2_arr = (cos(x)+cos(y)),-(sin(x)+sin(y))\n", + "x3_arr,y3_arr = np.linspace(p1[0],p2[0],nt),np.linspace(p1[1],p2[1],nt)\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(\n", + " 111, aspect=\"equal\", autoscale_on=True, xlim=(-2, 2), ylim=(-2, 2)\n", + ")\n", + "\n", + "ax.grid(alpha=1)\n", + "ax.set_title(\"PUMA Manipulator\")\n", + "ax.set_xticklabels([])\n", + "ax.set_yticklabels([])\n", + "(line, ) = ax.plot(\n", + " [], [], \".-\", lw=1, color=\"black\"\n", + ") \n", + "(line2, ) = ax.plot(\n", + " [], [], \".-\", lw=1, color='black'\n", + ") \n", + "\n", + "\n", + "def init():\n", + " line.set_data([], [])\n", + " return (line,)\n", + "\n", + "def animate(i):\n", + " x_points = [0, x1_arr[i], x3_arr[i]]\n", + " y_points = [0, y1_arr[i], y3_arr[i]]\n", + "\n", + " line.set_data(x_points, y_points) \n", + " return (line,line2,)\n", + "ani = animation.FuncAnimation(\n", + " fig, animate, init_func=init, frames=len(x1_arr)-1, interval=40, blit=True, repeat=False\n", + ")\n", + "\n", + "ani.save('PUMA.mp4', fps=30, extra_args=['-vcodec', 'libx264'])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + }, + "vscode": { + "interpreter": { + "hash": "f5b775166e527c2c4c8c7a313eadde439897f6893f91e429bbc029ec9a09e8d5" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}