Fly-by-Logic: Control of Multi-Drone Fleets with Temporal Logic Objectives

Abstract

The problem of safe planning and control for multi-agent systems across a variety of missions is of critical importance , as the scope of tasks assigned to such systems increases. In this paper, we present an approach to solve this problem for multi-quadrotor missions. Given a mission expressed in Signal Temporal Logic (STL), our controller maximizes robustness to generate trajectories for the quadrotors that satisfy the STL specification in continuous-time. We also show that the constraints on our optimization guarantees that these trajectories can be tracked nearly perfectly by lower level off-the-shelf position and attitude controllers. Our approach avoids the oversimplifying abstractions found in many planning methods, while retaining the expressiveness of missions encoded in STL allowing us to handle complex spatial, temporal and reactive requirements. Through experiments, both in simulation and on actual quadrotors, we show the performance, scalability and real-time applicability of our method.

Full text

1
Fly-by-Logic: Control of Multi-Drone Fleets with
Temporal Logic Objectives
Yash Vardhan Pant, Houssam Abbas, Rhudii A. Quaye, Rahul Mangharam
Abstract—The problem of safe planning and control for multi-
agent systems across a variety of missions is of critical impor-
tance, as the scope of tasks assigned to such systems increases.
In this paper, we present an approach to solve this problem for
multi-quadrotor missions. Given a mission expressed in Signal
Temporal Logic (STL), our controller maximizes robustness to
generate trajectories for the quadrotors that satisfy the STL spec-
ification in continuous-time. We also show that the constraints
on our optimization guarantees that these trajectories can be
tracked nearly perfectly by lower level off-the-shelf position and
attitude controllers. Our approach avoids the oversimplifying
abstractions found in many planning methods, while retaining the
expressiveness of missions encoded in STL allowing us to handle
complex spatial, temporal and reactive requirements. Through
experiments, both in simulation and on actual quadrotors, we
show the performance, scalability and real-time applicability of
our method.
I. INTRODUCTION
As the technology behind autonomous systems is starting to
mature, they are being envisioned to perform greater variety
of tasks. Fig. 1 shows a scenario where multiple quadrotors
have to fly a variety of missions in a common air space,
including package delivery, surveillance, and infrastructure
monitoring. Drone A is tasked with delivering a package,
which it has to do within 15 minutes and then return to base
in the following 10 minutes. Drone B is tasked with periodic
surveillance and date collection of the wildlife in the park,
while Drone C is tasked with collecting sensor data from
equipment on top of the white-and-blue building. All of these
missions have complex spatial requirements (e.g. avoid flying
over the buildings highlighted in red, perform surveillance or
monitoring of particular areas and maintain safe distance from
each other), temporal requirements (e.g., a deadline to deliver
package, periodicity of visiting the areas to be monitored)
and reactive requirements (like collision avoidance). The safe
planning and control of multi-agent systems for missions like
these is becoming an area of utmost importance. Most existing
work for this either lacks the expressiveness to capture such
requirements (e.g. [1], [2]), relies on simplifying abstractions
that result in conservative behavior ([3]), or do not take into
account explicit timing constraints ([4]). A more detailed
coverage of existing methods can be found in Sec.I-A. In
addition to these limitations, many of the planning methods
are computationally intractable (and hence do not scale well or
work in real-time), and provide guarantees only on a simplified
abstraction of the system behavior ([3]).
Department of Electrical and Systems Engineering, University of Pennsyl-
vania, Philadelphia, PA, USA.
{yashpant, habbas, quayerhu, rahulm}@seas.upenn.edu
This work was supported by STARnet a Semiconductor Research Corpora-
tion program sponsored by MARCO and DARPA, NSF MRI-0923518 and the
US Department of Transportation University Transportation Center Program.
DESIGNATED LANDING
AND TAKEOFF AREAS
MONITORING SIGNAL
STRENGTHS
GEOFENCING
AIRSPACE MANAGEMENT
SAFE SEPARATION
DISTANCE
1. 2.
DETECT AND
AVOID (DAA)
DRONE B DRONE A
DRONE C 1
2
NO FLY ZONES
FREE SPACE
DELIVERY
Fig. 1: Multiple autonomous drone missions in an urban envi-
ronment. (Figure adpated from https://phys.org/news/2016-12-traffic-
solutions-drones-singapore-airspace.html)
In this work, we aim to overcome some of those limitations,
by focusing on a single class of dynamical systems, namely
multi-rotor drones like quadrotors. By using Signal Temporal
Logic (STL) as the mission specification language, we retain
the flexibility to incorporate explicit timing constraints, as well
as a variety of behaviors. Without relying on oversimplifying
abstractions, we provide guarantees on the continuous-time
behavior of the dynamical system. We also show through
experiments that the resulting behavior of the drones is not
conservative. The control problem formulation we present
is aimed to be tractable, and through both simulations and
experiments on actual drones we show that we can control up
to two drones in real-time and up to 16 in simulation.
A. State of the art
The mission planning problem for multiple agents has been
extensively studied. Most solutions work in an abstract grid-
based representation of the environment [4], [5], and abstract
the dynamics of the agents [6], [3]. As a consequence they
have correctness guarantees for the discrete behavior but
not necessarily for the underlying continuous system. Multi-
agent planning with kinematic constraints in a discretized
environment has been studied in [7] with application to ground
robots. Planning in a discrete road map with priorities assigned
to agents has been studied in [2] and is applicable to a
wide variety of systems. Another priority-based scheme for
drones using a hierarchical discrete planner and trajectory
generator has been studied in [1]. Most of these use Linear
Temporal Logic (LTL) as the mission specification language,
which doesn’t allow explicit time bounds on the mission

2
Fig. 2: (Top) Five Crazyflie 2.0 quadrotors executing a reach-avoid
mission. (Bottom) A screenshot of a simulation with 16 quadrotors.
In both cases, the quadrotors have to satisfy a mission given in STL.
objectives. The wok in [3] uses STL. Other than [2] and
[1], none of the above methods can run in real-time because
of their computational requirements. While [2] and [1] are
real-time, they can only handle the Reach-Avoid mission, in
which agents have to reach a desired goal state while avoiding
obstacles and each other.
In a more control-theoretic line of work, control of systems
with STL or Metric Temporal Logic (MTL) specifications
without discretizing the environment or dynamics has been
studied in [8], [9], [10]. These methods are potentially com-
putationally more tractable than the purely planning-based
approaches discussed earlier, but are still not applicable to real-
time control of complex dynamical systems like quadrotors
(e.g. see [10]), and those that rely on Mixed Integer Pro-
gramming based approaches [8] do not scale well. Stochastic
heuristics like [11] have also been used for STL missions, but
offer very few or no guarantees. Non-smooth optimization [12]
has also been explored, but is limited in its applicability.
In this paper, we focus on multi-rotor systems, and work
with a continuous representation of the environment and take
into account the behaviour of the trajectories of the quadrotor.
With the mission specified as a STL formula, we maximize
a smooth version of the robustness ([3], [10]). This, unlike a
majority of the work outlined above, allows us to take into
account explicit timing requirements. Our method also allows
us to use the full expressiveness of STL, so our approach
is not limited to a particular mission type. Finally, unlike
most of the work discussed above, we offer guarantees on the
continuous-time behaviour of the system to satisfy the spatio-
temporal requirements. Through simulations and experiments
on actual platforms, we show real-time applicability of our
method for simple cases, as well as the scalability in planning
for multiple quadrotors in a constrained environment for a
variety of mission specifications.
B. Contributions
This paper presents a control framework for mission plan-
ning and execution for fleets of quadrotors, given a STL
specification.
1) Continuous-time STL satisfaction: We develop a con-
trol optimization that selects waypoints by maximizing
the robustness of the STL mission. A solution to the
optimization is guaranteed to satisfy the mission in
continuous-time, so trajectory sampling does not jeopar-
dize correctness, while the optimization only works with
a few waypoints.
2) Dynamic feasibility of trajectories: We demonstrate
that the trajectories generated by our controller respect
pre-set velocity and acceleartion constraints, and so can
be well-tracked by lower-level controllers.
3) Real-time control: We demonstrate our controller’s
suitability for online control by implementing it on real
quadrotors and executing a reach-avoid mission.
4) Performance and scalability: We demonstrate our con-
troller’s speed and performance on real quadrotors, and
its superiority to other methods in simulations.
The paper is organized as follows. Section II introduces STL
and its robust semantics. Section IV presents the proposed
control architecture and the trajectory generator we use, and
proves that the trajectories are dynamically feasible. The
main control optimization is presented in Sec. V. Extensive
simulation and experiments on real quadrotors are presented
in Sections VI and VII, resp. All experiments are illustrated
by videos available at the links in Table V.
II. PRELIMINARIES ON SIG NA L TEMPORAL LOGIC
Consider a continuous-time dynamical system Hand its
uniformly discretized version
˙xc(t) = fc(xc(t), u(t)), x+=f(x, u)(1)
where x∈X⊂Rnis the current state of the system, x+
is the next state, u∈U⊂Rmis its control input and f:
X×U→Xis differentiable in both arguments. The system’s
initial state x0takes value from some initial set X0⊂Rn.
In this paper we deal with trajectories of the same duration
(e.g. 5 seconds) but sampled at different rates, so we introduce
notation to make the sampling period explicit. Let dt ∈R+be
a sampling period and T∈R+be a trajectory duration. We
write [0 : dt :T] = (0, dt, 2dt, . . . , (H−1)dt)for the sampled
time interval s.t. (H−1)dt =T(we assume Tis divisible
by H−1). Given an initial state x0and a finite control input
sequence u= (u0, ut1...,utH−2), ut∈U, tk∈[0 : dt :T],
atrajectory of the system is the unique sequence of states

3
x= (x0, xt1...,xtH−1)s.t. for all t∈[0 : dt :T],xtis in
Xand xtk+1 =f(xtk, utk). We also denote such a trajectory
by x[dt]. Given a time domain T= [0 : dt :T], the signal
space XTis the set of all signals x:T→X. For an interval
I⊂R+and t∈R+, set t+I={t+a|a∈I}. The set
of subsets of a set Sis denoted P(S). The max operator is
written tand min is written u.
A. Signal Temporal Logic (STL)
The controller of His designed to make the closed loop
system (1) satisfy a specification expressed in Signal Temporal
Logic (STL) [13], [14]. STL is a logic that allows the succinct
and unambiguous specification of a wide variety of desired
system behaviors over time, such as “The quadrotor reaches
the goal within 10 time units while always avoiding obstacles”
and “While the quadrotor is in Zone 1, it must obey that zone’s
altitude constraints”. Formally, let M={µ1, . . . , µL}be a
set of real-valued functions of the state µk:X→R. For
each µkdefine the predicate pk:= µk(x)≥0. Set AP :=
{p1, . . . , pL}. Thus each predicate defines a set, namely pk
defines {x∈X|fk(x)≥0}. Let I⊂Rdenote a non-
singleton interval, >the Boolean True, pa predicate, ¬and
∧the Boolean negation and AND operators, respectively, and
Uthe Until temporal operator. An STL formula ϕis built
recursively from the predicates using the following grammar:
ϕ:= >|p|¬ϕ|ϕ1∧ϕ2|ϕ1UIϕ2
Informally, ϕ1UIϕ2means that ϕ2must hold at some point
in I, and until then, ϕ1must hold without interruption. The
disjunction (∨), implication ( =⇒), Always () and Eventu-
ally (♦) operators can be defined using the above operators.
Formally, the pointwise semantics of an STL formula ϕdefine
what it means for a system trajectory xto satisfy ϕ.
Definition 2.1 (STL semantics): Let T= [0 : dt :T]. The
boolean truth value of ϕw.r.t. the discrete-time trajectory x:
T→Xat time t∈Tis defined recursively.
(x, t)|=>⇔>
∀pk∈AP, (x, t)|=p⇔µk(xt)≥0
(x, t)|=¬ϕ⇔ ¬(x, t)|=ϕ
(x, t)|=ϕ1∧ϕ2⇔(x, t)|=ϕ1∧(x, t)|=ϕ2
(x, t)|=ϕ1UIϕ2⇔ ∃t0∈(t+I)∩T.(x, t0)|=ϕ2
∧∀t00 ∈(t, t0)∩T,(x, t00)|=ϕ1
We say xsatisfies ϕif (x,0) |=ϕ.
All formulas that appear in this paper have bounded tempo-
ral intervals: 0≤inf I < sup I < +∞.To evaluate whether
such a bounded formula ϕholds on a given trajectory, only a
finite-length prefix of that trajectory is needed. Its length can
be upper-bounded by the horizon of ϕ,hrz(ϕ)∈N, calculable
as shown in [8]. For example, the horizon of [0,2](♦[2,4]p)
is 2+4=6: we need to observe a trajectory of, at most, length
6 to determine whether the formula holds.
B. Control using the robust semantics of STL
Designing a controller that satisfies the STL formula ϕ1
is not always enough. In a dynamic environment, where the
1Strictly, a controller s.t. the closed-loop behavior satisfies the formula.
system must react to new unforeseen events, it is useful to have
a margin of maneuverability. That is, it is useful to control the
system such that we maximize our degree of satisfaction of
the formula. When unforeseen events occur, the system can
react to them without violating the formula. This degree of
satisfaction can be formally defined and computed using the
robust semantics of temporal logic [14], [15].
Definition 2.2 (Robustness[15], [14]): The robustness of
STL formula ϕrelative to x:T→Xat time t∈Tis
ρ>(x, t)=+∞
ρpk(x, t) = µk(xt)∀pk∈AP,
ρ¬ϕ(x, t) = −ρϕ(x, t)
ρϕ1∧ϕ2(x, t) = ρϕ1(x, t)uρϕ2(x, t)
ρϕ1UIϕ2(x, t) = tt0∈(t+I)∩Tρϕ2(x, t0)l
ut00∈[t,t0)∩Tρϕ1(x, t00 )
When t= 0, we write ρϕ(x)instead of ρϕ(x,0).
The robustness is a real-valued function of xwith the follow-
ing important property.
Theorem 2.1: [15] For any x∈XTand STL formula ϕ, if
ρϕ(x, t)<0then xviolates ϕat time t, and if ρϕ(x, t)>0
then xsatisfies ϕat t. The case ρϕ(x, t)=0is inconclusive.
Thus, we can compute control inputs by maximizing the
robustness over the set of finite input sequences of a certain
length. The obtained sequence u∗is valid if ρϕ(x∗, t)is
positive, where x∗and u∗obey (1). The larger ρϕ(x∗, t), the
more robust is the behavior of the system: intuitively, x∗can
be disturbed and ρϕmight decrease but not go negative. In
fact, the amount of disturbance that x∗can sustain is precisely
ρϕ: that is, if x∗|=ϕ, then x∗+e|=ϕfor all disturbances
e:T→Xs.t. supt∈Tke(t)k< ρϕ(x∗).
If T= [0, T ]then the above naturally defines satisfaction
of ϕby a continuous-time trajectory yc: [0, T ]→X.
III. CON TRO L USI NG A SM OOTH APPROX IM ATIO N OF STL
ROB USTNESS
The goal of this work is to find a provably correct control
scheme for fleets of quadrotors, which makes them meet a
control objective ϕexpressed in temporal logic. So let  >
0be a desired minimum robustness. We solve the following
problem.
P: max
u∈UN−1ρϕ(x)(2a)
s.t. xk+1 =f(xk, uk),∀k= 0, . . . , N −1(2b)
xk∈X, uk∈U∀k= 0, . . . , N (2c)
ρϕ(x)≥(2d)
Because ρϕuses the non-differentiable functions max and
min (see Def. 2.2), it is itself non-differentiable as a func-
tion of the trajectory and the control inputs. A priori, this
necessitates the use of Mixed-Integer Programming solvers [8],
non-smooth optimizers [16], or stochastic heuristics [11] to
solve Pρ. However, it was recently shown in [10] that it
is more efficient and more reliable to instead approximate
the non-differentiable objective ρϕby a smooth (infinitely
differentiable) function ˜ρϕand solve the resulting optimization
problem e
Pusing Sequential Quadratic Programming (SQP).

4
The approximate smooth robustness is obtained by using
smooth approximations of min and max in Def. 2.2. In this
paper, we also use the smoothed robustness ˜ρϕand solve e
P
instead of P. The lower bound on robustness (2d) is used to
ensure that if ˜ρϕ≥then ρϕ≥0. This approach was called
Smooth Operator.
Despite the improved runtime of Smooth Operator, our
experiments have shown that it is not possible to solve e
P
in real-time using the full quadrotor dynamics. Therefore, in
this paper, we develop a control architecture that is guaranteed
to produce a correct and dynamically feasible quadrotor tra-
jectory. By ‘correct’, we mean that the continuous-time, non-
sampled trajectory satisfies the formula ϕ, and by ‘dynam-
ically feasible’, we mean that it can be implemented by the
quadrotor dynamics. This trajectory is then tracked by a lower-
level MPC tracker. The control architecture and algorithms are
the subject of the next section.
IV. QUADROT OR CO NT ROL ARCHITECTURE
Fig. 3 shows the control architecture used in this paper, and
its components are detailed in what follows. The overall idea
is that we want the continuous-time trajectory yc: [0, T ]→X
of the quadrotor to satisfy the STL mission ϕ, but can only
compute a discrete-time trajectory x: [0:dt :T]→Xsampled
at a low rate 1/dt. So we do two things, illustrated in Fig.3:
A) to guarantee continuous-time satisfaction from discrete-
time satisfaction, we ensure that a discrete-time high-rate
trajectory q: [0 : dt0:T]→Xsatisfies a suitably stricter
version ϕsof ϕ. This is detailed in Section V.
B) To compute, in real-time, a sufficiently high-rate discrete-
time q[dt0]that satisfies ϕs, we perform a (smooth) robustness
maximization over a low-rate sequence of waypoints xwith
sampling period dt >> dt0. The optimization problem is such
that the optimal low-rate trajectory x: [0:dt:T]→Xand the
desired high-rate qare related analytically: q=L(x)for a
known L:R(T/dt)→R(T /dt0). So the robustness optimization
maximizes ˜ρϕs(L(x)), automatically yielding q[dt0]. More-
over, we must add constraints to ensure that qis dynamically
feasible, i.e., can be implemented by the quadrotor dynamics.
Thus, qualitatively, the optimization problem we solve is
max
x[dt]˜ρϕs(L(x[dt]))
s.t. L(x[dt]) obeys quadrotor dynamics and is feasible
xand L(x[dt]) are in the allowed air space
˜ρϕs(L(x[dt])) ≥ε(3)
The mathematical formulation of the above problem, includ-
ing the trajectory generator L, is given in Sec. IV-A. But first,
we end this section by a brief description of the position and
attitude controllers that take the high-rate q[dt0]and provide
motor forces to the rotors, and a description of the quadrotor
dynamics. The state of the quadrotor consists of its 3D position
pand 3D linear velocity v= ˙p. A more detailed version of
the quad-rotor dynamics is in Sec. IX-A.
Position controller To track the desired positions and
velocities from the trajectory generator, we consider a Model
Predictive Controller (MPC) formulated using the dynamics
of (17) linearized around hover. Given desired position and
࢖௧
ௗ࢖௧
஽
STL Specification
High-level Control for STL
Position
Controller
Attitude
Controller
Trajectory
Generator
ϕmission
࢖௧
ଵ
… …
(࢞௥௘௙
ௗ,࢞
ሶ
௥௘௙
ௗ)
Position
Controller
Attitude
Controller
Trajectory
Generator
(࢞௥௘௙
ଵ,࢞
ሶ
௥௘௙
ଵ)
Position
Controller
Attitude
Controller
Trajectory
Generator
(࢞௥௘௙
஽,࢞
ሶ
௥௘௙
஽)
ϕ, θ, ߰,ܶϕ, θ, ߰,ܶϕ, θ, ߰,ܶ
Motor PWM
Quad-rotor 1 Quad-rotor d
……
Quad-rotor D
Multi-drone mission
Central
computation
resource
20 Hz
1 Hz
20 Hz
50 Hz Motor PWM Motor PWM
Fig. 3: The control architecture. Given a mission specification in
STL, the high-level control optimization (centralized) generates a
sequence of waypoints. These waypoints are sent over to the drones,
and through a hierarchical control onboard control architecture, the
resulting trajectories are tracked near perfectly, with the continuous
time behavior of the system satisfying the STL specification.
velocity commands in the fixed-world x, y, z co-ordinates, the
controller outputs a desired thrust, roll, and pitch command
(yaw fixed to zero) to the attitude controller. This controller
also takes into account bounds on positions, velocities and the
desired roll, pitch and thrust commands.
Attitude controller Given a desired angular position and
thrust command generated by the MPC, the high-bandwidth
(50 −100 Hz) attitude controller maps them to motor forces.
In our control architecture, this is implemented as part of the
pre-existing firmware on board the Crazyflie 2.0 quadrotors.
An example of an attitude controller can be found in [17].
A. The trajectory generator
The mapping Lbetween low-rate x[dt]and high-rate y[dt0]
is implemented by the following trajectory generator, adapted
from [18]. It takes in a motion duration Tf>0and
a pair of position, velocity and acceleration tuples, called
waypoints: an initial waypoint q0= (p0, v0, a0)and a fi-
nal waypoint qf= (pf, vf, af). It produces a continuous-
time minimum-jerk (time derivative of acceleration) trajectory
q(t) = (p(t), v(t), a(t)) of duration Tfs.t. q(0) = q0and
q(Tf) = qf. In our control architecture, the waypoints are
the elements of the low-rate xcomputed by solving (3). The
generator of [18] formulates the quadrotor dynamics of (17)
in terms of 3D jerk and this allows a decoupling of the
equations along three orthogonal jerk axes. By solving three
independent optimal control problems, one along each axis, it
obtains three minimum-jerk trajectories, each being a spline
q∗: [0, Tf]→R3of the form:

p∗(t)
v∗(t)
a∗(t)

=

α
120 t5+β
24 t4+γ
6t3+a0t2+v0t+p0
α
24 t4+β
6t3+γ
2t2+a0t+v0
α
6t3+β
2t2+γt +a0

(4)
Here, α,β, and γare scalar linear functions of the initial q0
and final qf. Their exact expressions depend on the desired
type of motion:

5
-0.5 0 0.5 1 1.5 2
0
0.5
1
1.5
2
Position of q
0
p
0
Position of q(kdt
′
)
p
1
Position of q
1
p
2
Fig. 4: Planar splines connecting position waypoints p0,p1and p2.
q0is the continuous spline (positions, velocities and accelerations)
connecting p0and p1and q1is the spline from p1to p2.q(kdt
0)is
the kth sample of q0, with sampled time dt
0
. Note, unlike the stop-go
case, non-zero end point velocities mean that the resulting motion is
not simply a line connecting the way points.
1. Stop-and-go motion. [18] This type of motion yields
straight-line position trajectories p(·). These are suitable for
navigating tight spaces, since we know exactly the robot’s
path between waypoints. For Stop-and-Go, the quadrotor starts
from rest and ends at rest: v0=a0=vf=af= 0. I.e. the
quadrotor has to come to a complete stop at each waypoint.
In this case, the constants are defined as follows:

α
β
γ

=1
T5
f


720(pf−p0)
−360Tf(pf−p0)
60T2
f(pf−p0)

(5)
2. Trajectories with free endpoint velocities [18] Stop-
and-go trajectories have limited reach, since the robot must
spend part of the time coming to a full stop at every waypoint.
In order to get better reach, the other case from [18] that we
consider is when the desired initial and endpoint velocities,
v0and vf, are free. Like the previous case, we still assume
a0=af= 0. The constants in the spline (4) are then:

α
β
γ

=1
T5
f


90 −15T2
f
−90Tf15T3
f
30T2
f−3T4
f

pf−p0−v0Tf
vf−v0(6)
In this case, the trajectories between waypoints are not
restricted to be on a line, allowing for a wider range of
manoeuvres, as will be demonstrated in the simulations of
Sec. VI. An example of such a spline (planar) is shown in
Fig. 4.
B. Constraints for dynamically feasible trajectories
The splines (4) that define the trajectories come from
solving an unconstrained optimal control problem, so they
are not guaranteed to respect any state and input constraints,
and thus might not be dynamically feasible. By dynamically
feasible, we mean that the quadrotor can be actuated (by the
motion controller) to follow the spline. Typically, feasibility
requires that the spline velocity and acceleration be within
certain bounds. E.g. a sharp turn is not possible at high speed,
but can be done at low speed. Therefore, we formally define
dynamic feasibility as follows.
Definition 4.1 (Dynamically feasible trajectories): Let [v, ¯v]
be bounds on velocity and [a, ¯a]be bounds on acceleration. A
trajectory q: [0, Tf]→R3, with q(t) = (p(t), v(t), a(t)), is
dynamically feasible if v(t)∈[v, ¯v]and a(t)∈[a, ¯a]for all
t∈[0, Tf]for each of the three axes of motion.
Assumption 4.1: We assume that dynamically feasible tra-
jectories, as defined here, can be tracked almost perfectly
by the position (and attitude) controller. This assumption is
validated by our experiments on physical quadrotor platforms.
See Sec. VII.
In this section we derive constraints on the desired end state
(pf, vf, af)such that the resulting trajectory q(·)computed by
the generator [18] is dynamically feasible.
Since the trajectory generator works independently on each
jerk axis, we derive constraints for a one-axis spline given
by (4). An identical analysis applies to the splines of other
axes. Since a quadrotor can achieve the same velocities and
accelerations in either direction along an axis, we take v <
0<¯v=−vand a < 0<¯a=−a. We derive the bounds for
the two types of motion described earlier.
Stop-and-go trajectories: vf=v0=0=af=a0=0
Since the expressions for the splines are linear in pfand p0
(Eqs. (4), (5)), without loss of generality we assume p0= 0.
By substituting (5) in (4), we get:
p∗
t= (6 t5
T5
f
−15 t4
T4
f
+ 10 t3
T3
f
)pf(7a)
v∗
t= (30 t4
T5
f
−60 t3
T4
f
+ 30 t2
T3
f
)
| {z }
K1(t)
pf(7b)
a∗
t= (120 t4
T5
f
−180 t2
T4
f
+ 60 t2
T4
f
)
| {z }
K2(t)
pf(7c)
Fig. 11 shows the functions K1and K2for Tf= 1.
The following lemma is proved by examining the first two
derivatives of K1and K2.
Lemma 4.1: The function K1: [0, Tf]→Ris non-
negative and log-concave. The function K2: [0, Tf]→R
is anti-symmetric around t=Tf/2, concave on the interval
t∈[0, Tf/2) and convex on the interval [Tf/2, Tf].
Let maxt∈[0,Tf]K1(t) = K∗
1and maxt∈[0,Tf]|K2(t)|=
K∗
2. These are easily computed thanks to Lemma 4.1. We can
now state the feasibility constraints for Stop-and-Go motion.
See the appendix for a proof sketch.
Theorem 4.1 (Stop-and-go feasibility): Given an initial po-
sition p0(and v0=a0= 0), a maneuver duration Tf, and
desired bounds [v, ¯v]and [a, ¯a], if v/K ∗
1≤pf−p0≤¯v/K∗
1
and a/K∗
2≤pf−p0≤¯a/K∗
2then v∗
t∈[v, ¯v]and a∗
t∈[a, ¯a]
for all t∈[0, Tf].
Since v, ¯v, a, ¯a, K∗
1, K∗
2are all available offline, so they can
be used as constraints if solving problem (3) offline.
Free end velocities: af=a0=0, free vf. Here too,
without loss of generality p0= 0. Substituting (6) in (4)

6
Fig. 5: The upper and lower bounds on pfdue to the accel-
eration and velocity constraints. Shown as a function of v0for
t= 0,0.1,...,Tf= 1. The shaded region shows the feasible values
of pfas a function of v0.
and re-arranging terms yields the following expression for the
optimal translational state:
p∗
t= ( 90t5
240T5
f
−90t4
48T4
f
+30t3
12T3
f
)pf−(90t5
240T4
f
−90t4
48T3
f
+30t3
12T2
f
−t)v0
v∗
t= ( 90t4
48T5
f
−90t3
12T4
f
+30t2
4T3
f
)
| {z }
K3(t)
pf−(90t4
48T4
f
−90t3
12T3
f
+30t2
4T2
f
−1)v0
a∗
t= ( 90t3
12T5
f
−90t2
4T4
f
+30tt
2T3
f
)
| {z }
K4(t)
pf−(90t3
12T4
f
−90t2
4T3
f
+30tt
2T2
f
)v0
(8)
Applying the velocity and acceleration bounds v≤v∗≤¯v
and a≤a∗≤¯ato (8) and re-arranging terms yields:
(v−(1 −TfK3(t))v0)
K3(t)≤pf≤(¯v−(1 −TfK3(t))v0)
K3(t)∀t∈[0, Tf]
(9a)
a/K4(t) + Tfv0≤pf≤¯a/K4(t) + Tfv0∀t∈[0, Tf](9b)
The constraints on pfare linear in v0, but parametrized by
functions of t. Since tis continuous in [0, Tf], (9) is an infinite
system of linear inequalities. Fig. 5 shows these linear bounds
for t= 0,0.1,0.2,...,1 = Tfwith ¯v= 1 = −v, ¯a=2=−a.
The infinite system can be reduced to 2 inequalities only,
as proved in the appendix.
Lemma 4.2: pfsatisfies (9) if it satisfies the following
v−(1 −TfK3(Tf))v0
K3(Tf)≤pf≤¯v−(1 −TfK3(Tf))v0
K3(Tf)
Tfv0+a/K4(t0)≤pf≤Tfv0+ ¯a/K4(t0)(10)
where t0is a solution of the quadratic equation dK4(t)
dt = 0,
such that t0∈[0, Tf].
The main result follows:
Theorem 4.2 (Free endpoint velocity feasibility): Given
an initial translational state p0, v0∈[v, ¯v], a0= 0, and a
maneuver duration Tf, if pfsatisfies
v−(1 −TfK3(Tf))v0
K3(Tf)≤pf−p0≤¯v−(1 −TfK3(Tf))v0
K3(Tf)
Tfv0+a/K4(t0)≤pf−p0≤Tfv0+ ¯a/K4(t0)
(11)
with t0defined as in Lemma 4.2, then v∗(t)∈[v, ¯v]and
a∗
t∈[a, ¯a]for all t∈[0, Tf]and p∗(Tf) = pf.
V. CO NT ROL O F QUA DROTO RS F OR SATIS FACT IO N OF STL
SP EC IFI CATI ON S
We are now ready to formulate the mathematical robustness
maximization problem we solve for temporal logic planning.
We describe it for the Free Endpoint Velocity motion; an
almost-identical formulation applies for the Stop-and-Go case
with obvious modifications.
Recall the notions of low-rate trajectory xand high-rate
discrete-time trajectory qdefined in Section IV. Consider an
initial translational state xI= (pI, vI)and a desired final
position pfto be reached in Tfseconds, with free end velocity
and zero acceleration. Given such a pair, the generator of Sec-
tion IV-A computes a trajectory q= (p, v , a) : [0, Tf]→R9
that connects pIand pf. By (4), for every t∈[0, Tf],q(t)
is a linear function of pI,pfand vI. If the spline q(·)is
uniformly sampled with a period of dt0, let H=Tf/dt0be
the number of discrete samples in the interval [0, Tf]. Every
q(·dt0)(sampled point along the spline) is a linear function
of pI, vI, pf. Hereonafter, we use xI
Tf
→xfas shorthand for
saying that xIis the initial state, and xf= (pf, vf)is the final
state with desired end position pfand end velocity vf=v(Tf)
computed using the spline.
More generally, consider a sequence of low-rate waypoints
(x0
Tf
→x1, x1
Tf
→x2, . . . , xN−1
Tf
→xN), and a sequence
(qk)N−1
k=0 of splines connecting them and their high-rate sam-
pled versions ˆqksampled with a period dt0<< Tf. Then every
sample qk(i·dt0)is a linear function of pk−1,vk−1and pk.
We now put everything together. Write
ˆq = (q0(0), . . . , qN−1(H dt)) ∈R9N(H−1) ,
x= ((p0, v0),...,(pN−1, vN−1)) ∈R6N, and let
L:R6N→R9N(H−1) be the linear map between them. In
the Stop-and-Go case, this uses all velocities to 0 and uses
(7) for positions, and in the free velocity case, Luses (8).
The robustness maximization problem is finally:
max
x
˜ρϕs(L(x)) (12a)
s.t. LBv(vk−1)≤pk−pk−1≤UBv(vk−1)∀k= 1,...,N, (12b)
LBa(vk−1)≤pk−pk−1≤UBa(vk−1)∀k= 1,...,N, (12c)
˜ρϕs(L(x)) ≥ε(12d)
where (12b) and (12c) are the constraints from (11) in
Free Endpoint Velocity motion, and Thm. 4.1 in Stop-and-Go
motion, with pI=pk−1and pf=pk.
Since the optimization variables are only the waypoints p,
and not the high-rate discrete-time trajectory, this makes the
optimization problem much more tractable.

7
A. Strictification for Continuous time guarantees
In general, if the sampled trajectory qsatisfies ϕ, this
does not guarantee that the continuous-time trajectory qalso
satisfies it. For that, we use [19, Thm. 5.3.1], which defines a
strictification operator str:ϕ7→ ϕsthat computes a syntactical
variant of ϕhaving the following property.
Theorem 5.1: [19] Let dt be the sampling period, and
suppose that there exists a constant ∆g≥0s.t. for all t,
kq(t)−q(t+dt)k ≤ ∆gdt. Then ρϕs(q)>∆g⇒(q, 0) |=ϕ.
Intuitively, the stricter ϕstightens the temporal intervals and
the predicates µkso it is ‘harder’ to satisfy ϕsthan ϕ. See [19,
Ch. 5]. For the trajectory generator gof Section IV-A, ∆gcan
be computed given Tf,v, ¯v, a and ¯a.
We need the following east-to-prove result, to account for
the fact that we optimize a smoothed robustness:
Corollary 5.1.1: Let εbe the worst-case approximation error
for smooth robustness. If ˜ρϕs(q)>∆g+εthen (q, 0) |=ϕ
B. Robust and Boolean modes of solution
The control problem of (12) can be solved in two modes [8]:
the Robust (R) Mode, which solves the problem until a
maximum is found (or some other optimizer-specific criterion
is met). And a Boolean (B) Mode, in which the optimization
(12) stops as soon as the smooth robustness value exceeds ε.
C. Implementation of the control
The controller can be implemented in one of two ways:
One-shot: The optimization of (12) is solved once at time
0and the resulting trajectories are then used as a plan for the
quadrotors to follow. In our simulations, where there are no
disturbances, this method is acceptable or when any expected
disturbances are guaranteed to be less than ˜ρ∗, the robustness
value achieved by the optimization.
Shrinking horizon: In practice, disturbances and modeling
errors necessitate the use of an online feedback controller. We
use a shrinking horizon approach. At time 0, the waypoints
are computed by solving Eq. (12) and given to the quadrotors
to track. Then every Tfseconds, estimates for p, v, a are
obtained, and the optimization is solved again to generate new
waypoints for the remaining length of the trajectory. For the
kth such optimization, we re-use the k−1st as an initial guess.
This results in a faster optimization that can be run online, as
will be seen in the experiments.
VI. SIMULATIONS RESU LTS
We demonstrate the efficiency and the guarantees of our
method through multiple examples, in simulation and in real
experiments. For the simulations, we consider two case stud-
ies: a) A multi-drone reach-avoid problem in a constrained
environment, and b) A multi-mission example where several
drones have to fly one of two missions in the same environ-
ment. We assume a disturbance-free environment, and solve
the problem in one shot, i.e. the entire trajectory that satisfies
the mission is computed in one go (aka open-loop).
Fig. 6: The environment for the reach-avoid problem.
A. Simulation setup
The following simulations were done in MATLAB 2016b,
with the optimization formulated in Casadi [20] with Ipopt
[21] as the NLP solver. HSL routines [22] were used as
internal linear solvers in Ipopt. All simulations were run on a
laptop with a quadcore i7-7600 processor (2.8 Ghz) and 16Gb
RAM running Ubuntu 17.04. For all simulations, waypoints
are separated by Tf= 1 second. Links to the videos for all
simulations and experiments are in a table in the appendix.
B. Multi drone reach-avoid problem
The objective of the drone dis to reach a goal set Goal,
while avoiding an unsafe set Unsafe, in the 3D position space.
With pdenoting the drone’s 3D position, the mission for a
single drone dis:
ϕd
sra =[0,T ]¬(p∈Unsafe)∧♦[0,T ](p∈Goal)(13)
This says that for all times in [0, T ]the drone must avoid the
Unsafe set, and sometime during the interval [0, T ], it must
visit the Goal set. See Fig. 6.
The Multi drone Reach-Avoid problem adds the requirement
that every two drones d, d0must maintain a minimum separa-
tion δmin >0from each other: ϕd,d0
sep =[0,T ](||pd−pd0|| ≥
δmin. Assuming the number of drones is D, the specification
reads:
ϕmra =∧D
d=1 ϕd
sra ^∧D
d=1(∧d06=dϕd,d0
sep )(14)
The horizon of this formula is hrz(ϕmra ) = T. The robust-
ness of ϕmra is upper-bounded by 0.25, which is achievable
if all drones visit the center of the goal set Goal = [1.5,2] ×
[1.5,2]×[1,1.5] - at that time, they would be 0.25m away from
the boundaries of Goal - and maintain a minimum distance
of 0.25 to Unsafe and each other. We analyze the runtimes
and achieved robustness of our controller by running a 100
simulations, each one from different randomly-chosen initial
positions of the drones in the free space X/(Goal ∪Unsafe)).
1) Stop and go trajectories: We show the results of con-
trolling using (12) to satisfy ϕmra for the case of Stop-and-
Go motion (see Sec.IV-A). with T= 6 seconds. Videos of
the computed trajectories are available at link 1 (in Boolean
mode) and at link 2 (in Robust Mode) in Table V.

8
Table I shows the run-times for an increasing number of
drones Din the Robust and Boolean modes. It also shows
the robustness of the obtained optimal trajetories in Robust
mode. (We maximize smooth robustness, then compute true
robustness on the returned trajectories). As Dincreases, the
robustness values decrease. Starting from the upper bound of
0.25 with 1drone, the robustness decreases to an average
of 0.122 for D= 5. This is expected, as more and more
drones have to visit Goal within the same time [0,6], while
maintaining a pairwise minimum separation of δmin. As a
result, the drones cannot get deep into the goal set, and this
lowers the robustness value.
Up to 5 drones, the controller is successful in accomplishing
the mission every time. By contrast, for D > 5, the controller
starts failing, in up to half the simulations. We conclude that
for T= 6, the optimization can only handle up to 5 drones
for this mission, in this environment.
Comparison to MILP-based solution. The problem of
maximizing ρϕmra (y)to satisfy ϕmra can be encoded as a
Mixed Integer Linear Program (MILP) and solved. The tool
BluSTL [8] implements this approach. We compare our run-
times to those of BluSTL for the case D= 1. The robust-
ness maximization in BluSTL took 1.2±0.3sand returned
a robustness value of 0.25 for each simulation, while the
Boolean mode took 0.65 ±0.2sseconds. (Note we do not
include the time it takes BluSTL to encode the problem in
these numbers.) Thus our approach out-performs MILP in both
modes. For D > 1, BluSTL could not return a solution with
positive robustness. The negative-robustness solutions it did
return required several minutes to compute.
TABLE I: Stop-and-Go motion. Mean and standard deviations for
run-times (in seconds) and robustness values from 100 runs of the
reach-avoid problem.
D Boolean mode Robust mode ρ∗(Robust mode)
10.078 ±0.004 0.40 ±0.018 0.244 ±0
20.099 ±0.007 1.313 ±0.272 0.198 ±0.015
30.134 ±0.015 2.364 ±0.354 0.176 ±0.018
40.181 ±0.024 3.423 ±0.370 0.160 ±0.031
50.214 ±0.023 7.009 ±3.177 0.122 ±0.058
2) Trajectories with free end of point velocities: We also
solved the multi-drone reach-avoid problem for Free Velocity
motion (Section IV-A), with T= 6. An instance of the
resulting trajectories are available in links 3 and 4 for Boolean
mode and at links 5 and 6 for Robust mode in Table V. Table
II shows the runtimes for an increasing number of drones Din
the Robust and Boolean modes. It also shows the robustness of
the obtained optimal trajetories in Robust mode. As before, the
achieved robustness value decreases as Dincreases. Unlike the
stop-and-go case, positive robustness solutions are achieved
for all simulations, up to D= 16 drones. This is due to the
added freedom of motion between waypoints. This matches
the intuition that a wider range of motion is possible when
the quadrotors do not have to come to a full stop at every
waypoint.
For this case, we did not compare with BluSTL as the there
is no easy way to incorporate this formulation in BluSTL.
Discussion The simulations show the performance and
scalability of our method, finding satisfying trajectories for
ϕmra for 16 drones in less than 2seconds on average, while
TABLE II: Free Endpoint Velocity motion. Mean and standard
deviations for runtimes (in seconds) and robustness values from 100
runs of the reach-avoid problem.
D Boolean mode Robust mode ρ∗(Robust mode)
10.081 ±0.005 0.32 ±0.18 0.247 ±0
20.112 ±0.016 0.86 ±0.15 0.188 ±0.026
40.244 ±0.017 1.88 ±0.17 0.149 ±0.040
50.307 ±0.056 3.48 ±0.56 0.137 ±0.018
60.439 ±0.073 9.08 ±0.85 0.102 ±0.032
80.651 ±0.042 15.86 ±2.15 0.0734 ±0.018
10 0.843 ±0.077 16.64 ±1.30 0.051 ±0.017
12 1.123 ±0.096 23.99 ±5.81 0.033 ±0.003
16 1.575 ±0.114 32.21 ±6.25 0.028 ±0.005
maximizing robustness in 35 seconds. On the other hand, the
MILP-based approach does not scale well, and for the cases
where it does work, is considerably slower than our approach.
Since the high-level control problem is solved at 1Hz, the
runtimes (in the boolean mode) suggest that we can control up
to 2drones online in real-time without too much computation
delay: Stop-and-Go takes an average of 0.099s for 2 drones
(Table I), and Free Endpoint Velocity takes an average of
0.11s for 2 drones (Table II). Moreover, when applied online,
we solve the optimization in a shrinking horizon fashion,
drastically reducing runtimes in later iterations.
C. Multi drone multi mission example
Our method can be applied to scenarios with multiple mis-
sions We illustrate this with the following 2-mission scenario:
- Mission Pkg: A package delivery mission. The drone(s) d
has to visit a Delivery region to deliver a package within the
first 10 seconds and then visit the Base region to pick up
another package, which becomes available between 10 and 20
seconds later. In STL,
ϕd
pkg =♦[0,10](pd∈Deliver)∧♦(10,20](pd∈Base)(15)
- Mission Srv: A surveillance mission. The drone(s) dhas to,
within 20 seconds, monitor two regions sequentially. In STL,
ϕd
srv =♦[0,5](pd∈Zone1)∧♦(5,10] (pd∈Zone2)
∧♦[10,15)(pd∈Zone1)∧♦(15,20] (pd∈Zone2)(16)
In addition to these requirements, all the drones have to
always maintain a minimum separation of δmin from each other
(ϕd,d0
sep above), and avoid two unsafe sets Unsafe1and Unsafe2.
Given an even number Dof drones, the odd-numbered drones
are flying mission Pkg, while the even-numbered drones are
flying mission Srv. The overall mission specification over all
Ddrones is:
ϕx-mission =∧dOdd ϕd
pkg ^∧dEven ϕd
srv ^∧d≤D∧d06=dϕd,d0
sep
^∧d≤D∧2
i=1 [0,20]¬(pd∈Unsafei)
The mission environment is shown in Fig. 7. Note that the
upper bound on robustness is again 0.25.
Results. We solved this problem for D= 2,4,6,8drones,
again with randomly generated initial positions in both Robust
and Boolean modes. Videos of the resulting trajectories are in
links 7-10 of Table V. The runtimes increase with the number

9
Fig. 7: The environment for the multi-mission problem.
TABLE III: Mean and standard deviations for runtimes (in seconds)
and robustness values for one-shot optimization. Obtained from 50
runs of the multi-mission problem with random initial positions.
D Boolean mode Robust mode ρ∗(Robust mode)
20.33 ±0.08 4.93 ±0.18 0.2414 ±0
40.65 ±0.10 16.11 ±4.05 0.2158 ±0.0658
62.38 ±0.28 24.83 ±7.50 0.1531 ±0.0497
820.82 ±4.23 32.87 ±2.26 0.0845 ±0.0025
of drones, as shown in Table III.The runtimes are very suitable
for offline computation. For online computation in a shrinking
horizon fashion, they impose an update rate of at most 1/2
Hz (once every 2 seconds). In general, in the case of longer
horizons, this method can serve as a one-shot planner.
For D > 8, the optimization could not return a solution that
satisfied the STL specification. This is likely due to the small
size of the sets that have to be visited by all drones in the
same time interval, which is difficult to do while maintaining
minimum separation (see Fig. 7). In other words, it is likely
the case that no solution exists, which is corroborated by the
fact that maximum robustness decreases as Dincreases (Table
III).
VII. EXP ER IM EN TS O N RE AL QUAD ROTO RS
We evaluate our method on Crazyflie 2.0 quadrotors( Fig. 2).
Through these experiments we aim to show that: a) the
velocity and acceleration constraints from Section IV-B indeed
ensure that the high-rate trajectory ygenerated by robustness
maximization is dynamically feasible and can be tracked by
the MPC position controller, and b) our approach can control
the quadrotors to satisfy their specifications in a real-time
closed loop manner, A real-time playback of the experiments
is in the links 11-16 of Table V.
A. Experimental Setup
The Crazyflies are controlled by a single laptop running
ROS and MATLAB. For state estimation, a Vicon motion
capture system gave us quadrotor positions, velocities, orienta-
tions and angular velocities. In order to control the crazyflies,
we: a) implemented the robustness maximization using Casadi
in MATLAB, and interfaced it to ROS using the MATLAB-
ROS interface provided by the Robotics Toolbox. b) im-
plemented a Model Predictive Controller (MPC) using the
quadrotor dynamics linearized around hover for the position
controller, coded in C using CVXGEN and ROS, c) modified
the ETH tracker in C++ to work with ROS. The crazyflie has
its own attitude controller flashed to the onboard microcon-
troller. The robustness maximizer runs at 1Hz, the trajectory
generator runs at 20Hz, the position controller runs at 20Hz
and the attitude controller runs at 50Hz.
B. Online real-time rontrol
We fly the reach-avoid problem (in both Stop-and-Go and
Free Endpoint Velocity modes), for one and two drones, with
T= 6 seconds, and with a maneuver duration Tfset to 1
second. The controller operates in Boolean mode.
The shrinking horizon approach of Sec. V is used with
a re-calculation rate of 1Hz. We repeat each experiment
multiple times. For every run, the quadrotors satisfied the STL
specification of (14). The runtimes are shown in Table IV.
Using the optimal solution at the previous time step as the
initial solution for the current time step results in very small
average runtimes per time-step. This shows that our method
can be easily applied in a real-time closed-loop manner.
TABLE IV: Average runtime per time-step (in seconds) of shrinking
horizon robustness maximization in Boolean mode. These are aver-
aged over 5 repetitions of the experiment from the same initial point,
to demonstrate the reproducibility of the experiments.
D Stop-and-Go Free Endpoint Velocity)
1 0.052 0.065
2 0.071 0.088
We observed that for more than 2quadrotors, the online
delay due to the optimization and the MATLAB-ROS interface
(the latter takes upto 10ms for receiving a state-estimate and
publishing a waypoint command) is large enough that the
quadrotor has significantly less than Tftime to execute the
maneuver between waypoints, resulting in trajectories that
sometimes do not reach the goal state. Videos are in links
11-13 in table V.
C. Validating the dynamic feasibility of generated trajectories.
Figs. 8 and 9 shows the tracking of the positions and
velocities commanded by the spline. The near-perfect tracking
in x,y axes and satisfactory tracking in the z axis shows
that we are justified in assuming that imposing velocity and
acceleration bounds on the robustness maximizer produces
dynamically feasible trajectories that can be tracked by the
position and attitude controllers. Note that the tracking in z
is not perfect due to a combination of modeling error in the
model for the MPC and the lack of thrust compensation as the
batteries onboard the crazyflies deplete.
D. Offline planning for multiple drones
Our approach can be used as an offline path planner. Specif-
ically, we solve the problem (12) offline for Free Endpoint
Velocity motion, and use the solution low-rate trajectory
xas waypoints. Online, we run the trajectory generator
of Sec. IV-A (and lower-level controllers) to navigate the
crazyflies between the waypoints in a shrinking horizon fash-
ion. We did this for all 8 crazyflies at our disposal, and we

10
Fig. 8: The desired and actual trajectories for a crazyflie 2.0 flying
the reach-avoid problem with closed-loop control. The unsafe set
is in red and the goal set is in green (Color in online version).
The tracking is near-perfect, showing the dynamical feasibility of
the selected waypoints.
246
Time (s)
-1
0
1
2
2 4 6
Time (s)
-1
0
1
2
2 4 6
Time (s)
1
1.5
2
246
Time (s)
0
0.2
0.4
0.6
0.8
1
2 4 6
Time (s)
0
0.2
0.4
0.6
0.8
1
2 4 6
Time (s)
-1
-0.5
0
0.5
Fig. 9: The desired (dashed green) and actual (blue) positions and
velocities along the 3 axes.
expect it is possible to support significantly more crazyflies,
since the online computation is completely distributed. A video
of this experiment is available in the links of Table V.
VIII. CONCLUSIONS AND FUTURE WORK
We presented a method for generating trajectories for
multiple drones to satisfy a given STL requirement. The
correctness of satisfaction is guaranteed for the continuous-
time behavior of the resulting trajectories, and they can be
tracked nearly perfectly by lower level position and attitude
controllers. Through simulations, as well as experiments on
actual quadrotors, we show the applicability of our method
as a real-time high-level controller in a hierarchical control
scheme. We also show that our method is computationally
tractable and scales well for problems involving up to 16
drones. Ongoing work is on extending our method to STL
formulae with unbounded time horizons through a receding
horizon approach.
ACK NOW LE DG EM EN TS
The authors would like to acknowledge Bernd Pfrommer
for his initial loan of the Crazyflies as well as help setting
them up, Thejas Kesari for his help with the videos, and Jalaj
Maheshwari for his help with figures.
REFERENCES
[1] X. Ma, Z. Jiao, and Z. Wang, “Decentralized prioritized motion planning
for multiple autonomous uavs in 3d polygonal obstacle environments,”
in International Conference on Unmanned Aircraft Systems, 2016.
[2] J. P. van den Berg and M. H. Overmars, “Prioritized motion planning
for multiple robots,” in IEEE/RSJ International Conference on Intelligent
Robots and Systems, 2015.
[3] D. Aksaray, A. Jones, Z. Kong, M. Schwager, and C. Belta, “Q-learning
for robust satisfaction of signal temporal logic specifications,” in IEEE
Conference on Decision and Control, 2016.
[4] I. Saha, R. Rattanachai, V. Kumar, G. J. Pappas, and S. A. Seshia,
“Automated composition of motion primitives for multi-robot systems
from safe ltl specifications,” in IEEE/RSJ International Conference on
Intelligent Robots and Systems, 2014.
[5] J. A. DeCastro, J. Alonso-Mora, V. Raman, and H. Kress-Gazit,
“Collision-free reactive mission and motion planning for multi-robot
systems,” in Robitics Research, Springer Proceedings in Advanced
Robotics, 2017.
[6] A. Desai, I. Saha, Y. Jianqiao, S. Qadeer, and S. A. Seshia, “Drona: A
framework for safe distributed mobile robotics,” in ACM/IEEE Interna-
tional Conference on Cyber-Physical Systems, 2017.
[7] W. Honig, T. K. Satish Kumar, L. Cohen, H. Ma, H. Xu, N. Ayanian,
and S. Koenig, “Multi-agent path finding with kinematic constraints,” in
International Conference on Automated Planning and Scheduling, 2016.
[8] V. Raman, A. Donze, M. Maasoumy, R. M. Murray, A. Sangiovanni-
Vincentelli, and S. A. Seshia, “Model predictive control with signal
temporal logic specifications,” in 53rd IEEE Conference on Decision
and Control, Dec 2014, pp. 81–87.
[9] S. Sadraddini and C. Belta, “Robust temporal logic model predictive
control,” in Allerton conference, September 2015.
[10] Y. V. Pant, H. Abbas, and R. Mangharam, “Smooth operator: Control
using the smooth robustness of temporal logic,” in IEEE Conference on
Control Technology and Applications,, 2017.
[11] H. Abbas, G. E. Fainekos, S. Sankaranarayanan, F. Ivancic, and
A. Gupta, “Probabilistic temporal logic falsification of cyber-physical
systems,” ACM Transactions on Embedded Computing Systems, 2013.
[12] H. Abbas and G. Fainekos, “Computing descent direction of MTL
robustness for non-linear systems,” in American Control Conference,
2013.
[13] O. Maler and D. Nickovic, Monitoring Temporal Properties of Contin-
uous Signals. Springer Berlin Heidelberg, 2004.
[14] A. Donz´
e and O. Maler, “Robust satisfaction of temporal logic over
real-valued signals,” in Proceedings of the International Conference on
Formal Modeling and Analysis of Timed Systems, 2010.
[15] G. Fainekos and G. Pappas, “Robustness of temporal logic specifications
for continuous-time signals,” Theoretical Computer Science, 2009.
[16] H. Abbas and G. Fainekos, “Computing descent direction of mtl robust-
ness for non-linear systems,” in American Control Conference (ACC),
2013, pp. 4411–4416.
[17] T. Luukkonen, “Modelling and control of quadcopter,” in Independent
research project in applied mathematics. Aalto University School of
Science, 2011.
[18] M. W. Mueller, M. Hehn, and R. D ´
Andrea, “A computationally effi-
cient motion primitive for quadrocopter trajectory generation,” in IEEE
Transactions on Robotics, 2015.
[19] G. Fainekos, “Robustness of temporal logic specifications,” Ph.D.
dissertation, University of Pennsylvania, 2008. [Online]. Available:
http://www.public.asu.edu/∼gfaineko/pub/fainekos thesis.pdf
[20] J. Andersson, “A General-Purpose Software Framework for Dynamic
Optimization,” PhD thesis, Arenberg Doctoral School, KU Leuven,
2013.
[21] A. W¨
achter and L. T. Biegler, “On the implementation of an interior-
point filter line-search algorithm for large-scale nonlinear programming,”
Mathematical Programming, 2006.
[22] “Hsl. a collection of fortran codes for large scale scientific computation.”
http://www.hsl.rl.ac.uk, accessed: 2017-10-05.

11
e3f
g
ω1
ω2
ω3
z
x
y
θ
ϕ
߰
Fig. 10: World frame and rotation angles (left) and quadrotor frame
with angular rates (right). gis gravitational force. Figure adapted
from Fig. 2 in [18].
IX. APPENDIX
A. Quadrotor dynamics
Multi-rotor dynamics have been studied extensively in the
literature [17], [18], and we closely follow the conventions of
[18] Fig. 10 illustrates the following definitions. The quadrotor
has 6 degrees of freedom. The first three, (x, y, z), are the
linear position of the quadrotor in R3expressed in the world
frame. We write p= (x, y, z)for position. The remaining
three are the rotation angles (φ, θ, ψ)of the quadrotor body
frame with respect to the fixed world frame. Their first
time-derivatives, ω1, ω2, ω3, resp., are the quadrotor’s angular
velocities. We also write v= ˙pfor linear velocity and a= ˙v
for acceleration. If we let Rdenote the rotation matrix [17]
that maps the quadrotor frame to the world frame at time t,
e3= [0,0,1]0, and h∈Rbe the input to the system, which is
the total thrust normalized by the mass of the quadrotor, then
the dynamics are given by
¨p=Re3h+ [0,0,9.81]0
˙
R=R
0−ω3ω2
ω30−ω1
−ω2ω10

(17)
B. Links to videos
Table V has the links for the visualizations of all simulations
and experiments performed in this work.
C. Dyanmic feasibility proofs for Section IV-B
Stop-and-go motion. Dynamical feasibility for velocities
implies that v∗
t∈[v, ¯v]∀t∈[0, Tf], so by (7), v≤K1(t)pf≤
¯v. Similarly for accelerations, a≤K2(t)pf≤¯a. By non-
negativity of K1and negativity of v, the velocity constraints
are equivalent to:
v/K∗
1≤pf≤¯v/K∗
1(18)
Similarly for acceleration, the constraints are
a/K∗
2≤pf≤¯a/K∗
2(19)
This establishes the result for p0= 0. For the general case,
simply replace pfby pf−p0and apply the p0= 0 result.
Through the decoupling of axes, this result holds for all 3 jerk
axes.
0 0.2 0.4 0.6 0.8 1
t
-6
-4
-2
0
2
4
6
K1
K2
K3
K4
Fig. 11: The functions K1to K4for Tf= 1.
Free velocity motion. Proof of Lemma 4.2. We first prove
the upper bound of the first inequality, derived from velocity
bounds. The lower bound follows similarly. First, note that the
upper bounds v07→ (¯v−(1 −TfK3(t))v0)/K3(t)are lines
that intersect at v0= ¯vfor all t. Indeed, substituting v0= ¯v
in the upper bound yields ¯v−(1 −TfK3(t))¯v)/K3(t) = Tf¯v
regardless of t. See Fig. 5. Thus the least upper bound is
the line with the smallest intercept with the y-axis. Setting
v0= 0 in 9, the intercept is ¯v/K3(t). This is smallest when
K3(t)is maximized. Since K3is monotonically increasing
(dK3(t)
dt ≥0), K3(t)is largest at t=Tf. Thus the least upper
bound on pfis (¯v−(1 −TfK3(Tf))v0)/K3(Tf).
We now prove the upper bound for the second inequality,
derived from acceleration bounds. The lower bound follows
similarly. The upper bounds t7→ ¯a/K4(t) + Tfv0have the
same slope, T. See Fig. 5. The least upper bound therefore has
the smallest intercept with the y-axis, which is ¯a/K4(t). The
smallest intercept, yielding the smallest upper bound, occurs
at the tthat maximizes K4. Since K4(t)is concave in tin the
interval [0, Tf], it is maximized at the solution of dK4(t)
dt = 0.
This concludes the proof. Refer to Fig. 5 for the intuition
behind this proof.

12
TABLE V: Links for the videos for simulations and experiments. Here, Sim. stands for Matlab simulations, CF2.0 for experiments on the
Crazyflies. Stop-go and vel. free are the two modes of operation of the trajectory generator, and B (R) is the Boolean (Robust) mode of
solving the control problem. Shr. Hrz. stands for the shrinking horizon mode for online control. The reader is advised to make sure while
copying the link that special characters are not ignored when pasted in the browser.
Link number Platform Mode Specification Drones (D) Link
1 Sim. One-shot (B), stop-go ϕmRA 1,2,4,5 http://bit.ly/RABstopgo
2 Sim. One-shot (R), stop-go ϕmRA 1,2,4,5 http://bit.ly/RARstopgo
3 Sim. One-shot (B), vel. free ϕmRA 1,2,4,5,6 http://bit.ly/RAB1to6varvel
4 Sim. One-shot (B), vel. free ϕmRA 8,10,12,16 http://bit.ly/RAB8to16varvel
5 Sim. One-shot (R), vel. free ϕmRA 1,2,4,5,6 http://bit.ly/RAR1to6varvel
6 Sim. One-shot (R), vel. free ϕmRA 8,10,12,16 http://bit.ly/RAR8to16varvel
7 Sim. One-shot (R), vel. free ϕx−mission 2 http://bit.ly/multi2mission
8 Sim. One-shot (R), vel. free ϕx−mission 4 http://bit.ly/multi4mission
9 Sim. One-shot (R), vel. free ϕx−mission 6 http://bit.ly/multi6mission
10 Sim. One-shot (R), vel. free ϕx−mission 8 http://bit.ly/multi8mission
11 CF2.0 Shr.Hrz (B), vel. free ϕsRA 1 http://bit.ly/varvel1
12 CF2.0 Shr.Hrz (B), vel. free ϕmRA 2 http://bit.ly/varvel2
13 CF2.0 Shr.Hrz (B), stop-go ϕsRA 1 http://bit.ly/stopgo1
14 CF2.0 One-shot (R), vel. free ϕmR A 4 http://bit.ly/varvel4
15 CF2.0 One-shot (R), vel. free ϕmR A 6 http://bit.ly/varvel6
16 CF2.0 One-shot (R), vel. free ϕmR A 8 http://bit.ly/varvel8