pid_interactive_design_python_web.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "jupyter:kill_cell"
    ]
   },
   "outputs": [],
   "source": [
    "draft_mode = False\n",
    "from front_matter import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, load some general-purpose Python packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # for numerics\n",
    "import sympy as sp # for symbolics\n",
    "import control as c # the Control Systems module\n",
    "import matplotlib as mpl # for plots\n",
    "import matplotlib.pyplot as plt # also for plots\n",
    "from IPython.display import display, Markdown, Latex # pretty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following Python packages are specific for the interactive widget."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipywidgets import *\n",
    "%matplotlib widget"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symbolic transfer functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's investigate the transfer functions symbolically. We begin by defining the Laplace $s$ and gain symbolic variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "s,K_p,K_i,K_d = sp.symbols('s K_p K_i K_d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will design a PID controller for a plant with the following transfer function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{15000}{s^{4} + 50 s^{3} + 875 s^{2} + 6250 s + 15000}$"
      ],
      "text/plain": [
       "15000/(s**4 + 50*s**3 + 875*s**2 + 6250*s + 15000)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G_sym = 15000/(s**4+50*s**3+875*s**2+6250*s+15000)\n",
    "display(G_sym)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The controller has the following symbolic transfer function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle K_{d} s + \\frac{K_{i}}{s} + K_{p}$"
      ],
      "text/plain": [
       "K_d*s + K_i/s + K_p"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "C_sym = K_p + K_i/s + K_d*s\n",
    "display(C_sym)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The closed-loop transfer function for the unity feedback system is as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{15000 K_{i} + s \\left(15000 K_{d} s + 15000 K_{p}\\right)}{15000 K_{i} + s \\left(15000 K_{d} s + 15000 K_{p} + s^{4} + 50 s^{3} + 875 s^{2} + 6250 s + 15000\\right)}$"
      ],
      "text/plain": [
       "(15000*K_i + s*(15000*K_d*s + 15000*K_p))/(15000*K_i + s*(15000*K_d*s + 15000*K_p + s**4 + 50*s**3 + 875*s**2 + 6250*s + 15000))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "T_sym = sp.simplify(\n",
    "  C_sym*G_sym/(1+C_sym*G_sym)\n",
    ")\n",
    "T_num, T_den = list( # for simplifying\n",
    "  map(\n",
    "    lambda x: sp.collect(x,s),\n",
    "    sp.fraction(T_sym)\n",
    "  )\n",
    ")\n",
    "T_sym = T_num/T_den\n",
    "display(T_sym)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symbolic to `control` transfer functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `control` package has objects of type `TransferFunction` that will be useful for simulation in the next section. We begin by defining a function to convert a symbolic transfer function to a `control` `TransferFunction` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sym_to_tf(tf_sym,s_var):\n",
    "    global s # changes s globally!\n",
    "    S = s_var\n",
    "    s = sp.symbols('s')\n",
    "    tf_sym = tf_sym.subs(S,s)\n",
    "    tf_str = str(tf_sym)\n",
    "    s = c.TransferFunction.s\n",
    "    ldict = {}\n",
    "    exec('tf_out = '+tf_str,globals(),ldict)\n",
    "    tf_out = ldict['tf_out']\n",
    "    return tf_out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This isn't smooth, but it works. Note that `tf_sym` must have no symbolic variables besides `s_var`, the Laplace $s$. We can apply this to `G_sym`, then, but not yet `C_sym`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "control.xferfcn.TransferFunction"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(sym_to_tf(G_sym,s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining the closed-loop function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to create a function that specifies the gains, substitutes them into the symbolic closed-loop transfer function, then converts it to a `control` package `TransferFunction` object via `sym_to_tf`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pid_CL_tf(CL_sym,Kp=0,Ki=0,Kd=0):\n",
    "  sp.symbols('K_p K_i K_d')\n",
    "  s = c.TransferFunction.s\n",
    "  CL_subs = CL_sym.subs({K_p: Kp, K_i: Ki, K_d: Kd})\n",
    "  return sym_to_tf(CL_subs,s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For instance, we can let $K_p = 1$ and $K_i = K_d = 0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1.5 \\times 10^{4}}{s^4 + 50 s^3 + 875 s^2 + 6250 s + 3 \\times 10^{4}}$$"
      ],
      "text/plain": [
       "\n",
       "                1.5e+04\n",
       "---------------------------------------\n",
       "s^4 + 50 s^3 + 875 s^2 + 6250 s + 3e+04"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(\n",
    "  pid_CL_tf(T_sym,Kp=1)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is straightforward to use the `control` package's `step_response` function to get a step response for a single set of gains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "gains = {'Kp':2, 'Ki':1, 'Kd':0.1}\n",
    "sys_CL = pid_CL_tf(T_sym,**gains)\n",
    "t_step = np.linspace(0,3,200)\n",
    "t_step,y_step = c.step_response(sys_CL, t_step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's plot it. The result is shown in \\cref{pid_interactive_design_python_1}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "tags": [
     "jupyter:kill_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17565e601b6448499ed666516556bfeb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "line, = ax.plot(t_step, y_step)\n",
    "plt.xlabel('time (s)')\n",
    "plt.ylabel('step response')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interactive step response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following essentially repeats the same process of\n",
    "\n",
    "1. setting the PID gains with `pid_CL_tf`,\n",
    "2. simulating with `step_response`, and\n",
    "3. plotting the response.\n",
    "\n",
    "The caveat is that this happens with a GUI `interact`ion callback function `update` that sets new gains (based on the GUI sliders), simulates, and replaces the old `line` on the plot.\n",
    "The final plot is shown in \\cref{pid_interactive_design_python_2}. It appears to meet our performance requirements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": false,
    "tags": [
     "jupyter:kill_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73c0f3c9095b453192fa6734d4b9500f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e187db16735e4b11994bda22283acd35",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=1.0, description='Kp', max=10.0), FloatSlider(value=0.0, description='…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib widget\n",
    "# simulate\n",
    "t_step = np.linspace(0,3,200)\n",
    "sys_CL = pid_CL_tf(T_sym,Kp=1)\n",
    "t_step,y_step = c.step_response(sys_CL, t_step)\n",
    "\n",
    "# initial plot\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "line, = ax.plot(t_step, y_step)\n",
    "plt.xlabel('time (s)')\n",
    "plt.ylabel('step response')\n",
    "plt.show()\n",
    "\n",
    "# GUI callback function\n",
    "def update(Kp = 1.0, Ki = 0.0, Kd = 0.0):\n",
    "    global t_step, kp, ki, kd\n",
    "    kp,ki,kd = Kp,Ki,Kd\n",
    "    sys_CL = pid_CL_tf(T_sym,Kp=Kp,Ki=Ki,Kd=Kd)\n",
    "    t_step,y_step = c.step_response(sys_CL, t_step)\n",
    "    line.set_ydata(y_step)\n",
    "    ax.relim()\n",
    "    ax.autoscale_view()\n",
    "    fig.canvas.draw_idle()\n",
    "    plt.show()\n",
    "\n",
    "# interaction definition\n",
    "interact(\n",
    "  update,\n",
    "  Kp=(0.0,10.0),\n",
    "  Ki=(0.0,20.0),\n",
    "  Kd=(0.0,1.0)\n",
    ");"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.7.3"
  },
  "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()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}