From c7f89eaf05a06a473f4a3d0047deeef059783693 Mon Sep 17 00:00:00 2001 From: mcarfagno Date: Wed, 14 Apr 2021 11:38:30 +0100 Subject: [PATCH] forther r&d in track constrains and plots tidy up --- notebooks/3.0-MPC-v3-track-constrains.ipynb | 1094 ++++++++++++++++ notebooks/3.0-MPC-with-track-constrains.ipynb | 1125 ----------------- 2 files changed, 1094 insertions(+), 1125 deletions(-) create mode 100644 notebooks/3.0-MPC-v3-track-constrains.ipynb delete mode 100644 notebooks/3.0-MPC-with-track-constrains.ipynb diff --git a/notebooks/3.0-MPC-v3-track-constrains.ipynb b/notebooks/3.0-MPC-v3-track-constrains.ipynb new file mode 100644 index 0000000..489ee70 --- /dev/null +++ b/notebooks/3.0-MPC-v3-track-constrains.ipynb @@ -0,0 +1,1094 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy.integrate import odeint\n", + "from scipy.interpolate import interp1d\n", + "import cvxpy as cp\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use(\"ggplot\")\n", + "\n", + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Control problem statement.\n", + "\"\"\"\n", + "\n", + "N = 4 #number of state variables\n", + "M = 2 #number of control variables\n", + "T = 20 #Prediction Horizon\n", + "DT = 0.2 #discretization step\n", + "\n", + "def get_linear_model(x_bar,u_bar):\n", + " \"\"\"\n", + " Computes the LTI approximated state space model x' = Ax + Bu + C\n", + " \"\"\"\n", + " \n", + " L=0.3 #vehicle wheelbase\n", + " \n", + " x = x_bar[0]\n", + " y = x_bar[1]\n", + " v = x_bar[2]\n", + " theta = x_bar[3]\n", + " \n", + " a = u_bar[0]\n", + " delta = u_bar[1]\n", + " \n", + " A = np.zeros((N,N))\n", + " A[0,2]=np.cos(theta)\n", + " A[0,3]=-v*np.sin(theta)\n", + " A[1,2]=np.sin(theta)\n", + " A[1,3]=v*np.cos(theta)\n", + " A[3,2]=v*np.tan(delta)/L\n", + " A_lin=np.eye(N)+DT*A\n", + " \n", + " B = np.zeros((N,M))\n", + " B[2,0]=1\n", + " B[3,1]=v/(L*np.cos(delta)**2)\n", + " B_lin=DT*B\n", + " \n", + " f_xu=np.array([v*np.cos(theta), v*np.sin(theta), a,v*np.tan(delta)/L]).reshape(N,1)\n", + " C_lin = DT*(f_xu - np.dot(A,x_bar.reshape(N,1)) - np.dot(B,u_bar.reshape(M,1)))\n", + " \n", + " return np.round(A_lin,4), np.round(B_lin,4), np.round(C_lin,4)\n", + "\n", + "\"\"\"\n", + "the ODE is used to update the simulation given the mpc results\n", + "I use this insted of using the LTI twice\n", + "\"\"\"\n", + "def kinematics_model(x,t,u):\n", + " \"\"\"\n", + " Returns the set of ODE of the vehicle model.\n", + " \"\"\"\n", + " \n", + " L=0.3 #vehicle wheelbase\n", + " dxdt = x[2]*np.cos(x[3])\n", + " dydt = x[2]*np.sin(x[3])\n", + " dvdt = u[0]\n", + " dthetadt = x[2]*np.tan(u[1])/L\n", + "\n", + " dqdt = [dxdt,\n", + " dydt,\n", + " dvdt,\n", + " dthetadt]\n", + "\n", + " return dqdt\n", + "\n", + "def predict(x0,u):\n", + " \"\"\"\n", + " \"\"\"\n", + " \n", + " x_ = np.zeros((N,T+1))\n", + " \n", + " x_[:,0] = x0\n", + " \n", + " # solve ODE\n", + " for t in range(1,T+1):\n", + "\n", + " tspan = [0,DT]\n", + " x_next = odeint(kinematics_model,\n", + " x0,\n", + " tspan,\n", + " args=(u[:,t-1],))\n", + "\n", + " x0 = x_next[1]\n", + " x_[:,t]=x_next[1]\n", + " \n", + " return x_\n", + "\n", + "\n", + "\"\"\"\n", + "MODIFIED TO INCLUDE FRAME TRANSFORMATION\n", + "\"\"\"\n", + "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", + " # watch out to duplicate points!\n", + " final_xp=np.append(final_xp,fx(interp_range)[1:])\n", + " final_yp=np.append(final_yp,fy(interp_range)[1:])\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": "markdown", + "metadata": {}, + "source": [ + "## SMOOTHEN PATH\n", + "\n", + "I use a corner smoothing tecnique to help the line-finding proplem -> this way the line does not change from 0 to pi/2 instantly" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.signal import savgol_filter\n", + "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", + " # watch out to duplicate points!\n", + " final_xp=np.append(final_xp,fx(interp_range)[1:])\n", + " final_yp=np.append(final_yp,fy(interp_range)[1:])\n", + " \n", + " \"\"\"this smoothens up corners\"\"\"\n", + " window_size = 11 # Smoothening filter window\n", + " final_xp = savgol_filter(final_xp, window_size, 1)\n", + " final_yp = savgol_filter(final_yp, window_size, 1)\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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## V3 Add track constraints\n", + "inspried from -> https://arxiv.org/pdf/1711.07300.pdf\n", + "\n", + "explanation here...\n", + "\n", + "benefits:\n", + "* add a soft form of obstacle aoidance" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def generate_track_bounds(track,width=0.5):\n", + " \"\"\"\n", + " in world frame\n", + " \"\"\"\n", + " bounds_low=np.zeros((2, track.shape[1]))\n", + " bounds_upp=np.zeros((2, track.shape[1]))\n", + " \n", + " for idx in range(track.shape[1]):\n", + " x = track[0,idx]\n", + " y = track [1,idx]\n", + " th = track [2,idx]\n", + " \n", + " \"\"\"\n", + " trasform the points\n", + " \"\"\"\n", + " bounds_upp[0, idx] = 0 * np.cos(th) - width * np.sin(th) + x #X\n", + " bounds_upp[1, idx] = 0 * np.sin(th) + width * np.cos(th) + y #Y\n", + " \n", + " bounds_low[0, idx] = 0 * np.cos(th) - (-width) * np.sin(th) + x #X\n", + " bounds_low[1, idx] = 0 * np.sin(th) + (-width) * np.cos(th) + y #Y\n", + " \n", + " return bounds_low, bounds_upp\n", + "\n", + "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", + "lower, upper = generate_track_bounds(track)\n", + "\n", + "plt.figure(figsize=(15,10))\n", + "\n", + "plt.plot(track[0,:],track[1,:],\"b-\")\n", + "plt.plot(lower[0,:],lower[1,:],\"g-\")\n", + "plt.plot(upper[0,:],upper[1,:],\"r-\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "the points can be used to generate the **halfplane constrains** for each reference point.\n", + "the issues (outliers points) should be gone after we are in vehicle frame...\n", + "\n", + "the halfplane constrains are defined given the line equation:\n", + "\n", + "**lower halfplane**\n", + "$$ a1x_1 + b1x_2 = c1 \\rightarrow a1x_1 + b1x_2 \\leq c1$$\n", + "\n", + "**upper halfplane**\n", + "$$ a2x_1 - b2x_2 = c2 \\rightarrow a2x_1 + b2x_2 \\leq c2$$\n", + "\n", + "we want to combine this in matrix form:\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + "x_1 \\\\\n", + "x_2 \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "a_1 & a_2\\\\\n", + "b_1 & b_2\n", + "\\end{bmatrix}\n", + "\\leq\n", + "\\begin{bmatrix}\n", + "c_1 \\\\\n", + "c_2 \n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "becouse our track points have known heading the coefficients can be computed from:\n", + "\n", + "$$ y - y' = \\frac{sin(\\theta)}{cos(\\theta)}(x - x') $$\n", + "\n", + "we have:\n", + "\n", + "$$\n", + "-tan(\\theta)x + y = - tan(\\theta)x' + y'\n", + "$$\n", + "where:\n", + "* $ a = -tan(\\theta) $\n", + "* $ b = 1 $\n", + "* $ c = - tan(\\theta)x' + y' $" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-2.0, 2.0)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUwAAAEzCAYAAABaGjpLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAh0ElEQVR4nO3dfVRU54EG8GeYYYDhc+ZO1KCwCtZU2qSGA2vX+hHXCWtysl1PgqBJTIwxxmJ00eoqGOPZInQ0EhIaWU1EbExiAn5l255m6dRUu5pUFIyrNiGT5LR+lswMw5cQGebuH2mmoQxw5V7mDvD8zsk53Jl37vvMK3m89zIXNaIoiiAion6FqB2AiGioYGESEUnEwiQikoiFSUQkEQuTiEgiFiYRkUQ6uTtwOBzYsWMH3G43NBoNLBYL7r///m5jRFFERUUF6urqEBYWhpycHCQlJcmdmogooGQXplarxaJFi5CUlIT29nZs2LABd911F8aNG+cbU1dXh+vXr6O0tBSffPIJdu/ejaKiIrlTExEFlOxTcqPR6DtajIiIwNixY+FyubqNOX36NGbOnAmNRoNJkyahra0NjY2NcqcmIgooRa9hNjQ04PPPP8fEiRO7Pe5yuWA2m33bgiD0KFUiomAn+5T8ax0dHSguLsbixYthMBi6Pefv7kuNRuN3PzabDTabDQBgtVqVikdEJJsihenxeFBcXIwZM2Zg6tSpPZ4XBAEOh8O37XQ6YTQa/e7LYrHAYrH4tq9evapERFnMZnO3/GpiFv+YxT9m8S8+Pn5Ar5N9Si6KInbu3ImxY8figQce8DsmLS0Nx48fhyiKqK+vh8Fg6LUwiYiClewjzI8//hjHjx9HYmIi1q1bBwBYuHCh72+SjIwM3H333aitrcWqVaug1+uRk5Mjd1oiooCTXZjf/va3UVlZ2ecYjUaDpUuXyp2KiEhVvNOHiEgiFiYRkUQsTCIiiViYREQSsTCJiCRiYRIRScTCJCKSiIVJRCQRC5OISCIWJhGRRCxMIiKJWJhERBKxMImIJGJhEhFJxMIkIpKIhUlEJBELk4hIIhYmEZFELEwiIolYmEREErEwiYgkYmESEUnEwiQikoiFSUQkEQuTiEginRI7KSsrQ21tLWJjY1FcXNzj+QsXLmDbtm0YNWoUAGDq1KnIzMxUYmoiooBRpDDvuecezJ07Fzt27Oh1zOTJk7FhwwYlpiMiUoUip+QpKSmIiopSYldEREFLkSNMKerr67Fu3ToYjUYsWrQICQkJgZqaiEgRGlEURSV21NDQgK1bt/q9hnnjxg2EhIQgPDwctbW12Lt3L0pLS/3ux2azwWazAQCsVitu3rypRDxZdDodPB6P2jEAMEtvmMU/ZvFPr9cP6HUBOcI0GAy+r1NTU1FeXo7m5mbExMT0GGuxWGCxWHzbDocjEBH7ZDabgyIHwCy9YRb/mMW/+Pj4Ab0uIB8rcrvd+PpA1m63w+v1Ijo6OhBTExEpRpEjzBdffBEXL15ES0sLli9fjqysLN+hd0ZGBj744ANUV1dDq9VCr9cjNzcXGo1GiamJiAJGkcLMzc3t8/m5c+di7ty5SkxFRKQa3ulDRCQRC5OISCIWJhGRRCxMIiKJWJhERBKxMImIJGJhEhFJxMIkIpKIhUlEJBELk4hIIhYmEZFELEwiIolYmEREErEwiYgkYmESEUnEwiQikoiFSUQkEQuTiEgiFiYRkUQsTCIiiViYREQSsTCJiCRiYRIRScTCJCKSiIVJRCSRTomdlJWVoba2FrGxsSguLu7xvCiKqKioQF1dHcLCwpCTk4OkpCQlpiYiChhFjjDvuece5Ofn9/p8XV0drl+/jtLSUixbtgy7d+9WYloiooBSpDBTUlIQFRXV6/OnT5/GzJkzodFoMGnSJLS1taGxsVGJqYmIAiYg1zBdLhfMZrNvWxAEuFyuQExNRKQYRa5h9kcUxR6PaTQav2NtNhtsNhsAwGq1ditateh0uqDIATBLb5jFP2ZRVkAKUxAEOBwO37bT6YTRaPQ71mKxwGKx+La/+Tq1mM3moMgBMEtvmMU/ZvEvPj5+QK8LyCl5Wloajh8/DlEUUV9fD4PB0GthEhEFK0WOMF988UVcvHgRLS0tWL58ObKysuDxeAAAGRkZuPvuu1FbW4tVq1ZBr9cjJydHiWmJiAJKkcLMzc3t83mNRoOlS5cqMRURkWp4pw8RkUQsTCIiiViYREQSsTCJiCRiYRIRScTCJCKSiIVJRCQRC5OISCIWJhGRRCxMIiKJWJhERBKxMImIJGJhEhFJxMIkIpKIhUlEJBELk4hIIhYmEZFELEwiIolYmEREErEwiYgkYmESEUnEwiQikoiFSUQkEQuTiEgiFiYRkUQ6JXZy9uxZVFRUwOv1Ys6cOZg3b1635y9cuIBt27Zh1KhRAICpU6ciMzNTiamJiAJGdmF6vV6Ul5fj2WefhSAIyMvLQ1paGsaNG9dt3OTJk7Fhwwa50xERqUb2KbndbseYMWMwevRo6HQ6TJs2DTU1NUpkIyIKKrIL0+VyQRAE37YgCHC5XD3G1dfXY926dSgqKsKlS5fkTktEFHCyT8lFUezxmEaj6bY9YcIElJWVITw8HLW1tXj++edRWlrqd382mw02mw0AYLVaYTab5UaUTafTBUUOgFl6wyz+MYuyZBemIAhwOp2+bafTCaPR2G2MwWDwfZ2amory8nI0NzcjJiamx/4sFgssFotv2+FwyI0om9lsDoocALP0hln8Yxb/4uPjB/Q62afkycnJuHbtGhoaGuDxeHDy5EmkpaV1G+N2u31Hona7HV6vF9HR0XKnJiIKKNlHmFqtFkuWLEFhYSG8Xi9mz56NhIQEVFdXAwAyMjLwwQcfoLq6GlqtFnq9Hrm5uT1O24mIgp0in8NMTU1Fampqt8cyMjJ8X8+dOxdz585VYioiItXwTh8iIolYmEREErEwiYgkYmESEUnEwiQikoiFSUQkEQuTiEgiFiYRkUQsTCIiiViYREQSsTCJiCRiYRIRScTCJCKSiIVJRCQRC5OISCIWJhGRRCxMIiKJWJhERBKxMImIJGJhEhFJxMIkIpKIhUlEJBELk4hIIhYmEZFELEwiIol0Suzk7NmzqKiogNfrxZw5czBv3rxuz4uiiIqKCtTV1SEsLAw5OTlISkpSYmoiooCRfYTp9XpRXl6O/Px8lJSU4MSJE7h8+XK3MXV1dbh+/TpKS0uxbNky7N69W+60REQBJ7sw7XY7xowZg9GjR0On02HatGmoqanpNub06dOYOXMmNBoNJk2ahLa2NjQ2NsqdmojoltXXD/zEWnZhulwuCILg2xYEAS6Xq8cYs9nc5xgiosF28aIOmZlC/wN7IfsapiiKPR7TaDS3POZrNpsNNpsNAGC1WrsVrVp0Ol1Q5ACYpTfM4h+z/E1dnQbZ2ToYDAPfh+zCFAQBTqfTt+10OmE0GnuMcTgcfY75msVigcVi8W1/83VqMZvNQZEDYJbeMIt/zPKV2tpQPPKIgJiYLlRVOQGMHtB+ZJ+SJycn49q1a2hoaIDH48HJkyeRlpbWbUxaWhqOHz8OURRRX18Pg8HQa2ESESmppkaPhQsFGI1eHDzoRGJi14D3JfsIU6vVYsmSJSgsLITX68Xs2bORkJCA6upqAEBGRgbuvvtu1NbWYtWqVdDr9cjJyZE7LRFRv06e1OPxx00YM8aLykoHbr/dK2t/inwOMzU1Fampqd0ey8jI8H2t0WiwdOlSJaYiIpLk+HE9nnjChMTELrz9thOjRskrS4B3+hDRMHT0aBgWLxYwYcJX1yyVKEuAhUlEw0x1dRiefNKESZM6UVnpgNmsTFkCLEwiGkZ++ctwPPWUCd/5TifeftsJk6nnRxrlYGES0bBw5EgEcnKMmDKlE/v3OxEbq2xZAixMIhoGKisjsHJlHP7xH2/izTediI5WviwBFiYRDXFvvmnAmjVx+MEPbmLfPhciIwenLAEWJhENYXv3GrBuXRxmz/4Se/c6ERExeGUJsDCJaIh69dVIbNwYh4yMduze7UJ4+ODPqcgH14mIAmnHjigUFcXg/vvbsWNHI/T6wMzLwiSiIaWkJArbt8dg3rwbeOklN3QBbDEWJhENCaIIbNsWjdLSaGRm3sALL7ih1QY2AwuTiIKeKAJbtsRg584oPPxwG7ZubUKICj+B4Q99iCioiSKwefNXZfn44+qVJcAjTCIKYl4vkJ8fi337IvHUU63YvLkZvfxjDQHBwiSioNTVBfzHf8Tirbci8cwzLdiwoUXVsgRYmEQUhDweYPXqOBw6ZMCaNS1Ys0b9sgRYmEQUZDo7gZUrjfjFLyKwfn0zVq1qVTuSDwuTiILGzZtATo4Rv/51BDZtasLy5W1qR+qGhUlEQaGjA1i2zITf/jYcP/lJE558MrjKEmBhElEQaG8HnnzShGPHwmG1urFo0Q21I/nFwiQiVd24ocHixSacPKnHCy80Iju7Xe1IvWJhEpFqWls1eOwxE2pq9HjpJTceeih4yxJgYRKRSpqaNHj0UQEffhiKHTsa8cMfdqgdqV8sTCIKuMZGDR5+WMAf/xiKXbsacd99wV+WAAuTiALM5QpBdrYAu12HV1914d57v1Q7kmSyCrO1tRUlJSX44osvcNttt2H16tWIiorqMW7FihUIDw9HSEgItFotrFarnGmJaIj64ouvyvJPf9Jh714XZs0aOmUJyCzMI0eO4M4778S8efNw5MgRHDlyBI8++qjfsZs3b0ZMTIyc6YhoCLt6FcjMFHDlihY//7kT06ffVDvSLZP1S5Jqamowa9YsAMCsWbNQU1OjSCgiGl6uXAmBxRKKa9e0eOMN15AsS0DmEWZTUxOMRiMAwGg0orm5udexhYWFAIB7770XFotFzrRENIRcuqTF/PkCmpqAN990Ii2tU+1IA9ZvYRYUFMDtdvd4fMGCBZInKSgogMlkQlNTE7Zs2YL4+HikpKT4HWuz2WCz2QAAVqsVZrNZ8jyDRafTBUUOgFl6wyz+qZ3Fbgfmzw9Fayvwm9+ImDIlVrUsSui3MDdt2tTrc7GxsWhsbITRaERjY2Ov1yhNJpNvfHp6Oux2e6+FabFYuh2BOhyO/iIOOrPZHBQ5AGbpDbP4p2YWu12H7GwBN2968dZbTkyZEhc06xIfHz+g18m6hpmWloZjx44BAI4dO4b09PQeYzo6OtDe3u77+ty5c0hMTJQzLREFuY8+0iEzU0BXF1BV5cR3v+tRO5IiZF3DnDdvHkpKSnD06FGYzWasWbMGAOByubBr1y7k5eWhqakJ27dvBwB0dXVh+vTpmDJliuzgRBScLlzQYcECAaGhQGWlExMnDo+yBACNKIqi2iH6cvXqVbUj8BSrF8zi30jOcu5cKBYuFBARIaKy0oGkpC7VsvRFlVNyIqKvnTkTiuxsAdHRXhw61L0shwsWJhHJduqUHgsXCjCZvDh40InExOFXlgALk4hkOnFCj4cfNmHMmC4cOODA2LHDsywBFiYRyXDsWBgee0xAQkIXDhxw4vbbvWpHGlQsTCIakN/+NgxPPGFCUpIHBw44MWrU8C5LgIVJRAPw7rvhePJJE+64oxOVlQ4IwvAvS4CFSUS36Be/CMfTTxvx3e924q23nDAag/qTiYpiYRKRZIcORSAnx4jU1JvYv9+J2NiRU5YAC5OIJHr77QisWhWH73//Jl5/3YXo6JFVlgALk4gkeP11A9asMWLGjC/x2msuREaOvLIEWJhE1I+KCgPWr4/DnDkdqKhwISJiZJYlwMIkoj7s3BmJZ5+Nw9y57di924XwcLUTqYv/aiQR+fWzn0XBao3BAw+04+WXGxEaqnYi9bEwiagbUQRKSqJQXByDBx+8gZISN3RsCgAsTCL6BlEErNZovPxyNLKybmD7dje0WrVTBQ8WJhEB+Kosf/KTGLzyShQeeaQNVmsTQvhTjm64HEQErxfYtOmrsnziiVZs3cqy9IdHmEQjnNcLbNgQizfeiMTTT7di06ZmaDRqpwpOLEyiEayrC1i7Ng6VlQasXNmC9etbWJZ9YGESjVAeD5CbG4fDhw1Yu7YZubmtLMt+sDCJRqDOTuCZZ4z45S8jsGFDM1aubFU70pDAwiQaYb78EvjRj4z4n/+JwHPPNeHpp9vUjjRksDCJRpCODuCpp0w4ejQcW7a48cQTN9SONKSwMIlGiPZ2DZYsMeL3vw/D1q1uPPooy/JWsTCJRoC2Ng0ef9yEDz7Qo7jYjezsdrUjDUmyCvP9999HVVUVrly5gqKiIiQnJ/sdd/bsWVRUVMDr9WLOnDmYN2+enGmJ6Ba0tGiwaJEJZ87oUVrqxoMPsiwHStZn+RMSErB27VpMnjy51zFerxfl5eXIz89HSUkJTpw4gcuXL8uZlogkcruBhQsF1NXpUVbWyLKUSVZhjhs3DvHx8X2OsdvtGDNmDEaPHg2dTodp06ahpqZGzrREJEFjowb33afD+fOheOWVRvzrv3aoHWnIG/S7RV0uFwRB8G0LggCXyzXY0xKNaE5nCObPN+PCBQ1273bhX/6FZamEfq9hFhQUwO1293h8wYIFSE9P73cCUez56+w1fdxOYLPZYLPZAABWqxVms7nfOQabTqcLihwAs/SGWf7m+nUgO1uHzz/X4J13RMyeHQ0gWrU8X1N7XZTQb2Fu2rRJ1gSCIMDpdPq2nU4njEZjr+MtFgssFotv2+FwyJpfCWazOShyAMzSG2b5yrVrIcjKMuPaNeC115yYPTuG6+JHf5cSezPop+TJycm4du0aGhoa4PF4cPLkSaSlpQ32tEQjzpUrWmRmmtHQEII333ThBz+4qXakYUfWx4pOnTqFPXv2oLm5GVarFePHj8fGjRvhcrmwa9cu5OXlQavVYsmSJSgsLITX68Xs2bORkJCgVH4iAvDnP2uRlSWgqSkE+/c7kZraqXakYUkj+rvIGESuXr2qdoSgOpVgFv9GcpbPPtMiK8uM9nYN9u934q67/laWI3ld+jLQU3Le6UM0hNntOmRlCejsBCorHfjOdzxqRxrWWJhEQ9RHH+mQnS1AowEOHHDijjtYloON/2oH0RB0/rwOmZkCdDrgwAEHyzJAWJhEQ8yHH4YiO9uMiAgRBw44MHFil9qRRgwWJtEQcvp0KLKzBURHe3HokBMTJrAsA4mFSTRE/OEPejz8sABB8OLgQQcSEliWgcbCJBoC/vd/9XjkERNuv70LBw86MHasV+1IIxILkyjIHTsWhscfF/AP/9CFAwecGDOGZakWFiZREPvNb8KweLEJSUkeVFU5cdttLEs1sTCJgtSvfx2Op54yYfLkTlRWOmAysSzVxsIkCkL//d/hePppI+68sxNvveWE0RjUdzCPGCxMoiBz8GAEVqwwIi3tJvbvdyImhmUZLFiYREHkrbci8O//Hofvf/8mXn/dhagolmUwYWESBYnXXjPgxz82YubML/Haay4YDCzLYMPCJAoC5eWRyMuLw5w5Hdizx4WICJZlMGJhEqls585IPPdcLO67rx27d7sQHq52IuoNf70bkYpeeikK27bF4Ic/bEdpaSNCQ9VORH1hYRKpQBSB4uJolJRE48EHb6CkxA0d/28MevwjIgowUQSs1mi8/HI0srNv4Pnn3dBq1U5FUrAwiQJIFIH//M8YvPpqFBYtakNRURNC+JOEIYN/VEQB4vUCzz4bi1dfjcKTT7bipz9lWQ41PMIkCgCvF9iwIRZvvBGJ5ctb8eyzzdBo1E5Ft4qFSTTIurqAH/84DlVVBqxc2YL161tYlkMUC5NoEHk8QG5uHA4fNmDt2masXt2qdiSSgYVJNEg6O4EVK4z41a8ikJ/fjBUrWJZDnazCfP/991FVVYUrV66gqKgIycnJfsetWLEC4eHhCAkJgVarhdVqlTMtUdD78ktg+XIjqqsjsHlzE5Yta1M7EilAVmEmJCRg7dq1eOWVV/odu3nzZsTExMiZjmhIaG8Hli414ejRcBQWurF48Q21I5FCZBXmuHHjlMpBNCy0t2uwaJEO772nwbZtbjzyCMtyOAnYNczCwkIAwL333guLxRKoaYkCpq1Ng8cfN+EPf9DghRfcyMpqVzsSKazfwiwoKIDb7e7x+IIFC5Ceni5pkoKCAphMJjQ1NWHLli2Ij49HSkqK37E2mw02mw0AYLVaYTabJc0xmHQ6XVDkAJilN2pnaW4G5s/X4dQpDV57TcT8+ZEAIlXL8zW11+WbginLQPVbmJs2bZI9iclkAgDExsYiPT0ddru918K0WCzdjkAdDofs+eUym81BkQNglt6omcXt1uDRRwX83/9pUFbWiPnzo7gufgRTlvj4+AG9btBvzOro6EB7e7vv63PnziExMXGwpyUKCJdLgwULBJw/H4pXXmnEAw90qB2JBpGsa5inTp3Cnj170NzcDKvVivHjx2Pjxo1wuVzYtWsX8vLy0NTUhO3btwMAurq6MH36dEyZMkWJ7ESqcjhCsGCBgM8+02HPHhf++Z+/VDsSDTKNKIpB/bvwr169qnaEoDqVYBb/Ap3lL3/5qiz//GctKipcmDnzpmpZ+sIs/g30lJx3+hDdomvXQpCVZcb16yF4/XUX/umfbvb/IhoWWJhEt+DyZS2ysgQ4nSF4800X0tNZliMJC5NIoj/9SYv58wW0tIRg/34nUlM71Y5EAcbCJJLgs8+0mD/fjI4ODSornbjzTpblSMTCJOrHJ5/okJUloKsLqKpyICXFo3YkUgl/QT5RH/74Rx0eekgAABw44GRZjnAsTKJenD+vw/z5AkJDgQMHHJg0iWU50rEwifyoqwtFVpYZBoOIgwcdSE7uUjsSBQEWJtHfqakJxYIFAmJjvTh0yInx41mW9BUWJtE3fPCBHg8/LOC227w4eNCBceNYlvQ3LEyiv/r97/V45BETxo7twsGDDsTHe9WOREGGhUkE4L33wrB4sYAJE7pw4IATo0ezLKknFiaNeNXVYViyxISJEztRWemA2cyyJP9YmDSi/epX4XjqKRNSUjrx9ttOmExB/cu7SGUsTBqx3nknHD/6kRFTpnRi/34n4uJYltQ3FiaNSFVVEXjmGSPS02/ijTeciIlhWVL/WJg04uzfb8Dq1XGYNu0m9u1zISqKZUnSsDBpRNm714C1a+Nwzz1fYu9eJwwGliVJx8KkEePVVyOxcWMc7r23A+XlLkREqJ2Ihhr+ejcaEcrKolBYGIP772/Hjh2N0OvVTkRDEQuThr2Skihs3x6Df/u3GygtdUPH73oaIH7r0LAlisDzz0fjpZei8dBDN1BS4oZWq3YqGspYmDQsiSJQWBiD//qvKCxc2IatW5tYliQbC5OGHVEENm+OQXl5FB57rA2FhU0I4Y83SQH8NqJhxesF8vNjUV4ehaVLW1FUxLIk5cg6wty3bx/OnDkDnU6H0aNHIycnB5GRkT3GnT17FhUVFfB6vZgzZw7mzZsnZ1oiv7q6gPXrY7F/fyRyclqQn98CjUbtVDScyPq796677kJxcTG2b9+O22+/HYcPH+4xxuv1ory8HPn5+SgpKcGJEydw+fJlOdMS9dDVBaxeHYf9+yORm8uypMEhqzC/973vQfvXK+mTJk2Cy+XqMcZut2PMmDEYPXo0dDodpk2bhpqaGjnTEnXT2QksXqzFwYMGrFvXjHXrWJY0OBS7unP06FFMmTKlx+MulwuCIPi2BUHwW6xEA5WbG4fKSi02bmxGbm6r2nFoGOv3GmZBQQHcbnePxxcsWID09HQAwKFDh6DVajFjxowe40Sx5726mj7++rfZbLDZbAAAq9WK+Pj4/iIGRLDkAJjl7/3tSlDMX/9TXzCsy9eYRUGiTO+9956Yn58vdnR0+H3+448/Frds2eLbPnTokHjo0CFJ+16/fr3ceIoIlhyiyCy9YRb/mMW/gWaRdUp+9uxZvPPOO1i/fj3CwsL8jklOTsa1a9fQ0NAAj8eDkydPIi0tTc60RESqkPWxovLycng8HhQUFAAAvvWtb2HZsmVwuVzYtWsX8vLyoNVqsWTJEhQWFsLr9WL27NlISEhQJDwRUSDJKsyf/exnfh83mUzIy8vzbaempiI1NfWW92+xWAacTUnBkgNglt4wi3/M4t9As2hE0c9PZYiIqAfeNEZEJFHQ/PKNYLrN8v3330dVVRWuXLmCoqIiJCcn+x23YsUKhIeHIyQkBFqtFlarVbUsgViX1tZWlJSU4IsvvsBtt92G1atXIyoqqse4wVyX/t6nKIqoqKhAXV0dwsLCkJOTg6SkJMXmv5UsFy5cwLZt2zBq1CgAwNSpU5GZmal4jrKyMtTW1iI2NhbFxcU9ng/kmvSXJVBr4nA4sGPHDrjdbmg0GlgsFtx///3dxgxoXZT7Qb08Z8+eFT0ejyiKorhv3z5x3759PcZ0dXWJzzzzjHj9+nWxs7NTXLt2rXjp0iXFs1y6dEm8cuWKuHnzZtFut/c6LicnR2xqalJ8/lvNEqh12bdvn3j48GFRFEXx8OHDfv+MRHHw1kXK+zxz5oxYWFgoer1e8eOPPxbz8vIUzyE1y/nz58Wf/vSngzL/N124cEH89NNPxTVr1vh9PlBrIiVLoNbE5XKJn376qSiKonjjxg1x1apVinyvBM0peTDdZjlu3Lig+YCtlCyBWpeamhrMmjULADBr1qyA3+Iq5X2ePn0aM2fOhEajwaRJk9DW1obGxkZVsgRKSkqK3yP9rwVqTaRkCRSj0eg7WoyIiMDYsWN7dMpA1iVoCvObhtJtloWFhVi/fr3v7iQ1BGpdmpqaYDQaAXz1Ddnc3Nzr2MFYFynv0+VywWw29zkmUFkAoL6+HuvWrUNRUREuXbqkeA4pArUmUgV6TRoaGvD5559j4sSJ3R4fyLoE9BpmoG+zlJtFyj5MJhOampqwZcsWxMfHIyUlJeBZArUut7IPJdbl70l5n0quhdwsEyZMQFlZGcLDw1FbW4vnn38epaWlimfpT6DWRIpAr0lHRweKi4uxePFiGAyGbs8NZF0CWpibNm3q8/nf/e53OHPmDJ577jm/wQVBgNPp9G07nU7fEY/SWaQwmUwAgNjYWKSnp8Nutw+oGORmCdS6xMbGorGxEUajEY2NjYiJ8X/ftlLr8vekvE9BEOBwOPocowQpWb75P2hqairKy8vR3Nzc67oNlkCtiRSBXBOPx4Pi4mLMmDEDU6dO7fH8QNYlaE7Jh9ptlh0dHWhvb/d9fe7cOSQmJqqSJVDrkpaWhmPHjgEAjh075vfodzDXRcr7TEtLw/HjxyGKIurr62EwGAalHKRkcbvdvqMYu90Or9eL6OhoxbP0J1BrIkWg1kQURezcuRNjx47FAw884HfMQNYlaD64vnLlSng8Ht8FY3+3WQJAbW0tfv7zn/tus3zwwQcVz3Lq1Cns2bMHzc3NiIyMxPjx47Fx48ZuWf7yl79g+/btAICuri5Mnz5dtSxAYNalpaUFJSUlcDgcMJvNWLNmDaKiogK6Lv7eZ3V1NQAgIyMDoiiivLwcH374IfR6PXJycnr9KNZgZ3n33XdRXV0NrVYLvV6Pxx57DHfccYfiOV588UVcvHgRLS0tiI2NRVZWFjwejy9HINekvyyBWpOPPvoIzz33HBITE31nqwsXLvQdUQ50XYKmMImIgl3QnJITEQU7FiYRkUQsTCIiiViYREQSsTCJiCRiYRIRScTCJCKSiIVJRCTR/wNulR8BW1DrJAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use(\"ggplot\")\n", + "\n", + "def get_coeff(x,y,theta):\n", + " m = np.sin(theta)/np.cos(theta)\n", + " return(-m,1,y-m*x)\n", + "\n", + "#test -> assume point 10,1,pi/6\n", + "#coeff = get_coeff(1,-1, np.pi/2)\n", + "coeff = get_coeff(1,-1, np.pi/4)\n", + "y = []\n", + "pts = np.linspace(0,20,100)\n", + "\n", + "for x in pts:\n", + " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", + " \n", + "plt.figure(figsize=(5,5))\n", + "plt.plot(pts,y,\"b-\")\n", + "\n", + "plt.xlim((-2, 2))\n", + "plt.ylim((-2, 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## WARN TANGENT BREAKS AROUND PI/2?\n", + "force the equation to x = val" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-2.0, 2.0)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# def get_coeff(x,y,theta):\n", + " \n", + "# if (theta - np.pi/2) < 0.01:\n", + "# #print (\"WARN -> theta is 90, tan is: \" + str(theta))\n", + "# # eq is x = val\n", + "# m = 0\n", + "# return (1,1e-6,x)\n", + "# else:\n", + "# m = np.sin(theta)/np.cos(theta)\n", + "# return(-m,1,y-m*x)\n", + " \n", + "#test -> assume point 10,1,pi/6\n", + "coeff = get_coeff(1,-1, np.pi/2)\n", + "y = []\n", + "pts = np.linspace(0,20,100)\n", + "\n", + "for x in pts:\n", + " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", + " \n", + "plt.figure(figsize=(5,5))\n", + "\n", + "plt.plot(pts,y,\"b-\")\n", + "plt.axis(\"equal\")\n", + "plt.xlim((-2, 2))\n", + "plt.ylim((-2, 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "becouse the controller uses vhicle reference frame this rquire adapting -> the semiplane constraints must be gathetered from **x_ref points**\n", + "\n", + "*low and up are w.r.t vehicle y axis*" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def get_track_constrains(x_ref, width=0.5):\n", + " \"\"\"\n", + " x_ref has hape (4,T) -> [x,y,v,theta]_ref \n", + " \"\"\"\n", + " \n", + " #1-> get the upper and lower points\n", + " pts_low=np.zeros((3, x_ref.shape[1]))\n", + " pts_upp=np.zeros((3, x_ref.shape[1]))\n", + " \n", + " for idx in range(x_ref.shape[1]):\n", + " x = x_ref [0, idx]\n", + " y = x_ref [1, idx]\n", + " th = x_ref [3, idx]\n", + " \n", + " \"\"\"\n", + " trasform the points\n", + " \"\"\"\n", + " pts_upp[0, idx] = 0 * np.cos(th) - width * np.sin(th) + x #X\n", + " pts_upp[1, idx] = 0 * np.sin(th) + width * np.cos(th) + y #Y\n", + " pts_upp[2, idx] = th #heading\n", + " \n", + " pts_low[0, idx] = 0 * np.cos(th) - (-width) * np.sin(th) + x #X\n", + " pts_low[1, idx] = 0 * np.sin(th) + (-width) * np.cos(th) + y #Y\n", + " pts_low[2, idx] = th #heading\n", + " \n", + " #get coefficients ->(a,b,c)\n", + " coeff_low=np.zeros((3, x_ref.shape[1]))\n", + " coeff_upp=np.zeros((3, x_ref.shape[1]))\n", + " \n", + " for idx in range(pts_upp.shape[1]):\n", + " f = get_coeff(pts_low[0,idx],pts_low[1,idx],pts_low[2,idx])\n", + " coeff_low[0,idx]=f[0]\n", + " coeff_low[1,idx]=f[1]\n", + " coeff_low[2,idx]=f[2]\n", + " \n", + " f = get_coeff(pts_upp[0,idx],pts_upp[1,idx],pts_upp[2,idx])\n", + " coeff_upp[0,idx]=f[0]\n", + " coeff_upp[1,idx]=f[1]\n", + " coeff_upp[2,idx]=f[2]\n", + " \n", + " return coeff_low, coeff_upp\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MPC INTEGRATION\n", + "\n", + "compare the results with and without" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "simpe u-turn test\n", + "\n", + "## 1-> NO BOUNDS" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CVXPY Optimization Time: Avrg: 0.1672s Max: 0.2184s Min: 0.1477s\n" + ] + } + ], + "source": [ + "track = compute_path_from_wp([0,3,3,0],\n", + " [0,0,1,1],0.05)\n", + "\n", + "track_lower, track_upper = generate_track_bounds(track,0.12)\n", + "\n", + "sim_duration = 50 #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.05 #y\n", + "x0[2] = 0.0 #v\n", + "x0[3] = np.radians(-0) #yaw\n", + "x_sim[:,0] = x0 #simulation_starting conditions\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,20]) #state error cost\n", + " Qf = np.diag([30,30,30,30]) #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": 9, + "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(track_lower[0,:],track_lower[1,:],\"g-\")\n", + "plt.plot(track_upper[0,:],track_upper[1,:],\"r-\")\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()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2-> WITH BOUNDS\n", + "if there is 90 deg turn the optimization fails!\n", + "if speed is too high it also fails ..." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CVXPY Optimization Time: Avrg: 0.1760s Max: 0.2117s Min: 0.1617s\n" + ] + } + ], + "source": [ + "WIDTH=0.25\n", + "REF_VEL = 0.2 #m/s\n", + "\n", + "computed_coeff = []\n", + "\n", + "track = compute_path_from_wp([0,3,3,0],\n", + " [0,0,1,1],0.05)\n", + "\n", + "track_lower, track_upper = generate_track_bounds(track,WIDTH)\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", + "\n", + "# Starting Condition\n", + "x0 = np.zeros(N)\n", + "x0[0] = 0 #x\n", + "x0[1] = -WIDTH/2 #y\n", + "x0[2] = 0.0 #v\n", + "x0[3] = np.radians(-0) #yaw\n", + "x_sim[:,0] = x0 #simulation_starting conditions\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,20]) #state error cost\n", + " Qf = np.diag([30,30,30,30]) #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", + " #Track constrains\n", + " low,upp = get_track_constrains(x_ref,WIDTH)\n", + " computed_coeff.append((low,upp))\n", + " for ii in range(low.shape[1]):\n", + " constr += [low[0,ii]*x[0,ii] + x[1,ii] >= low[2,ii]]\n", + " #constr += [upp[0,ii]*x[0,ii] + x[1,ii] <= upp[2,ii]]\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": 14, + "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(track_lower[0,:],track_lower[1,:],\"g.\")\n", + "plt.plot(track_upper[0,:],track_upper[1,:],\"r.\")\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", + "\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()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## VISUALIZE THE COMPUTED HALF-PLANES" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use(\"ggplot\")\n", + "\n", + "\n", + "def plot_low_upp(low, up):\n", + " \"\"\"\n", + " low and upp arre arrays of shape (3,N)\n", + " each column represent the couefficient at each\n", + " step of the optimization\n", + " \"\"\"\n", + " \n", + " #for low,up in zip(low, up):\n", + " for idx in range(low.shape[1]):\n", + " \n", + " ll = low[:,idx]\n", + " uu = up[:,idx]\n", + " \n", + " x = np.linspace(-2,2,100)\n", + "\n", + " #low\n", + " y = []\n", + " for xx in x:\n", + " y.append((-ll[0]*xx+ll[2])/ll[1])\n", + "\n", + " plt.plot(x,y,\"b-\")\n", + "\n", + " #high\n", + " y = []\n", + " for xx in x:\n", + " y.append((-uu[0]*xx+uu[2])/uu[1])\n", + "\n", + " plt.plot(x,y,\"r-\")\n", + "\n", + " plt.xlim((-2, 2))\n", + " plt.ylim((-2, 2))\n", + "\n", + "def plot_lines():\n", + " \"\"\"\n", + " sample randomly from computed coeff\n", + " and plot grid\n", + " \"\"\"\n", + " \n", + " plt.figure(figsize=(15,15))\n", + " indices = np.random.choice(len(computed_coeff), 9)\n", + "\n", + " for i in range(len(indices)):\n", + " plt.subplot(3,3,i+1)\n", + " plt.title(\"t = \"+str(indices[i]))\n", + " plot_low_upp(computed_coeff[indices[i]][0]\n", + " ,computed_coeff[indices[i]][1])\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_lines()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:.conda-jupyter] *", + "language": "python", + "name": "conda-env-.conda-jupyter-py" + }, + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/3.0-MPC-with-track-constrains.ipynb b/notebooks/3.0-MPC-with-track-constrains.ipynb deleted file mode 100644 index 24470f9..0000000 --- a/notebooks/3.0-MPC-with-track-constrains.ipynb +++ /dev/null @@ -1,1125 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from scipy.integrate import odeint\n", - "from scipy.interpolate import interp1d\n", - "import cvxpy as cp\n", - "\n", - "import matplotlib.pyplot as plt\n", - "plt.style.use(\"ggplot\")\n", - "\n", - "import time" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## V3 Add track constraints\n", - "inspried from -> https://arxiv.org/pdf/1711.07300.pdf\n", - "\n", - "explanation here...\n", - "\n", - "benefits:\n", - "* add a soft form of obstacle aoidance" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def generate_track_bounds(track,width=0.5):\n", - " \"\"\"\n", - " in world frame\n", - " \"\"\"\n", - " bounds_low=np.zeros((2, track.shape[1]))\n", - " bounds_upp=np.zeros((2, track.shape[1]))\n", - " \n", - " for idx in range(track.shape[1]):\n", - " x = track[0,idx]\n", - " y = track [1,idx]\n", - " th = track [2,idx]\n", - " \n", - " \"\"\"\n", - " trasform the points\n", - " \"\"\"\n", - " bounds_upp[0, idx] = 0 * np.cos(th) - width * np.sin(th) + x #X\n", - " bounds_upp[1, idx] = 0 * np.sin(th) + width * np.cos(th) + y #Y\n", - " \n", - " bounds_low[0, idx] = 0 * np.cos(th) - (-width) * np.sin(th) + x #X\n", - " bounds_low[1, idx] = 0 * np.sin(th) + (-width) * np.cos(th) + y #Y\n", - " \n", - " return bounds_low, bounds_upp\n", - "\n", - "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", - "lower, upper = generate_track_bounds(track)\n", - "\n", - "plt.figure(figsize=(15,10))\n", - "\n", - "plt.plot(track[0,:],track[1,:],\"b-\")\n", - "plt.plot(lower[0,:],lower[1,:],\"g-\")\n", - "plt.plot(upper[0,:],upper[1,:],\"r-\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "the points can be used to generate the **halfplane constrains** for each reference point.\n", - "the issues (outliers points) should be gone after we are in vehicle frame...\n", - "\n", - "the halfplane constrains are defined given the line equation:\n", - "\n", - "**lower halfplane**\n", - "$$ a1x_1 + b1x_2 = c1 \\rightarrow a1x_1 + b1x_2 \\leq c1$$\n", - "\n", - "**upper halfplane**\n", - "$$ a2x_1 - b2x_2 = c2 \\rightarrow a2x_1 + b2x_2 \\leq c2$$\n", - "\n", - "we want to combine this in matrix form:\n", - "\n", - "$$\n", - "\\begin{bmatrix}\n", - "x_1 \\\\\n", - "x_2 \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "a_1 & a_2\\\\\n", - "b_1 & b_2\n", - "\\end{bmatrix}\n", - "\\leq\n", - "\\begin{bmatrix}\n", - "c_1 \\\\\n", - "c_2 \n", - "\\end{bmatrix}\n", - "$$\n", - "\n", - "becouse our track points have known heading the coefficients can be computed from:\n", - "\n", - "$$ y - y' = \\frac{sin(\\theta)}{cos(\\theta)}(x - x') $$" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-2.0, 2.0)" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "plt.style.use(\"ggplot\")\n", - "\n", - "def get_coeff(x,y,theta):\n", - " m = np.sin(theta)/np.cos(theta)\n", - " return(-m,1,y-m*x)\n", - "\n", - "#test -> assume point 10,1,pi/6\n", - "coeff = get_coeff(1,-1, np.pi/2)\n", - "y = []\n", - "pts = np.linspace(0,20,100)\n", - "\n", - "for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - "plt.figure(figsize=(5,5))\n", - "plt.plot(pts,y,\"b-\")\n", - "\n", - "plt.xlim((-2, 2))\n", - "plt.ylim((-2, 2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## WARN TANGENT BREAKS AROUND PI/2?\n", - "force the equation to x = val" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-2.0, 2.0)" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def get_coeff(x,y,theta):\n", - " \n", - " if (theta - np.pi/2) < 0.01:\n", - " #print (\"WARN -> theta is 90, tan is: \" + str(theta))\n", - " # eq is x = val\n", - " m = 0\n", - " return (1,1e-6,x)\n", - " else:\n", - " m = np.sin(theta)/np.cos(theta)\n", - " return(-m,1,y-m*x)\n", - " \n", - "#test -> assume point 10,1,pi/6\n", - "coeff = get_coeff(1,-1, np.pi/2)\n", - "y = []\n", - "pts = np.linspace(0,20,100)\n", - "\n", - "for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - "plt.figure(figsize=(5,5))\n", - "\n", - "plt.plot(pts,y,\"b-\")\n", - "plt.axis(\"equal\")\n", - "plt.xlim((-2, 2))\n", - "plt.ylim((-2, 2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "becouse the controller uses vhicle reference frame this rquire adapting -> the semiplane constraints must be gathetered from **x_ref points**\n", - "\n", - "*low and up are w.r.t vehicle y axis*" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "def get_track_constrains(x_ref, width=0.5):\n", - " \"\"\"\n", - " x_ref has hape (4,T) -> [x,y,v,theta]_ref \n", - " \"\"\"\n", - " \n", - " #1-> get the upper and lower points\n", - " pts_low=np.zeros((3, x_ref.shape[1]))\n", - " pts_upp=np.zeros((3, x_ref.shape[1]))\n", - " \n", - " for idx in range(x_ref.shape[1]):\n", - " x = x_ref [0, idx]\n", - " y = x_ref [1, idx]\n", - " th = x_ref [3, idx]\n", - " \n", - " \"\"\"\n", - " trasform the points\n", - " \"\"\"\n", - " pts_upp[0, idx] = 0 * np.cos(th) - width * np.sin(th) + x #X\n", - " pts_upp[1, idx] = 0 * np.sin(th) + width * np.cos(th) + y #Y\n", - " pts_upp[2, idx] = th #heading\n", - " \n", - " pts_low[0, idx] = 0 * np.cos(th) - (-width) * np.sin(th) + x #X\n", - " pts_low[1, idx] = 0 * np.sin(th) + (-width) * np.cos(th) + y #Y\n", - " pts_low[2, idx] = th #heading\n", - " \n", - " #get coefficients ->(a,b,c)\n", - " coeff_low=np.zeros((3, x_ref.shape[1]))\n", - " coeff_upp=np.zeros((3, x_ref.shape[1]))\n", - " \n", - " for idx in range(pts_upp.shape[1]):\n", - " f = get_coeff(pts_low[0,idx],pts_low[1,idx],pts_low[2,idx])\n", - " coeff_low[0,idx]=f[0]\n", - " coeff_low[1,idx]=f[1]\n", - " coeff_low[2,idx]=f[2]\n", - " \n", - " f = get_coeff(pts_upp[0,idx],pts_upp[1,idx],pts_upp[2,idx])\n", - " coeff_upp[0,idx]=f[0]\n", - " coeff_upp[1,idx]=f[1]\n", - " coeff_upp[2,idx]=f[2]\n", - " \n", - " return coeff_low, coeff_upp\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## MPC INTEGRATION\n", - "\n", - "compare the results with and without" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "Control problem statement.\n", - "\"\"\"\n", - "\n", - "N = 4 #number of state variables\n", - "M = 2 #number of control variables\n", - "T = 20 #Prediction Horizon\n", - "DT = 0.2 #discretization step\n", - "\n", - "def get_linear_model(x_bar,u_bar):\n", - " \"\"\"\n", - " Computes the LTI approximated state space model x' = Ax + Bu + C\n", - " \"\"\"\n", - " \n", - " L=0.3 #vehicle wheelbase\n", - " \n", - " x = x_bar[0]\n", - " y = x_bar[1]\n", - " v = x_bar[2]\n", - " theta = x_bar[3]\n", - " \n", - " a = u_bar[0]\n", - " delta = u_bar[1]\n", - " \n", - " A = np.zeros((N,N))\n", - " A[0,2]=np.cos(theta)\n", - " A[0,3]=-v*np.sin(theta)\n", - " A[1,2]=np.sin(theta)\n", - " A[1,3]=v*np.cos(theta)\n", - " A[3,2]=v*np.tan(delta)/L\n", - " A_lin=np.eye(N)+DT*A\n", - " \n", - " B = np.zeros((N,M))\n", - " B[2,0]=1\n", - " B[3,1]=v/(L*np.cos(delta)**2)\n", - " B_lin=DT*B\n", - " \n", - " f_xu=np.array([v*np.cos(theta), v*np.sin(theta), a,v*np.tan(delta)/L]).reshape(N,1)\n", - " C_lin = DT*(f_xu - np.dot(A,x_bar.reshape(N,1)) - np.dot(B,u_bar.reshape(M,1)))\n", - " \n", - " return np.round(A_lin,4), np.round(B_lin,4), np.round(C_lin,4)\n", - "\n", - "\"\"\"\n", - "the ODE is used to update the simulation given the mpc results\n", - "I use this insted of using the LTI twice\n", - "\"\"\"\n", - "def kinematics_model(x,t,u):\n", - " \"\"\"\n", - " Returns the set of ODE of the vehicle model.\n", - " \"\"\"\n", - " \n", - " L=0.3 #vehicle wheelbase\n", - " dxdt = x[2]*np.cos(x[3])\n", - " dydt = x[2]*np.sin(x[3])\n", - " dvdt = u[0]\n", - " dthetadt = x[2]*np.tan(u[1])/L\n", - "\n", - " dqdt = [dxdt,\n", - " dydt,\n", - " dvdt,\n", - " dthetadt]\n", - "\n", - " return dqdt\n", - "\n", - "def predict(x0,u):\n", - " \"\"\"\n", - " \"\"\"\n", - " \n", - " x_ = np.zeros((N,T+1))\n", - " \n", - " x_[:,0] = x0\n", - " \n", - " # solve ODE\n", - " for t in range(1,T+1):\n", - "\n", - " tspan = [0,DT]\n", - " x_next = odeint(kinematics_model,\n", - " x0,\n", - " tspan,\n", - " args=(u[:,t-1],))\n", - "\n", - " x0 = x_next[1]\n", - " x_[:,t]=x_next[1]\n", - " \n", - " return x_\n", - "\n", - "\n", - "\"\"\"\n", - "MODIFIED TO INCLUDE FRAME TRANSFORMATION\n", - "\"\"\"\n", - "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", - " # watch out to duplicate points!\n", - " final_xp=np.append(final_xp,fx(interp_range)[1:])\n", - " final_yp=np.append(final_yp,fy(interp_range)[1:])\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": "markdown", - "metadata": {}, - "source": [ - "simpe u-turn test\n", - "\n", - "## 1-> NO BOUNDS" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CVXPY Optimization Time: Avrg: 0.1656s Max: 0.2061s Min: 0.1480s\n" - ] - } - ], - "source": [ - "track = compute_path_from_wp([0,3,3,0],\n", - " [0,0,1,1],0.05)\n", - "\n", - "track_lower, track_upper = generate_track_bounds(track,0.12)\n", - "\n", - "sim_duration = 50 #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,20]) #state error cost\n", - " Qf = np.diag([30,30,30,30]) #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": 23, - "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(track_lower[0,:],track_lower[1,:],\"g-\")\n", - "plt.plot(track_upper[0,:],track_upper[1,:],\"r-\")\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()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2-> WITH BOUNDS\n", - "if there is 90 deg turn the optimization fails!\n", - "if speed is too high it also fails ..." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.signal import savgol_filter\n", - "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", - " # watch out to duplicate points!\n", - " final_xp=np.append(final_xp,fx(interp_range)[1:])\n", - " final_yp=np.append(final_yp,fy(interp_range)[1:])\n", - " \n", - " \"\"\"this smoothens up corners\"\"\"\n", - " window_size = 11 # Smoothening filter window\n", - " final_xp = savgol_filter(final_xp, window_size, 1)\n", - " final_yp = savgol_filter(final_yp, window_size, 1)\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" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/marcello/.conda/envs/jupyter/lib/python3.8/site-packages/cvxpy/problems/problem.py:1054: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CVXPY Optimization Time: Avrg: 0.1837s Max: 0.2651s Min: 0.1593s\n" - ] - } - ], - "source": [ - "WIDTH=0.12\n", - "computed_coeff = []\n", - "\n", - "track = compute_path_from_wp([0,3,3,0],\n", - " [0,0,1,1],0.05)\n", - "\n", - "track_lower, track_upper = generate_track_bounds(track,WIDTH)\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 = 0.4 #m/s\n", - "\n", - "# Starting Condition\n", - "x0 = np.zeros(N)\n", - "x0[0] = 0 #x\n", - "x0[1] = -WIDTH/2 #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,20]) #state error cost\n", - " Qf = np.diag([30,30,30,30]) #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", - " #Track constrains\n", - " low,upp = get_track_constrains(x_ref,WIDTH)\n", - " computed_coeff.append((low,upp))\n", - " for ii in range(low.shape[1]):\n", - " constr += [low[0,ii]*x[0,ii] + x[1,ii] >= low[2,ii]]\n", - " #constr += [upp[0,ii]*x[0,ii] + x[1,ii] <= upp[2,ii]]\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": 63, - "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(track_lower[0,:],track_lower[1,:],\"g.\")\n", - "plt.plot(track_upper[0,:],track_upper[1,:],\"r.\")\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", - "\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()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## VISUALIZE THE COMPUTED HALF-PLANES" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "plt.style.use(\"ggplot\")\n", - "\n", - "times = np.linspace(1,len(computed_coeff)/10,4).astype(int)\n", - "\n", - "plt.figure(figsize=(5,5))\n", - "pts = np.linspace(-2,2,100)\n", - "\n", - "\"\"\"\n", - "this needs tydy up badly...\n", - "\"\"\"\n", - "\n", - "plt.subplot(2, 2, 1)\n", - "c1 = computed_coeff[times[0]][0]\n", - "c2 = computed_coeff[times[0]][1]\n", - "for idx in range(c.shape[1]):\n", - " #low\n", - " coeff = c1[:,idx]\n", - " y = []\n", - "\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"b-\")\n", - " \n", - " #high\n", - " coeff = c2[:,idx]\n", - " y = []\n", - "\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"r-\")\n", - " plt.xlim((-2, 2))\n", - " plt.ylim((-2, 2))\n", - "\n", - "\n", - "plt.subplot(2, 2, 2)\n", - "c1 = computed_coeff[times[1]][0]\n", - "c2 = computed_coeff[times[1]][1]\n", - "for idx in range(c.shape[1]):\n", - " #low\n", - " coeff = c1[:,idx]\n", - " y = []\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"b-\")\n", - " \n", - " #high\n", - " coeff = c2[:,idx]\n", - " y = []\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"r-\")\n", - " plt.xlim((-2, 2))\n", - " plt.ylim((-2, 2))\n", - "\n", - "\n", - "plt.subplot(2, 2, 3)\n", - "c1 = computed_coeff[times[2]][0]\n", - "c2 = computed_coeff[times[2]][1]\n", - "for idx in range(c.shape[1]):\n", - " #low\n", - " coeff = c1[:,idx]\n", - " y = []\n", - "\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"b-\")\n", - " \n", - " #high\n", - " coeff = c2[:,idx]\n", - " y = []\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"r-\")\n", - " plt.xlim((-2, 2))\n", - " plt.ylim((-2, 2))\n", - "\n", - "plt.subplot(2, 2, 4)\n", - "c1 = computed_coeff[times[3]][0]\n", - "c2 = computed_coeff[times[3]][1]\n", - "for idx in range(c.shape[1]):\n", - " #low\n", - " coeff = c1[:,idx]\n", - " y = []\n", - "\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"b-\")\n", - " \n", - " #high\n", - " coeff = c2[:,idx]\n", - " y = []\n", - " for x in pts:\n", - " y.append((-coeff[0]*x+coeff[2])/coeff[1])\n", - " \n", - " plt.plot(pts,y,\"r-\")\n", - " plt.xlim((-2, 2))\n", - " plt.ylim((-2, 2))\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:.conda-jupyter] *", - "language": "python", - "name": "conda-env-.conda-jupyter-py" - }, - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -}