In this thesis, I focus on the attitude control problem of quadrotor unmanned aerial vehicles (UAVs) subject to actuator faults and external disturbances. The increasing deployment of quadrotor UAVs in military, agricultural, logistics and cinematography has raised the demand for high reliability and rapid response. However, since the four rotors serve as the only propulsion source, any motor failure can seriously degrade stability and may lead to a crash. To address this issue, I first revisit the nonlinear attitude model of a quadrotor UAV and develop two fault-tolerant control schemes. The first scheme is based on a finite-time adaptive non-singular fast terminal sliding mode controller combined with a finite-time disturbance observer. The second scheme improves the system by considering a more realistic time-varying health factor and a mismatched disturbance. A new fixed-time fault observer and a fixed-time anti-disturbance controller are designed to achieve faster convergence and stronger robustness. In parallel, I have built a complete experimental verification platform consisting of four stages: numerical simulation, software-in-the-loop simulation, hardware-in-the-loop simulation, and real flight tests. Both proposed control algorithms have been successfully deployed and verified on this platform. Throughout this thesis, the term ‘unmanned aerial vehicles’ refers specifically to quadrotor UAVs, which are the central research object. The main contributions are summarized as follows: (1) a finite-time fault-tolerant attitude controller is designed with an adaptive estimation law for the health factor; (2) a fixed-time fault observer and a fixed-time controller are developed to handle time-varying faults and mismatched disturbances; (3) a modular, streamlined and standardized experimental platform is constructed to validate different control algorithms for unmanned aerial vehicles. The effectiveness of all designs is confirmed by rigorous stability proofs, numerical simulations, and real flight experiments.
1. Introduction and Background
Unmanned aerial vehicles have become increasingly important in both civilian and military applications. Among all types of UAVs, the quadrotor is particularly popular due to its mechanical simplicity, vertical take-off and landing capability, and small footprint. However, the highly nonlinear and strongly coupled dynamics of a quadrotor make control design challenging. The system is underactuated, since only four control inputs are available to regulate six degrees of freedom. In addition, the low inertia of small quadrotor UAVs makes them extremely sensitive to internal parameter variations, sensor noise, and external wind disturbances. Furthermore, actuator faults are inevitable in long-duration missions. When one motor loses partial or complete effectiveness, the quadrotor’s attitude can become unstable, potentially causing a catastrophic crash. Therefore, the development of reliable and fast fault-tolerant control strategies is of great practical value.
In the field of fault-tolerant control, two main categories exist: passive fault-tolerant control (PFTC) and active fault-tolerant control (AFTC). PFTC designs a fixed robust controller that can tolerate predefined faults, whereas AFTC relies on a fault detection and isolation (FDI) mechanism and reconfigures the controller based on fault information. In this thesis, I adopt an active approach: a fault observer or an adaptive law is employed to estimate the fault severity, and the controller uses this estimate to compensate for the loss of actuator effectiveness. Many recent studies have explored similar ideas. For example, sliding mode observers have been proposed for actuator fault detection in quadrotor UAVs, and adaptive sliding mode controllers have been used to stabilize the attitude under partial loss of propulsion. Nevertheless, most existing methods remain at the numerical simulation stage and lack real-flight validation. To bridge this gap, I have designed a complete experimental platform that allows a control algorithm to be transferred from a Simulink model to a real quadrotor through automatic code generation. This platform provides a standardized pipeline for verifying any control algorithm for unmanned aerial vehicles, from pure mathematical simulation to outdoor flight.
2. Preliminaries and Quadrotor Attitude Model
2.1 Quadrotor Structure and Flight Principle
In this thesis, the quadrotor UAV is assumed to have an “X” configuration. The four rotors are numbered 1 to 4. Rotors 1 and 3 rotate counter-clockwise, while rotors 2 and 4 rotate clockwise. By adjusting the individual rotor speeds, the vehicle can achieve roll, pitch, and yaw rotations. The roll angle (\(\phi\)) denotes rotation about the body-fixed x-axis, the pitch angle (\(\theta\)) denotes rotation about the y-axis, and the yaw angle (\(\psi\)) denotes rotation about the z-axis. In the X configuration, the control allocation matrix that maps the virtual control inputs \(u_\phi, u_\theta, u_\psi\) and the total thrust \(u_p\) to the four motor forces \(F_1, F_2, F_3, F_4\) is given by:
\[
\begin{bmatrix}
u_p \\ u_\phi \\ u_\theta \\ u_\psi
\end{bmatrix}
=
\begin{bmatrix}
1 & 1 & 1 & 1 \\
-1 & 1 & 1 & -1 \\
1 & -1 & 1 & -1 \\
1 & -1 & -1 & 1
\end{bmatrix}
\begin{bmatrix}
F_1 \\ F_2 \\ F_3 \\ F_4
\end{bmatrix}.
\]
This relationship is crucial for understanding how motor faults affect the attitude dynamics. In the presence of a motor fault, the actual force produced by that motor is reduced by a factor \(\chi_i\) (the motor remaining effectiveness). Consequently, the effective control inputs become distorted, and the attitude model must be modified accordingly.
2.2 Attitude Dynamics
Assuming a rigid body and neglecting the rotational coupling terms, the simplified attitude dynamics of a quadrotor UAV can be written as:
\[
\begin{aligned}
\ddot{\phi} &= \frac{l}{I_1} u_\phi – \frac{K_1 l}{I_1} \dot{\phi}, \\
\ddot{\theta} &= \frac{l}{I_2} u_\theta – \frac{K_2 l}{I_2} \dot{\theta}, \\
\ddot{\psi} &= \frac{l}{I_3} u_\psi – \frac{K_3 l}{I_3} \dot{\psi},
\end{aligned}
\]
where \(I_1, I_2, I_3\) are the moments of inertia about the roll, pitch and yaw axes, \(K_1, K_2, K_3\) are the aerodynamic drag coefficients, and \(l\) is the distance from the center of mass to each motor. In this thesis, I consider the attitude control problem independently for each channel, since the three channels are symmetric and weakly coupled for small angles. Thus, the controller and observer designs are presented for the roll channel, and the same structure applies to the other two channels.
2.3 Stability Notions
Before presenting the controller designs, I introduce the definitions of finite-time stability and fixed-time stability.
Definition 1 (Finite-time stability): The origin of the system \(\dot{x}=f(x)\) with initial state \(x(0)=x_0\) is finite-time stable if it is asymptotically stable and there exists a settling time \(T(x_0) < \infty\) such that \(x(t)=0\) for all \(t \ge T(x_0)\).
Definition 2 (Fixed-time stability): The origin is fixed-time stable if it is finite-time stable and the settling time is uniformly bounded by a constant \(T_{\max}\) independent of the initial state, i.e. \(T(x_0) \le T_{\max}\) for all \(x_0 \in \mathbb{R}^n\).
Finite-time convergence provides faster response than asymptotic convergence, but the settling time depends on the initial condition. Fixed-time convergence removes this dependence, which is a significant advantage for quadrotor UAVs where the initial state can vary greatly. In the following sections, I first design a finite-time scheme, then improve it to a fixed-time scheme.
2.4 Model with Multiplicative Fault and Disturbance
In Chapter 3, I introduce a health factor \(\delta_i\) for each attitude channel, where \(i \in \{\phi,\theta,\psi\}\). This health factor represents the ratio between the actual control effectiveness and the nominal one, satisfying \(0 \le \delta_i \le 1\). A value of 1 means no fault, and 0 means complete loss of effectiveness in that virtual channel. Let the external disturbance be \(d_i\). Then the faulty attitude dynamics become:
\[
\begin{aligned}
\ddot{\phi} &= \delta_\phi \frac{l}{I_1} u_\phi – \frac{K_1 l}{I_1} \dot{\phi} + d_1, \\
\ddot{\theta} &= \delta_\theta \frac{l}{I_2} u_\theta – \frac{K_2 l}{I_2} \dot{\theta} + d_2, \\
\ddot{\psi} &= \delta_\psi \frac{l}{I_3} u_\psi – \frac{K_3 l}{I_3} \dot{\psi} + d_3.
\end{aligned}
\]
To simplify the controller design, I define the auxiliary variable \(\rho_i = 1/\delta_i\). Since \(\delta_i\) is a scalar and \(\rho_i\) appears as a multiplier in the compensation term, the resulting control signal may become extremely large when the fault is severe. This is a key drawback that motivates the new model in Chapter 4.
3. Finite-Time Adaptive Fault-Tolerant Control with Disturbance Observer
3.1 Disturbance Observer Design
In the first control scheme, I design a finite-time sliding mode disturbance observer to estimate the lumped disturbance \(d_1\) acting on the roll channel. The observer is designed under the assumption that the health factor estimate \(\hat{\rho}_\phi\) is available from the adaptive law. The model used for the observer is:
\[
\ddot{\phi} = \hat{\rho}_\phi \frac{l}{I_1} u_\phi – \frac{K_1 l}{I_1} \dot{\phi} + d_1.
\]
I introduce a sliding variable \(s = z – \dot{\phi}\) and an auxiliary variable \(z\) satisfying:
\[
\dot{z} = d^*_1 \text{sign}(s) + a_1 \frac{|s|^\eta}{1+|s|^\eta} + a_2 s + \left(\hat{\rho}_\phi \frac{l}{I_1} u_\phi – \frac{K_1 l}{I_1} \dot{\phi}\right),
\]
where \(a_1, a_2 > 0\), \(\eta > 0\), and \(d^*_1\) is the upper bound of \(d_1\). The disturbance observer is designed as:
\[
\dot{\hat{d}}_1 = d^*_1 \text{sign}(s) + a_1 \frac{|s|^\eta}{1+|s|^\eta} + a_2 s.
\]
The stability analysis is carried out using the Lyapunov function \(V = \frac{1}{2} s^2\). Its derivative satisfies:
\[
\dot{V} \le – a_2 s^2 – \frac{a_1 |s|^{\eta+1}}{1+|s|^\eta} \le – a_2 s^2 \le – 2 a_2 V.
\]
This proves that \(s\) converges to zero in finite time, which in turn guarantees that the disturbance estimation error \(\tilde{d}_1 = d_1 – \hat{d}_1\) converges to zero. The same structure is applied to the pitch and yaw channels.
3.2 Adaptive Non-singular Fast Terminal Sliding Mode Controller
The controller is designed to ensure that the tracking error \(e_\phi = \phi – \phi_d\) converges to zero in finite time. I use the following non-singular fast terminal sliding surface:
\[
\sigma = e_\phi + \lambda_1 |e_\phi|^{\gamma_1} \text{sign}(e_\phi) + \lambda_2 \int_0^t |e_\phi|^{\gamma_2} \text{sign}(e_\phi) d\tau,
\]
where \(\lambda_1, \lambda_2 > 0\), \(\gamma_1 \in (0,1)\), and \(\gamma_2 = \gamma_1/(2-\gamma_1)\) ensures a singularity-free structure. The proposed controller is:
\[
u_\phi = \hat{\rho}_\phi \alpha(\sigma, e_\phi),
\]
with
\[
\alpha(\sigma, e_\phi) = \frac{I_1}{l} \left( -b_1 |\sigma|^{\beta} \text{sign}(\sigma) – b_2 \text{sign}(\sigma) + \ddot{\phi}_d – \frac{K_1 l}{I_1} \dot{\phi} + \lambda_1 \gamma_1 |e_\phi|^{\gamma_1-1} \dot{e}_\phi + \lambda_2 |e_\phi|^{\gamma_2} \text{sign}(e_\phi) – \hat{d}_1 \right),
\]
where \(b_1, b_2 > 0\) and \(0 < \beta < 1\). The adaptive law for the health factor inverse is:
\[
\dot{\hat{\rho}}_\phi = \frac{l}{I_1} \tau \sigma \alpha(\sigma, e_\phi),
\]
with tuning gain \(\tau > 0\). The Lyapunov function \(V = \frac{1}{2} \sigma^2 + \frac{\delta_\phi}{2\tau} \tilde{\rho}_\phi^2\) is used to prove that \(\sigma\) and the estimation error \(\tilde{\rho}_\phi\) converge to zero in finite time. Then, the sliding surface dynamics reduce to:
\[
\dot{e}_\phi = -\lambda_1 |e_\phi|^{\gamma_1} \text{sign}(e_\phi) – \lambda_2 |e_\phi|^{\gamma_2} \text{sign}(e_\phi),
\]
which is also finite-time stable according to the homogeneity theory. Thus the overall closed-loop system is finite-time stable.
3.3 Simulation Results of the First Control Scheme
I implemented the proposed finite-time fault-tolerant controller and disturbance observer in Matlab/Simulink. The simulation parameters are listed in Table 1.
| Parameter | Symbol | Value | Unit |
|---|---|---|---|
| Inertia for roll | \(I_1\) | 0.02 | kg·m² |
| Inertia for pitch | \(I_2\) | 0.02 | kg·m² |
| Inertia for yaw | \(I_3\) | 0.03 | kg·m² |
| Arm length | \(l\) | 0.2 | m |
| Drag coefficient | \(K_i\) | 0.01 | — |
| Observer gain | \(a_1\) | 3 | — |
| Observer gain | \(a_2\) | 1 | — |
| Sliding gain | \(b_1\) | 10 | — |
| Sliding gain | \(b_2\) | 10 | — |
Two cases were tested: a yaw channel fault causing 50 percent loss of effectiveness and a pitch channel fault causing 80 percent loss of effectiveness. The adaptive law was able to estimate the health factor quickly, and the controller maintained tracking performance. The disturbance observer effectively estimated a time-varying sinusoidal disturbance, and the feedback compensation greatly reduced the attitude error compared to the case without the observer. However, I observed that when the fault becomes large (e.g. 90 percent or more), the control input grows substantially because of the inverse operation involved in \(\hat{\rho}_\phi\). This may saturate the actuators in a real system. Moreover, the health factor in the actual motor fault is time-varying, and the scalar multiplicative model cannot capture this fast transient. These issues motivated the second control scheme.
4. Fixed-Time Fault-Tolerant Control under Mismatched Disturbance
4.1 New Fault Modeling with Time-Varying Health Factors
To overcome the limitations of the multiplicative fault model, I redefine the fault at the motor level. Let the motor reliability factor \(\xi_i(t)\in(0,1]\) denote the remaining effectiveness of motor \(i\), \(i=1,2,3,4\). When a motor suffers a power loss, \(\xi_i(t)\) becomes a time-varying function. Using the control allocation matrix, the faulty force vector can be expressed as the nominal vector plus an additive uncertainty:
\[
\begin{bmatrix}
u_p \\ u_\phi \\ u_\theta \\ u_\psi
\end{bmatrix}
=
\begin{bmatrix}
1 & 1 & 1 & 1 \\
-1 & 1 & 1 & -1 \\
1 & -1 & 1 & -1 \\
1 & -1 & -1 & 1
\end{bmatrix}
\begin{bmatrix}
F_1 \\ F_2 \\ F_3 \\ F_4
\end{bmatrix}
+
\begin{bmatrix}
\rho_p(t) \\ \rho_\phi(t) \\ \rho_\theta(t) \\ \rho_\psi(t)
\end{bmatrix},
\]
where the new health factors \(\rho_i(t)\) are time-varying and depend on \(\xi_i(t)\). Unlike the previous model, the fault enters additively into the dynamic equation. The resulting attitude dynamics are:
\[
\begin{aligned}
\ddot{\phi} &= \frac{l}{I_1} u_\phi – \frac{K_1 l}{I_1} \dot{\phi} + \rho_\phi(t), \\
\ddot{\theta} &= \frac{l}{I_2} u_\theta – \frac{K_2 l}{I_2} \dot{\theta} + \rho_\theta(t), \\
\ddot{\psi} &= \frac{l}{I_3} u_\psi – \frac{K_3 l}{I_3} \dot{\psi} + \rho_\psi(t).
\end{aligned}
\]
Moreover, to reflect the effect of modeling uncertainty and sensor bias, I place a mismatched disturbance \(d_1\) at the angular velocity level. The roll channel becomes:
\[
\begin{aligned}
\dot{\phi} &= \omega_\phi + d_1, \\
\dot{\omega}_\phi &= \frac{l}{I_1} u_\phi – \frac{K_1 l}{I_1} \omega_\phi + \rho_\phi(t),
\end{aligned}
\]
where \(d_1\) and its derivative are bounded. This model is more realistic for actual quadrotor UAVs because the disturbance and the control input do not appear on the same layer.
4.2 Fixed-Time Fault Observer Design
I design a fixed-time observer to estimate the time-varying health factor \(\rho_\phi(t)\). Let \(h = \omega_\phi – z\) be an auxiliary variable. The observer structure is:
\[
\dot{z} = \frac{l}{I_1} u_\phi – \frac{K_1 l}{I_1} \omega_\phi + \mathcal{B}(s),
\]
where \(s = h – \mathcal{A}(h)\) is a sliding variable, and the functions \(\mathcal{A}(h)\) and \(\mathcal{B}(s)\) are chosen as:
\[
\mathcal{A}(h) = -\alpha_1 |h|^p \text{sign}(h) – \beta_1 b(h,q),
\]
\[
\mathcal{B}(s) = k_1 |s|^m \text{sign}(s) + k_2 s^{m/n},
\]
with \(p \in (0,1)\), \(m\) a positive odd integer, \(n\) a positive even integer, \(k_1 > \rho_\phi^*\), and \(k_2>0\). The nonlinear function \(b(h,q)\) is defined by:
\[
b(h,q) = \frac{h}{1+\arctan(|h|)}, \quad b'(h,q) = \frac{q \,\text{sign}(h)}{(1+\arctan(|h|))^2}.
\]
The fault estimate is obtained by integration:
\[
\hat{\rho}_\phi(t) = \int_0^t \left[ k_1 |s|^m \text{sign}(s) + k_2 s^{m/n} \right] d\tau.
\]
Through the Lyapunov function \(V(s)=\frac{1}{2}s^2\), I obtain:
\[
\dot{V} \le – k_1 |s|^{m+1} – k_2 |s|^{m/n+1} + \rho_\phi^* |s| \le – \underline{k}_1 |s|^{m+1} – k_2 |s|^{m/n+1},
\]
which ensures fixed-time convergence of \(s\) to zero. Then the auxiliary variable \(h\) converges in fixed time to zero due to the term \(-\alpha_1 |h|^p – \beta_1 b(h,q)\). Hence, the observer error \(\tilde{\rho}_\phi = \rho_\phi – \hat{\rho}_\phi\) converges to zero within a fixed time independent of the initial state.
4.3 Fixed-Time Controller under Mismatched Disturbance
The tracking error for the roll channel is \(e_\phi = \phi – \phi_d\). I propose a non-singular fixed-time sliding surface:
\[
s_\phi = e_\phi + \delta \frac{|e_\phi|^{m/n}}{|e_\phi| + \eta} + \gamma \dot{e}_\phi,
\]
where \(\delta, \eta, \gamma > 0\), \(m>n\) and \(m,n\) are odd/even integers as above. The controller is designed as:
\[
u_\phi = \frac{I_1}{l} \left( \ddot{\phi}_d – \frac{K_1 l}{I_1}\dot{\phi} + \frac{1}{\gamma} \left[ -\delta \frac{m}{n} |e_\phi|^{m/n-1} \dot{e}_\phi \frac{\eta}{(|e_\phi|+\eta)^2} – k_1 s_\phi – k_2 |s_\phi|^{m/n} \text{sign}(s_\phi) – \frac{\delta}{2} s_\phi \right] – \hat{\rho}_\phi \right),
\]
where \(k_1, k_2 > 0\). The derivative of the Lyapunov function \(V=\frac{1}{2} s_\phi^2\) satisfies:
\[
\dot{V} \le – k_1 s_\phi^2 – k_2 |s_\phi|^{m/n+1} + d_1^* |s_\phi| \frac{\delta}{2\gamma} \le – \bar{k}_1 s_\phi^2 – k_2 |s_\phi|^{m/n+1},
\]
provided that \(\delta > 2\gamma d_1^*\). This proves fixed-time convergence of \(s_\phi\). When \(s_\phi=0\), the dynamics reduce to a fixed-time stable second-order system, so the tracking error \(e_\phi\) converges to a small neighborhood of zero within a fixed time. The same controller is applied to the pitch and yaw channels.
4.4 Simulation Results of the Second Control Scheme
To verify the theoretical results, I simulated the second scheme in Simulink with the parameters listed in Table 2.
| Parameter | Symbol | Value |
|---|---|---|
| Observer gain | \(\alpha_1\) | 2 |
| Observer gain | \(\beta_1\) | 1 |
| Power p | \(p\) | 0.5 |
| Observer gain | \(k_1\) | 30 |
| Observer gain | \(k_2\) | 2 |
| Power m | \(m\) | 3 |
| Power n | \(n\) | 2 |
| Controller gain | \(k_1\) | 2 |
| Controller gain | \(k_2\) | 1 |
| Sliding parameter | \(\delta\) | 1 |
| Sliding parameter | \(\eta\) | 0.001 |
| Sliding parameter | \(\gamma\) | 1 |
In the simulation, I set motor faults as follows: motor 1 healthy, motor 2 with a 50 percent loss, motor 3 with a sinusoidal time-varying loss, and motor 4 almost completely failed (motor reliability factor 0.001). The observer successfully estimated the resulting time-varying health factors in fixed time. The controller maintained stable attitude tracking with a maximum error less than 0.05 rad even under this severe fault. I also performed a comparative simulation between the first and second schemes. When the fault becomes large and time-varying, the first scheme produces excessive control effort and oscillatory behavior, while the second scheme gives a faster and smoother response. These results clearly demonstrate the advantage of the fixed-time fault observer and the mismatched-disturbance controller for unmanned aerial vehicles.
5. Control Algorithm Verification Platform for Quadrotor UAVs
Although many advanced control algorithms for quadrotor UAVs have been proposed, most of them remain in the stage of mathematical simulation. Real flight conditions introduce sensor noise, wind gusts, model mismatch, and actuator saturation, which can invalidate theoretically sound algorithms. Therefore, I have developed an experimental platform that provides a systematic pathway from algorithm design to real flight verification. The platform is built with three design principles: modularity, streamlined process, and standardization. The overall architecture consists of four consecutive modules: (1) numerical simulation in Simulink, (2) software-in-the-loop simulation in Gazebo and ROS, (3) hardware-in-the-loop simulation with real quadrotor hardware, and (4) real flight tests with an onboard computer.
5.1 Numerical Simulation Module
The first module uses Simulink for pure numerical simulation. The user can implement a new control algorithm as a graphical Simulink block diagram. The quadrotor model, disturbance model, and reference signals are provided by the platform. The advantage of using Simulink is the built-in automatic code generation capability, which allows the same control model to be converted into a ROS node for subsequent real-time deployment. Table 3 summarizes the software environment of each module.
| Module | Control Algorithm | Quadrotor Platform | Software Environment |
|---|---|---|---|
| Numerical simulation | Simulink controller | Ideal mathematical model | Matlab / Simulink |
| Software-in-the-loop | Generated ROS node | Virtual physical model in Gazebo | ROS + Gazebo + PX4 |
| Hardware-in-the-loop | Simulink controller | Real quadrotor hardware | Simulink + PX4 |
| Real flight | Generated ROS node | Real quadrotor with Raspberry Pi | ROS + MAVROS + PX4 |
5.2 Software-in-the-Loop Simulation Module
The second module aims to verify the software implementation in a realistic virtual environment. The Simulink controller files are automatically code-generated into a ROS node. This ROS node is then compiled and deployed into the ROS environment, where it communicates with the PX4 flight stack through the MAVROS package. Gazebo provides a virtual quadrotor model with mass, inertia, propeller aerodynamics, and ground contact. The developer can launch the simulation and observe the UAV’s behavior through the ground control station (QGroundControl or QGC). This step is essential to detect code-level bugs, interface mismatches, and communication issues before using real hardware. In the platform, the software-in-the-loop module reuses the exact code that will later be deployed to the onboard computer, so no additional manual recoding is required.
5.3 Hardware-in-the-Loop Simulation Module
The third module bridges the gap between simulation and real flight. In this module, the same Simulink controller file used in the numerical simulation is executed on a host computer. The host computer reads real-time attitude and angular velocity data from a Pixhawk 2.4.8 flight controller through a serial link. The control algorithm computes the virtual control signals, which are then converted into PWM signals and sent back to the ESC (electronic speed controller) interfaces of the real quadrotor. The real motors spin according to these PWM commands, while the flight controller remains in a loopback mode. This setup allows the engineer to tune controller gains and observe the system response under actual actuator dynamics, but without the risk of crash. Table 4 lists the main hardware components used in the platform.
| Component | Model | Quantity |
|---|---|---|
| Flight controller | Pixhawk 2.4.8 | 1 |
| Quadrotor frame | F330 | 1 |
| Brushless DC motor | 2212 KV950 | 4 |
| Electronic speed controller | 20A | 4 |
| Propeller | 8045 | 2 pairs |
| Battery | 3S 2200 mAh 45C | 1 |
| Onboard computer | Raspberry Pi 4B | 1 |
| Wireless telemetry | 433 MHz | 1 pair |
| Remote controller | RadioLink V5 | 1 |
5.4 Real Flight Verification Module
The final module is the real outdoor flight test. The quadrotor is equipped with a Raspberry Pi 4B running Ubuntu Linux and a ROS node generated from the Simulink controller. The ROS node communicates with the Pixhawk flight controller through MAVROS, which translates messages between the ROS topic interface and the MAVLink protocol. The original attitude controller inside PX4 is disabled, while the custom controller runs at a rate of 250 Hz on the Raspberry Pi. The total thrust command is still generated by the PX4 position controller, so the vehicle can remain in a hover and follow attitude setpoints. To inject a fault, I map a virtual fault factor to one of the transmitter sticks. When the stick is moved, the PWM outputs sent to the motors are multiplied by the corresponding motor reliability factor, simulating partial loss of motor effectiveness. During the experiment, the remote-controlled fault profile is shown in Figure 5.16 (not reproduced here). I collected attitude data, control inputs and error signals using a Python script that subscribed to the relevant ROS topics.
5.5 Deployment and Real Flight Results
Both control schemes from Chapter 3 and Chapter 4 were implemented and tested on the platform. The same motor fault profile was applied in the experiments: motor 1 healthy, motor 2 with a sinusoidal fault with amplitude 0.2, motor 3 with a reliability factor of 0.9, and motor 4 with a 30 percent power loss (reliability factor 0.7). The attitude tracking performances are compared in Table 5.
| Metric | Chapter 3 Scheme | Chapter 4 Scheme |
|---|---|---|
| Maximum roll tracking error | 0.12 rad | 0.05 rad |
| Maximum pitch tracking error | 0.15 rad | 0.06 rad |
| Settling time after fault | 2.5 s | 0.8 s |
| Control input oscillation | High | Low |
| Maximum tolerable fault severity | ~0.8 | ~0.5 motor loss |
The real flight data confirm that the fixed-time scheme in Chapter 4 provides faster convergence, smaller tracking error, and lower control effort chattering. The Chapter 3 scheme still functioned for moderate faults, but it produced large overshoots when the fault was applied quickly, and it struggled when the fault magnitude was large. In contrast, the Chapter 4 scheme, with the fixed-time fault observer, was able to estimate the time-varying fault almost instantly and compensate for it. The experimental platform thus proved to be a reliable and convenient tool for validating fault-tolerant control algorithms for unmanned aerial vehicles.
6. Conclusion and Future Work
In this thesis, I have presented a comprehensive study of fault-tolerant attitude control for quadrotor unmanned aerial vehicles, combined with an experimental verification platform. The main findings can be summarized as follows. First, the finite-time adaptive fault-tolerant controller using a non-singular fast terminal sliding mode and a disturbance observer can maintain attitude stability under moderate multiplicative faults and bounded disturbances. However, the inverse-based compensation leads to actuator saturation for severe faults, and the scalar health factor cannot represent time-varying motor faults. Second, by reformulating the fault as an additive time-varying health factor and considering a mismatched disturbance, I have developed a fixed-time fault observer and a fixed-time sliding mode controller. The new scheme achieves faster and guaranteed convergence times independent of initial conditions, and it can handle a wider range of fault severities. Third, the proposed control algorithm verification platform successfully integrates numerical simulation, software-in-the-loop, hardware-in-the-loop and real flight tests in a standardized workflow. Both control schemes have been deployed without manual code rewriting, demonstrating the flexibility of the platform.
Future research directions include: (1) extending the fault-tolerant controller to handle complete motor failure by redesigning the control allocation and using a switching strategy; (2) reducing the number of tuning parameters and developing self-tuning mechanisms; (3) incorporating preset-time or prescribed-time convergence to further improve the response speed; (4) upgrading the experimental platform to support position control and multi-UAV cooperative algorithms. The platform will be continuously improved to accelerate the transfer of advanced control theories into practical applications for unmanned aerial vehicles.