quadsim.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quadrotor Simulator\n",
    "\n",
    "In order to easily simulate different algorithms, a simulation test bed must be created. This Python class deals with the plumbing between the controller, estimation, and the model of a quadrotor system. This notebook also provides abstract base classes for `Controller` and `Estimator`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "%run quadrotor_model.ipynb\n",
    "%run utils.ipynb\n",
    "%run sensors.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Controller(object):\n",
    "    \"\"\"Controller\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.name = \"Manual\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "    \n",
    "    def update(self, commanded, state, pkt, Ts):\n",
    "        return np.array([[10, 0, 0, 0]]).T, commanded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Estimator(object):\n",
    "    \"\"\"Estimator\n",
    "    \"\"\"\n",
    "    def __init__(self, body=False):\n",
    "        self.name = \"Truth\"\n",
    "        \n",
    "        # should the translational velocity be expressed\n",
    "        # in the body-fixed frame or the inertial frame?\n",
    "        self.body = body\n",
    "        \n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "    \n",
    "    def get_truth(self, quad):\n",
    "        \"\"\"Get Truth\n",
    "        \n",
    "        Obtain the true state from the simulated\n",
    "        quadrotor object.\n",
    "        \"\"\"\n",
    "        state = np.zeros((12,1))\n",
    "        state[0:3] = quad.r\n",
    "        state[3:6] = Rot_i_to_b(*quad.Phi.flatten()).dot(quad.v) if self.body else quad.v\n",
    "        state[6:9] = quad.Phi\n",
    "        state[9:12] = quad.omega\n",
    "        return state\n",
    "    \n",
    "    def update(self, quad, u, Ts):\n",
    "        \"\"\"Update\n",
    "        \n",
    "        The default estimator is to use truth.\n",
    "        \"\"\"\n",
    "        state = self.get_truth(quad)\n",
    "        return state, state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Commander(object):\n",
    "    \"\"\"Commander\n",
    "    \n",
    "    Allows the user to create flexible vehicle commands\n",
    "    for the given controller. The default commander is\n",
    "    a set point at 0.\n",
    "    \n",
    "    This class also allows the user to command any subset\n",
    "    of vehicle states.\n",
    "    \"\"\"\n",
    "    def __init__(self, default=False):\n",
    "        # which subset of states should be commanded?\n",
    "        self.pos = None\n",
    "        self.vel = None\n",
    "        self.Phi = None\n",
    "        self.omega = None\n",
    "        \n",
    "        #\n",
    "        # Default: Command everything to zero\n",
    "        #\n",
    "        \n",
    "        if default:\n",
    "            self.position(np.array([0.0, 0.0, 0.0]))\n",
    "            self.velocity(np.array([None, None, None]))\n",
    "            self.attitude(np.array([0.0, 0.0, 0.0]))\n",
    "            self.angular_rates(np.array([None, None, None]))\n",
    "        \n",
    "    def position(self, pos):\n",
    "        self.pos = pos\n",
    "        \n",
    "    def velocity(self, vel):\n",
    "        self.vel = vel\n",
    "        \n",
    "    def attitude(self, Phi):\n",
    "        self.Phi = Phi\n",
    "        \n",
    "    def angular_rates(self, omega):\n",
    "        self.omega = omega\n",
    "        \n",
    "    def get_commands(self, i, Ts):\n",
    "        pos = self.pos(i, Ts) if callable(self.pos) else self.pos\n",
    "        Phi = self.Phi(i, Ts) if callable(self.Phi) else self.Phi\n",
    "        commanded = np.hstack((pos, self.vel, Phi, self.omega))\n",
    "        return commanded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Simulator(object):\n",
    "    \"\"\"Simulator\n",
    "        \n",
    "    This class deals with the high-level simulation plumbing for a quadrotor system\n",
    "    \"\"\"\n",
    "    def __init__(self, quad=None, ctrl=None, estm=None, cmdr=None, sens=None):\n",
    "        self.quad = quad if quad else Quadrotor()\n",
    "        self.ctrl = ctrl if ctrl else Controller()\n",
    "        self.estm = estm if estm else Estimator()\n",
    "        self.cmdr = cmdr if cmdr else Commander(default=True)\n",
    "        self.sens = sens if sens else SensorManager()\n",
    "        \n",
    "        # Keep a history for plotting\n",
    "        self.hist = {}\n",
    "        \n",
    "        # Simulation parameters\n",
    "        self.Tf = 0\n",
    "        self.Ts = 0\n",
    "        self.N = 0\n",
    "        \n",
    "    def __str__(self):\n",
    "        s  = \"Simulation\"\n",
    "        return s\n",
    "\n",
    "    def run(self, Tf, Ts=0.01):\n",
    "        \n",
    "        try:\n",
    "            if _NO_SIM == True:\n",
    "                return\n",
    "        except Exception as e:\n",
    "            pass\n",
    "        \n",
    "        # save simulation parameters\n",
    "        self.Tf = Tf\n",
    "        self.Ts = Ts\n",
    "        \n",
    "        # How many iterations are needed\n",
    "        self.N = int(Tf/Ts)\n",
    "        \n",
    "        # quadrotor state\n",
    "        state = truth = np.zeros((12,1))\n",
    "        truth[0:3] = self.quad.r\n",
    "        truth[3:6] = self.quad.v\n",
    "        truth[6:9] = self.quad.Phi\n",
    "        truth[9:12] = self.quad.omega\n",
    "        \n",
    "        # initialize data packet\n",
    "        pkt = {}\n",
    "        \n",
    "        # initialize the plot history\n",
    "        self.hist['u'] = np.zeros((4,self.N))\n",
    "        self.hist['commanded'] = np.zeros((12,self.N))\n",
    "        self.hist['state'] = np.zeros((12,self.N))\n",
    "        self.hist['truth'] = np.zeros((12,self.N))\n",
    "        \n",
    "        #\n",
    "        # Main Simulation Loop\n",
    "        #\n",
    "        \n",
    "        for i in range(self.N):\n",
    "            # determine the desired command\n",
    "            commanded = self.cmdr.get_commands(i, Ts)\n",
    "            \n",
    "            # calculate control\n",
    "            u, commanded = self.ctrl.update(commanded, truth, pkt, Ts)\n",
    "                      \n",
    "            # actuate physical model\n",
    "            usat = self.quad.update(u, Ts)\n",
    "            \n",
    "            # read sensors\n",
    "            pkt = self.sens.get_data_packet(self.quad, i, Ts)\n",
    "            \n",
    "            # run estimator\n",
    "            state, truth = self.estm.update(self.quad, usat, Ts)\n",
    "                \n",
    "            # Update history\n",
    "            self.hist['u'][:, i] = usat.flatten()\n",
    "            self.hist['commanded'][:, i] = commanded.flatten()\n",
    "            self.hist['state'][:, i] = state.flatten()\n",
    "            self.hist['truth'][:, i] = truth.flatten()\n",
    "    \n",
    "    def plot(self):\n",
    "        \"\"\"Plot\n",
    "        Create plot(s) of the evolution of the quadrotor state\n",
    "        over the simulation horizon.\n",
    "        \"\"\"\n",
    "        # Make sure that there is even data to plot\n",
    "        if 'state' not in self.hist:\n",
    "            return\n",
    "        \n",
    "        plt.ioff()\n",
    "        fig = plt.figure(figsize=(12,10))\n",
    "        fig.subplots_adjust(wspace=0.25)\n",
    "        fig.suptitle('Vehicle State', fontsize=16)\n",
    "        \n",
    "        tvec = np.arange(self.N)*self.Ts\n",
    "        \n",
    "        #\n",
    "        # Position\n",
    "        #\n",
    "        \n",
    "        # for convenience\n",
    "        xpos = self.hist['truth'][0, :]\n",
    "        ypos = self.hist['truth'][1, :]\n",
    "        zpos = self.hist['truth'][2, :]\n",
    "        \n",
    "        xcmd = self.hist['commanded'][0, :]\n",
    "        ycmd = self.hist['commanded'][1, :]\n",
    "        zcmd = self.hist['commanded'][2, :]\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,1)\n",
    "        if not np.isnan(xcmd).any():\n",
    "            ax.plot(tvec, xcmd, 'r-', label='command')\n",
    "        ax.plot(tvec, xpos, 'b-', label='truth')\n",
    "        ax.set_ylabel('x'); ax.grid()\n",
    "        ax.legend()\n",
    "\n",
    "        ax = fig.add_subplot(6,2,3)\n",
    "        if not np.isnan(ycmd).any():\n",
    "            ax.plot(tvec, ycmd, 'r-', label='command')\n",
    "        ax.plot(tvec, ypos, 'b-', label='truth')\n",
    "        ax.set_ylabel('y'); ax.grid()\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,5)\n",
    "        if not np.isnan(zcmd).any():\n",
    "            ax.plot(tvec, zcmd, 'r-', label='command')\n",
    "        ax.plot(tvec, zpos, 'b-', label='truth')\n",
    "        ax.set_ylabel('z'); ax.grid()\n",
    "        \n",
    "        #\n",
    "        # Velocity\n",
    "        #\n",
    "        \n",
    "        # for convenience\n",
    "        xvel = self.hist['truth'][3, :]\n",
    "        yvel = self.hist['truth'][4, :]\n",
    "        zvel = self.hist['truth'][5, :]\n",
    "        \n",
    "        xvelhat = self.hist['state'][3, :]\n",
    "        yvelhat = self.hist['state'][4, :]\n",
    "        zvelhat = self.hist['state'][5, :]\n",
    "        \n",
    "        xcmd = self.hist['commanded'][3, :]\n",
    "        ycmd = self.hist['commanded'][4, :]\n",
    "        zcmd = self.hist['commanded'][5, :]\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,2)\n",
    "        if not np.isnan(xcmd).any():\n",
    "            ax.plot(tvec, xcmd, 'r-', label='command')\n",
    "        ax.plot(tvec, xvel, 'b-', label='truth')\n",
    "        if not np.isnan(xvelhat).any() and self.estm.name != 'Truth':\n",
    "            ax.plot(tvec, xvelhat, 'k:', label='estimate', linewidth=2)\n",
    "        ax.set_ylabel('vx'); ax.grid()\n",
    "\n",
    "        ax = fig.add_subplot(6,2,4)\n",
    "        if not np.isnan(ycmd).any():\n",
    "            ax.plot(tvec, ycmd, 'r-', label='command')\n",
    "        ax.plot(tvec, yvel, 'b-', label='truth')\n",
    "        if not np.isnan(yvelhat).any() and self.estm.name != 'Truth':\n",
    "            ax.plot(tvec, yvelhat, 'k:', label='estimate', linewidth=2)\n",
    "        ax.set_ylabel('vy'); ax.grid()\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,6)\n",
    "        if not np.isnan(zcmd).any():\n",
    "            ax.plot(tvec, zcmd, 'r-', label='command')\n",
    "        ax.plot(tvec, zvel, 'b-', label='truth')\n",
    "        if not np.isnan(zvelhat).any() and self.estm.name != 'Truth':\n",
    "            ax.plot(tvec, zvelhat, 'k:', label='estimate', linewidth=2)\n",
    "        ax.set_ylabel('vz'); ax.grid()\n",
    "        \n",
    "        #\n",
    "        # Attitude\n",
    "        #\n",
    "        \n",
    "        # for convenience\n",
    "        ph = self.hist['truth'][6, :]\n",
    "        th = self.hist['truth'][7, :]\n",
    "        ps = self.hist['truth'][8, :]\n",
    "        \n",
    "        phcmd = self.hist['commanded'][6, :]\n",
    "        thcmd = self.hist['commanded'][7, :]\n",
    "        pscmd = self.hist['commanded'][8, :]\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,7)\n",
    "        if not np.isnan(phcmd).any():\n",
    "            ax.plot(tvec, np.degrees(phcmd), 'r-', label='command')\n",
    "        ax.plot(tvec, np.degrees(ph), 'b-', label='truth')\n",
    "        ax.set_ylabel(r'$\\phi$'); ax.grid()\n",
    "\n",
    "        ax = fig.add_subplot(6,2,9)\n",
    "        if not np.isnan(thcmd).any():\n",
    "            ax.plot(tvec, np.degrees(thcmd), 'r-', label='command')\n",
    "        ax.plot(tvec, np.degrees(th), 'b-', label='truth')\n",
    "        ax.set_ylabel(r'$\\theta$'); ax.grid()\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,11)\n",
    "        if not np.isnan(pscmd).any():\n",
    "            ax.plot(tvec, np.degrees(pscmd), 'r-', label='command')\n",
    "        ax.plot(tvec, np.degrees(ps), 'b-', label='truth')\n",
    "        ax.set_ylabel(r'$\\psi$'); ax.grid()\n",
    "        \n",
    "        #\n",
    "        # Angular Rates\n",
    "        #\n",
    "        \n",
    "        # for convenience\n",
    "        p = self.hist['truth'][9, :]\n",
    "        q = self.hist['truth'][10, :]\n",
    "        r = self.hist['truth'][11, :]\n",
    "\n",
    "        pcmd = self.hist['commanded'][9, :]\n",
    "        qcmd = self.hist['commanded'][10, :]\n",
    "        rcmd = self.hist['commanded'][11, :]\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,8)\n",
    "        if not np.isnan(pcmd).any():\n",
    "            ax.plot(tvec, pcmd, 'r-', label='command')\n",
    "        ax.plot(tvec, p, 'b-', label='truth')\n",
    "        ax.set_ylabel('p'); ax.grid()\n",
    "\n",
    "        ax = fig.add_subplot(6,2,10)\n",
    "        if not np.isnan(qcmd).any():\n",
    "            ax.plot(tvec, qcmd, 'r-', label='command')\n",
    "        ax.plot(tvec, q, 'b-', label='truth')\n",
    "        ax.set_ylabel('q'); ax.grid()\n",
    "        \n",
    "        ax = fig.add_subplot(6,2,12)\n",
    "        if not np.isnan(rcmd).any():\n",
    "            ax.plot(tvec, rcmd, 'r-', label='command')\n",
    "        ax.plot(tvec, r, 'b-', label='truth')\n",
    "        ax.set_ylabel('r'); ax.grid()\n",
    "        \n",
    "        plt.show()\n",
    "        \n",
    "        #\n",
    "        # Control Effort\n",
    "        #\n",
    "        \n",
    "        thrust = self.hist['u'][0, :]\n",
    "        tau_ph = self.hist['u'][1, :]\n",
    "        tau_th = self.hist['u'][2, :]\n",
    "        tau_ps = self.hist['u'][3, :]\n",
    "        \n",
    "        fig = plt.figure(figsize=(12,3))\n",
    "        fig.subplots_adjust(wspace=0.25)\n",
    "        fig.suptitle('Control Effort', fontsize=16)\n",
    "        \n",
    "        ax = fig.add_subplot(221)\n",
    "        ax.plot(tvec, thrust, 'g-')\n",
    "        ax.set_ylabel('Thrust'); ax.grid()\n",
    "        \n",
    "        ax = fig.add_subplot(222)\n",
    "        ax.plot(tvec, tau_ph, 'g-')\n",
    "        ax.set_ylabel(r'$\\tau_\\phi$'); ax.grid()\n",
    "        \n",
    "        ax = fig.add_subplot(223)\n",
    "        ax.plot(tvec, tau_th, 'g-')\n",
    "        ax.set_ylabel(r'$\\tau_\\theta$'); ax.grid()\n",
    "        \n",
    "        ax = fig.add_subplot(224)\n",
    "        ax.plot(tvec, tau_ps, 'g-')\n",
    "        ax.set_ylabel(r'$\\tau_\\psi$'); ax.grid()\n",
    "        \n",
    "        plt.show()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd1da14d828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd1d9ba2d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quadrotor state after 500 iters:\n",
      "\tr:     [[ 0.000  0.000  63.880]].T\n",
      "\tPhi:   [[ 0.000  0.000  0.000]].T\n",
      "\tv:     [[ 0.000  0.000  21.651]].T\n",
      "\tomega: [[ 0.000  0.000  0.000]].T\n",
      "\n"
     ]
    }
   ],
   "source": [
    "sim = Simulator()\n",
    "sim.run(5, Ts=0.01)\n",
    "sim.plot()\n",
    "\n",
    "print(sim.quad)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "528px",
    "left": "1318px",
    "right": "20px",
    "top": "127px",
    "width": "494px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}