Sampling-based Motion Planning via Control Barrier Functions

TL;DR

This paper introduces CBF-RRT, a sampling-based motion planning algorithm that uses control barrier functions to efficiently generate obstacle-free paths for nonlinear systems in dynamic environments, reducing computational overhead.

Contribution

The paper presents a novel CBF-guided RRT algorithm that integrates control barrier functions into sampling-based planning for nonlinear systems, enabling real-time obstacle avoidance without collision checks.

Findings

Reduces run-time compared to standard RRT methods.

Handles dynamic obstacles in continuous time.

Enforces obstacle avoidance via quadratic programming.

Abstract

Robot motion planning is central to real-world autonomous applications, such as self-driving cars, persistence surveillance, and robotic arm manipulation. One challenge in motion planning is generating control signals for nonlinear systems that result in obstacle free paths through dynamic environments. In this paper, we propose Control Barrier Function guided Rapidly-exploring Random Trees (CBF-RRT), a sampling-based motion planning algorithm for continuous-time nonlinear systems in dynamic environments. The algorithm focuses on two objectives: efficiently generating feasible controls that steer the system toward a goal region, and handling environments with dynamical obstacles in continuous time. We formulate the control synthesis problem as a Quadratic Program (QP) that enforces Control Barrier Function (CBF) constraints to achieve obstacle avoidance. Additionally, CBF-RRT does not require nearest neighbor or collision checks when sampling, which greatly reduce the run-time overhead when compared to standard RRT variants.

Tables

Table 1. Table 1: Hyper Parameters for Example 1

Case	$k_1$	$k_2$	${\sigma }^2$	$ϵ$	$t_h$	v	Run Time
1	2.0	4.0	0.2	0.15	0.5	1.0	20.37s
2	2.0	4.0	0.6	0.15	0.5	1.0	1.81s

Table 2. Table 2: Hyper Parameters for Example 2

Case	$k_1$	$k_2$	${\sigma }^2$	$ϵ$	$t_h$	v	$v_{obs,1}$	$v_{obs,2}$	Run Time
1	0.6	1.5	0.2	0.15	0.5	1.0	-0.1	0.3	17.62s
2	0.6	1.5	0.6	0.15	0.5	1.0	-0.1	0.3	2.48s

Table 3. Table 3: Comparison of CBF-RRT, RRT, and RRT*

Algorithm	Step Size	Run Time (s)	Number of Vertices
CBF-RRT	0.25s	2.98	496
RRT	0.25m	0.00125	39
RRT*	0.25m	2.109	488
CBF-RRT	1s	0.281	26
RRT	1m	0.00027	9
RRT*	1m	1.480	494

Equations

$$\dot{x}=f(x)+g(x)u,$$

$${\dot{x}}_{obs}=f_{obs}(x_{obs}),$$

$$C$$

$$\partial C$$

$$Int(C)$$

$${\dot{\xi }}_b(x)=A_b{\xi }_b(x)+B_b\mu ,$$

$$h_l(x)=C_b{\xi }_b(x),$$

$$A_b=\left[\begin{array}{ccccc}0& 1& \cdot & \cdot & 0\\ \cdot & \cdot & \cdot & \cdot & \cdot \\ 0& 0& 0& \cdot & 1\\ 0& 0& 0& \cdot & 0\end{array}\right],B_b=\left[\begin{array}{c}0\\ ⋮\\ 0\\ 1\end{array}\right],$$

$$C_b=\left[1\dots 0\right],$$

$$\underset{u\in U}{\inf }[{\pounds }_f^{r_b}h(x)+{\pounds }_g{\pounds }_f^{r_b-1}h(x)u+K_b{\xi }_b(x)]\ge 0,\forall x\in Int(C),$$

$${\zeta }_i(x)={\pounds }_f^{r_b}{h}_i(x)+{\pounds }_g{\pounds }_f^{r_b-1}{h}_i(x)u+K_{b,i}{\xi }_{b,i}(x)\ge 0.$$

$$\underset{u\in \mathrm{U}}{\min }$$

$${\zeta }_i(x)\ge 0,i=1,...,N_{obs}$$

$$\underline{u}\le u\le \overline{u},$$

$$\dot{x_1}=v\cos (\theta ),$$

$$\dot{x_2}=v\sin (\theta ),$$

$$\dot{\theta }=\omega ,$$

$$\left[\begin{array}{c}\dot{x_1}\\ \dot{x_2}\\ \dot{\theta }\end{array}\right]=\left[\begin{array}{c}\cos (\theta )\\ \sin (\theta )\\ 0\end{array}\right]v+\left[\begin{array}{c}0\\ 0\\ 1\end{array}\right]\omega .$$

$$C_i=\{x\in R^2:h_i(x)\ge 0\},$$

$$h_i(x)=(x_1(t)-x_{obs,i,1}(t){)}^2+(x_2(t)-x_{obs,i,2}(t){)}^2-r_{obs,i}^2.$$

$${\dot{x}}_{obs,i,1}=v_{obs,i,1},$$

$${\dot{x}}_{obs,i,2}=v_{obs,i,2},\forall i.$$

$$C_{robot}=\bigcap _{i=1}^{N_{obs}}{C}_i.$$

$${\zeta }_i(x)={\pounds }_f^2{h}_i(x)+{\pounds }_g{\pounds }_f{h}_i(x)u+k_1{h}_i(x)+k_2{\pounds }_f{h}_i(x)\ge 0,\forall x\in Int(C_i),$$

$$h_i(x)=(x_1(t)-x_{obs,i,1}(t){)}^2+(x_2(t)-x_{obs,i,2}(t){)}^2-r^2$$

$${\pounds }_f{h}_i(x)=2v(x_1(t)-x_{obs,i,1}(t))\cos \theta +2v(x_2(t)-x_{obs,i,2}(t))\sin \theta$$

$$-2(x_1(t)-x_{obs,i,1}(t))v_{obs,i,1}-2(x_2(t)-x_{obs,i,2}(t))v_{obs,i,2},$$

$${\zeta }_i(x)=2x_1{v}^2{\cos }^2\theta +2x_2{v}^2{\sin }^2\theta$$

$$+(2(x_2-x_{obs,2})\cos \theta -2(x_1-x_{obs,1})\sin \theta )\omega$$

$$+2v_{obs,i,1}^2+2v_{obs,i,2}^2+k_{1}h(x)+k_2{\pounds }_{f}h(x)\ge 0.$$

$$p_v=\frac{1}{N_v},$$

$${\theta }_{goal}=\arctan \left(\frac{x_{2,goal}-x_{2,e}}{x_{1,goal}-x_{1,e}}\right)$$

$$p_{state}({\theta }_{free})=\frac{1}{\sqrt{2\pi {\sigma }^2}}{e}^{-\frac{({\theta }_{free}-{\theta }_{goal}{)}^2}{2{\sigma }^2}},$$

$${\zeta }_i(x)$$

$$+[-2v(x_1-x_{obs,i,1})\sin (\theta )+2v(x_2-x_{obs,i,2})\cos (\theta )]w\ge 0.$$

$$\left[\begin{array}{c}\dot{x_1}\\ \dot{x_2}\\ \dot{\theta }\\ {\dot{x}}_{obs,1}\\ {\dot{x}}_{obs,2}\end{array}\right]=\left[\begin{array}{c}v\cos (\theta )\\ v\sin (\theta )\\ 0\\ v_{obs,1}\\ v_{obs,2}\end{array}\right]+\left[\begin{array}{c}0\\ 0\\ 1\\ 0\\ 0\end{array}\right]\omega .$$

Full text

1 Introduction

Motion planning is a cornerstone of modern robotics, but it is still a challenging problem when non-trivial robot dynamics are combined with input constraints and dynamic obstacles. Control Barrier Functions (CBFs) have been shown to be effective for feedback control in similar settings; however, they cannot be used alone for producing complete planners, as they can get trapped in “local minima” created by obstacles. CBFs can also become infeasible if there is no possible control that allows the robot to remain safe (i.e., to avoid collision). We look to overcome CBF limitations by generating and connecting many smaller, feasible trajectories through sampling. This results in a complete CBF-based planner that can find trajectories not considered by CBFs alone.

Sampling-based motion planning is not a novel concept, however, much of the literature is this area tends to focus on either high-level path planning, or lower level control and trajectory planning. In this paper, we attempt to present a unified approach that takes advantage of both collision free and efficient trajectory planning, as well as efficient path planning. Using CBFs developed in the formal methods and controls community, we augment the classic rapidly exploring random trees algorithm to handle dynamic obstacles and non-linear robot dynamics while also generating controls that are guaranteed to produce safe, collision free, trajectories.

1.1 Related Work

This work draws in past work on both sampling-based algorithms in the motion planning literature, as well as provably correct control synthesis in the formal methods for robotics community.

Motion planning in real-world applications often considers high level path planning and low level control synthesis, given safety requirements and dynamical constraints. Sampling-based motion planning algorithms, such as Probabilistic Road Map [1], Rapidly-exploring Random Trees (RRT) [2], and RRT*[3], have been widely explored and are efficient strategies for high dimensional kinematic planning; however, generally these algorithms assume that a low level controller exists to generate collision free trajectories at run time. In recent years, there has been considerable effort to try to bridge the gap between path planning and control synthesis by designing controller that steer the system in-between two generated vertices, such as Kinodynamic RRT* [4], LQR-RRT* [5] and its variants in [6] and [7], however these approaches are limited to linear systems and static environments. Our proposed CBF-RRT method takes a different approach compared to the work in [4], [5], and [6]. Instead of first generating straight paths with a fixed number of vertices and then treating control synthesis as a two point boundary value problem (as in [5]), we generate both controls and paths “on-the-fly” and work with nonlinear systems. Motion planning in dynamical environments has been studied in [8] and [9], but focuses on replanning when obstacles cause collisions.

Considerable work has been done on generating control strategies for safety-critical systems using CBFs. A popular formulation is to combine CBFs and Control Lyapunov Functions (CLFs) in a Quadratic Program (QP) where the CBF ensures safety and the CLF ensures stability. This approach has been successfully applied to applications such as adaptive cruise control [10], bipedal robot walking [11], and swarm control [12]. The QP based formulation works well when the desired equilibrium point is well-defined and there exists a feasible control sequence for the given problem. Under certain conditions, however, the QP may be infeasible due to the environment or dynamical constraints. Work has also been done, in [13], in designing a safe controller that follows a pre-planned path, but does not include a path-planner that explicitly explores the environment, and therefore also, occassionally, leads to infeasibility in finding a solution.

Contributions:

In this paper, we propose Control Barrier Function guided Rapidly-exploring Random Trees, a motion planning algorithm that uses sampling techniques to explore the state space and a QP based controller with CBF constraints to generate intermediate controls and trajectories between samples. From the sampling-based motion planning point of view, this paper provides formal guarantees for collision free continuous trajectories between samples. From a formal methods in robotics point of view, this paper offers a partial solution to infeasibility in finding a solution in CBF/CLF QP based controller formulations. The proposed framework guarantees safety, handles obstacles with known dynamics, and its internal control synthesis can be utilized as the low level controller at run-time.

This paper is organized as follows: preliminary information is provided in Section 2; the problem statement and proposed algorithm are presented in Section 3 and Section 4, respectively; a differential drive model is considered in Section 5 followed by simulations in Section 6; Conclusions are given in Section 7.

2 Preliminaries

2.1 Notation

Let $\mathbb{R}^{n}$ be the set of real numbers in $n$ dimensions. The Lie derivative of a smooth function $h(x(t))$ along dynamics $\dot{x}(t)=f(x(t))$ is denoted as $\pounds_{f}h(x):=\frac{\partial h(x(t))}{\partial x(t)}f(x(t))$. Given a continuously differentiable function $h:\mathbb{R}^{n}\mapsto\mathbb{R}$, we denote $h^{r_{b}}$ as its $r_{b}$-th derivative with respect to time $t$. A continuous function $\alpha:(-b,a)\mapsto(-\infty,\infty)$, for some $a,b>0$, belongs to the extended class $\mathcal{K}$ if $\alpha$ is strictly increasing and $\alpha(0)=0$. The set difference between set $A$ and set $B$ is denoted as $A\backslash B$.

2.2 Dynamics

We consider a motion planing problem for a continuous-time control system

[TABLE]

where $x\in\mathcal{X}\subset\mathbb{R}^{n}$ is the state and $u\in\mathcal{U}\subset\mathbb{R}^{m}$ is the control input, where $\mathcal{U}$ is a set of admissible controls for system (1). The functions $f(x)$ and $g(x)$ are assumed to be locally Lipschitz continuous. The initial state is denoted as $x_{init}:=x(t_{0})\in\mathcal{X}$ and the goal region is defined as $\mathcal{X}_{goal}\subset\mathcal{X}$. Obstacles are assumed to be non-stationary with known dynamics and move according to the equation

[TABLE]

where $x_{obs}\in\mathcal{X}_{obs}\subset\mathcal{X}$ is the state variable for the obstacles (e.g., center of mass). The function $f_{obs}$ is again assumed to be locally Lipschtiz continuous.

Remark 2.1**.**

For special cases where the obstacle dynamics are unknown, we could approximate their dynamics with techniques, such as Gaussian Process (GP)[14] or online Linear Regression[15]. For simplicity, in this paper, we assume that all obstacle dynamics are known.

2.3 Exponential Control Barrier Functions (ECBF)

In traditional path planning approaches, obstacle avoidance is often enforced by a collision check along segments or regions of the path. To create a more complete and provably safe trajectory, we instead formulate obstacle avoidance as remaining within a safety set defined by Control Barrier Functions (CBFs, [10]) and their extensions for higher relative degree, Exponential CBFs [16]. Given a continuously differentiable function $h:\mathbb{R}^{n}\mapsto\mathbb{R}$, the safety set $C$ is defined as

[TABLE]

where $\partial{C}$ is the boundary and $Int(C)$ is the interior. The set $C$ is called forward invariant for system (1) if $x_{0}\in C$ implies $x(t)\in C$ for all $t$.

For systems with relative degree $r_{b}$, we define a traverse variable as $\xi_{b}(x)=\left[\begin{matrix}h(x),\dot{h}(x),\ldots,h^{(r_{b})}(x)\end{matrix}\right]^{T}=\left[\begin{matrix}h(x),\pounds_{f}h(x),\ldots,\pounds_{f}h^{r_{b}}(x)\end{matrix}\right]^{T}$, and formulate a virtual system with input-output linearization [17]:

[TABLE]

where

[TABLE]

and $\mu=(\pounds_{g}\pounds_{f}^{r_{b}-1}h(x))^{-1}(\mu-\pounds_{f}^{r_{b}}h(x))$ is the input-output linearized control.

Definition 2.2** (Exponential Control Barrier Function [16]).**

Consider the dynamical system in (1) and the safety set $C$ defined in (3). A continuously differentiable function $h(x)$ with relative degree $r_{b}\geq 1$ is an Exponential Control Barrier Function (ECBF) if there exists $K_{b}\in\mathbb{R}^{1\times r_{b}}$, such that

[TABLE]

where the row vector $K_{b}$ is selected such that the closed-loop matrix $A_{b}-B_{b}K_{b}$ for (4) is stable.

Theorem 2.3**.**

Given the system (1), and the safety set $C$ defined in (3), if there exists an ECBF $h(x)$, then the system is forward invariant in $C$ [16].

Remark 2.4**.**

There exist a more general notion of Higher Order Control Barrier Function (HOCBF) [18], of which ECBF is a special case. For the purposes of this paper, we only need ECBFs, although the use of HOCBFs could lead to improved performance.

2.4 Rapidly-exploring Random Trees (RRT)

We use $\mathcal{T}=(\mathcal{V},\mathcal{E})$ to denote a tree with a set of vertices $\mathcal{V}\subseteq\mathcal{X}$ and a set of edges $\mathcal{E}$. The classic Rapidly-exploring Random Trees algorithm (RRT, [2]), builds a tree $\mathcal{T}$ where each vertex $\mathit{v}\in\mathcal{V}$ is associated to a full state $\mathit{v}=x\in\mathbb{R}^{n}$, and edges follow the system dynamics (1). To work, the algorithm needs the following essential components:

• •

State Space and Goal Region: A configuration space $\mathcal{X}$, such that $x\in\mathcal{X}$, and a goal region $\mathcal{X}_{goal}\subset\mathcal{X}$.

• •

Collision Check: A function $\texttt{CollisionCheck}(x)$ that detects if a state trajectory $x$ violates any collision constraint.

• •

Metric: A function $d:\mathcal{X}\times\mathcal{X}\rightarrow[0,\infty)$ that returns the distance between two vertices within $\mathcal{X}$.

• •

Nearest Neighbor: A function $\texttt{NearestNeighbor}:(\mathcal{T},x_{sample})\mapsto x_{nn}$ which utilizes the distance function $d$ to find the vertex $x_{nn}$ in $\mathcal{T}$ that is closest to $x_{sample}$.

• •

Inputs: A set of admissible controls $U$, such that $u\in U$, for steering the state $x$.

• •

Steer: Given a sampled vertex $x_{sample}$ and nearest vertex $x_{nn}$, the function $\texttt{Steer}(x_{nn},x_{sample})$ steers the system from $x_{nn}$ to $x_{sample}$ with control $u$ while performing collision checks. The function terminates after the trajectory progresses some fixed distance and returns false if no trajectory is possible.

The RRT algorithm is summarized in Algorithm 1 and Algorithm 2.

There are three possible outcomes from the Steer function: Reached indicates that $x_{new}=x_{sample}$ can be reached under the dynamical and obstacle constraints, Advanced indicates that $\|x_{sample}-x_{new}\|\leq\delta d$, where $\delta d$ is a positive constant, Trapped indicates that the function cannot find a feasible control $u$ to steer the system. The Steer function is demonstrated in Figure 1.

3 Problem Statement and Approach

Problem 3.1**.**

*Consider a nonlinear system in the form of (1), with initial state $x_{init}\in\mathcal{X}_{init}\subset\mathcal{X}\subset\mathbb{R}^{n}$, where $\mathcal{X}_{init}$ is an initial obstacle free set, and a bounded goal region $\mathcal{X}_{goal}$, generate feasible control inputs $u(t)$ that steer the system to $\mathcal{X}_{goal}$ while avoiding dynamical obstacles. *

To approach the problem, we combine both obstacle dynamics and system dynamics into a composite system. By treating the obstacles’ state as part of the composite system, we can effectively construct the CBF constraints for the QP controller. The path planning algorithm is given in Section 3.

4 CBF-RRT

The CBF-RRT algorithm is different from other RRT variants in that there is no explicit collision or nearest neighbor checks. Instead, we introduce the notion of safe steering that encodes collision avoidance as staying within the safety set (3). The nearest neighbor check is implicitly handled by sampling the vertices in $\mathcal{V}$.

Before we formally introduce the algorithm, we define the following components:

• •

State Space: A topological space $\mathcal{X}\subset\mathbb{R}^{n}$, and $\mathcal{X}_{goal},\mathcal{X}_{obs}\subset\mathcal{X}$.

• •

Inputs: A set of admissible controls $U$ for steering the state $x$.

• •

Safe Steering: A function that generates both safe controls and trajectories in a time interval $t_{h}$, given the system kinematics (1) and obstacle dynamics (2). More details are introduced in Section 4.2.

In general, the vertices are sampled points of the state space, $\mathcal{V}\subseteq\mathcal{X}$ and we assume $\mathcal{X}_{goal}\backslash\mathcal{X}_{obs}$. To account for the time-varying obstacles, the vertices need to store an additional parameter that determines when, in time, the vertices are safe. In other words $\mathcal{V}\subseteq\mathcal{X}\times\mathbb{R}$ where the additional parameter is time and an element $v=(x,t)\in\mathcal{V}$. We use $\mathcal{T}=(\mathcal{V\subseteq\mathcal{X}\times\mathbb{R}},\mathcal{E})$.

4.1 Sampling

4.1.1 Vertices

The function $\mathtt{VerticesSample}:v_{s}\in\mathcal{V}$ samples, with a desired probability distribution, $p_{v}(\mathcal{V})$, on the existing vertices of the tree $\mathcal{T}$. By varying the probability distributions, the behavior of the tree expansion, as well as convergence speed, will be drastically different.

4.1.2 State Space

Depending on the problem, some state variables may not play an essential role in the task requirements and/or system dynamical constraints. We denote these variables as free state variables that can be arbitrarily chosen to increase the probability of finding a path that satisfies the dynamics and safety constraints. We define function $\mathtt{StateSample}:v_{s}\mapsto v_{e}$ that updates the free state variables of a given vertex with a probability distribution. We denote this probability distribution as $p_{state}(x)$ and define $v_{e}$ as the expanding vertex. For example, if the task is to steer a nonholonomic first-order planar robot, such as a unicycle, from one position to another and orientation does not matter. Then, the vertices only need to contain information relevant to the position of the robot, i.e. $\mathcal{V}\in\mathbb{R}^{2}\times\mathbb{R}\subset\mathbb{R}^{3}\times\mathbb{R}$.

4.1.3 Control Reference

If no free states exist in the system dynamics, the $u_{ref}$ value must be sampled from a distribution $p_{u_{ref}}$ in order to maintain the probabilistic nature of CBF-RRT. In this case, we define a function $\mathtt{ReferenceSample}:u_{ref}\in U$ that updates the $u_{ref}$ for the chosen sample from $p_{u_{ref}}$.

4.2 Safe Steering

We define a function SafeSteer$(v_{0},t_{h},u_{ref})$ that contains two components: controls synthesis and collision-free trajectory generation. Given an initial vertex $v_{0}$ which includes an initial state $x_{0}$ and time element $t_{0}$, a fixed time horizon $t_{h}$, a control reference $u_{ref}$, obstacle dynamics (2) and system dynamics (1), SafeSteer solves a sequence of QPs (Section 4.4) with CBF constraints and generate a sequence of control inputs $u(t)$. The control inputs generate a collision-free trajectory to $x_{new}$ at time $t_{0}+t_{h}$ which is added to the tree $\mathcal{T}$ as a new vertex.

Remark 4.1**.**

The control reference $u_{ref}$ determines how the robot explores the space and the QP ensures the robot’s safety while doing so by modifying $u_{ref}$ as necessary. For example, if the reference command $u_{ref}$ is defined as ”go forward in the body-fixed frame”, then the QP’s job is to steer the robot away from obstacles when necessary. If there are no obstacles, the robot should move in a straight line.

4.3 Goal Check

Given a desired goal $x_{goal}$, we define a goal region $\mathcal{X}_{goal}=\{y\in\mathbb{R}^{n}:d(y,x_{goal})\leq\epsilon\}$, where $\epsilon$ is a positive constant chosen such that $\mathcal{X}_{goal}$ is obstacle free. If the trajectory $x(t)\in\mathcal{X}_{goal}$, then the algorithm terminates and a path is found. Otherwise, the algorithm continues.

4.4 Quadratic Program Formulation with Control Barrier Function

The QP based controller takes in a reference control $u_{ref}$, current state of the system $x(t)$ and obstacle $x_{obs}(t)$ as inputs and finds a feasible control $u(t)$ point-wise in time that tries to follow $u_{ref}$. Given a safety set $h_{i}(x)$ and a system with relative degree $r_{b}$, we define the $i$-th CBF constraint as

[TABLE]

Additional linear constraints (with respect to $u$) may be considered, such as control bounds. These requirements may be formulated as a QP as follows:

[TABLE]

where $\underline{u},\overline{u}$ are the lower and upper control bounds, respectively. The CBF constraint $\zeta_{i}$ is linear in terms of decision variable $u$ and $N_{obs}$ is the total number of obstacles.

5 Numerical Examples

In this section, we consider the motion planning problem of steering a planar robot from an initial state $x_{init}$ to a goal position that is independent of orientation. In particular, the goal region $\mathcal{X}_{goal}$ is defined by $x_{goal}$ and $\epsilon$ where $x_{goal}=[x_{1,goal},x_{2,goal},\theta_{goal}]^{T}$ and $\theta_{goal}$ is arbitrary. Thus, the motion planning problem is solved in the work space $\mathcal{X}_{work}\in\mathbb{R}^{2}$.

5.1 Dynamical System

Consider a unicycle model for a two-wheeled differential drive robot

[TABLE]

where the state $x=[x_{1},x_{2},\theta]^{T}\in\mathbb{R}^{3}$ corresponds to the location ($x_{1},x_{2}$) in work space $\mathcal{X}_{work}\subset\mathbb{R}^{2}$ and heading $\theta$ with respect to the inertial frame. The control input $u=[v,\omega]^{T}\in\mathbb{R}^{2}$ consists of the translational and angular velocity that are bounded, respectively. The equations of motion (7) can be write in control affine form as

[TABLE]

5.2 Safety Sets

We consider rigid body obstacles and model them as the union of circles with centroids $(x_{obs,i,1}(t),x_{obs,i,2}(t))$ and fixed radii $r_{obs,i}$ where each obstacle is inscribed by the union of their respective circles. We denote the i-th safety set as

[TABLE]

where

[TABLE]

Each circle has the following dynamics

[TABLE]

The safe set of the robot is given as the intersection of all the safe sets for the circles

[TABLE]

The relative degree is 1 for translation velocity $v$ and 2 for angular velocity $\omega$, with respect to system dynamics (7) and CBF constraint (10). Therefore, we have a nonlinear system with mixed-relative degree control inputs and $r_{b}=2$. The i-th ECBF constraint is

[TABLE]

where

[TABLE]

and $k_{1},k_{2}$ are positive constants that are selected appropriately to ensure forward invariance, as mentioned in [16]. The resultant ECBF constraint is

[TABLE]

Remark 5.1**.**

The inequality (15) is linear with respect to $\omega$ but not $v$, therefore it cannot be add directly into the QP as a linear constraint. This is due to the mixed-relative degree of the control inputs. To overcome this limitation, we set the translational velocity $v=c\in\mathbb{R}$, which becomes part of the system dynamics function $f(x)$ in (1).

5.3 Sampling Distributions

Vertex Sampling:

Given a set of vertices $\mathcal{V}$ in $\mathcal{T}$, we define a discrete uniform distribution over all vertices

[TABLE]

where $N_{v}$ is the total number of vertices in $\mathcal{V}$. Therefore, each vertex has equal probability to be selected as an expanding vertex.

State Sampling:

Given the state of the current sampled vertex $[x_{1,s},x_{2,s},\theta_{free}]^{T}$, we first calculate the desired heading angle $\theta_{goal}$ toward $x_{goal}$ by

[TABLE]

We then define a Gaussian distribution for the state $\theta_{free}$

[TABLE]

where $\sigma^{2}$ is the variance and we set $\theta_{goal}$ as the mean.

6 Simulations

For simulations, the control inputs are $v\in[-1,1]$ and $\omega\in[-4.25,4.25]$. We then add (15) as linear constraints in the QP (6) with $\omega$ as the only decision variable and $v=1$ (see Remark 5.1). We choose $\omega_{ref}=0$, i.e., the system minimally change its heading direction $\theta$. The combination of $(v,\omega_{ref})$ is chosen such that the robot moves in straight lines as it explores the space. All experiments are performed on a desktop computer with a i7-8700K CPU with the Gurobi 8.1.1 [19] solver.

6.1 Example 1: Static Environment

In the first example, we consider an environment with $N_{obs}=3$ static obstacles, i.e., $v_{obs,i,1}=v_{obs,i,2}=0,\forall i=1,...,N_{obs}$, which implies $x_{obs,i,1}$ and $x_{obs,i,2}$ are constants in (10). The corresponding ECBF is

[TABLE]

The initial state is $x_{init}=[-0.5,-0.5,1]^{T}$ and the goal state is $x_{goal}=[2,2,\cdot]^{T}$. We define three obstacles with their centroids locate at $(0.3,1.2)$, $(1.0,0.5)$, $(1.7,-0.5)$ with a radius $r_{i}=0.2,\forall i$. The hyper parameters in Table 1 include ECBF coefficients $k_{1},k_{2}$, variance $\sigma^{2}$ for state distribution $p_{state}$, radius of the goal region $\epsilon$ and time horizon $t_{h}$.

In Fig. 3, the generated tree curves around the obstacle as the SafeSteer function ensures the generated trajectory never enter the obstacle regions. Note case 2 has a higher variance ($\sigma^{2}=0.6$) which result in more exploration in the work space before finding a path to $\mathcal{X}_{goal}$.

6.2 Example 2: Dynamical Environment

In this example, without the loss of generality, we consider a single obstacle with constant velocities $v_{obs,1},v_{obs,2}$. We formulate a composite system that includes obstacle dynamics (11) as the following

[TABLE]

Remark 6.1**.**

The composite system (18) can be easily extended to multi-agents path planning problems. In this example, we only consider path planning problem for a single agent.

We enforce the ECBF constraint (15) and the result from Fig. 4 shows the generated path under different variances. Similar to the result from example 1, the case with $\sigma^{2}=0.6$ leads to a more sparse tree and both trajectories are able to avoid the moving obstacle as shown in Fig. 5. The hyper parameters for this example is shown in Table 2.

6.3 Comparison with RRT and RRT* End-point Collision Check

One of the major advantages of CBF-RRT is the guarantee of collision free trajectory generation in continuous time. In RRT and RRT* path planning, an end-point collision check function typically only checks if the end vertex $x_{new}$ is within an obstacle region. While it is computationally efficient, the generated trajectories have the potential to collide with intermediary obstacles that are smaller than the chosen step size $\delta d$ (Fig. 1). We compare our proposed CBF-RRT algorithm with both RRT and RRT* in the same static environment from Example 1 and Fig. 6 highlights how trajectories have the potential to collide with the obstacles when $\delta d$ is chosen to be too large. CBF-RRT however does not suffer from this issue since it considers continuous trajectories and has no such explicit collision check. Table 3 shows the run time and number of vertices comparisons between the CBF-RRT, RRT, and RRT* algorithms. CBF-RRT preforms between RRT and RRT* in terms of both computation time and number of vertices generated. This illustrates that CBF-RRT is able to guarantee collision free trajectories for non-linear dynamics without excessive increases in computation time over less-safe RRT and RRT*. Furthermore, we expect CBF-RRT to outperform RRT and RRT* in highly complex (crowded) environments because it does not need to perform a collision check explicitly.

7 Conclusion and Future Work

In this paper we present CBF-RRT, a motion planning algorithm that successfully generates collision-free trajectories and control strategies for a nonlinear system under both static and dynamic environments. In future work, we will further increase the richness of the mission specifications by adding temporal logic based constraints. Second, we will further improve the current algorithm with rewiring technique that is similar to RRT* and perform theoretical analysis. Third, we would like to extend the current algorithm to handle multi-agent motion planning.

8 Acknowledgements

This work was partially supported by MIT Lincoln Labs 7000443517 and NSF IIS-1723995.