planar_quadrotor_cbf_clf_qp.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sEhvW2OpdeXn",
        "outputId": "48e77881-1520-402f-df89-542ff95f3b5b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: cvxpy in /usr/local/lib/python3.10/dist-packages (1.3.4)\n",
            "Requirement already satisfied: osqp in /usr/local/lib/python3.10/dist-packages (0.6.2.post8)\n",
            "Requirement already satisfied: ecos>=2 in /usr/local/lib/python3.10/dist-packages (from cvxpy) (2.0.13)\n",
            "Requirement already satisfied: scs>=1.1.6 in /usr/local/lib/python3.10/dist-packages (from cvxpy) (3.2.4.post1)\n",
            "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.10/dist-packages (from cvxpy) (1.25.2)\n",
            "Requirement already satisfied: scipy>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from cvxpy) (1.11.4)\n",
            "Requirement already satisfied: setuptools>65.5.1 in /usr/local/lib/python3.10/dist-packages (from cvxpy) (67.7.2)\n",
            "Requirement already satisfied: qdldl in /usr/local/lib/python3.10/dist-packages (from osqp) (0.1.7.post2)\n"
          ]
        }
      ],
      "source": [
        "!pip install  cvxpy osqp"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "mr5vY25DeFTZ"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import cvxpy as cp\n",
        "from scipy.integrate import solve_ivp\n",
        "from matplotlib import pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "f2V5y3ledidg"
      },
      "outputs": [],
      "source": [
        "# Quadrotor parameters\n",
        "m_q = 1.0 # kg\n",
        "I_xx = 0.1 # kg.m^2\n",
        "l_q = 0.3 # m, length of the quadrotor\n",
        "g = 9.81\n",
        "\n",
        "# Controller parameters\n",
        "params = {\n",
        "    'alpha': 7.5,\n",
        "    'beta': 5.0,\n",
        "    'gamma_p': 2.5334991360748047,\n",
        "    'gamma_o': 6.8100624327890635,\n",
        "    'kp_ey': 0.8060171897461441,\n",
        "    'kp_ez': 1.666562251062336,\n",
        "    'kp_e_yzdot': 1.5596285831810783,\n",
        "    'ko_e': 7.612698055588866,\n",
        "    'ko_phidot': 0.04242324430833757,\n",
        "    'ko_e_phidot': 0.7556504455549217\n",
        "}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WWqnprviFlcL"
      },
      "source": [
        "## Define 2D planar quadrotor models\n",
        "\n",
        "The model of the planar quadrotor is from an [Aerial Robitics lecture](https://www.coursera.org/lecture/robotics-flight/2-d-quadrotor-control-kakc6) on couyrsera.\n",
        "\n",
        "The state of the planar quadrotor is defined as\n",
        "\n",
        "\\begin{equation}\n",
        "(y, \\dot{y}, z, \\dot{z}, \\phi, \\dot{\\phi})\n",
        "\\end{equation}\n",
        "where:\n",
        "- $(y, z)$ is the position.\n",
        "- $\\phi$ is the roll angle.\n",
        "\n",
        "The control input consists of:\n",
        "- The total thrust $u_1$.\n",
        "- The torque provided by the rotors $u_2$.\n",
        "\n",
        "The dynamics of the planar quadrotor are described by the following equations:\n",
        "$$\n",
        "\\begin{align}\n",
        "    \\ddot{y} &= \\frac{-u_1}{m_q}\\cdot{\\sin(\\phi)} \\\\\n",
        "    \\ddot{z} &= -g + \\frac{u_1}{m_q}\\cdot{\\cos(\\phi)} \\\\\n",
        "    \\ddot{\\phi} &= \\frac{u_2}{I_{xx}}\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "where $m_q$ is the mass of the quadrotor, $I_{xx}$ is the inertia moment of the quadrotor, and $g$ is the gravity."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "qJXgGYcwFlcM"
      },
      "outputs": [],
      "source": [
        "def dynamics_ode(t, state, u1, u2, m_q=m_q, g=g, I_xx=I_xx):\n",
        "    \"\"\"\n",
        "    Calculate the next state of the system based on the current state and control inputs.\n",
        "    :param u1: Thrust input\n",
        "    :param u2: Moments input\n",
        "    :return: New state\n",
        "    \"\"\"\n",
        "    y, y_dot, z, z_dot, phi, phi_dot = state\n",
        "    # Quadrotor dynamics\n",
        "    y_ddot = -u1 * np.sin(phi) / m_q\n",
        "    z_ddot = -g + u1 * np.cos(phi) / m_q\n",
        "    phi_ddot = u2 / I_xx\n",
        "\n",
        "    return np.array([y_dot, y_ddot, z_dot, z_ddot, phi_dot, phi_ddot])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FQEH2sLhFlcM"
      },
      "source": [
        "## Define QP controllers\n",
        "\n",
        "The controller design discussed here is adapted from the research presented by Guofan Wu and Koushil Sreenat. The full paper is available [here](https://hybrid-robotics.berkeley.edu/publications/ACC2016_Safety_Control_Planar_Quadrotor.pdf).\n",
        "\n",
        "> Wu, Guofan, and Koushil Sreenath. \"Safety-critical control of a planar quadrotor.\" 2016 American control conference (ACC). IEEE, 2016.\n",
        "\n",
        "### Overview of the Controller Architecture\n",
        "The proposed architecture divides the control system into two main components: the position-level controller and the orientation-level controller. Each targets specific aspects of the quadrotor's flight dynamics.\n",
        "\n",
        "![](https://github.com/shaoanlu/mppi_cbf_playground/blob/main/assets/clf_cbf_qp_arch.jpg?raw=1)\n",
        "\n",
        "### Position-level controller\n",
        "The main purposes of the posiiton-level controll are:\n",
        "1) To calculate intermediate signals that will be used to drive the quadrotor toward the target position $y^*$ and $z^*$.\n",
        "2) To addresses the challenges associated with the quadrotor being an underactuated system, which means direct thrust and moment controls are not presented in both the Control Barrier Function (CBF) and Control Lyapunov Function (CLF).\n",
        "\n",
        "To address the latter issue, the controller employs virtual controls using the following simplified dynamics:\n",
        "$$\n",
        "\\begin{align}\n",
        "    \\ddot{y} &= m_q u_{v1}, & \\ddot{z} &= m_q u_{v2}\n",
        "\\end{align}\n",
        "$$\n",
        "Here, $u_{v1}$ and $u_{v2}$ are virtual controls. The controller optimizes these controls by solving a Quadratic Programming (QP) problem that incorporates both CLF and CBF constraints to ensure that the quadrotor reaching target position in finite time without collision:\n",
        "$$\n",
        "\\begin{align}\n",
        "    u^*_{v1},u^*_{v2} &= \\text{argmin  } u^2_{v1} + u^2_{v2} + 10\\cdot{\\delta} \\\\\n",
        "    \\text{s.t.} & \\\\\n",
        "    &\\dot{V}_p + \\gamma V_p \\le 0 & \\text{(CLF constraint)}\\\\\n",
        "    & \\ddot{h_p} + \\beta \\dot{h_p} + \\alpha h_p + \\delta \\ge 0 & \\text{(CBF constraint)}\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "After solving the QP, desired state $u_{1d}$ and $\\phi_d$ is then calculated for the downstream orientation-level controller.\n",
        "$$\n",
        "\\begin{align}\n",
        "    u_{1d} &=  \\text{max} \\{U_v\\cos{\\phi}, U_v\\sin{\\phi}, 0\\}, & U_v = \\sqrt{u^2_{v1}+u^2_{v2}}\\\\\n",
        "    \\phi_d &= -\\arctan{(u_{v1}/u_{v2})}\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "\n",
        "### Orientation-level conrtoller\n",
        "The main purpose of the orientaiton-level controller is to track the desired signals $u_{1d}$ and $\\phi_d$. As such, it uses desired states from the position-level output and solves another QP problem to determine the actual commands for the quadrotor. This controller incorporates the full dynamics of the quadrotor in its CLF/CBF constraints and is defined as follows:\n",
        "$$\n",
        "\\begin{align}\n",
        "    u^*_{1},u^*_{2} &= \\text{argmin  } (u_1-u_{1d})^2 + u^2_2 + 10^2\\delta_{CBF} + 10^4\\delta_{CLF} \\\\\n",
        "    \\text{s.t.} & \\\\\n",
        "    &\\dot{V}_o + \\gamma V_o \\le \\delta_{CLF} & \\text{(CLF constraint)}\\\\\n",
        "    & \\ddot{h_o} + \\beta \\dot{h_o} + \\alpha h_o + \\delta_{CBF} \\ge 0 & \\text{(CBF constraint)}\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "For further details on the formulation and implementation, please refer to Section V of the cited paper and the code below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "n8fMG65wwnA5"
      },
      "outputs": [],
      "source": [
        "def position_qp_controller(state, obs_center, obs_radius, target_position, params=None):\n",
        "    # Get parameters\n",
        "    if params is not None:\n",
        "        gamma = params[\"gamma_p\"]\n",
        "        alpha, beta = params[\"alpha\"], params[\"beta\"]\n",
        "        kp_yzdot, kp_ey, kp_ez, kp_e_yzdot = m_q, params[\"kp_ey\"], params[\"kp_ez\"], params[\"kp_e_yzdot\"]\n",
        "    else:\n",
        "        # default values\n",
        "        gamma = 0.6009727117576193\n",
        "        alpha, beta = 1, 0.5\n",
        "        kp_yzdot, kp_ey, kp_ez, kp_e_yzdot = m_q, 0.6233345302311967, 6.38664193836647, 1.231530796565488\n",
        "\n",
        "    # Get state\n",
        "    y, y_dot, z, z_dot, phi, phi_dot = state\n",
        "    sin_phi, cos_phi = np.sin(phi), np.cos(phi)\n",
        "\n",
        "    # Define virtual control inputs and control variables\n",
        "    virtual_u1 = cp.Variable()\n",
        "    virtual_u2 = cp.Variable()\n",
        "    slack_cbf = cp.Variable()\n",
        "    y_ddot = virtual_u1 / m_q  # assume direct control on YZ direction\n",
        "    z_ddot = virtual_u2 / m_q  # assume direct control on YZ direction\n",
        "\n",
        "    # Construct CBF constraints\n",
        "    cbf_constraints = []\n",
        "    for (y_obs, z_obs), radius in zip(obs_center, obs_radius):\n",
        "      # Barrier function h(x): Distance to each obstacle\n",
        "      d = (y - y_obs)**2 + (z - z_obs)**2\n",
        "      h = d - (radius + l_q)**2\n",
        "      h_dot = 2*((y - y_obs) * y_dot) + 2*((z - z_obs) * z_dot)  # First derivative of the barrier function\n",
        "      h_ddot = 2*(y - y_obs) * y_ddot + 2*(z - z_obs) * z_ddot + 2*(y_dot**2 + z_dot**2)  # Second derivative of the barrier function\n",
        "      cbf_constraint = h_ddot + beta * h_dot + alpha * h >= -slack_cbf  # Second-order CBF constraint\n",
        "      cbf_constraints.append(cbf_constraint)\n",
        "\n",
        "    # Construct the Lyapunov function\n",
        "    y_des, z_des = target_position\n",
        "    V = (\n",
        "        kp_ey*(y - y_des)**2 +\n",
        "        kp_ez*(z - z_des)**2 +\n",
        "        kp_yzdot*y_dot**2 +\n",
        "        kp_yzdot*z_dot**2 +\n",
        "        kp_e_yzdot*(y - y_des)*z_dot +\n",
        "        kp_e_yzdot*(z - z_des)*z_dot\n",
        "    )\n",
        "    # Derivative of the Lyapunov function\n",
        "    V_dot = (\n",
        "        2 * kp_ey * (y - y_des) * y_dot +\n",
        "        2 * kp_ez * (z - z_des) * z_dot +\n",
        "        2 * kp_yzdot * y_dot * y_ddot +\n",
        "        2 * kp_yzdot * z_dot * z_ddot +\n",
        "        kp_e_yzdot*y_dot**2 + kp_e_yzdot*(y - y_des)*y_ddot +\n",
        "        kp_e_yzdot*z_dot**2 + kp_e_yzdot*(z - z_des)*z_ddot\n",
        "    )\n",
        "\n",
        "    # CLF constraint (no need for CLF slack variabl as we are using virtual force control)\n",
        "    clf_condition = V_dot + gamma * V <= 0\n",
        "\n",
        "    # Objective: minimize control efforts while satisfying CBF and CLF constraints\n",
        "    objective = cp.Minimize(cp.square(virtual_u1) + cp.square(virtual_u2) + 1e3*cp.square(slack_cbf))\n",
        "    prob = cp.Problem(objective,[clf_condition] + cbf_constraints)\n",
        "    _ = prob.solve(solver=cp.OSQP)\n",
        "\n",
        "    # Compute actual control inputs from the optimized virtual inputs\n",
        "    comp_virtual_u2 = virtual_u2.value + g  # IMPORTANT: gravity compensation\n",
        "    desired_thrust = np.sqrt(virtual_u1.value**2 + comp_virtual_u2**2)\n",
        "    desired_thrust = np.clip(np.maximum(desired_thrust*sin_phi, desired_thrust*cos_phi), 0, np.inf)\n",
        "    desired_phi = -np.arctan(virtual_u1.value/comp_virtual_u2)\n",
        "\n",
        "    return np.array([desired_thrust, desired_phi])\n",
        "\n",
        "def orientation_qp_controller(state, desired_thrust, desired_phi, obs_center, obs_radius, params=None):\n",
        "    # Get parameters\n",
        "    if params is not None:\n",
        "        gamma = params[\"gamma_o\"]\n",
        "        alpha, beta = params[\"alpha\"], params[\"beta\"]\n",
        "        ko_e, ko_phidot, ko_e_phidot = params[\"ko_e\"], params[\"ko_phidot\"], params[\"ko_e_phidot\"]\n",
        "    else:\n",
        "        # default values\n",
        "        gamma = 10.486772559058295\n",
        "        alpha, beta = 7.5, 5.0\n",
        "        ko_e, ko_phidot, ko_e_phidot = 4.543613398627403, 0.07817105307302716, 1.3579531762833574\n",
        "\n",
        "    # Define the control variables\n",
        "    u1 = cp.Variable()\n",
        "    u2 = cp.Variable()\n",
        "    slack_clf = cp.Variable()\n",
        "    slack_cbf = cp.Variable()\n",
        "\n",
        "    # Get state\n",
        "    y, y_dot, z, z_dot, phi, phi_dot = state\n",
        "    sin_phi, cos_phi = np.sin(phi), np.cos(phi)\n",
        "    y_ddot = -u1 * sin_phi / m_q\n",
        "    z_ddot = -g + u1 * cos_phi / m_q\n",
        "\n",
        "    # Construct CBF constraints\n",
        "    cbf_constraints = []\n",
        "    for (y_obs, z_obs), radius in zip(obs_center, obs_radius):\n",
        "      # Barrier function h(x): Distance to each obstacle\n",
        "      d = (y - y_obs)**2 + (z - z_obs)**2\n",
        "      h = d - (radius + l_q)**2\n",
        "      h_dot = 2*((y - y_obs) * y_dot) + 2*((z - z_obs) * z_dot)  # First derivative of the barrier function\n",
        "      h_ddot = 2*(y - y_obs) * y_ddot + 2*(z - z_obs) * z_ddot + 2*(y_dot**2 + z_dot**2)  # Second derivative of the barrier function\n",
        "      cbf_constraint = h_ddot + beta * h_dot + alpha * h >= -slack_cbf  # Second-order CBF constraint\n",
        "      cbf_constraints.append(cbf_constraint)\n",
        "\n",
        "    # Construct CLF constraint\n",
        "    phi_ddot = u2 / I_xx\n",
        "    e_phi = (phi - desired_phi)\n",
        "    V = ko_e*e_phi**2 + ko_phidot*phi_dot**2 + ko_e_phidot*e_phi*phi_dot\n",
        "    V_dot = 2 * ko_e * e_phi * phi_dot + 2 * ko_phidot * phi_dot * phi_ddot + ko_e_phidot*phi_dot**2 + ko_e_phidot*e_phi*phi_ddot\n",
        "    clf_condition = V_dot + gamma * V <= slack_clf\n",
        "\n",
        "    # Objective: minimize the deviation from the desired control while satisfying CBF and CLF constraints\n",
        "    objective = cp.Minimize(cp.square(u1 - desired_thrust) + cp.square(u2) + 1e2*cp.square(slack_clf) + 1e4*cp.square(slack_cbf))\n",
        "    prob = cp.Problem(objective,[clf_condition, u1 >= 0, u1 <= 40, u2 >= -20, u2 <= 20] + cbf_constraints)\n",
        "    _ = prob.solve(solver=cp.OSQP)\n",
        "\n",
        "    return np.array([u1.value, u2.value])\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "zZScq2qeFlcM"
      },
      "outputs": [],
      "source": [
        "def cbf_clf_controller(state, obs_center, obs_radius, target_position, params=None):\n",
        "    desired_thrust, desired_phi = position_qp_controller(state, obs_center, obs_radius, target_position, params=params)\n",
        "    control_command = orientation_qp_controller(state, desired_thrust, desired_phi, obs_center, obs_radius, params=params)\n",
        "    return control_command"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JbcJTVPFFlcM"
      },
      "source": [
        "## Run simulation and visualize result"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Em2oMk2PdigK",
        "outputId": "daf38b8e-63ba-4964-e9f9-d6643a56f79c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "target_position=[8, 5]\n"
          ]
        }
      ],
      "source": [
        "# Environment parameters\n",
        "sim_time_sec = 20\n",
        "dt = 0.1  # Time step [sec]\n",
        "obs_center = [(5, 5), (2, 2), (8, 2), (2, 6)]  # position of the obstacles\n",
        "obs_radius = [1.2, 1.5, 0.98, 2]  # Radius of the obstacles\n",
        "target_position = [8, 5]\n",
        "print(f\"{target_position=}\")\n",
        "\n",
        "# Set initial state of the quadrotor\n",
        "y = 0.0\n",
        "z = 0.0\n",
        "phi = 0.0\n",
        "y_dot = 0.0\n",
        "z_dot = 0.0\n",
        "phi_dot = 0.0\n",
        "state = np.array([y, y_dot, z, z_dot, phi, phi_dot])\n",
        "\n",
        "# Variables for logging\n",
        "states = [state]\n",
        "u_actual = [np.zeros((2,))]\n",
        "\n",
        "# Run closed-loop simulation\n",
        "for t in np.linspace(0, sim_time_sec, int(sim_time_sec/dt)+1):\n",
        "  #safe_control = cbf_control(state, u_desired, obs_center, obs_radius)\n",
        "  control = cbf_clf_controller(state, obs_center, obs_radius, target_position=target_position, params=None)\n",
        "\n",
        "  sol = solve_ivp(dynamics_ode, [t, t+dt], state, args=(control[0], control[1]), method='RK45')\n",
        "  state = sol.y[:, -1]\n",
        "  states.append(state)\n",
        "  u_actual.append(control)\n",
        "\n",
        "# post process\n",
        "states = np.array(states)\n",
        "u_actual = np.array(u_actual)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 791
        },
        "id": "djQuMxzKdiio",
        "outputId": "59648ab2-0020-4b25-b69a-865f044804cd"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:matplotlib.legend:No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.gca().set_aspect('equal', adjustable='box')\n",
        "# Plot obstacles\n",
        "for obs_idx in range(len(obs_center)):\n",
        "    circle = plt.Circle((obs_center[obs_idx][0], obs_center[obs_idx][1]), obs_radius[obs_idx], color='grey', fill=True, linestyle='--', linewidth=2, alpha=0.5)\n",
        "    plt.gca().add_artist(circle)\n",
        "\n",
        "ys, zs, phis = states[..., 0], states[..., 2], states[..., 4]\n",
        "# Plot quadrotor pose\n",
        "y_ = [(y-l_q*np.cos(phi), y+l_q*np.cos(phi)) for (y, phi) in zip(ys[::7], phis[::7])]\n",
        "z_ = [(z-l_q*np.sin(phi), z+l_q*np.sin(phi)) for (z, phi) in zip(zs[::7], phis[::7])]\n",
        "for yy, zz in zip(y_, z_):\n",
        "  plt.plot(yy, zz, marker=\"o\", color=\"r\", alpha=0.5)\n",
        "\n",
        "# Plot trajectory\n",
        "plt.scatter([y], [z], s=150, color=\"g\")\n",
        "plt.scatter([target_position[0]], [target_position[1]], s=150, color=\"purple\")\n",
        "plt.plot(states[:, 0], states[:, 2])\n",
        "plt.xlim(-3.5, 12); plt.ylim(-1.2, 8); plt.grid(); plt.legend()\n",
        "plt.show()\n",
        "\n",
        "# Plot control signals\n",
        "plt.plot(u_actual)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "70B8O1EFbDt8"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wrMB8-e2X5k9"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}