FaSTrack: a Modular Framework for Fast and Guaranteed Safe Motion Planning

TL;DR

FaSTrack is a modular framework that enables fast, safe, and guaranteed tracking of high-dimensional dynamical systems by combining simplified planning with a safety controller that accounts for tracking errors.

Contribution

The paper introduces FaSTrack, a novel modular framework that guarantees safety and tracking accuracy for high-dimensional systems using simplified planning models.

Findings

Successfully applied to a 10D quadrotor model

Provides guaranteed tracking error bounds

Compatible with existing path planners

Abstract

Fast and safe navigation of dynamical systems through a priori unknown cluttered environments is vital to many applications of autonomous systems. However, trajectory planning for autonomous systems is computationally intensive, often requiring simplified dynamics that sacrifice safety and dynamic feasibility in order to plan efficiently. Conversely, safe trajectories can be computed using more sophisticated dynamic models, but this is typically too slow to be used for real-time planning. We propose a new algorithm FaSTrack: Fast and Safe Tracking for High Dimensional systems. A path or trajectory planner using simplified dynamics to plan quickly can be incorporated into the FaSTrack framework, which provides a safety controller for the vehicle along with a guaranteed tracking error bound. This bound captures all possible deviations due to high dimensional dynamics and external disturbances. Note that FaSTrack is modular and can be used with most current path or trajectory planners. We demonstrate this framework using a 10D nonlinear quadrotor model tracking a 3D path obtained from an RRT planner.

Figures

Equations

$$\frac{ds}{dt}=\dot{s}=f(s,u_s,d),t\in [0,T]$$

$$s\in \mathcal{S},u_s\in {\mathcal{U}}_s,d\in \mathcal{D}$$

$$u_s(\cdot )\in {\mathbb{U}}_s(t)=\{\varphi :[0,T]\to {\mathcal{U}}_s:\varphi (\cdot )\text{ is measurable}\}$$

$$d(\cdot )\in \mathbb{D}(t)=\{\varphi :[0,T]\to \mathcal{D}:\varphi (\cdot )\text{ is measurable}\}$$

$$\frac{d}{dt}{\xi }_f(t;s,t_0,u_s(\cdot ))$$

$${\xi }_f(t;s,t,u_s(\cdot ))$$

$$\frac{dp}{dt}=\dot{p}=h(p,u_p),t\in [0,T],p\in \mathcal{P},\underline{u_p}\le u_p\le \overline{u_p}$$

$$r=s-Qp,\dot{r}=g(r,u_s,u_p,d)$$

$$\displaystyle V(r,T)=\sup_{\gamma_{p}\in\Gamma_{p}(t),\gamma_{d}\in\Gamma_{d}(t)}\inf_{u_{s}(\cdot)\in\mathbb{U}_{s}(t)}\big{\{}$$

$$\displaystyle\qquad\qquad\max_{t\in[0,T]}l\Big{(}\xi_{g}(t;r,0,u_{s}(\cdot),\gamma_{p}[u_{s}](\cdot),\gamma_{d}[u_{s}](\cdot))\Big{)}\big{\}}$$

$$V_{\infty }(r):=\underset{T\to \infty }{\lim }V(r,T)$$

$$V_{\infty}(r)\geq V_{\infty}\Big{(}\xi_{g}^{*}(t_{2};r,t_{1})\Big{)},\text{where}$$

$${\xi }_g^{\ast }(t;r,0):={\xi }_g(t;r,0,u_s^{\ast }(\cdot ),u_p^{\ast }(\cdot ),d^{\ast }(\cdot )))$$

$$\displaystyle u_{s}^{*}(\cdot)=\arg\inf_{u_{s}(\cdot)\in\mathbb{U}_{s}(t)}\big{\{}$$

$$\displaystyle\qquad\max_{t\in[0,T]}l(\xi_{g}(t;r,0,u_{s}(\cdot),u_{p}^{*}(\cdot),d^{*}(\cdot)))\big{\}}$$

$$\displaystyle u_{p}^{*}(\cdot):=\gamma_{p}^{*}[u_{s}](\cdot)=\arg\sup_{\gamma_{p}\in\Gamma_{p}(t)}\inf_{u_{s}(\cdot)\in\mathbb{U}_{s}(t)}\big{\{}$$

$$\displaystyle\qquad\max_{t\in[0,T]}l(\xi_{g}(t;r,0,u_{s}(\cdot),\gamma_{p}[u_{s}](\cdot),d^{*}(\cdot)))\big{\}}$$

$$\displaystyle d^{*}(\cdot)=\arg\sup_{\gamma_{d}\in\Gamma_{d}(t)}\sup_{\gamma_{p}\in\Gamma_{p}(t)}\inf_{u_{s}(\cdot)\in\mathbb{U}_{s}(t)}\big{\{}$$

$$\displaystyle\qquad\max_{t\in[0,T]}l(\xi_{g}(t;r,0,u_{s}(\cdot),\gamma_{p}[u_{s}](\cdot),\gamma_{d}[u_{s}](\cdot)))\big{\}}$$

$${\mathcal{B}}_p(s)=\{p:V_{\infty }(s-Qp)\le \underline{V}\}$$

$$V_{\infty }(r)$$

$$\ge \underset{T\to \infty }{\lim }\underset{t\in [0,T]}{\max }l({\xi }_g^{\ast }(t;r,-t_2))$$

$${\xi }_g^{\ast }(t;r,-\tau )$$

$$={\xi }_g^{\ast }(t;{\xi }_g^{\ast }(t_2;r,0),0)$$

$$V_{\infty }(r)$$

$$=V_{\infty }({\xi }_g^{\ast }(t_2;r,0))$$

$$u_s^{\ast }=\arg \underset{u_s\in {\mathcal{U}}_s}{\min }\underset{u_p\in {\mathcal{U}}_p,d\in \mathcal{D}}{\max }\nabla V(r_{next})\cdot g(r_{next},u_s,u_p,d)$$

$$\displaystyle\begin{array}[]{c}\left[\begin{array}[]{c}\dot{x}\\ \dot{v_{x}}\\ \dot{\theta_{x}}\\ \dot{\omega}_{x}\\ \dot{y}\\ \dot{v_{y}}\\ \dot{\theta_{y}}\\ \dot{\omega}_{y}\\ \dot{z}\\ \dot{v_{z}}\end{array}\right]=\left[\begin{array}[]{c}v_{x}+d_{x}\\ g\tan\theta_{x}\\ -d_{1}\theta_{x}+\omega_{x}\\ -d_{0}\theta_{x}+n_{0}a_{x}\\ v_{y}+d_{y}\\ g\tan\theta_{y}\\ -d_{1}\theta_{y}+\omega_{y}\\ -d_{0}\theta_{y}+n_{0}a_{y}\\ v_{z}+d_{z}\\ k_{T}a_{z}-g\end{array}\right]\left[\begin{array}[]{c}\dot{x}\\ \dot{y}\\ \dot{z}\\ \end{array}\right]=\left[\begin{array}[]{c}b_{x}\\ b_{y}\\ b_{z}\\ \end{array}\right]\end{array}$$

$$\displaystyle\begin{array}[]{c}\left[\begin{array}[]{c}\dot{x_{r}}\\ \dot{v_{x}}\\ \dot{\theta_{x}}\\ \dot{\omega}_{x}\\ \dot{y_{r}}\\ \dot{v_{y}}\\ \dot{\theta_{y}}\\ \dot{\omega}_{y}\\ \dot{z_{r}}\\ \dot{v_{z}}\end{array}\right]=\left[\begin{array}[]{c}v_{x}-b_{x}+d_{x}\\ g\tan\theta_{x}\\ -d_{1}\theta_{x}+\omega_{x}\\ -d_{0}\theta_{x}+n_{0}a_{x}\\ v_{y}-b_{y}+d_{y}\\ g\tan\theta_{y}\\ -d_{1}\theta_{y}+\omega_{y}\\ -d_{0}\theta_{y}+n_{0}a_{y}\\ v_{z}-b_{z}+d_{z}\\ k_{T}a_{z}-g\end{array}\right]\end{array}$$

Full text

I Introduction

As unmanned aerial vehicles (UAVs) and other autonomous systems become more commonplace, it is essential that they be able to plan safe motion paths through crowded environments in real time. This is particularly crucial for navigating through environments that are a priori unknown. However, for many common dynamical systems, accurate and robust path planning can be too computationally expensive to perform efficiently. In order to achieve real-time planning, many algorithms use highly simplified model dynamics or kinematics, resulting in a tracking error between the planned path and the true high-dimensional system. This concept is illustrated in Fig. 1, where the path was planned using a simplified planning model, but the real vehicle cannot track this path exactly. In addition, external disturbances (e.g. wind) can be difficult to account for. Crucially, such tracking errors can lead to dangerous situations in which the planned path is safe, but the actual system trajectory enters unsafe regions.

We propose the modular tool FaSTrack: Fast and Safe Tracking, which models the navigation task as a sophisticated tracking system that pursues a simplified planning system. The tracking system accounts for complex system dynamics as well as bounded external disturbances, while the simple planning system enables the use of real-time planning algorithms. Offline, a precomputed pursuit-evasion game between the two systems is analyzed using Hamilton Jacobi (HJ) reachability analysis. This results in a tracking error function that maps the initial relative state between the two systems to the tracking error bound: the maximum possible relative distance that could occur over time. This tracking error bound can be thought of as a “safety bubble” around the planning system that the tracking system is guaranteed to stay within. Because the tracking error is bounded in the relative state space, we can precompute and store a safety control function that maps the real-time relative state to the optimal safety control for the tracking system to “catch” the planning system. It is important to note that the offline computations are independent of the path planned in real-time; what matters are the relative states and dynamics between the systems, not the absolute state of the online path.

In the online computation, the autonomous system senses local obstacles, which are then augmented by the tracking error bound to ensure that no potentially unsafe paths can be computed. Next, a path or trajectory planner uses the simplified planning model to determine the next desired state. The tracking system then finds the relative state between itself and the next desired state. If this relative state is nearing the tracking error bound then it is plugged into the safety control function to find the instantaneous optimal safety control of the tracking system; otherwise, any controller may be used. In this sense, FaSTrack provides a least-restrictive control law. This process is repeated until the navigation goal is reached.

Because we designed FaSTrack to be modular, it can be used with existing fast path or trajectory planners, enabling motion planning that is rapid, safe, and dynamically accurate. In this paper, we demonstrate this tool by computing the tracking error bound between a 10D quadrotor model affected by wind and a linear 3D kinematic model. Online, the simulated system travels through a static, windy environment with obstacles that are only known once they are within the limited sensing range of the vehicle. Combining this bound with a kinematic rapidly exploring random trees (RRT) fast path planner [39], the system is able to safely plan and track a trajectory through the environment in real time.

II Related Work

Motion planning is a very active area of research in the controls and robotics communities [1]. In this section we will discuss past work on path planning, kinematic planning, and dynamic planning. A major current challenge is to find an intersection of robust and real-time planning for general nonlinear systems.

Sample-based planning methods like rapidly-exploring random trees (RRT) [2], probabilistic road maps (PRM) [3], fast marching tree (FMT) [4], and many others [5, 6, 7] can find collision-free paths through known or partially known environments. While extremely effective in a number of use cases, these algorithms are not designed to be robust to model uncertainty or disturbances.

Motion planning for kinematic systems can also be accomplished through online trajectory optimization using methods such as TrajOpt [8] and CHOMP [9]. These methods can work extremely well in many applications, but are generally challenging to implement in real time for nonlinear dynamic systems due to the computational load.

Model predictive control (MPC) has been a very successful method for dynamic trajectory optimization in both academia and industry [10]. However, combining speed, safety, and complex dynamics is a difficult balance to achieve. Using MPC for robotic and aircraft systems typically requires model reduction to take advantage of linear programming or mixed integer linear programming [11, 12, 13]; robustness can also be achieved in linear systems [14, 15]. Nonlinear MPC is most often used on systems that evolve more slowly over time [16, 17], with active work to speed up computation [18, 19]. Adding robustness to nonlinear MPC is being explored through algorithms based on minimax formulations and tube MPCs that bound output trajectories with a tube around a nominal path (see [1] for references).

There are other methods of dynamic trajectory planning that manage to cleverly skirt the issue of solving for optimal trajectories online. One such class of methods involve motion primitives [20, 21]. Other methods include making use of safety funnels [22], or generating and choosing random trajectories at waypoints [23, 24]. The latter has been implemented successfully in many scenarios, but is risky in its reliance on finding randomly-generated safe trajectories.

Recent work has considered using offline Hamilton-Jacobi analysis to guarantee tracking error bounds, which can then be used for robust trajectory planning [25]. A similar new approach, based on contraction theory and convex optimization, allows computation of offline error bounds that can then define safe tubes around a nominal dynamic trajectory computable online [26].

Finally, some online control techniques can be applied to trajectory tracking with constraint satisfaction. For control-affine systems in which a control barrier function can be identified, it is possible to guarantee forward invariance of the desired set through a state-dependent affine constraint on the control, which can be incorporated into an online optimization problem, and solved in real time [27].

The work presented in this paper differs from the robust planning methods above because FaSTrack is designed to be modular and easy to use in conjunction with any path or trajectory planner. Additionally, FaSTrack can handle bounded external disturbances (e.g. wind) and work with both known and unknown environments with static obstacles.

III Problem Formulation

In this paper we seek to simultaneously plan and track a trajectory (or path converted to a trajectory) online and in real time. The planning is done using a kinematic or dynamic planning model. The tracking is done by a tracking model representing the autonomous system. The environment may contain static obstacles that are either known a priori or can be observed by the system within a limited sensing range (see Section VI). In this section we will define the tracking and planning models, as well as the goals of the paper.

III-A Tracking Model

The tracking model is a representation of the autonomous system dynamics, and in general may be nonlinear and high-dimensional. Let $s$ represent the state variables of the tracking model. The evolution of the dynamics satisfy the ordinary differential equation:

[TABLE]

We assume that the system dynamics $f:\mathcal{S}\ \times\ \mathcal{U}_{s}\times\mathcal{D}\rightarrow\mathcal{S}$ are uniformly continuous, bounded, and Lipschitz continuous in $s$ for fixed control $u_{s}$. The control function $u_{s}(\cdot)$ and disturbance function $d(\cdot)$ are drawn from the following sets:

[TABLE]

where $\mathcal{U}_{s},\mathcal{D}$ are compact and $t\in[0,T]$ for some $T>0$. Under these assumptions there exists a unique trajectory solving (1) for a given $u_{s}(\cdot)\in\mathcal{U}_{s}$ [28]. The trajectories of (1) that solve this ODE will be denoted as $\xi_{f}(t;s,t_{0},u_{s}(\cdot))$, where $t_{0},t\in[0,T]$ and $t_{0}\leq t$. These trajectories will satisfy the initial condition and the ODE (1) almost everywhere:

[TABLE]

III-B Planning Model

The planning model is used by the path or trajectory planner to solve for the desired path online. Kinematics or low-dimensional dynamics are typically used depending on the requirements of the planner. Let $p$ represent the state variables of the planning model, with control $u_{p}$. The planning states $p\in\mathcal{P}$ are a subset of the tracking states $s\in\mathcal{S}$. The dynamics similarly satisfy the ordinary differential equation:

[TABLE]

Note that the planning model does not involve a disturbance input. This is a key feature of FaSTrack: the treatment of disturbances is only necessary in the tracking model, which is modular with respect to any planning method, including those that do not account for disturbances.

III-C Goals of This Paper

The goals of the paper are threefold:

To provide a tool for precomputing functions (or look-up tables) to determine a guaranteed tracking error bound between tracking and planning models, and optimal safety controller for robust motion planning with nonlinear dynamic systems 2. 2.

To develop a framework for easily implementing this tool with fast real-time path and trajectory planners. 3. 3.

To demonstrate the tool and framework in an example using a high dimensional system

IV General Framework

The overall framework of FaSTrack is summarized in Figs. 2, 3, 4. The online real-time framework is shown in Fig. 2. At the center of this framework is the path or trajectory planner; our framework is agnostic to the planner, so any may be used (e.g. MPC, RRT, neural networks). We will present an example using an RRT planner in Section VII.

When executing the online framework, the first step is to sense obstacles in the environment, and then augment the sensed obstacles by a precomputed tracking error bound as described in Section V. This tracking error bound is a safety margin that guarantees robustness despite the worst-case disturbance. Augmenting the obstacles by this margin can be thought of as equivalent to wrapping the planning system with a “safety bubble”. These augmented obstacles are given as inputs to the planner along with the current state of the planning system. The planner then outputs the next desired state of the planning system.

The tracking system is a model of the physical system (such as a quadrotor). The hybrid tracking controller block takes in the state of the tracking system as well as the desired state of the planning system. Based on the relative state between these two systems, the hybrid tracking controller outputs a control signal to the tracking system. The goal of this control is to make the tracking system track the desired planning state as closely as possible.

The hybrid tracking controller is expanded in Fig. 3 and consists of two controllers: a safety controller and a performance controller. In general, there may be multiple safety and performance controllers depending on various factors such as observed size of disturbances, but for simplicity we will just consider one safety and one performance controller in this paper. The safety controller consists of a function (or look-up table) computed offline via HJ reachability, and guarantees that the tracking error bound is not violated, despite the worst-case disturbance. In addition, the table look-up operation is computationally inexpensive. When the system is close to violating the tracking error bound, the safety controller must be used to prevent the violation. On the other hand, when the system is far from violating the tracking error bound, any controller (such as one that minimizes fuel usage), can be used. This control is used to update the tracking system, which in turn updates the planning system, and the process repeats.

To determine both the tracking error bound and safety controller functions/look-up tables, an offline framework is used as shown in Fig. 4. The planning and tracking system dynamics are plugged into an HJ reachability computation, which computes a value function that acts as the tracking error bound function/look-up table. The spatial gradients of the value function comprise the safety controller function/look-up table. These functions are independent of the online computations—they depend only on the relative states and dynamics between the planning and tracking systems, not on the absolute states along the trajectory at execution time.

In the following sections we will first explain the precomputation steps taken in the offline framework. We will then walk through the online framework and provide a complete example.

V Offline Computation

The offline computation begins with setting up a pursuit-evasion game [29, 30] between the tracking system and the planning system, which we then analyze using HJ reachability. In this game, the tracking system will try to “capture” the planning system, while the planning system is doing everything it can to avoid capture. In reality the planner is typically not actively trying to avoid the tracking system, but this allows us to account for worst-case scenarios. If both systems are acting optimally in this way, we want to determine the largest relative distance that may occur over time. This distance is the maximum possible tracking error between the two systems.

V-A Relative Dynamics

To determine the relative distance that may occur over time we must first define the relative states and dynamics between the tracking and planning models. The individual dynamics are defined in Section III, equations (1) and (4). The relative system is found by fixing the planning model to the origin and finding the dynamics of the tracking model relative to the planning model, as shown below.

[TABLE]

where $Q$ matches the common states of $s$ and $p$ by augmenting the state space of the planning model (as shown in Section VII). The relative states $r$ now represent the tracking states relative to the planning states. Similarly, $Q^{T}$ projects the state space of the tracking model onto the planning model: $p=Q^{T}(s-r)$. This will be used to update the planning model in the online algorithm.

V-B Formalizing the Pursuit-Evasion Game

Now that we have the relative dynamics between the two systems we must define a metric for the tracking error bound between these systems. We do this by defining an implicit surface function as a cost function $l(r)$ in the new frame of reference. Because the metric we care about is distance to the origin (and thus distance to the planning system), this cost function can be as simple as distance in position space to the origin. An example can be seen in Fig. 5-a, where $l(r)$ is defined for a 4D quadrotor model tracking a 2D kinematic planning model. The contour rings beneath the function represent varying level sets of the cost function. The tracking system will try to minimize this cost to reduce the relative distance, while the planning system will do the opposite.

Before constructing the differential game we must first determine the method each player must use for making decisions. We define a strategy for planning system as the mapping $\gamma_{p}:\mathcal{U}_{s}\rightarrow\mathcal{U}_{p}$ that determines a control for the planning model based on the control of the planning model. We restrict $\gamma$ to draw from only non-anticipative strategies $\gamma_{p}\in\Gamma_{p}(t)$, as defined in [31]. We similarly define the disturbance strategy $\gamma_{d}:\mathcal{U}_{s}\rightarrow\mathcal{D}$, $\gamma_{d}\in\Gamma_{d}(t)$.

We want to find the farthest distance (and thus highest cost) that this game will ever reach when both players are acting optimally. Therefore we want to find a mapping between the initial relative state of the system and the maximum possible cost achieved over the time horizon. This mapping is through our value function, defined as

[TABLE]

By implementing HJ reachability analysis we solve for this value function over the time horizon. If the control authority of the tracking system is powerful enough to always eventually reach the planning system, this value function will converge to an invariant solution for all time, i.e. $V_{\infty}(r):=\lim_{T\rightarrow\infty}V(r,T)$. An example of this converged value function is in Fig. 5-b. In the next section we will prove that the sub-level sets of this value function will map initial relative states to the guaranteed furthest possible tracking error over all time, as seen in Fig. 5-c.

In the context of the online framework, the value function $V_{\infty}(r)$ is the tracking error bound function. The spatial gradients of the value function, $\nabla V_{\infty}(r)$, comprise the safety controller function (as described in Section VI). When the framework is executed on a computer, these two functions are saved as look-up tables over a grid representing the state space of the relative system.

V-C Invariance of Converged Value Function

Proposition 1

Suppose that the value function converges, and define

[TABLE]

Then $\forall t_{1},t_{2}$ with $t_{2}\geq t_{1}$,

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

Proposition 1 proves that every level set of $V_{\infty}(r)$ is invariant under the following conditions:

The tracking system applies the optimal control which tries to track the planning system; 2. 2.

The planning system applies (at worst) the optimal control that tries to escape from the tracking system; 3. 3.

The tracking system experiences (at worst) the optimal disturbance that tries to prevent successful tracking.

In practice, conditions 2 and 3 may not hold; the result of this is only advantageous to the tracking system and will make it easier to stay within its current level set of $V_{\infty}(r)$, or to move to a smaller invariant level set of $V_{\infty}(r)$. The smallest invariant level set corresponding to the value $\underline{V}:=\min_{r}V_{\infty}(r)$ can be interpreted as the smallest possible tracking error of the system. The tracking error bound is given by111In practice, since $V_{\infty}$ is obtained numerically, we set $\mathcal{B}=\{r:V_{\infty}(r)\leq\underline{V}+\epsilon\}$ for some suitably small $\epsilon>0$ the set $\mathcal{B}=\{r:V_{\infty}(r)\leq\underline{V}\}$. This tracking error bound in the planner’s frame of reference is given by:

[TABLE]

This is the tracking error bound that will be used in the online framework as shown in Fig. 2. Within this bound the tracking system may use any controller, but on the border of this bound the tracking system must use the safety optimal controller. We now prove Proposition 1.

Proof:

Without loss of generality, assume $t_{1}=0$. By definition, we have

[TABLE]

By time-invariance, for some $t_{2}>0$,

[TABLE]

where the sub-interval $[-t_{2},0)$ has been removed in the last line. Next, by time invariance again, we have

[TABLE]

Now, (15) implies

[TABLE]

∎

Remark 1

Proposition 1 is very similar to well-known results in differential game theory with a slightly different cost function [32], and has been utilized in the context of using the subzero level set of $V_{\infty}$ as a backward reachable set for tasks such as collision avoidance or reach-avoid games [31]. In our work we do not assign special meaning to any particular level set, and instead consider all level sets at the same time. This effectively allows us to perform solve many simultaneous reachability problems in a single computation, thereby removing the need to check whether resulting invariant sets are empty, as was done in [25].

VI Online Computation

Algorithm 1 describes the online computation. The inputs are the tracking error function $V_{\infty}(r)$ and the safety control look-up function $\nabla V_{\infty}(r)$. Note that when discretized on a computer these functions will be look-up tables; practical issues arising from sampled data control can be handled using methods such as [33, 34, 35] and are not the focus of our paper.

Lines 1-3 initialize the computation by setting the planning and tracking model states (and therefore the relative state) to zero. The tracking error bound in the planning frame of reference is computed using (13). Note that by initializing the relative state to be zero we can use the smallest possible invariant $\mathcal{B}_{p}$ for the entire online computation.

The tracking error bound block is shown on lines 5-6. The sensor detects obstacles $\mathcal{O}_{sense}$ within the sensing distance around the vehicle. The sensed obstacles are augmented by $\mathcal{B}_{p}(0)$ using the Minkowski sum. This is done to ensure that no unsafe path can be generated222The minimum allowable sensing distance is $m=2\mathcal{B}_{p}(0)+\Delta x$, where $\Delta x$ is the largest step in space that the planner can make in one time step..

The path planner block (lines 7-8) takes in the planning model state $p$ and the augmented obstacles $\mathcal{O}_{aug}$, and outputs the next state of the planning system $p_{next}$. The hybrid tracking controller block (lines 9-16) first computes the updated relative state $r_{next}$. If the $r_{next}$ is on the tracking bound $\mathcal{B}_{p}(0)$, the safety controller must be used to remain within the safe bound. The safety control is given by:

[TABLE]

For many practical systems (such as control affine systems), this minimization can be found extremely quickly.

If the relative state is not on the tracking boundary, a performance controller may be used. For the example in Section VII the safety and performance controllers are identical, but in general this performance controller can suit the needs of the individual applications.

The control $u_{s}^{*}$ is then applied to the physical system in the tracking block (lines 17-18) for a time period of $\Delta t$. The next state is saved as $s_{next}$. This then updates the planning model state in the planning model block (lines 19-22). We repeat this process until the planning goal has been reached.

VII 10D Quadrotor RRT Example

We demonstrate this framework with a 10D near-hover quadrotor developed in [36] tracking a 3D point source path generated by an RRT planner [39]. First we perform the offline computations to acquire the tracking error bound and safety controller look-up tables. Next we set up the RRT to convert paths to simple 3D trajectories. Finally we implement the online framework to navigate the 10D system through a 3D environment with static obstacles.

VII-A Precomputation of 10D-3D system

First we define the 10D dynamics of the tracking quadrotor and the 3D dynamics of a holonomic vehicle:

[TABLE]

where states $(x,y,z)$ denote the position, $(v_{x},v_{y},v_{z})$ denote the velocity, $(\theta_{x},\theta_{y})$ denote the pitch and roll, and $(\omega_{x},\omega_{y})$ denote the pitch and roll rates. The controls of the 10D system are $(a_{x},a_{y},a_{z})$, where $a_{x}$ and $a_{y}$ represent the desired pitch and roll angle, and $a_{z}$ represents the vertical thrust. The 3D system controls are $(b_{x},b_{y},b_{z})$, and represent the velocity in each positional dimension. The disturbances in the 10D system $(d_{x},d_{y},d_{z})$ are caused by wind, which acts on the velocity in each dimension. Note that the states of the 3D dynamics are a subset of the 10D state space; the matrix Q used in the online computation matches the position states of both systems. Next the relative dynamics between the two systems is defined using (5):

[TABLE]

The values for parameters $d_{0},d_{1},n_{0},k_{T},g$ used were: $d_{0}=10,d_{1}=8,n_{0}=10,k_{T}=0.91,g=9.81$. The 10D control bounds were $|a_{x}|,|a_{y}|\leq 10$ degrees, $0\leq a_{z}\leq 1.5g$ m/s2. The 3D control bounds were $|b_{x}|,|b_{y}|,|b_{z}|\leq 0.5$ m/s. The disturbance bounds were $|d_{x}|,|d_{y}|,|d_{z}|\leq 0.1$ m/s.

Next we follow the setup in section V to create a cost function, which we then evaluate using HJ reachability until convergence to produce the invariant value function as in (LABEL:eq:valfunc). Historically this 10D nonlinear relative system would be intractable for HJ reachability analysis, but using new methods in [37, 38] we can decompose this system into 3 subsystems (for each positional dimension). Doing this also requires decomposing the cost function; therefore we represent the cost function as a 1-norm instead of a 2-norm. This cost function as well as the resulting value function can be seen projected onto the $x,y$ dimensions in Fig. 6.

Fig. 6 also shows 3D positional projections of the mapping between initial relative state to maximum potential relative distance over all time (i.e. tracking error bound). If the real system starts exactly at the origin in relative coordinates, its tracking error bound will be a box of $\underline{V}=0.81$ m in each direction. Slices of the 3D set and corresponding tracking error bounds are also shown in Fig. 7. We save the look-up tables of the value function (i.e. the tracking error function) and its spatial gradients (i.e. the safety controller function).

VII-B Online Planning with RRT and Sensing

Our precomputed value function can serve as a tracking error bound, and its gradients form a look-up table for the optimal tracking controller. These can be combined with any planning algorithm such as MPC, RRT, or neural-network-based planners in a modular way.

To demonstrate the combination of fast planning and provably robust tracking, we used a simple multi-tree RRT planner implemented in MATLAB modified from [39]. We assigned a speed of $0.5$ m/s to the piecewise linear paths obtained from the RRT planner, so that the planning model is as given in (19). Besides planning a path to the goal, the quadrotor must also sense obstacles in the vicinity. For illustration, we chose a simple virtual sensor that reveals obstacles within a range of 2 m in the $x$, $y$, or $z$ directions.

Once an obstacle is sensed, the RRT planner replans while taking into account all obstacles that have been sensed so far. To ensure that the quadrotor does not collide with the obstacles despite error in tracking, planning is done with respect to augmented obstacles that are “expanded” from the sensed obstacles by $\underline{V}$ in the $x$, $y$, and $z$ directions.

On an unoptimized MATLAB implementation on a desktop computer with a Core i7-2600K CPU, each iteration took approximately $25$ ms on average. Most of this time is spent on planning: obtaining the tracking controller took approximately $5$ ms per iteration on average. The frequency of control was once every $100$ ms.

Fig. 8 shows the simulation results. Four time snapshots are shown. The initial position is $(-12,0,0)$, and the goal position is $(12,0,0)$. The top left subplot shows the entire trajectory from beginning to end. In all plots, a magenta star represents the position of the planning model; its movement is based on the paths planned by RRT, and is modeled by a 3D holonomic vehicle with a maximum speed. The blue box around the magenta star represents the tracking error bound.

The position of the tracking model is shown in blue. Throughout the simulation, the tracking model’s position is always inside the tracking error, in agreement with Proposition 1. In addition, the tracking error bound never intersects with the obstacles, a consequence of the RRT planner planning with respect to a set of augmented obstacles (not shown). In the latter two subplots, one can see that the quadrotor appears to be exploring the environment briefly before reaching the goal. In this paper, we did not employ any exploration algorithm; this exploration behavior is simply emerging from replanning using RRT whenever a new part (a $3$ m2 portion) of an obstacle is sensed.

VIII Conclusions and Future work

In this paper we introduced our new tool FaSTrack: Fast and Safe Tracking. This tool can be used to add robustness to various path and trajectory planners without sacrificing fast online computation. So far this tool can be applied to unknown environments with a limited sensing range and static obstacles. We are excited to explore several future directions for FaSTrack in the near future, including exploring robustness for moving obstacles, adaptable error bounds based on external disturbances, and demonstration on a variety of planners.