steady-state-error.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Steady State Error Analysis\n",
    "\n",
    "A feedback control system is a system in which the output of the system is fed back to the input. The purpose of using feedback is to regulate the system's behavior. The steady-state error is the difference between the desired output R(s) and the actual output Y(s) when the system has reached a stable condition. The input into the plant, G(s), is E(s) = R(s) - Y(s)\n",
    "\n",
    "## Unity Feedback Schema\n",
    "\n",
    "The schema of the system is the following:\n",
    "\n",
    "![Unity Feedback Schema](images/unity-feedback-schema.png)\n",
    "\n",
    "<br>\n",
    "\n",
    "The original schema can be seen in a more simple way: R(s) is the input, T(s) = G(s) / (1 + G(s)) is the plant with the feedback, Y(s) is the output\n",
    "\n",
    "![Equivalent Unity Feedback Schema](images/unity-feedback-equivalent-schema.png)\n",
    "\n",
    "## Type of the system\n",
    "\n",
    "The plant G(s) can be classified based on the numbers of poles equals to zero:\n",
    "- Type 0: No poles in zero\n",
    "- Type 1: 1 pole in zero\n",
    "- Type 2: 2 poles in zero\n",
    "\n",
    "## Steady State Error\n",
    "\n",
    "Based on the input signal R(s) and the type of the plant G(s) we know what is the steady-state error:\n",
    "| Type               | 0           | 1               | 2        |\n",
    "|--------------------|-------------|-----------------|----------|\n",
    "| Step (R0/s)        | R0/(1+Kp)   | 0               | 0        |\n",
    "| Ramp (R0/s^2)      | Inf         | R0/Kv           | 0        |\n",
    "| Parabola (R0/s^3)  | Inf         | 0               | R0/Ka    |\n",
    "\n",
    "Note: make sure the closed loop T(s) is stable, otherwise this table is not valid\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h1> Type 0 system </h1> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step Response\n",
    "\n",
    "This interactive plot illustrates the step response of a unity feedback system with a proportional controller. The transfer function of the system is given by G(s) = Kp / (0.5s + 1). You can adjust the proportional gain (Kp) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's step response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a step input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Step Input (r(t)):** The reference step input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Kp and R0 to observe changes in the step response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Proportional Gain (Kp):** Adjust the proportional gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "26cad8763f254840ab39a376b64dd6c1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='Kp', max=10.0, min=0.1), FloatSlider(value=5.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Kp, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = Kp / (tau * s + 1)\n",
    "    numerator = [Kp]\n",
    "    denominator = [tau, 1]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Step input in Laplace domain: R(s) = 1/s\n",
    "    step_input = R0 * np.ones(len(time))\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, step_input)\n",
    "\n",
    "    # Calculate steady-state error\n",
    "    steady_state_error = R0 / (1 + Kp)\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, step_input, label='r(t): Reference Step Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [step_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Ramp Response of G(s) = {Kp:.2f} / (1+s*{tau:.2f})\\nSteady-State Error = R0 / (1 + Kp) = {steady_state_error:.2f}')\n",
    "    plt.ylim(0, 10)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Kp=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='Kp'),\n",
    "         R0=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ramp Response\n",
    "\n",
    "This interactive plot illustrates the ramp response of a unity feedback system with a proportional controller. The transfer function of the system is given by G(s) = Kp / (0.5s + 1). You can adjust the proportional gain (Kp) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's ramp response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a ramp input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Ramp Input (r(t)):** The reference ramp input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. In the case of a ramp input, the steady-state error is infinite.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Kp and R0 to observe changes in the ramp response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Proportional Gain (Kp):** Adjust the proportional gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "847a9914fb484c1c9b328bf8f6a985f4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=1.0, description='Kp', max=10.0, min=0.1), FloatSlider(value=1.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Kp, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = Kp / (tau * s + 1)\n",
    "    numerator = [Kp]\n",
    "    denominator = [tau, 1]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Ramp input in Laplace domain: R(s) = 1/(s^2)\n",
    "    ramp_input = R0 * time\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, ramp_input)\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, ramp_input, label='r(t): Reference Ramp Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [ramp_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Ramp Response of G(s) = {Kp:.2f} / (1+s*{tau:.2f})\\nSteady-State Error = ∞')\n",
    "    plt.ylim(0, 50)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Kp=widgets.FloatSlider(value=1.0, min=0.1, max=10.0, step=0.1, description='Kp'),\n",
    "         R0=widgets.FloatSlider(value=1.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parabolic Response\n",
    "\n",
    "This interactive plot illustrates the parabolic response of a unity feedback system with a proportional controller. The transfer function of the system is given by G(s) = Kp / (0.5s + 1). You can adjust the proportional gain (Kp) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's parabolic response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a parabolic input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Parabolic Input (r(t)):** The reference parabolic input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. In the case of a parabolic input, the steady-state error is infinite.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Kp and R0 to observe changes in the parabolic response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Proportional Gain (Kp):** Adjust the proportional gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "79a524a572d34a15b0a096ec9637f1e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=1.0, description='Kp', max=10.0, min=0.1), FloatSlider(value=1.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Kp, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = Kp / (tau * s + 1)\n",
    "    numerator = [Kp]\n",
    "    denominator = [tau, 1]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Parabolic input in Laplace domain: R(s) = 1/(s^3)\n",
    "    parabola_input = R0 * (time ** 2)\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, parabola_input)\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, parabola_input, label='r(t): Reference Parabolic Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [parabola_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Parabolic Response of G(s) = {Kp:.2f} / (1+s*{tau:.2f})\\nSteady-State Error = ∞')\n",
    "    plt.ylim(0, 100)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Kp=widgets.FloatSlider(value=1.0, min=0.1, max=10.0, step=0.1, description='Kp'),\n",
    "         R0=widgets.FloatSlider(value=1.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h1> Type 1 system </h1> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step Response\n",
    "\n",
    "This interactive plot demonstrates the step response of a unity feedback system with a velocity controller. The transfer function of the system is given by G(s) = Kv / (s * (0.5s + 1)). You can adjust the velocity gain (Kv) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's step response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a unit step input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Step Input (r(t)):** The reference step input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. In this case, the steady-state error is 0.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Kv and R0 to observe changes in the step response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Velocity Gain (Kv):** Adjust the velocity gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c72df83950014df5a97722982a59991b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='Kv', max=10.0, min=0.1), FloatSlider(value=5.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Kv, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = Kv / (s * (tau * s + 1))\n",
    "    numerator = [Kv]\n",
    "    denominator = [tau, 1, 0]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Step input in Laplace domain: R(s) = 1/s\n",
    "    step_input = R0 * np.ones(len(time))\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, step_input)\n",
    "\n",
    "    # Calculate steady-state error\n",
    "    steady_state_error = 0\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, step_input, label='r(t): Reference Step Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [step_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Step Response of G(s) = {Kv:.2f} / (s * (1+s*{tau:.2f}))\\nSteady-State Error = {steady_state_error:.2f}')\n",
    "    plt.ylim(0, 10)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Kv=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='Kv'),\n",
    "         R0=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ramp Response\n",
    "\n",
    "This interactive plot illustrates the ramp response of a unity feedback system with a velocity controller. The transfer function of the system is given by G(s) = Kv / (s * (0.5s + 1)). You can adjust the velocity gain (Kv) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's ramp response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a ramp input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Ramp Input (r(t)):** The reference ramp input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. The steady-state error value is calculated as R0 / Kv.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Kv and R0 to observe changes in the ramp response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Velocity Gain (Kv):** Adjust the velocity gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9e48f3986dbb4abfbe416109330eee30",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='Kv', max=10.0, min=0.1), FloatSlider(value=5.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Kv, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = Kv / (s * (tau * s + 1))\n",
    "    numerator = [Kv]\n",
    "    denominator = [tau, 1, 0]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Ramp input in Laplace domain: R(s) = 1/(s^2)\n",
    "    ramp_input = R0 * time\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, ramp_input)\n",
    "\n",
    "    # Calculate steady-state error\n",
    "    steady_state_error = R0 / Kv\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, ramp_input, label='r(t): Reference Ramp Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [ramp_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Ramp Response of G(s) = {Kv:.2f} / (s * (1+s*{tau:.2f}))\\nSteady-State Error = R0 / Kv = {steady_state_error:.2f}')\n",
    "    plt.ylim(0, 10)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Kv=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='Kv'),\n",
    "         R0=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parabolic Response\n",
    "\n",
    "This interactive plot illustrates the parabolic response of a unity feedback system with a velocity controller. The transfer function of the system is given by G(s) = Kv / (s * (0.5s + 1)). You can adjust the velocity gain (Kv) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's parabolic response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a parabolic input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Parabolic Input (r(t)):** The reference parabolic input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. The steady-state error value is infinite for a parabolic input.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Kv and R0 to observe changes in the parabolic response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Velocity Gain (Kv):** Adjust the velocity gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ef44c2310699491eb79fee03ed6d643c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='Kv', max=10.0, min=0.1), FloatSlider(value=5.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Kv, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = Kv / (s * (tau * s + 1))\n",
    "    numerator = [Kv]\n",
    "    denominator = [tau, 1, 0]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Parabolic input in Laplace domain: R(s) = 1/(s^3)\n",
    "    parabola_input = R0 * (time ** 2)\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, parabola_input)\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, parabola_input, label='r(t): Reference Parabolic Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [parabola_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Parabolic Response of G(s) = {Kv:.2f} / (s * (1+s*{tau:.2f}))\\nSteady-State Error = ∞')\n",
    "    plt.ylim(0, 10)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Kv=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='Kv'),\n",
    "         R0=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h1> Type 2 system </h1></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step Response\n",
    "\n",
    "This interactive plot demonstrates the step response of a unity feedback system with a acceleration controller. The transfer function of the system is given by G(s) = (Ka * (0.5s + 1)) / (s * (0.5s + 1)). You can adjust the acceleration gain (Ka) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's step response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a unit step input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Step Input (r(t)):** The reference step input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. In this case, the steady-state error is 0.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Ka and R0 to observe changes in the step response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Acceleration Gain (Ka):** Adjust the acceleration gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "78623c08c2f54d2fb8dbff461713a41f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='Ka', max=10.0, min=0.1), FloatSlider(value=5.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Ka, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = (Ka * (tau * s + 1)) / ((s^2) * (tau * s + 1))\n",
    "    numerator = [Ka * tau, 1]\n",
    "    denominator = [tau, 1, 0, 0]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Step input in Laplace domain: R(s) = 1/s\n",
    "    step_input = R0 * np.ones(len(time))\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, step_input)\n",
    "\n",
    "    # Calculate steady-state error\n",
    "    steady_state_error = 0\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, step_input, label='r(t): Reference Step Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [step_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Step Response of G(s) = ({Ka:.2f}*(1+s*{tau:.2f})) / ((s^2)(1+s*{tau:.2f}))\\nSteady-State Error = {steady_state_error:.2f}')\n",
    "    plt.ylim(0, 10)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Ka=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='Ka'),\n",
    "         R0=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ramp Response\n",
    "\n",
    "This interactive plot illustrates the ramp response of a unity feedback system with a acceleration controller. The transfer function of the system is given by G(s) = (Ka * (0.5s + 1)) / (s * (0.5s + 1)). You can adjust the acceleration gain (Ka) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's ramp response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a ramp input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Ramp Input (r(t)):** The reference ramp input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. The steady-state error value is calculated as R0 / Ka.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Ka and R0 to observe changes in the ramp response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Acceleration Gain (Ka):** Adjust the acceleration gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "02bb5fdae3e04bb2a9681875f3fcca35",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='Ka', max=10.0, min=0.1), FloatSlider(value=5.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Ka, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = (Ka * (tau * s + 1)) / ((s^2) * (tau * s + 1))\n",
    "    numerator = [Ka * tau, 1]\n",
    "    denominator = [tau, 1, 0, 0]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Ramp input in Laplace domain: R(s) = 1/(s^2)\n",
    "    ramp_input = R0 * time\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, ramp_input)\n",
    "\n",
    "    # Calculate steady-state error\n",
    "    steady_state_error = 0\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, ramp_input, label='r(t): Reference Ramp Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [ramp_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Ramp Response of G(s) = ({Ka:.2f}*(1+s*{tau:.2f})) / ((s^2)(1+s*{tau:.2f}))\\nSteady-State Error = {steady_state_error:.2f}')\n",
    "    plt.ylim(0, 10)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Ka=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='Ka'),\n",
    "         R0=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parabolic Response\n",
    "\n",
    "This interactive plot illustrates the parabolic response of a unity feedback system with an acceleration controller. The transfer function of the system is given by G(s) = (Ka * (0.5s + 1)) / (s * (0.5s + 1)). You can adjust the acceleration gain (Ka) and the reference input (R0) using sliders and observe how changes in these parameters affect the system's parabolic response.\n",
    "\n",
    "### Function Description:\n",
    "\n",
    "The plot includes the following components:\n",
    "\n",
    "1. **System Response (y(t)):** The response of the feedback system to a parabolic input. Displayed as a solid line.\n",
    "\n",
    "2. **Reference Parabolic Input (r(t)):** The reference parabolic input signal. Displayed as a solid line.\n",
    "\n",
    "3. **Steady-State Error Marker:** A purple dashed line indicates the time at which the system reaches its maximum response, highlighting the steady-state error. The steady-state error value is infinite for a parabolic input.\n",
    "\n",
    "### Instructions:\n",
    "\n",
    "Adjust the sliders for Ka and R0 to observe changes in the parabolic response. The plot includes a marker for steady-state error, providing insights into system performance.\n",
    "\n",
    "### Sliders:\n",
    "\n",
    "- **Acceleration Gain (Ka):** Adjust the acceleration gain of the system.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "- **Reference Input (R0):** Adjust the reference input to observe its impact on the system's response.\n",
    "  - *Range:* 0.1 to 10 with a step size of 0.1.\n",
    "\n",
    "Feel free to experiment with different values to gain a deeper understanding of the system's behavior under different control parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6aeb7f74a4a244719e6229f1880c243e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='Ka', max=10.0, min=0.1), FloatSlider(value=5.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import control as ctrl\n",
    "from ipywidgets import interact, widgets\n",
    "\n",
    "# Function to update the plot with interactive sliders\n",
    "def update_plot(Ka, R0):\n",
    "    # Time constant\n",
    "    tau = 0.5\n",
    "\n",
    "    # Given transfer function G(s) = (Ka * (tau * s + 1)) / ((s^2) * (tau * s + 1))\n",
    "    numerator = [Ka * tau, 1]\n",
    "    denominator = [tau, 1, 0, 0]\n",
    "\n",
    "    # Create the transfer function\n",
    "    sys = ctrl.TransferFunction(numerator, denominator)\n",
    "\n",
    "    # Unity feedback system\n",
    "    sys_feedback = ctrl.feedback(sys, 1)\n",
    "\n",
    "    # Time vector for simulation\n",
    "    t_max = 10\n",
    "    step = 0.01\n",
    "    time = np.arange(0, t_max, step)\n",
    "\n",
    "    # Parabolic input in Laplace domain: R(s) = 1/(s^3)\n",
    "    parabola_input = R0 * (time ** 2)\n",
    "\n",
    "    # Simulate the response using forced_response\n",
    "    time, y = ctrl.forced_response(sys_feedback, time, parabola_input)\n",
    "\n",
    "    # Calculate steady-state error\n",
    "    steady_state_error = R0 / Ka\n",
    "\n",
    "    # Plot the response and the reference input\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(time, y, label='y(t): Feedback System Response')\n",
    "    plt.plot(time, parabola_input, label='r(t): Reference Parabolic Input')\n",
    "\n",
    "    # Plot the steady-state error\n",
    "    plt.plot([t_max, t_max], [parabola_input[len(time)-1], y[len(time)-1]], color='purple', linestyle='--', linewidth=2, label='Steady-State Error')\n",
    "\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.title(f'Parabolic Response of G(s) = ({Ka:.2f}*(1+s*{tau:.2f})) / ((s^2)(1+s*{tau:.2f}))\\nSteady-State Error = R0 / Ka = {steady_state_error:.2f}')\n",
    "    plt.ylim(0, 10)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# Create interactive sliders\n",
    "interact(update_plot, Ka=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='Ka'),\n",
    "         R0=widgets.FloatSlider(value=5.0, min=0.1, max=10.0, step=0.1, description='R0'));\n"
   ]
  }
 ],
 "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}