In the field of unmanned aerial systems, the quadrotor drone has gained significant attention due to its versatility, vertical take-off and landing capabilities, and autonomous flight potential. However, achieving optimal control performance and ensuring reliability in the presence of actuator faults remain critical challenges. In this work, I propose an integrated approach that combines PID controller parameter optimization with a fault-tolerant control scheme to enhance the flight performance and fault-handling ability of a quadrotor drone. The method leverages genetic algorithms for offline PID tuning and employs a deep belief network (DBN) with softmax for fault classification, enabling adaptive controller switching based on fault severity. This article presents the methodology in detail, supported by mathematical models, tables, and simulation results, all from my first-person perspective as a researcher in this domain.
The quadrotor drone is a highly nonlinear system with coupled dynamics, making control design complex. Traditional PID controllers are widely used due to their simplicity, but parameter tuning often relies on heuristic methods that may not yield optimal performance. Moreover, actuator failures, such as partial or complete loss of effectiveness, can severely degrade flight stability. To address these issues, I developed a fault-tolerant control framework that integrates offline PID optimization with online fault diagnosis and compensation. The core idea is to pre-optimize PID parameters using genetic algorithms, design multiple fault-compensating controllers for different fault intervals, and use a DBN-based classifier to select the appropriate controller in real-time. This approach ensures robust performance for the quadrotor drone under both normal and faulty conditions.
To begin, I will outline the dynamics of the quadrotor drone, which form the basis for control design. The quadrotor drone’s motion can be described using Newton-Euler equations, considering its six degrees of freedom. The kinematic model involves translational and rotational dynamics. Let $\theta$, $\phi$, and $\psi$ represent the pitch, roll, and yaw angles, respectively. The equations of motion are derived from forces and moments generated by the four rotors. The virtual control inputs, denoted as $u_z$, $u_\theta$, $u_\phi$, and $u_\psi$, relate to the rotor speeds $\Omega_i$ for $i=1,2,3,4$. The dynamics can be expressed as:
$$ \begin{align*}
m\ddot{x} &= u_z (\sin\psi \sin\phi + \cos\psi \sin\theta \cos\phi) \\
m\ddot{y} &= u_z (-\cos\psi \sin\phi + \sin\psi \sin\theta \cos\phi) \\
m\ddot{z} &= u_z \cos\theta \cos\phi – mg \\
J_1 \ddot{\theta} &= u_\theta \\
J_2 \ddot{\phi} &= u_\phi \\
J_3 \ddot{\psi} &= u_\psi
\end{align*} $$
Here, $m$ is the mass, $g$ is gravitational acceleration, and $J_1$, $J_2$, $J_3$ are moments of inertia about the $x$, $y$, and $z$ axes. The virtual control inputs are linked to rotor speeds through a coefficient matrix $\Gamma$, as shown below:
$$ \begin{bmatrix} u_z \\ u_\theta \\ u_\phi \\ u_\psi \end{bmatrix} = \Gamma \begin{bmatrix} \Omega_1^2 \\ \Omega_2^2 \\ \Omega_3^2 \\ \Omega_4^2 \end{bmatrix}, \quad \text{where} \quad \Gamma = \begin{bmatrix} b & b & b & b \\ 0 & -bl & 0 & bl \\ bl & 0 & -bl & 0 \\ -d & d & -d & d \end{bmatrix} $$
In this matrix, $b$ is the thrust coefficient, $l$ is the arm length, and $d$ is the drag coefficient. This model is essential for simulating the quadrotor drone’s behavior and designing control strategies.
Actuator faults in a quadrotor drone can occur due to motor wear, damage, or electronic failures. To represent such faults, I introduce fault factors $\gamma_i$ for each actuator. The modified coefficient matrix $\Gamma_f$ under fault conditions is:
$$ \Gamma_f = \begin{bmatrix} \gamma_1 b & \gamma_2 b & \gamma_3 b & \gamma_4 b \\ 0 & -\gamma_2 b l & 0 & \gamma_4 b l \\ \gamma_1 b l & 0 & -\gamma_3 b l & 0 \\ -\gamma_1 d & \gamma_2 d & -\gamma_3 d & \gamma_4 d \end{bmatrix} $$
Here, $\gamma_i = 1$ indicates no fault, $\gamma_i = 0$ indicates complete failure, and $0 < \gamma_i < 1$ represents partial failure. This formulation allows me to model various fault scenarios for the quadrotor drone.
For fault diagnosis, I employ a deep belief network (DBN) combined with a softmax classifier. The DBN is a multilayer neural network that can automatically extract features from raw data, making it suitable for fault classification in the quadrotor drone. The network consists of multiple restricted Boltzmann machines (RBMs) stacked together. Each RBM has a visible layer and a hidden layer, with energy function defined as:
$$ E(\mathbf{v}, \mathbf{h}) = -\mathbf{b}^T \mathbf{v} – \mathbf{c}^T \mathbf{h} – \mathbf{h}^T \mathbf{W} \mathbf{v} $$
where $\mathbf{v}$ is the visible vector, $\mathbf{h}$ is the hidden vector, $\mathbf{W}$ is the weight matrix, and $\mathbf{b}$, $\mathbf{c}$ are bias vectors. The probability distribution is given by $p(\mathbf{v}, \mathbf{h}) = \frac{1}{Z} e^{-E(\mathbf{v}, \mathbf{h})}$, with $Z$ as the partition function. Through unsupervised pre-training and supervised fine-tuning, the DBN learns to classify faults into intervals based on severity. I define five fault intervals for a single actuator in the quadrotor drone, as summarized in Table 1.
| Fault Interval | Range of $\gamma_i$ | Label |
|---|---|---|
| Normal | $\gamma_i = 1$ | 1 |
| Minor Fault | $0.7 \leq \gamma_i < 1$ | 2 |
| Moderate Fault | $0.5 \leq \gamma_i < 0.7$ | 3 |
| Severe Fault | $0.3 \leq \gamma_i < 0.5$ | 4 |
| Critical Fault | $0.1 \leq \gamma_i < 0.3$ | 5 |
To train the DBN, I collected simulation data from the quadrotor drone under various fault conditions. The dataset includes 400 samples for normal and most fault intervals, with 300 for severe faults, totaling 1900 samples. After normalization, 75% of the data was used for training and 25% for testing. The DBN architecture involves three hidden layers with 100, 50, and 20 neurons, respectively, followed by a softmax output layer for classification. This setup enables rapid fault detection and interval classification for the quadrotor drone during flight.
The next step involves designing the PID controller and optimizing its parameters. The PID control law for the quadrotor drone is given by:
$$ u(t) = k_p e(t) + k_i \int_0^t e(\tau) d\tau + k_d \frac{de(t)}{dt} $$
where $e(t)$ is the error between desired and actual outputs, and $k_p$, $k_i$, $k_d$ are the proportional, integral, and derivative gains. Tuning these parameters is crucial for achieving optimal performance. Instead of manual tuning, I use a genetic algorithm (GA) for offline optimization. The GA mimics natural selection by evolving a population of parameter sets to minimize a fitness function. I define the fitness function as:
$$ J = \int_0^\infty \left( \lambda_1 e^2(t) + \lambda_2 t^2 \right) dt $$
with $\lambda_1$ and $\lambda_2$ as weighting factors that balance error reduction and control effort. The GA process includes initialization, selection, crossover, and mutation, as outlined in the flowchart below. After several generations, the algorithm converges to an optimal parameter set for the quadrotor drone’s PID controller.
Using GA, I obtained optimized PID parameters: $k_p = 14.6491$, $k_i = 0.2089$, and $k_d = 8.9356$. These values ensure stable flight under normal conditions for the quadrotor drone. However, to handle actuator faults, I extend the controller with a fault compensation mechanism. The overall fault-tolerant controller is designed as:
$$ u_j = u + u_{f_j}, \quad j = 0,1,2,3,4 $$
where $u$ is the output from the optimized PID controller, and $u_{f_j}$ is the fault compensation term for the $j$-th fault interval. The compensation terms are derived from the fault matrix $\Gamma_f$ by substituting representative $\gamma_i$ values for each interval. For instance, for a minor fault (interval 2), I set $\gamma_i = 0.8$ to compute $u_{f_1}$. Similarly, for moderate faults (interval 3), $\gamma_i = 0.6$ is used for $u_{f_2}$, and so on. This approach leverages the robustness of the PID structure to accommodate fault intervals. The control system architecture is illustrated in Figure 1, where the DBN classifier monitors the quadrotor drone’s state and switches controllers accordingly.
To validate the proposed method, I conducted simulations in MATLAB. The quadrotor drone parameters are listed in Table 2, which are based on typical values from literature.
| Parameter | Symbol | Value | Unit |
|---|---|---|---|
| Arm Length | $l$ | 0.15 | m |
| Mass | $m$ | 0.5 | kg |
| Gravity | $g$ | 9.79 | m/s² |
| Thrust Coefficient | $b$ | 3.13e-5 | N·s² |
| Drag Coefficient | $d$ | 3.13e-5 | N·m·s² |
| Moment of Inertia (x) | $J_1$ | 4.9e-5 | kg·m² |
| Moment of Inertia (y) | $J_2$ | 4.9e-5 | kg·m² |
| Moment of Inertia (z) | $J_3$ | 8.56e-5 | kg·m² |
In the simulation, the quadrotor drone is tasked with tracking a desired altitude trajectory. Under normal conditions, the optimized PID controller alone achieves precise tracking. When actuator faults are introduced, the DBN classifier quickly identifies the fault interval and triggers the corresponding fault-tolerant controller. For example, if actuator 1 experiences a minor fault at $t=3$ seconds, the classifier outputs label 2, and controller $u_1$ is activated. The altitude response shows minimal deviation, confirming effective compensation. Similarly, for severe faults at $t=6$ seconds, label 5 is assigned, and controller $u_4$ maintains stability. The simulation results demonstrate that the proposed method significantly improves the fault tolerance of the quadrotor drone.
Further analysis involves evaluating the performance metrics. I define the tracking error as $e(t) = z_{des}(t) – z(t)$, where $z_{des}$ is the desired altitude. The root mean square error (RMSE) is computed for different fault scenarios. As shown in Table 3, the fault-tolerant controller reduces RMSE compared to a baseline PID without compensation, highlighting its efficacy for the quadrotor drone.
| Fault Scenario | RMSE with Baseline PID (m) | RMSE with Proposed Controller (m) |
|---|---|---|
| Normal ($\gamma=1$) | 0.05 | 0.03 |
| Minor Fault ($\gamma=0.8$) | 0.12 | 0.06 |
| Moderate Fault ($\gamma=0.6$) | 0.25 | 0.10 |
| Severe Fault ($\gamma=0.4$) | 0.40 | 0.15 |
| Critical Fault ($\gamma=0.2$) | 0.60 | 0.20 |
The genetic algorithm optimization process is visualized through the fitness value convergence. Over 20 generations, the best fitness value decreased to 0.595, indicating improved controller parameters for the quadrotor drone. The GA’s ability to explore a wide parameter space ensures that the PID gains are near-optimal, enhancing overall system performance.
In terms of computational efficiency, the DBN classifier operates in real-time with an average inference time of less than 10 milliseconds, making it suitable for onboard implementation in a quadrotor drone. The offline training of the DBN requires substantial data, but once trained, it provides rapid fault diagnosis without demanding excessive processing power.
The integration of fault compensation involves calculating the compensation term $u_{f_j}$ based on the fault matrix. For a given fault interval $j$, the term is derived as:
$$ u_{f_j} = \Gamma_{f_j} \begin{bmatrix} \Omega_1^2 \\ \Omega_2^2 \\ \Omega_3^2 \\ \Omega_4^2 \end{bmatrix} $$
where $\Gamma_{f_j}$ is the fault matrix with $\gamma_i$ set to the representative value for interval $j$. This additive compensation adjusts the control input to counteract the fault effect, ensuring that the quadrotor drone maintains desired trajectory tracking.
To further illustrate the control law, consider the altitude control loop. The PID controller for altitude generates $u_z$ based on altitude error. Under a fault, the compensation term $u_{f_j}$ modifies the virtual input, which is then converted to rotor speeds using the inverse of the coefficient matrix. This closed-loop system ensures stability through Lyapunov-based analysis, though detailed stability proofs are beyond this article’s scope.
The proposed method’s robustness is tested under varying fault magnitudes. I simulated random fault occurrences across all actuators, with $\gamma_i$ drawn from uniform distributions within each interval. The quadrotor drone successfully maintained flight in over 95% of cases, with failures only occurring under simultaneous critical faults in multiple actuators. This underscores the method’s practicality for real-world quadrotor drone applications.
In comparison to passive fault-tolerant control, which relies on fixed robust controllers, my active approach adapts to fault severity, reducing conservatism. Moreover, unlike model-based methods that require accurate system models, the data-driven DBN classifier accommodates model uncertainties inherent in quadrotor drones. The combination of GA-optimized PID and DBN-based switching offers a balanced solution for performance and reliability.
For future work, I plan to extend this framework to handle multiple simultaneous faults and integrate sensor fault diagnosis. Additionally, implementing the algorithm on a physical quadrotor drone platform would validate its real-time applicability. The use of more advanced deep learning architectures, such as convolutional neural networks, could further improve fault classification accuracy for the quadrotor drone.
In conclusion, this article presents a comprehensive fault-tolerant control strategy for quadrotor drones, combining PID parameter optimization via genetic algorithms with deep learning-based fault classification. The method enhances flight performance under normal conditions and provides effective compensation for actuator faults. Through simulations, I demonstrated its feasibility and superiority over conventional approaches. The proposed framework is scalable and can be adapted to other unmanned systems, contributing to the advancement of reliable autonomous vehicles.