From bb54b772c5fa32a99bcb04e420db33bf0be9ad69 Mon Sep 17 00:00:00 2001 From: mcarfagno Date: Tue, 2 Mar 2021 14:25:29 +0000 Subject: [PATCH] added trial with ref traj in robot frame --- notebooks/MPC_racecar_crosstrack.ipynb | 2 +- notebooks/MPC_racecar_tracking.ipynb | 344 +++++++++++++++++++++++-- 2 files changed, 327 insertions(+), 19 deletions(-) diff --git a/notebooks/MPC_racecar_crosstrack.ipynb b/notebooks/MPC_racecar_crosstrack.ipynb index 310adac..d6b4e58 100644 --- a/notebooks/MPC_racecar_crosstrack.ipynb +++ b/notebooks/MPC_racecar_crosstrack.ipynb @@ -1217,7 +1217,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/notebooks/MPC_racecar_tracking.ipynb b/notebooks/MPC_racecar_tracking.ipynb index cbce5c7..06e4d66 100644 --- a/notebooks/MPC_racecar_tracking.ipynb +++ b/notebooks/MPC_racecar_tracking.ipynb @@ -292,8 +292,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.06 ms, sys: 0 ns, total: 3.06 ms\n", - "Wall time: 2.72 ms\n" + "CPU times: user 3.29 ms, sys: 0 ns, total: 3.29 ms\n", + "Wall time: 2.74 ms\n" ] } ], @@ -371,8 +371,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 0 ns, sys: 2.51 ms, total: 2.51 ms\n", - "Wall time: 1.74 ms\n" + "CPU times: user 2.63 ms, sys: 0 ns, total: 2.63 ms\n", + "Wall time: 1.94 ms\n" ] } ], @@ -673,18 +673,18 @@ " warm start: on, polish: on, time_limit: off\n", "\n", "iter objective pri res dua res rho time\n", - " 1 0.0000e+00 4.27e+00 4.67e+02 1.00e-01 3.72e-04s\n", - " 175 1.6965e+02 2.63e-05 3.49e-05 7.14e+00 1.83e-03s\n", + " 1 0.0000e+00 4.27e+00 4.67e+02 1.00e-01 3.81e-04s\n", + " 175 1.6965e+02 2.63e-05 3.49e-05 7.14e+00 1.84e-03s\n", "\n", "status: solved\n", "solution polish: unsuccessful\n", "number of iterations: 175\n", "optimal objective: 169.6454\n", - "run time: 2.07e-03s\n", + "run time: 2.10e-03s\n", "optimal rho estimate: 6.34e+00\n", "\n", - "CPU times: user 120 ms, sys: 4.12 ms, total: 125 ms\n", - "Wall time: 127 ms\n" + "CPU times: user 122 ms, sys: 187 µs, total: 123 ms\n", + "Wall time: 119 ms\n" ] } ], @@ -838,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -853,7 +853,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CVXPY Optimization Time: Avrg: 0.1708s Max: 0.2599s Min: 0.1510s\n" + "CVXPY Optimization Time: Avrg: 0.1610s Max: 0.2291s Min: 0.1434s\n" ] } ], @@ -977,7 +977,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -1040,7 +1040,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -1055,7 +1055,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CVXPY Optimization Time: Avrg: 0.6106s Max: 0.9317s Min: 0.3077s\n" + "CVXPY Optimization Time: Avrg: 0.5635s Max: 0.8227s Min: 0.2898s\n" ] } ], @@ -1194,7 +1194,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1245,8 +1245,316 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## OBSTACLE AVOIDANCE\n", - "see dccp paper for reference" + "## Use Dynamics w.r.t Robot Frame\n", + "\n", + "explanation here...\n", + "\n", + "benefits:\n", + "* faster mpc convergence time" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_path_from_wp(start_xp, start_yp, step = 0.1):\n", + " \"\"\"\n", + " Computes a reference path given a set of waypoints\n", + " \"\"\"\n", + " \n", + " final_xp=[]\n", + " final_yp=[]\n", + " delta = step #[m]\n", + "\n", + " for idx in range(len(start_xp)-1):\n", + " section_len = np.sum(np.sqrt(np.power(np.diff(start_xp[idx:idx+2]),2)+np.power(np.diff(start_yp[idx:idx+2]),2)))\n", + "\n", + " interp_range = np.linspace(0,1,np.floor(section_len/delta).astype(int))\n", + " \n", + " fx=interp1d(np.linspace(0,1,2),start_xp[idx:idx+2],kind=1)\n", + " fy=interp1d(np.linspace(0,1,2),start_yp[idx:idx+2],kind=1)\n", + " \n", + " final_xp=np.append(final_xp,fx(interp_range))\n", + " final_yp=np.append(final_yp,fy(interp_range))\n", + " \n", + " dx = np.append(0, np.diff(final_xp))\n", + " dy = np.append(0, np.diff(final_yp))\n", + " theta = np.arctan2(dy, dx)\n", + "\n", + " return np.vstack((final_xp,final_yp,theta))\n", + "\n", + "\n", + "def get_nn_idx(state,path):\n", + " \"\"\"\n", + " Computes the index of the waypoint closest to vehicle\n", + " \"\"\"\n", + "\n", + " dx = state[0]-path[0,:]\n", + " dy = state[1]-path[1,:]\n", + " dist = np.hypot(dx,dy)\n", + " nn_idx = np.argmin(dist)\n", + "\n", + " try:\n", + " v = [path[0,nn_idx+1] - path[0,nn_idx],\n", + " path[1,nn_idx+1] - path[1,nn_idx]] \n", + " v /= np.linalg.norm(v)\n", + "\n", + " d = [path[0,nn_idx] - state[0],\n", + " path[1,nn_idx] - state[1]]\n", + "\n", + " if np.dot(d,v) > 0:\n", + " target_idx = nn_idx\n", + " else:\n", + " target_idx = nn_idx+1\n", + "\n", + " except IndexError as e:\n", + " target_idx = nn_idx\n", + "\n", + " return target_idx\n", + "\n", + "def normalize_angle(angle):\n", + " \"\"\"\n", + " Normalize an angle to [-pi, pi]\n", + " \"\"\"\n", + " while angle > np.pi:\n", + " angle -= 2.0 * np.pi\n", + "\n", + " while angle < -np.pi:\n", + " angle += 2.0 * np.pi\n", + "\n", + " return angle\n", + "\n", + "def get_ref_trajectory(state, path, target_v):\n", + " \"\"\"\n", + " modified reference in robot frame\n", + " \"\"\"\n", + " xref = np.zeros((N, T + 1))\n", + " dref = np.zeros((1, T + 1))\n", + " \n", + " #sp = np.ones((1,T +1))*target_v #speed profile\n", + " \n", + " ncourse = path.shape[1]\n", + "\n", + " ind = get_nn_idx(state, path)\n", + " dx=path[0,ind] - state[0]\n", + " dy=path[1,ind] - state[1]\n", + " \n", + " xref[0, 0] = dx * np.cos(-state[3]) - dy * np.sin(-state[3]) #X\n", + " xref[1, 0] = dy * np.cos(-state[3]) + dx * np.sin(-state[3]) #Y\n", + " xref[2, 0] = target_v #V\n", + " xref[3, 0] = normalize_angle(path[2,ind]- state[3]) #Theta\n", + " dref[0, 0] = 0.0 # steer operational point should be 0\n", + " \n", + " dl = 0.05 # Waypoints spacing [m]\n", + " travel = 0.0\n", + " \n", + " for i in range(T + 1):\n", + " travel += abs(target_v) * DT #current V or target V?\n", + " dind = int(round(travel / dl))\n", + " \n", + " if (ind + dind) < ncourse:\n", + " dx=path[0,ind + dind] - state[0]\n", + " dy=path[1,ind + dind] - state[1]\n", + " \n", + " xref[0, i] = dx * np.cos(-state[3]) - dy * np.sin(-state[3])\n", + " xref[1, i] = dy * np.cos(-state[3]) + dx * np.sin(-state[3])\n", + " xref[2, i] = target_v #sp[ind + dind]\n", + " xref[3, i] = normalize_angle(path[2,ind + dind] - state[3])\n", + " dref[0, i] = 0.0\n", + " else:\n", + " dx=path[0,ncourse - 1] - state[0]\n", + " dy=path[1,ncourse - 1] - state[1]\n", + " \n", + " xref[0, i] = dx * np.cos(-state[3]) - dy * np.sin(-state[3])\n", + " xref[1, i] = dy * np.cos(-state[3]) + dx * np.sin(-state[3])\n", + " xref[2, i] = 0.0 #stop? #sp[ncourse - 1]\n", + " xref[3, i] = normalize_angle(path[2,ncourse - 1] - state[3])\n", + " dref[0, i] = 0.0\n", + "\n", + " return xref, dref" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CVXPY Optimization Time: Avrg: 0.1598s Max: 0.1950s Min: 0.1460s\n" + ] + } + ], + "source": [ + "track = compute_path_from_wp([0,3,4,6,10,12,14,6,1,0],\n", + " [0,0,2,4,3,3,-2,-6,-2,-2],0.05)\n", + "\n", + "# track = compute_path_from_wp([0,10,10,0],\n", + "# [0,0,1,1],0.05)\n", + "\n", + "sim_duration = 200 #time steps\n", + "opt_time=[]\n", + "\n", + "x_sim = np.zeros((N,sim_duration))\n", + "u_sim = np.zeros((M,sim_duration-1))\n", + "\n", + "MAX_SPEED = 1.5 #m/s\n", + "MAX_ACC = 1.0 #m/ss\n", + "MAX_D_ACC = 1.0 #m/sss\n", + "MAX_STEER = np.radians(30) #rad\n", + "MAX_D_STEER = np.radians(30) #rad/s\n", + "\n", + "REF_VEL = 1.0 #m/s\n", + "\n", + "# Starting Condition\n", + "x0 = np.zeros(N)\n", + "x0[0] = 0 #x\n", + "x0[1] = -0.25 #y\n", + "x0[2] = 0.0 #v\n", + "x0[3] = np.radians(-0) #yaw\n", + " \n", + "#starting guess\n", + "u_bar = np.zeros((M,T))\n", + "u_bar[0,:] = MAX_ACC/2 #a\n", + "u_bar[1,:] = 0.0 #delta\n", + "\n", + "for sim_time in range(sim_duration-1):\n", + " \n", + " iter_start = time.time()\n", + " \n", + " # dynamics starting state w.r.t. robot are always null except vel \n", + " x_bar = np.zeros((N,T+1))\n", + " x_bar[2,0] = x_sim[2,sim_time]\n", + " \n", + " #prediction for linearization of costrains\n", + " for t in range (1,T+1):\n", + " xt = x_bar[:,t-1].reshape(N,1)\n", + " ut = u_bar[:,t-1].reshape(M,1)\n", + " A,B,C = get_linear_model(xt,ut)\n", + " xt_plus_one = np.squeeze(np.dot(A,xt)+np.dot(B,ut)+C)\n", + " x_bar[:,t] = xt_plus_one\n", + " \n", + " #CVXPY Linear MPC problem statement\n", + " x = cp.Variable((N, T+1))\n", + " u = cp.Variable((M, T))\n", + " cost = 0\n", + " constr = []\n", + "\n", + " # Cost Matrices\n", + " Q = np.diag([20,20,10,0]) #state error cost\n", + " Qf = np.diag([30,30,30,0]) #state final error cost\n", + " R = np.diag([10,10]) #input cost\n", + " R_ = np.diag([10,10]) #input rate of change cost\n", + "\n", + " #Get Reference_traj\n", + " #dont use x0 in this case\n", + " x_ref, d_ref = get_ref_trajectory(x_sim[:,sim_time] ,track, REF_VEL)\n", + " \n", + " #Prediction Horizon\n", + " for t in range(T):\n", + "\n", + " # Tracking Error\n", + " cost += cp.quad_form(x[:,t] - x_ref[:,t], Q)\n", + "\n", + " # Actuation effort\n", + " cost += cp.quad_form(u[:,t], R)\n", + "\n", + " # Actuation rate of change\n", + " if t < (T - 1):\n", + " cost += cp.quad_form(u[:,t+1] - u[:,t], R_)\n", + " constr+= [cp.abs(u[0, t + 1] - u[0, t])/DT <= MAX_D_ACC] #max acc rate of change\n", + " constr += [cp.abs(u[1, t + 1] - u[1, t])/DT <= MAX_D_STEER] #max steer rate of change\n", + "\n", + " # Kinrmatics Constrains (Linearized model)\n", + " A,B,C = get_linear_model(x_bar[:,t], u_bar[:,t])\n", + " constr += [x[:,t+1] == A@x[:,t] + B@u[:,t] + C.flatten()]\n", + " \n", + " #Final Point tracking\n", + " cost += cp.quad_form(x[:, T] - x_ref[:, T], Qf)\n", + "\n", + " # sums problem objectives and concatenates constraints.\n", + " constr += [x[:,0] == x_bar[:,0]] #starting condition\n", + " constr += [x[2,:] <= MAX_SPEED] #max speed\n", + " constr += [x[2,:] >= 0.0] #min_speed (not really needed)\n", + " constr += [cp.abs(u[0,:]) <= MAX_ACC] #max acc\n", + " constr += [cp.abs(u[1,:]) <= MAX_STEER] #max steer\n", + " \n", + " # Solve\n", + " prob = cp.Problem(cp.Minimize(cost), constr)\n", + " solution = prob.solve(solver=cp.OSQP, verbose=False)\n", + " \n", + " #retrieved optimized U and assign to u_bar to linearize in next step\n", + " u_bar = np.vstack((np.array(u.value[0,:]).flatten(),\n", + " (np.array(u.value[1,:]).flatten())))\n", + " \n", + " u_sim[:,sim_time] = u_bar[:,0]\n", + " \n", + " # Measure elpased time to get results from cvxpy\n", + " opt_time.append(time.time()-iter_start)\n", + " \n", + " # move simulation to t+1\n", + " tspan = [0,DT]\n", + " x_sim[:,sim_time+1] = odeint(kinematics_model,\n", + " x_sim[:,sim_time],\n", + " tspan,\n", + " args=(u_bar[:,0],))[1]\n", + " \n", + "print(\"CVXPY Optimization Time: Avrg: {:.4f}s Max: {:.4f}s Min: {:.4f}s\".format(np.mean(opt_time),\n", + " np.max(opt_time),\n", + " np.min(opt_time))) " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot trajectory\n", + "grid = plt.GridSpec(4, 5)\n", + "\n", + "plt.figure(figsize=(15,10))\n", + "\n", + "plt.subplot(grid[0:4, 0:4])\n", + "plt.plot(track[0,:],track[1,:],\"b+\")\n", + "plt.plot(x_sim[0,:],x_sim[1,:])\n", + "plt.axis(\"equal\")\n", + "plt.ylabel('y')\n", + "plt.xlabel('x')\n", + "\n", + "plt.subplot(grid[0, 4])\n", + "plt.plot(u_sim[0,:])\n", + "plt.ylabel('a(t) [m/ss]')\n", + "\n", + "plt.subplot(grid[1, 4])\n", + "plt.plot(x_sim[2,:])\n", + "plt.ylabel('v(t) [m/s]')\n", + "\n", + "plt.subplot(grid[2, 4])\n", + "plt.plot(np.degrees(u_sim[1,:]))\n", + "plt.ylabel('delta(t) [rad]')\n", + "\n", + "plt.subplot(grid[3, 4])\n", + "plt.plot(x_sim[3,:])\n", + "plt.ylabel('theta(t) [rad]')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" ] }, { @@ -1273,7 +1581,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.8.5" } }, "nbformat": 4,