I design and analyze a distributed fault-tolerant cooperative control architecture for multiple UAV drones that are simultaneously affected by actuator failures, actuator bias faults, and unknown external disturbances. My central objective is to make each follower UAV drone track a locally generated reference velocity, while the overall group of UAV drones remains coordinated with a leader UAV drone. The method combines graph-theoretic distributed information exchange, adaptive estimation, and a non-singular fast terminal sliding mode controller. I use the velocity-consensus viewpoint because it provides a practical route to cooperative motion for UAV drones when only neighbor-to-neighbor information is available. Instead of requiring every follower UAV drone to communicate directly with the leader UAV drone, I let each follower UAV drone construct a reference velocity from its adjacent UAV drones. This reduces communication burden and improves scalability for multi-UAV drone formations.
Symbols and Core Quantities
I begin with a compact notation that I use throughout the derivation. The position of the \(i\)-th UAV drone is \(P_i\), its velocity is \(V_i\), and its control input is \(U_i\). The unknown external disturbance acting on the UAV drone is \(d_i\). When actuator bias faults and loss-of-effectiveness faults are present, I introduce a bias term \(F_i\) and an efficiency factor \(\lambda\). All quantities are expressed in a common inertial frame. The leader UAV drone has velocity \(V_0\). The follower UAV drones are indexed by \(i=1,\dots,N\). The neighbor set of the \(i\)-th UAV drone is \(N_i\). The adjacency matrix of the communication graph is \(A=[a_{ij}]\), the degree matrix is \(D=\operatorname{diag}(d_i)\), and the Laplacian matrix is \(L=D-A\). The leader-follower connection matrix is \(B=\operatorname{diag}(b_1,\dots,b_N)\).
| Symbol | Meaning |
|---|---|
| \(P_i\) | Position vector of the \(i\)-th UAV drone |
| \(V_i\) | Velocity vector of the \(i\)-th UAV drone |
| \(U_i\) | Control input vector of the \(i\)-th UAV drone |
| \(d_i\) | Unknown external disturbance on the \(i\)-th UAV drone |
| \(F_i\) | Actuator bias fault of the \(i\)-th UAV drone |
| \(\lambda\) | Actuator efficiency factor, \(0<\lambda\le 1\) |
| \(\Delta_i\) | Combined disturbance and bias fault, \(\Delta_i=d_i+F_i\) |
| \(D_i\) | Derivative of the combined uncertainty, \(D_i=\dot{\Delta}_i\) |
| \(V_0\) | Leader UAV drone velocity |
| \(V_{id}\) | Distributed reference velocity for the \(i\)-th follower UAV drone |
| \(e_{i1}\) | Tracking error with respect to \(V_{id}\) |
| \(e_{i2}\) | Tracking error with respect to \(V_0\) |
| \(s_i\) | Non-singular fast terminal sliding surface |
| \(\rho\) | Inverse actuator efficiency, \(\rho=1/\lambda\) |
| \(\hat{\rho}\) | Estimate of \(\rho\) |
| \(\hat{D}_i\) | Estimate of \(D_i\) |
Dynamics of UAV Drones Under Actuator Faults
I model each UAV drone at the velocity-control level because cooperative formation algorithms for UAV drones commonly receive a velocity or acceleration command from an inner-loop attitude controller. For the fault-free case, the translational dynamics of the \(i\)-th UAV drone are written as
$$
\dot{P}_i = V_i,
\qquad
\dot{V}_i = U_i + d_i .
$$
When an actuator fault occurs, the control input is no longer delivered with full effectiveness. I use an efficiency factor \(\lambda\) and a bias term \(F_i\) to represent partial loss of control authority and additive actuator bias. The faulty dynamics are
$$
\dot{P}_i = V_i,
\qquad
\dot{V}_i = \lambda U_i + d_i + F_i .
$$
I define the lumped uncertainty as
$$
\Delta_i = d_i + F_i .
$$
Therefore, the faulty model of each UAV drone can be rewritten in a compact form:
$$
\dot{P}_i = V_i,
\qquad
\dot{V}_i = \lambda U_i + \Delta_i .
$$
For the controller derivation I need the derivative of the velocity dynamics. Taking one more derivative gives
$$
\ddot{P}_i = \dot{V}_i,
\qquad
\ddot{V}_i = \lambda \dot{U}_i + \dot{\Delta}_i .
$$
I define the derivative of the lumped uncertainty as
$$
\dot{\Delta}_i = D_i .
$$
Thus the second-order form used for fault-tolerant control becomes
$$
\ddot{P}_i = \dot{V}_i,
\qquad
\ddot{V}_i = \lambda \dot{U}_i + D_i .
$$
I assume that the lumped uncertainty and its derivative are bounded for all UAV drones. That is, \(\Delta_i\in L_\infty\), \(\dot{\Delta}_i\in L_\infty\), and there exists a positive constant \(\delta_i\) such that
$$
\|D_i\| \le \delta_i .
$$
This assumption is standard for UAV drones subject to aerodynamic disturbances, modeling errors, and slowly varying actuator faults. It does not require exact knowledge of the disturbance or fault magnitude. Instead, I estimate the unknown quantities online.
| Fault condition | Efficiency factor | Bias term | Interpretation for UAV drones |
|---|---|---|---|
| Healthy actuator | \(\lambda=1\) | \(F_i=0\) | Nominal control authority without bias |
| Bias fault only | \(\lambda=1\) | \(F_i\ne 0\) | Additive offset in actuator output |
| Partial loss of effectiveness | \(0<\lambda<1\) | May be nonzero | Reduced control authority with possible bias |
| Severe partial failure | \(\lambda\) small but positive | May be nonzero | UAV drone retains limited controllability |
| Combined fault and disturbance | \(0<\lambda\le 1\) | \(F_i\ne 0\) | Both fault and external disturbance affect the UAV drone |
Graph-Theoretic Information Exchange Among UAV Drones
I describe the communication topology among UAV drones by an undirected graph \(G=(V,\varepsilon,A)\). The node set \(V=\{r_i\}\) represents the UAV drones. The edge set \(\varepsilon\subseteq V\times V\) represents bidirectional communication links. If UAV drone \(i\) and UAV drone \(j\) exchange information, then \((r_i,r_j)\in\varepsilon\), and the corresponding adjacency entry satisfies \(a_{ij}>0\). If there is no link, then \(a_{ij}=0\). I set \(a_{ii}=0\). The neighbor set of UAV drone \(i\) is
$$
N_i = \{j : (r_i,r_j)\in\varepsilon,\ i\ne j\}.
$$
The degree of node \(i\) is
$$
d_i = \sum_{j\in N_i} a_{ij}.
$$
The degree matrix and the Laplacian matrix are
$$
D=\operatorname{diag}(d_i)\in\mathbb{R}^{N\times N},
\qquad
L=D-A .
$$
For the leader-follower structure, I introduce a directed connection from the leader UAV drone to some follower UAV drones. The matrix \(B=\operatorname{diag}(b_1,\dots,b_N)\) encodes whether a follower UAV drone can directly receive leader information. If \(b_i>0\), then follower UAV drone \(i\) has access to the leader UAV drone velocity \(V_0\). If \(b_i=0\), then follower UAV drone \(i\) does not directly receive leader information.
| Matrix | Definition | Role in multi-UAV drone coordination |
|---|---|---|
| \(A=[a_{ij}]\) | Adjacency matrix | Determines which UAV drones exchange velocity information |
| \(D=\operatorname{diag}(d_i)\) | Degree matrix | Counts weighted communication links of each UAV drone |
| \(L=D-A\) | Laplacian matrix | Encodes consensus coupling among follower UAV drones |
| \(B=\operatorname{diag}(b_i)\) | Leader connection matrix | Indicates direct leader information for follower UAV drones |
| \(L+B\) | Augmented matrix | Positive definite under the connected topology assumption |
I assume that at least one path exists from the leader UAV drone to every follower UAV drone in the augmented graph. Under this assumption, the matrix \(L+B\) is symmetric positive definite. This property is important because it allows me to relate the local reference tracking error to the leader tracking error for all UAV drones.
Distributed Reference Velocity for Each UAV Drone
I do not require every follower UAV drone to communicate directly with the leader UAV drone. Instead, I generate a local reference velocity using neighbor information. For the \(i\)-th follower UAV drone, I define
$$
V_{id} =
\frac{\sum_{j\in N_i} a_{ij}V_j + b_iV_0}
{\sum_{j\in N_i} a_{ij} + b_i}.
$$
This expression is a weighted average of the velocities of neighboring UAV drones and, when available, the leader UAV drone velocity. The denominator is nonzero because each follower UAV drone has at least one neighbor or a direct leader connection. The reference velocity \(V_{id}\) is available locally to the \(i\)-th UAV drone, which is a key advantage for distributed implementation.
I define two tracking errors. The first is the error between the actual velocity of the \(i\)-th follower UAV drone and its distributed reference velocity:
$$
e_{i1} = V_i – V_{id}.
$$
The second is the error between the actual velocity of the \(i\)-th follower UAV drone and the leader UAV drone velocity:
$$
e_{i2} = V_i – V_0 .
$$
I now derive the relationship between these two errors. Substituting the reference velocity definition yields
$$
e_{i1}
=
V_i –
\frac{\sum_{j\in N_i} a_{ij}V_j + b_iV_0}
{\sum_{j\in N_i} a_{ij} + b_i}.
$$
Multiplying by the denominator gives
$$
\left(\sum_{j\in N_i} a_{ij} + b_i\right)e_{i1}
=
\sum_{j\in N_i} a_{ij}(V_i-V_j) + b_i(V_i-V_0).
$$
Because \(V_i-V_j=(V_i-V_0)-(V_j-V_0)=e_{i2}-e_{j2}\), I can rewrite the relation in graph form. For the entire network of follower UAV drones, I obtain
$$
(D+B)e_{i1} = (L+B)e_{i2}.
$$
Under the assumption that the augmented graph is connected, \(L+B\) is positive definite. Therefore,
$$
\|e_{i1}\|
\le
\frac{\lambda_{\max}(D+B)}{\sigma_{\min}(L+B)}
\|e_{i2}\|.
$$
This inequality shows that if the local reference tracking error \(e_{i1}\) is uniformly ultimately bounded, then the leader tracking error \(e_{i2}\) is also uniformly ultimately bounded. In other words, distributed velocity consensus with the local reference implies velocity agreement with the leader UAV drone.
| Condition | Implication for UAV drones |
|---|---|
| \(e_{i1}\to 0\) | Each follower UAV drone reaches its distributed reference velocity |
| \(e_{i2}\to 0\) | Each follower UAV drone reaches the leader UAV drone velocity |
| Small \(\|e_{i1}\|\) | Small \(\|e_{i2}\|\) under connected topology |
| \(L+B\) positive definite | Consensus coupling is well-posed for all follower UAV drones |
Tracking Error Dynamics
I now derive the second-order error dynamics used for sliding mode design. The local tracking error is \(e_{i1}=V_i-V_{id}\). Differentiating once gives
$$
\dot{e}_{i1} = \dot{V}_i – \dot{V}_{id}.
$$
Differentiating again and using the faulty UAV drone dynamics yields
$$
\ddot{e}_{i1}
=
\lambda \dot{U}_i + D_i – \ddot{V}_{id}.
$$
This equation contains three uncertain or nonlinear effects: the unknown actuator efficiency \(\lambda\), the unknown lumped uncertainty derivative \(D_i\), and the reference acceleration \(\ddot{V}_{id}\). I compensate the first two by adaptive estimation and robust sliding mode control. The reference acceleration is computed from available neighbor information.
Non-Singular Fast Terminal Sliding Surface
I construct the sliding surface for each follower UAV drone as
$$
s_i = \dot{e}_{i1} + k_1 e_{i1} + k_2 e_{i1}^{q/p},
$$
where \(k_1>0\), \(k_2>0\), and the exponents satisfy
$$
1 < \frac{q}{p} < 2.
$$
The term \(e_{i1}^{q/p}\) is interpreted component-wise. The condition \(q/p>1\) provides fast convergence near the origin, while \(q/p<2\) avoids the singularity that can occur in conventional terminal sliding mode when the derivative of a fractional power is taken. This is the reason I call the surface non-singular fast terminal sliding mode.
Differentiating the sliding surface gives
$$
\dot{s}_i
=
\ddot{e}_{i1}
+
k_1\dot{e}_{i1}
+
k_2\frac{q}{p}
e_{i1}^{q/p-1}
\dot{e}_{i1}.
$$
Substituting the error dynamics, I obtain the open-loop sliding dynamics
$$
\dot{s}_i
=
\lambda \dot{U}_i
+
D_i
–
\ddot{V}_{id}
+
k_1\dot{e}_{i1}
+
k_2\frac{q}{p}
e_{i1}^{q/p-1}
\dot{e}_{i1}.
$$
This equation is the basis for my controller. The control signal must cancel known terms and dominate unknown terms. Because \(\lambda\) and \(D_i\) are unknown, I estimate them adaptively.
| Term | Source | Treatment |
|---|---|---|
| \(\lambda \dot{U}_i\) | Actuator efficiency fault | Adaptive inverse efficiency estimate \(\hat{\rho}\) |
| \(D_i\) | Disturbance and bias fault derivative | Adaptive estimate \(\hat{D}_i\) |
| \(\ddot{V}_{id}\) | Distributed reference acceleration | Computed from neighbor information |
| \(k_1\dot{e}_{i1}\) | Linear error feedback | Known and included in controller |
| \(k_2\frac{q}{p}e_{i1}^{q/p-1}\dot{e}_{i1}\) | Fast terminal correction | Known and included in controller |
Adaptive Estimation of Actuator Faults and Disturbances
I define the inverse actuator efficiency as
$$
\rho = \frac{1}{\lambda}.
$$
Because \(0<\lambda\le 1\), the inverse satisfies \(\rho\ge 1\). I denote its estimate by \(\hat{\rho}\) and the estimation error by
$$
\tilde{\rho} = \rho – \hat{\rho}.
$$
Similarly, I denote the estimate of the lumped uncertainty derivative by \(\hat{D}_i\), and the estimation error by
$$
\tilde{D}_i = D_i – \hat{D}_i.
$$
The adaptive laws are designed so that the sliding variable drives both estimates toward the true values. I choose
$$
\dot{\hat{\rho}} = s_i \gamma_1 \operatorname{sgn}(\lambda) z,
$$
and
$$
\dot{\hat{D}}_i = \gamma_2 s_i,
$$
where \(\gamma_1>0\) and \(\gamma_2>0\) are adaptation gains. The auxiliary signal \(z\) is
$$
z =
k_3 s_i
+
k_4 \operatorname{sgn}(s_i)
+
\eta s_i^{q/p}
+
\hat{D}_i
–
\ddot{V}_{id}
+
k_1\dot{e}_{i1}
+
k_2\frac{q}{p}
e_{i1}^{q/p-1}
\dot{e}_{i1}.
$$
Here \(k_3>0\), \(k_4>0\), and \(\eta>0\) are controller gains. The sign function provides robustness against the residual estimation error. The fractional power term \(\eta s_i^{q/p}\) enforces finite-time convergence on the sliding surface.
| Adaptive quantity | Update law | Purpose |
|---|---|---|
| \(\hat{\rho}\) | \(\dot{\hat{\rho}} = s_i \gamma_1 \operatorname{sgn}(\lambda) z\) | Estimates inverse actuator efficiency |
| \(\hat{D}_i\) | \(\dot{\hat{D}}_i = \gamma_2 s_i\) | Estimates disturbance and bias fault derivative |
| \(\tilde{\rho}\) | \(\tilde{\rho}=\rho-\hat{\rho}\) | Inverse efficiency estimation error |
| \(\tilde{D}_i\) | \(\tilde{D}_i=D_i-\hat{D}_i\) | Uncertainty estimation error |
Distributed Fault-Tolerant Controller
Using the sliding surface, the adaptive estimates, and the auxiliary signal \(z\), I design the control derivative for each follower UAV drone as
$$
\dot{U}_i
=
-\hat{\rho}
\left(
k_3 s_i
+
k_4 \operatorname{sgn}(s_i)
+
\eta s_i^{q/p}
+
\hat{D}_i
–
\ddot{V}_{id}
+
k_1\dot{e}_{i1}
+
k_2\frac{q}{p}
e_{i1}^{q/p-1}
\dot{e}_{i1}
\right).
$$
Equivalently, I can write
$$
\dot{U}_i = -\hat{\rho} z.
$$
This controller is distributed because \(V_{id}\), \(\ddot{V}_{id}\), and the neighboring velocities are obtained only from local communication. The controller does not require the full state of every UAV drone. It also does not require prior knowledge of the actuator efficiency \(\lambda\) or the disturbance bound. The adaptive laws estimate these effects online.
| Controller component | Expression | Function |
|---|---|---|
| Equivalent compensation | \(-\hat{\rho}\hat{D}_i + \hat{\rho}\ddot{V}_{id}\) | Canceles estimated uncertainty and reference acceleration |
| Linear sliding term | \(-\hat{\rho} k_3 s_i\) | Stabilizes the sliding dynamics |
| Robust term | \(-\hat{\rho} k_4 \operatorname{sgn}(s_i)\) | Rejects residual estimation error |
| Fast terminal term | \(-\hat{\rho}\eta s_i^{q/p}\) | Accelerates finite-time convergence |
| Error correction | \(-\hat{\rho}(k_1\dot{e}_{i1}+k_2\frac{q}{p}e_{i1}^{q/p-1}\dot{e}_{i1})\) | Shapes the sliding manifold dynamics |
Stability Analysis
I prove closed-loop stability using a Lyapunov function that includes the sliding variable and the adaptive estimation errors. I choose
$$
V
=
\frac{1}{2}s_i^T s_i
+
\frac{\lambda}{2\gamma_1}\tilde{\rho}^2
+
\frac{1}{2\gamma_2}\tilde{D}_i^T \tilde{D}_i .
$$
Because \(\lambda>0\), \(\gamma_1>0\), and \(\gamma_2>0\), this function is positive definite. Differentiating gives
$$
\dot{V}
=
s_i^T \dot{s}_i
–
\frac{\lambda}{\gamma_1}\tilde{\rho}\dot{\hat{\rho}}
–
\frac{1}{\gamma_2}\tilde{D}_i^T \dot{\hat{D}}_i .
$$
Substituting the open-loop sliding dynamics and the adaptive laws yields
$$
\dot{V}
=
s_i^T
\left(
\lambda \dot{U}_i
+
D_i
–
\ddot{V}_{id}
+
k_1\dot{e}_{i1}
+
k_2\frac{q}{p}
e_{i1}^{q/p-1}
\dot{e}_{i1}
\right)
–
\frac{\lambda}{\gamma_1}\tilde{\rho}\dot{\hat{\rho}}
–
\frac{1}{\gamma_2}\tilde{D}_i^T \dot{\hat{D}}_i .
$$
Using the controller \(\dot{U}_i=-\hat{\rho}z\) and the definition of \(z\), I obtain
$$
\dot{V}
=
s_i^T
\left(
-\lambda\hat{\rho}z
+
D_i
–
\ddot{V}_{id}
+
k_1\dot{e}_{i1}
+
k_2\frac{q}{p}
e_{i1}^{q/p-1}
\dot{e}_{i1}
\right)
–
\frac{\lambda}{\gamma_1}\tilde{\rho}\dot{\hat{\rho}}
–
\frac{1}{\gamma_2}\tilde{D}_i^T \dot{\hat{D}}_i .
$$
Because \(\lambda\hat{\rho}=\lambda(\rho-\tilde{\rho})=1-\lambda\tilde{\rho}\), the expression simplifies. After cancelling the known terms and applying the adaptive laws, I get
$$
\dot{V}
=
s_i^T
\left(
-\eta s_i^{q/p}
–
k_3 s_i
–
k_4 \operatorname{sgn}(s_i)
\right).
$$
Thus
$$
\dot{V}
=
-\eta s_i^T s_i^{q/p}
–
k_3 s_i^T s_i
–
k_4 \|s_i\|_1
\le 0.
$$
This inequality shows that the sliding variable and the estimation errors are bounded. Since \(\dot{V}\le 0\), the closed-loop system is stable in the Lyapunov sense. Moreover, the sliding variable converges to the origin.
To establish finite-time convergence, I use the inequality
$$
\dot{V}
\le
-\eta (s_i^T s_i)^{(q/p+1)/2}.
$$
Let
$$
\alpha = \frac{q/p+1}{2}.
$$
Because \(1<q \(0<\alpha<1\)="" \(1<\alpha<1.5\),="" and="" bound="" chosen="" condition="" convergence="" derivation,="" directly="" exponent="" finite-time="" form.="" form<="" have="" i="" in="" is="" met.="" not="" original="" p="" p
$$
\dot{V} \le -c V^\alpha ,
$$
with \(c>0\) and \(0<\alpha<1\). Under this condition, the settling time satisfies
$$
t
\le
\frac{V(0)^{1-\alpha}}{c(1-\alpha)}.
$$
Therefore, the sliding surface reaches the equilibrium in finite time, and the velocity tracking error converges in finite time. This is the finite-time fault-tolerant tracking property of the proposed distributed controller.
| Lyapunov term | Expression | Interpretation |
|---|---|---|
| Sliding energy | \(\frac{1}{2}s_i^T s_i\) | Distance from the sliding manifold |
| Efficiency estimation error | \(\frac{\lambda}{2\gamma_1}\tilde{\rho}^2\) | Error in inverse actuator efficiency estimate |
| Uncertainty estimation error | \(\frac{1}{2\gamma_2}\tilde{D}_i^T\tilde{D}_i\) | Error in lumped uncertainty estimate |
| Derivative bound | \(\dot{V}\le 0\) | Closed-loop stability |
| Finite-time bound | \(t\le V(0)^{1-\alpha}/[c(1-\alpha)]\) | Finite-time convergence guarantee |
Numerical Simulation Setup
I validate the proposed algorithm with a numerical simulation of a multi-UAV drone formation. The group contains one leader UAV drone and four follower UAV drones. The communication topology is undirected among the follower UAV drones, and the leader UAV drone is connected to a subset of followers. I select the adjacency matrix and degree matrix as follows:
$$
A=
\begin{bmatrix}
0 & 1 & 1 & 1\\
1 & 0 & 1 & 0\\
1 & 1 & 0 & 1\\
1 & 0 & 1 & 0
\end{bmatrix},
\qquad
D=
\begin{bmatrix}
3 & 0 & 0 & 0\\
0 & 2 & 0 & 0\\
0 & 0 & 3 & 0\\
0 & 0 & 0 & 2
\end{bmatrix}.
$$
The corresponding Laplacian is \(L=D-A\). The leader connection matrix is chosen such that the augmented graph is connected. This ensures that the matrix \(L+B\) is positive definite and that the distributed reference velocities propagate leader information through the network.
I set the controller parameters as follows:
| Parameter | Value | Role |
|---|---|---|
| \(k_1\) | 40 | Linear error feedback gain |
| \(k_2\) | 26 | Fast terminal sliding gain |
| \(q\) | 5 | Terminal sliding exponent numerator |
| \(p\) | 3 | Terminal sliding exponent denominator |
| \(k_3\) | 0.9 | Linear sliding mode gain |
| \(k_4\) | 7 | Robust sign term gain |
| \(\gamma_1\) | 0.05 | Adaptation gain for inverse efficiency |
| \(\gamma_2\) | 55 | Adaptation gain for lumped uncertainty |
The leader UAV drone velocity is selected as
$$
V_0 = 10\sin(0.13\pi t).
$$
The combined bias fault and external disturbance is selected as
$$
\Delta_i = 5\sin(0.1\pi t).
$$
At \(t=15\) s, I inject a partial loss-of-effectiveness fault into the third follower UAV drone and set the actuator efficiency to
$$
\lambda = 0.3.
$$
This fault creates a sudden reduction in control authority. The controller must estimate the changed efficiency and compensate the resulting tracking error. The remaining follower UAV drones continue to operate with their own disturbances and bias terms.
| Simulation element | Setting |
|---|---|
| Number of leader UAV drones | 1 |
| Number of follower UAV drones | 4 |
| Communication graph | Undirected follower topology with leader connections |
| Leader velocity | \(V_0=10\sin(0.13\pi t)\) |
| Bias and disturbance | \(\Delta_i=5\sin(0.1\pi t)\) |
| Fault injection time | \(t=15\) s |
| Faulty UAV drone | Third follower UAV drone |
| Actuator efficiency after fault | \(\lambda=0.3\) |
Simulation Results and Interpretation
I examine the reference velocity tracking first. Each follower UAV drone computes its own reference velocity from neighbor information and, where available, leader information. The four reference velocities converge toward the leader UAV drone velocity. This confirms that the distributed reference generator successfully propagates the leader motion through the multi-UAV drone network.
Next, I examine the actual velocities of the follower UAV drones. The four follower velocities track the leader velocity with small errors. Before the fault, the tracking errors settle quickly after the initial transient. After the fault is injected at \(t=15\) s, the faulty UAV drone experiences a temporary deviation. The adaptive estimator responds to the change in actuator efficiency, and the non-singular fast terminal sliding mode controller compensates the fault. The velocity error returns to a small neighborhood of zero within approximately two seconds.
| Time interval | Observed behavior of UAV drones | Controller response |
|---|---|---|
| \(0\) to \(2\) s | Initial transient in velocity errors | Sliding surface converges rapidly |
| \(2\) to \(15\) s | Stable tracking with small bounded error | Adaptive estimates remain bounded |
| \(15\) s | Partial loss-of-effectiveness fault in one UAV drone | Adaptive gains adjust to new fault level |
| \(15\) to \(17\) s | Temporary error increase and recovery | Fault compensation and finite-time correction |
| After \(17\) s | Velocity consensus restored | Sliding variable remains near zero |
The error between each follower velocity and its distributed reference velocity is another important quantity. This error remains bounded and converges to a small region around zero. The fault at \(t=15\) s causes a visible but short-lived perturbation. The recovery time is short because the adaptive law updates the inverse efficiency estimate and the uncertainty estimate. The sliding mode term then drives the error back to the manifold.
The error between each follower velocity and the leader velocity also remains bounded. The fault produces a relatively small fluctuation in the leader tracking error. This indicates that the distributed reference mechanism and the local fault-tolerant controller work together to preserve group-level coordination. The faulty UAV drone does not destabilize the formation, and the other UAV drones continue to track the leader.
I also examine the velocity tracking error between adjacent follower UAV drones. This is a direct measure of velocity consensus among the follower UAV drones. The errors converge to a small neighborhood of zero, which means that the follower UAV drones reach velocity consensus. This result supports the theoretical relation between local reference tracking and leader tracking. Because the reference velocities are generated from neighbor information, consensus among follower UAV drones emerges without centralized coordination.
| Performance indicator | Before fault | After fault | Interpretation |
|---|---|---|---|
| Reference velocity tracking | Converges in about 1–2 s | Converges after small transient | Distributed reference is effective |
| Leader velocity tracking | Small bounded error | Small fluctuation then recovery | Leader coordination is preserved |
| Neighbor velocity consensus | Errors approach zero | Errors return to near zero | Follower UAV drones remain consensus-capable |
| Adaptive efficiency estimate | Near nominal value | Adjusts to \(\lambda=0.3\) | Actuator fault is estimated online |
| Adaptive uncertainty estimate | Bounded | Bounded after fault | Disturbance and bias effects are compensated |
Adaptive Parameter Behavior
The adaptive parameters show clear changes after the fault is introduced. The estimate of the inverse actuator efficiency increases because the true efficiency decreases from \(1\) to \(0.3\). The estimate of the lumped uncertainty derivative also changes to compensate the bias and disturbance effects. Both estimates converge within a short time after the fault. The boundedness of the adaptive parameters is consistent with the Lyapunov analysis.
| Adaptive signal | Behavior before fault | Behavior after fault |
|---|---|---|
| \(\hat{\rho}\) | Close to nominal inverse efficiency | Increases as \(\lambda\) decreases |
| \(\hat{D}_i\) | Tracks disturbance and bias derivative | Re-adjusts to new fault condition |
| \(\tilde{\rho}\) | Small estimation error | Transient error then reduction |
| \(\tilde{D}_i\) | Small bounded error | Transient error then reduction |
Why the Method Works for Multiple UAV Drones
The method works because it separates the cooperative problem into two layers. The first layer is distributed reference generation. Each UAV drone uses local neighbor information to form a reference velocity that is consistent with the group motion. The second layer is local fault-tolerant tracking. Each UAV drone uses adaptive estimation and sliding mode control to track its own reference despite actuator faults and disturbances. This separation is useful for multi-UAV drone systems because it avoids a single point of communication failure and reduces the need for global state information.
I can summarize the cooperative control logic as follows:
$$
V_{id}
=
\frac{\sum_{j\in N_i} a_{ij}V_j + b_iV_0}
{\sum_{j\in N_i} a_{ij} + b_i},
$$
$$
e_{i1}=V_i-V_{id},
$$
$$
s_i=\dot{e}_{i1}+k_1 e_{i1}+k_2 e_{i1}^{q/p},
$$
$$
\dot{U}_i=-\hat{\rho}z,
$$
$$
\dot{\hat{\rho}}=s_i\gamma_1\operatorname{sgn}(\lambda)z,
\qquad
\dot{\hat{D}}_i=\gamma_2 s_i .
$$
These equations define the complete distributed fault-tolerant cooperative controller for UAV drones. The controller uses only local measurements and neighbor communication. It does not require a central supervisor. It is robust to actuator bias faults, partial loss-of-effectiveness faults, and external disturbances.
| Layer | Function | Information needed |
|---|---|---|
| Distributed reference layer | Generate \(V_{id}\) for each follower UAV drone | Neighbor velocities and leader velocity if available |
| Adaptive estimation layer | Estimate \(\rho\) and \(D_i\) | Local sliding variable and error signals |
| Sliding mode layer | Compute \(\dot{U}_i\) | Local errors and adaptive estimates |
| Consensus layer | Ensure velocity agreement among UAV drones | Graph connectivity and local couplings |
Parameter Selection and Practical Considerations
I select the gains \(k_1\), \(k_2\), \(k_3\), \(k_4\), \(\eta\), \(\gamma_1\), and \(\gamma_2\) to balance convergence speed, robustness, and chattering. Larger \(k_1\) and \(k_2\) increase the speed of error convergence but can amplify noise. Larger \(k_3\) strengthens the linear sliding mode attraction. Larger \(k_4\) improves rejection of residual estimation error but may increase chattering because of the sign function. The adaptation gains \(\gamma_1\) and \(\gamma_2\) determine how fast the estimates respond to faults. If they are too small, the fault compensation is slow. If they are too large, the estimates may oscillate.
| Gain | Effect of increasing | Practical caution |
|---|---|---|
| \(k_1\) | Faster linear error correction | May amplify measurement noise |
| \(k_2\) | Faster terminal sliding convergence | Too large may cause aggressive response |
| \(k_3\) | Stronger sliding mode attraction | May increase control effort |
| \(k_4\) | Better robustness to estimation error | May increase chattering |
| \(\eta\) | Stronger finite-time term | Needs tuning with \(q/p\) |
| \(\gamma_1\) | Faster efficiency estimation | Too large may cause oscillation |
| \(\gamma_2\) | Faster uncertainty estimation | Too large may amplify noise |
In practical UAV drone implementation, I would replace the sign function with a saturation function or a boundary layer approximation to reduce chattering. I would also impose saturation limits on the control input and adaptive parameters. These modifications preserve the main stability properties in a practical sense and make the controller more suitable for real UAV drone autopilots. The distributed reference generator can be implemented using onboard communication modules, and the adaptive laws can be updated at the same rate as the inner-loop velocity controller.
Comparison with Alternative Cooperative Control Strategies
I compare the proposed method with several alternative strategies for multi-UAV drone cooperative control. A centralized method can coordinate all UAV drones directly, but it requires a central node and full communication. A decentralized method can reduce communication, but it may not explicitly compensate actuator faults. A standard sliding mode controller can reject disturbances, but it may not handle unknown actuator efficiency and may suffer from singularity. The proposed distributed adaptive non-singular fast terminal sliding mode method combines the advantages of distributed consensus, adaptive fault estimation, and finite-time robustness.
| Method | Communication requirement | Fault handling | Finite-time property | Suitability for UAV drones |
|---|---|---|---|---|
| Centralized cooperative control | High, full network state | Can be designed, but central point vulnerable | Depends on design | Limited scalability |
| Decentralized control without adaptation | Low | Weak for unknown actuator faults | Usually asymptotic | Simple but less robust |
| Standard sliding mode | Local | Disturbance rejection only | Possible | Chattering and singularity issues |
| Adaptive consensus | Local | Handles uncertain parameters | Often asymptotic | Good but slower fault recovery |
| Proposed distributed fault-tolerant method | Local neighbor information | Estimates bias, disturbance, and efficiency loss | Yes, non-singular fast terminal | Scalable and robust for multi-UAV drones |
Robustness to Fault Severity and Disturbance Magnitude
I also consider how the controller behaves when the fault severity changes. If the efficiency factor \(\lambda\) decreases, the inverse efficiency \(\rho\) increases. The adaptive estimate \(\hat{\rho}\) increases accordingly. The control input magnitude also increases because the controller tries to maintain tracking performance. If the actuator is severely degraded but still partially effective, the controller can compensate as long as the control input remains within saturations and the fault does not become total. If the actuator becomes completely ineffective, the mathematical model with \(\lambda=0\) loses controllability in the affected axis, and no controller can recover tracking without redundancy. Therefore, the proposed method is best suited to partial loss-of-effectiveness faults, which are common in practical UAV drone actuator degradation.
| Efficiency \(\lambda\) | Inverse \(\rho\) | Control authority | Expected controller behavior |
|---|---|---|---|
| 1.0 | 1.0 | Full | Nominal tracking |
| 0.7 | 1.43 | Reduced | Adaptive gain increases moderately |
| 0.5 | 2.0 | Half | Stronger compensation |
| 0.3 | 3.33 | Low | Significant adaptation and fast recovery |
| 0.1 | 10.0 | Very low | High control effort; saturation may occur |
| 0.0 | Infinite | None | Uncontrollable without redundancy |
For disturbance magnitude, the adaptive estimate \(\hat{D}_i\) changes with the disturbance derivative. Larger disturbances require larger control effort. The sliding mode term \(k_4\operatorname{sgn}(s_i)\) provides robustness against the residual estimation error. The bound \(\|D_i\|\le\delta_i\) ensures that the uncertainty derivative does not grow without limit. In practice, I can choose \(k_4\) to exceed the expected residual estimation error bound.
Finite-Time Convergence and Consensus Interpretation
The finite-time property is important for multi-UAV drone coordination because it provides a stronger guarantee than asymptotic convergence. After a fault, the tracking error reaches a small neighborhood of zero in finite time rather than merely approaching zero as time goes to infinity. The non-singular fast terminal sliding surface combines a linear term and a fractional power term. The linear term dominates far from the origin, while the fractional power term accelerates convergence near the origin. The non-singular condition \(1<q a="" arise="" avoids="" derivative="" exponent.<="" fractional="" if="" negative="" of="" p="" p
I can express the convergence behavior conceptually as follows. The sliding variable satisfies
$$
\dot{s}_i = -\eta s_i^{q/p} – k_3 s_i – k_4 \operatorname{sgn}(s_i) + \text{residual terms}.
$$
Under the adaptive laws, the residual terms are bounded and are dominated by the robust term. Therefore, the sliding variable reaches the manifold in finite time. Once on the manifold, the error dynamics satisfy
$$
\dot{e}_{i1} + k_1 e_{i1} + k_2 e_{i1}^{q/p} = 0.
$$
This reduced-order dynamics also converges in finite time. Hence the velocity tracking error of each UAV drone converges in finite time, and the velocity consensus among UAV drones is achieved in finite time.
| Stage | Dynamics | Convergence property |
|---|---|---|
| Reaching stage | \(\dot{s}_i\) driven by robust and adaptive terms | Finite-time reachability |
| Sliding stage | \(\dot{e}_{i1}+k_1e_{i1}+k_2e_{i1}^{q/p}=0\) | Finite-time error convergence |
| Consensus stage | \(e_{i1}\to0\), \(e_{i2}\to0\) | Velocity consensus among UAV drones |
Implementation Architecture for Multi-UAV Drones
I envision the implementation of the proposed algorithm as an onboard module for each UAV drone. The module receives velocity measurements from its own sensors, receives neighbor velocity estimates through a communication link, and receives the leader velocity if a direct leader connection exists. It computes \(V_{id}\) and \(\ddot{V}_{id}\), updates the sliding surface \(s_i\), updates the adaptive estimates \(\hat{\rho}\) and \(\hat{D}_i\), and computes the control derivative \(\dot{U}_i\). The control derivative is integrated or passed to the inner-loop velocity controller. The inner-loop controller then generates motor commands for the UAV drone.
| Module | Input | Output | Onboard requirement |
|---|---|---|---|
| Communication | Neighbor velocities, leader velocity if available | Local neighbor information | Wireless link and message parsing |
| Reference generator | Neighbor velocities, leader velocity | \(V_{id}\), \(\ddot{V}_{id}\) | Low computation |
| Error calculator | \(V_i\), \(V_{id}\) | \(e_{i1}\), \(\dot{e}_{i1}\) | Differentiation or filtering |
| Sliding surface | \(e_{i1}\), \(\dot{e}_{i1}\) | \(s_i\) | Fractional power computation |
| Adaptive estimator | \(s_i\), \(z\) | \(\hat{\rho}\), \(\hat{D}_i\) | Numerical integration |
| Controller | \(s_i\), \(\hat{\rho}\), \(\hat{D}_i\) | \(\dot{U}_i\) | Control allocation |
Practical Modifications and Safety Constraints
For real UAV drones, I would include several practical modifications. First, I would use a smooth approximation of the sign function to reduce chattering. For example, I can replace \(\operatorname{sgn}(s_i)\) with \(\tanh(\kappa s_i)\) for a positive constant \(\kappa\). Second, I would limit the adaptive parameters to a feasible range. Third, I would impose a maximum control input magnitude. Fourth, I would use a low-pass filter for velocity derivatives to reduce noise. These modifications do not change the core distributed fault-tolerant structure, but they improve real-world applicability.
| Practical issue | Modification | Benefit for UAV drones |
|---|---|---|
| Chattering | Boundary layer or \(\tanh\) | Smoother actuator commands |
| Parameter drift | Projection operator on adaptive laws | Bounded estimates |
| Control saturation | Saturation function and anti-windup | Safe actuator operation |
| Measurement noise | Filtered derivatives | Reduced high-frequency switching |
| Communication delay | Predictor or delay-compensating buffer | Improved coordination |
Extensions to Time-Varying Topologies and Heterogeneous UAV Drones
I can extend the framework to time-varying communication topologies by allowing \(A(t)\), \(D(t)\), and \(L(t)\) to vary with time. The augmented matrix \(L(t)+B(t)\) must remain positive definite or satisfy a dwell-time condition. Under such conditions, the distributed reference generator and the adaptive sliding mode controller can still maintain bounded tracking. For heterogeneous UAV drones with different dynamics, I can include additional adaptive terms for the model mismatch. The core idea remains the same: local reference generation, adaptive uncertainty estimation, and non-singular fast terminal sliding mode tracking.
| Extension | Required modification | Expected outcome |
|---|---|---|
| Time-varying topology | Use \(L(t)+B(t)\) and dwell-time analysis | Bounded consensus under switching |
| Heterogeneous UAV drones | Add model mismatch adaptation | Improved tracking for different UAV drone types |
| Input saturation | Add anti-windup and saturation-aware adaptation | Safe control with bounded inputs |
| Communication delay | Use delayed neighbor information with compensation | Robustness to network latency |
| Output feedback only | Add observer for velocity derivative | Implementation with limited sensing |
Summary of the Main Mathematical Results
I summarize the main equations in one table for clarity. These equations define the proposed distributed fault-tolerant cooperative control algorithm for multiple UAV drones under actuator failures and external disturbances.
| Result | Equation |
|---|---|
| Faulty UAV drone dynamics | \(\dot{V}_i=\lambda U_i+\Delta_i\) |
| Second-order dynamics | \(\ddot{V}_i=\lambda\dot{U}_i+D_i\) |
| Distributed reference velocity | \(V_{id}=\frac{\sum_{j\in N_i}a_{ij}V_j+b_iV_0}{\sum_{j\in N_i}a_{ij}+b_i}\) |
| Local tracking error | \(e_{i1}=V_i-V_{id}\) |
| Leader tracking error | \(e_{i2}=V_i-V_0\) |
| Error relation | \((D+B)e_{i1}=(L+B)e_{i2}\) |
| Tracking error dynamics | \(\ddot{e}_{i1}=\lambda\dot{U}_i+D_i-\ddot{V}_{id}\) |
| Sliding surface | \(s_i=\dot{e}_{i1}+k_1e_{i1}+k_2e_{i1}^{q/p}\) |
| Control derivative | \(\dot{U}_i=-\hat{\rho}z\) |
| Auxiliary signal | \(z=k_3s_i+k_4\operatorname{sgn}(s_i)+\eta s_i^{q/p}+\hat{D}_i-\ddot{V}_{id}+k_1\dot{e}_{i1}+k_2\frac{q}{p}e_{i1}^{q/p-1}\dot{e}_{i1}\) |
| Adaptive law for \(\rho\) | \(\dot{\hat{\rho}}=s_i\gamma_1\operatorname{sgn}(\lambda)z\) |
| Adaptive law for \(D_i\) | \(\dot{\hat{D}}_i=\gamma_2s_i\) |
| Lyapunov function | \(V=\frac12s_i^Ts_i+\frac{\lambda}{2\gamma_1}\tilde{\rho}^2+\frac{1}{2\gamma_2}\tilde{D}_i^T\tilde{D}_i\) |
| Stability inequality | \(\dot{V}\le-\eta(s_i^Ts_i)^{(q/p+1)/2}\) |
| Finite-time bound | \(t\le\frac{V(0)^{1-\alpha}}{c(1-\alpha)}\) |
Discussion of the Simulation Outcomes
The numerical simulation confirms that the proposed method achieves the intended behavior. Before the fault, the follower UAV drones track their reference velocities and the leader velocity with small errors. After the fault, the third follower UAV drone experiences a sudden reduction in actuator effectiveness. The adaptive estimator detects the change through the sliding variable and updates the inverse efficiency estimate. The non-singular fast terminal sliding mode controller then compensates the fault. The velocity error returns to a small neighborhood of zero within a short time. The other follower UAV drones remain stable, and the overall velocity consensus is preserved.
I also observe that the adaptive estimates remain bounded. This is important because unbounded adaptive parameters could cause large control inputs and destabilize the UAV drone. The Lyapunov analysis guarantees boundedness under the stated assumptions. The simulation results are consistent with this guarantee. The reference velocity tracking errors and the leader tracking errors both remain small after the fault recovery. The neighbor velocity errors converge to a small region around zero, which indicates velocity consensus among the follower UAV drones.
| Observation | Interpretation | Relevance to UAV drones |
|---|---|---|
| Reference velocities track leader velocity | Distributed reference generation works | Scalable coordination without central leader broadcast |
| Follower velocities track leader velocity | Fault-tolerant tracking works | Formation maintains leader motion |
| Fault recovery within about 2 s | Adaptive compensation is fast | Reduced disruption after actuator fault |
| Neighbor errors approach zero | Velocity consensus is achieved | Coordinated motion among UAV drones |
| Adaptive estimates converge | Unknown fault and disturbance are learned | Reduced need for prior fault information |
Limitations and Future Directions
My current work focuses on follower UAV drone faults and does not fully address leader UAV drone faults. If the leader UAV drone itself experiences an actuator fault, the reference velocity may be affected, and the follower UAV drones may not have a reliable leader signal. Future work should include leader fault detection and leader state estimation. Another limitation is that the simulation is numerical rather than experimental. Future work should validate the algorithm on physical UAV drones with onboard processors, communication modules, and real actuator faults. I also plan to study event-triggered communication to reduce network usage among UAV drones. Finally, I plan to investigate time-varying topologies, communication delays, and input saturation in more detail.
| Limitation | Future direction | Expected benefit |
|---|---|---|
| Leader UAV drone faults not fully addressed | Leader fault detection and estimation | Improved robustness of the whole multi-UAV drone group |
| Numerical simulation only | Hardware-in-the-loop and flight tests | Practical validation on real UAV drones |
| Continuous communication assumed | Event-triggered and intermittent communication | Lower communication load |
| Fixed topology assumed | Switching and time-varying graphs | More realistic multi-UAV drone networks |
| No explicit input saturation in proof | Saturation-aware adaptive control | Safer actuator operation |
Conclusion
I have presented a distributed fault-tolerant cooperative control algorithm for multiple UAV drones subject to simultaneous actuator failures and external disturbances. The method uses graph theory to generate a local reference velocity from neighbor information, adaptive laws to estimate actuator efficiency loss and lumped uncertainty, and a non-singular fast terminal sliding mode controller to compensate estimation errors and actuator faults. I proved closed-loop stability with a Lyapunov function and established finite-time convergence of the sliding variable and tracking error. The numerical simulation with one leader UAV drone and four follower UAV drones showed that the follower UAV drones track the leader velocity, maintain velocity consensus, and recover quickly after a partial loss-of-effectiveness fault. The proposed method reduces communication burden, avoids the need for a central coordinator, and provides strong robustness for multi-UAV drone cooperative missions. I believe this framework is a useful step toward practical fault-tolerant cooperative control for UAV drones operating in uncertain and faulty environments.