Proportional Integral Derivative(PID) Velocity Control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Proportional Integral Derivative(PID) Controller\n",
    "Proportional Integral Derivative (PID) control automatically adjusts a control output based on the difference between a set point (SP) and a measured process variable (PV). The value of the controller output $u(t)$ is transferred as the system input.\n",
    "$$e(t) = SP-PV$$\n",
    "$$u(t) = u_{bias} + K_c \\, e(t) + \\frac{K_c}{\\tau_I}\\int_0^t e(t)dt - K_c \\tau_D \\frac{d(PV)}{dt}$$\n",
    "$$u(t) = u_{bias} + K_c \\, e(t) + \\frac{K_c}{\\tau_I}\\sum_{i=1}^{n_t} e_i(t)\\Delta t  - K_c \\tau_D \\frac{PV_{n_t}-PV_{n_t-1}}{\\Delta t}$$\n",
    "The $u_{bias}$ term is a constant that is typically set to the value of $u(t)$when the controller is first switched from manual to automatic mode. This gives \"bumpless\" transfer if the error is zero when the controller is turned on.\n",
    "\n",
    "PID controller is best suited for non-integrating processes, meaning any process that eventually returns to the same output given the same set of inputs and disturbances.\n",
    "\n",
    "Derivative action is used to decrease the oscillations of PV(Process Variable)\n",
    "\n",
    "## IMC(Internal Mode Control) Tuning Correlations:\n",
    "$$\\mathrm{Aggressive\\,Tuning:} \\quad \\tau_c = \\max \\left( 0.1 \\tau_p, 0.8 \\theta_p \\right)$$\n",
    "$$\\mathrm{Moderate\\,Tuning:} \\quad \\tau_c = \\max \\left( 1.0 \\tau_p, 8.0 \\theta_p \\right)$$\n",
    "$$\\mathrm{Conservative\\,Tuning:} \\quad \\tau_c = \\max \\left( 10.0 \\tau_p, 80.0 \\theta_p \\right)$$\n",
    "$$K_c = \\frac{1}{K_p}\\frac{\\tau_p+0.5\\theta_p}{\\left( \\tau_c + 0.5\\theta_p \\right)} \\quad \\quad \\tau_I = \\tau_p + 0.5 \\theta_p \\quad \\quad \\tau_D = \\frac{\\tau_p\\theta_p}{2\\tau_p + \\theta_p}$$\n",
    "\n",
    "## Simple Tuning Rules:\n",
    "Note that with moderate tuning and negligible dead-time $(\\theta_p -> 0\\ and \\tau_c = 1.0 \\tau_p)$, IMC reduces to simple tuning correlations that are easy to recall without a reference book.\n",
    "$$K_c = \\frac{1}{K_p} \\quad \\quad \\tau_I = \\tau_p \\quad \\quad \\tau_D = 0 \\quad \\quad \\mathrm{Simple\\,tuning\\,correlations}$$\n",
    "\n",
    "## Optional Derivative Filter:\n",
    "The optional parameter $\\alpha$ is a derivative filter constant. The filter reduces the effect of measurement noise on the derivative term that can lead to controller output amplification of the noise.\n",
    "$$\\alpha = \\frac{\\tau_c\\left(\\tau_p+0.5\\theta_p\\right)}{\\tau_p\\left(\\tau_c+\\theta_p\\right)}$$\n",
    "The PID with the filter is augmented as:\n",
    "$$u(t) = u_{bias} + K_c \\, e(t) + \\frac{K_c}{\\tau_I}\\int_0^t e(t)dt - K_c \\tau_D \\frac{d(PV)}{dt} - \\alpha \\tau_D \\frac{du(t)}{dt}$$\n",
    "\n",
    "## Anti-Reset Windup:\n",
    "An important feature of a controller with an integral term is to consider the case where the controller output $u(t)$ saturates at an upper or lower bound for an extended period of time. This causes the integral term to accumulate to a large summation that causes the controller to stay at the saturation limit until the integral summation is reduced. Anti-reset windup is that the integral term does not accumulate if the controller output is saturated at an upper or lower limit.\n",
    "\n",
    "## Derivative Kick:\n",
    "Derivative kick occurs because the value of the error changes suddenly whenever the set point is adjusted. The derivative of a sudden jump in the error causes the derivative of the error to be instantaneously large and causes the controller output to saturate for one cycle at either an upper or lower bound. While this momentary jump isn't typically a problem for most systems, a sudden saturation of the controller output can put undue stress on the final control element or potentially disturb the process.\n",
    "\n",
    "To overcome derivative kick, it is assumed that the set point is constant with $(d(SP))/dt=0$\n",
    "\n",
    "$$\\frac{de(t)}{dt} = \\frac{d\\left(SP-PV\\right)}{dt} = \\frac{d\\left(SP\\right)}{dt} - \\frac{d\\left(PV\\right)}{dt} = - \\frac{d\\left(PV\\right)}{dt}$$\n",
    "This modification avoids derivative kick but keeps a derivative term in the PID equation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment: Automobile Velocity Control\n",
    "A self-driving car company has requested a speed controller for their new model of electric autonomous vehicles. Unlike standard cruise control systems, this speed controller must manage transitions between all velocities ranging from 0 to 25 m/s (56 mph or 90 km/hr).\n",
    "<img src=\"http://apmonitor.com/pdc/uploads/Main/auto_schematic.png\">\n",
    "Regenerative braking is part of this application by allowing the gas pedal to go from -50% to 100%.\n",
    "\n",
    "#### Process Equation:\n",
    "$$m\\frac{dv(t)}{dt} = F_p u(t) - \\frac{1}{2} \\rho \\, A \\, C_d v(t)^2$$\n",
    "with u(t) as gas pedal position (%pedal), v(t) as velocity (m/s), m as the mass of the vehicle (500 kg) plus the mass of the passengers and cargo (200 kg), Cd as the drag coefficient (0.24),$\\rho$ as the air density (1.225 kg/m3), A as the vehicle cross-sectional area (5 m2), and Fp as the thrust parameter (30 N/%pedal).\n",
    "\n",
    "#### Simplified Block Diagram:\n",
    "<img src=\"https://i.imgur.com/nqCRZIi.png\" width=\"500\" height=\"600\">\n",
    "\n",
    "#### Steps to Follow:\n",
    "    1.Simulating Model\n",
    "    2.FOPDT\n",
    "    3.PID Tuning\n",
    "    4.Simulating PID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#Simulating Model\n",
    "from ipywidgets import interactive\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy.integrate import odeint\n",
    "%matplotlib inline\n",
    "\n",
    "def car(v,t,u,load):\n",
    "    #Constants for Process Equation\n",
    "    Cd = 0.24\n",
    "    rho = 1.225\n",
    "    m = 500\n",
    "    A = 5\n",
    "    Fp = 30\n",
    "    #Process equation\n",
    "    dvdt = (Fp*u - (rho*A*Cd*(v**2))/2)/(m + load)\n",
    "    return dvdt\n",
    "\n",
    "def simModel():\n",
    "    #Time span\n",
    "    t = np.linspace(0,60,61)\n",
    "    delta_t = t[1]-t[0]\n",
    "\n",
    "    #Initial constants\n",
    "    load = 200\n",
    "    v0 = 0\n",
    "\n",
    "    #Storing Gas-Peddal/Controller Output(u) Responses\n",
    "    op = np.zeros(len(t))\n",
    "    #Step-Adding through Gas Peddal\n",
    "    op[11:] = 25\n",
    "\n",
    "    #Storing velocity responses\n",
    "    v = np.ones(len(t))*v0\n",
    "\n",
    "    #Simulating Model\n",
    "    for i in range(len(t)-1):\n",
    "        time = t[i:i+2]\n",
    "        u = op[i]\n",
    "        #Regenerative Breaking\n",
    "        if u>=100:\n",
    "            u = 100\n",
    "        elif u<=-50:\n",
    "            u = -50\n",
    "        y = odeint(car, v0, time, args=(u, load))\n",
    "        v0 = y[-1]\n",
    "        v[i+1] = v0\n",
    "\n",
    "    #Plotting\n",
    "    plt.figure()\n",
    "    plt.subplot(2,1,1)\n",
    "    plt.plot(t, op, label='Gas Pedal')\n",
    "    plt.legend(loc='best')\n",
    "    plt.subplot(2,1,2)\n",
    "    plt.plot(t, v, 'r-', label='v(t)')\n",
    "    plt.plot(t, np.ones(len(t))*25, 'b--', label='SetPoint')\n",
    "    plt.xlabel('time')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "simModel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### FOPDT\n",
    "By analysing the above graph we find that:\n",
    "1. $K_p$ = 1.2\n",
    "2. $\\theta_p$ = 0\n",
    "3. $\\tau_p$ = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### PID Tuning\n",
    "Using Simple tuning rules we get:\n",
    "1. $\\tau_I = \\tau_p = 20$\n",
    "2. $K_c = 1/K_p = 1/1.2$\n",
    "3. $\\tau_D = 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating PID\n",
    "def PID(v2, v1, SP, sum_int, delta_t, Kc, tauI, tauD, ubias):\n",
    "    #Error: SP - PV\n",
    "    error = SP - v2\n",
    "    #Approximation of Integration of error \n",
    "    sum_int = sum_int + error*delta_t\n",
    "    #Approximation of Differentiation i.e d(PV)/dt\n",
    "    derivative = (v2-v1)/delta_t\n",
    "    #Controller Output\n",
    "    u = ubias + Kc*error + (Kc*sum_int)/tauI - (Kc*tauD*derivative)\n",
    "    return u, error, sum_int, derivative\n",
    "\n",
    "def simModelPID(Kc=1/1.2, tauI=20, tauD=0, ubias=0.0):\n",
    "    #Time span\n",
    "    t = np.linspace(0,300,301)\n",
    "    delta_t = t[1]-t[0]\n",
    "    \n",
    "    #Initial constants\n",
    "    load = 200\n",
    "    v0 = 0\n",
    "    \n",
    "    #Step-Adding through set points(of velocity)\n",
    "    SP = np.ones(len(t))*25\n",
    "    SP[50: 100] = 0\n",
    "    SP[100: 150] = 15\n",
    "    SP[150: 200] = 20\n",
    "    SP[200: ] = 10\n",
    "    \n",
    "    #Storing Velocity/Process Variable(v) responses\n",
    "    v = np.ones(len(t))*v0\n",
    "\n",
    "    #Storing Gas-Peddal/Controller Output(u) responses\n",
    "    op = np.zeros(len(t))\n",
    "\n",
    "    #Storing propotional error responses\n",
    "    er = np.zeros(len(t))\n",
    "    #Storing integral error responses\n",
    "    ier = np.zeros(len(t))\n",
    "    #Storing derivative error response\n",
    "    der = np.zeros(len(t))\n",
    "\n",
    "    #Simulating PID+Model\n",
    "    sum_int = 0\n",
    "    for i in range(len(t)-1):\n",
    "        time=t[i:i+2]\n",
    "        if i==0:\n",
    "            u, error, sum_int, derivative = PID(v0, 0, SP[i], sum_int, delta_t, Kc, tauI, tauD, ubias)\n",
    "        else:\n",
    "            u, error, sum_int, derivative = PID(v0, v[i-1], SP[i], sum_int, delta_t, Kc, tauI, tauD, ubias)\n",
    "        #Regenerative Breaking and Anti-Reset Wrapup\n",
    "        if u>=100:\n",
    "            u = 100\n",
    "            sum_int = sum_int - error*delta_t\n",
    "        elif u<=-50:\n",
    "            u = -50\n",
    "            sum_int = sum_int - error*delta_t\n",
    "        er[i+1] = error\n",
    "        ier[i+1] = sum_int\n",
    "        der[i+1] = derivative\n",
    "        op[i+1] = u\n",
    "        y = odeint(car, v0, time, args=(u, load))\n",
    "        v0 = y[-1]\n",
    "        v[i+1] = v0\n",
    "\n",
    "    #Plotting\n",
    "    plt.figure(figsize=(18, 16), dpi= 80, facecolor='w', edgecolor='k')\n",
    "    plt.subplot(5,1,1)\n",
    "    plt.plot(t,v,'r-', linewidth=3, label='v(t)')\n",
    "    plt.plot(t,SP,'b--', linewidth=3, label='Set Point')\n",
    "    plt.legend(loc='best')\n",
    "    plt.ylabel('Velocity/Process Variable')\n",
    "\n",
    "    plt.subplot(5,1,2)\n",
    "    plt.plot(t, op, 'r-', label='u(t)')\n",
    "    plt.legend(loc='best')\n",
    "    plt.ylabel('Gas Peddal/Controller Output')\n",
    "\n",
    "\n",
    "    plt.subplot(5,1,3)\n",
    "    plt.plot(t, er, 'g:')\n",
    "    plt.ylabel('Proportional error')\n",
    "\n",
    "    plt.subplot(5,1,4)\n",
    "    plt.plot(t, ier, 'r:')\n",
    "    plt.ylabel('Integral Error')\n",
    "    \n",
    "    plt.subplot(5,1,5)\n",
    "    plt.plot(t, der, 'k:')\n",
    "    plt.ylabel('Derivative Error')\n",
    "    plt.xlabel('Time')\n",
    "    plt.show()\n",
    "#simModelPI()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3621d9006b114dd693091b5ab9c8e097",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.8333333333333334, description='Kc', max=10.0, min=-5.0), FloatSlider…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "interactive_plot = interactive(simModelPID, Kc=(-5.0,10.0), tauI=(0,50.0), tauD=(0, 50.0), ubias=(-1.0,5.0))\n",
    "interactive_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}