In recent years, the rapid advancement of communication and sensor technologies has propelled unmanned aerial vehicles (UAVs), particularly quadrotor drones, into widespread use across military and civilian domains. However, the inherent nonlinearity and sensitivity to internal and external disturbances of quadrotor drones necessitate reliable attitude measurement systems for stability during flight. Traditional attitude sensors, such as single micro-electro-mechanical system (MEMS) gyroscopes, are often plagued by noise interference and limited accuracy, which can compromise flight performance. While high-precision military-grade sensors exist, their cost and size make them impractical for most consumer and industrial quadrotor drone applications. To address these challenges, I propose a novel multi-attitude measurement system based on a gyroscope array for quadrotor drones, coupled with a data fusion algorithm that leverages a backpropagation (BP) neural network enhanced by a neighborhood search mechanism. This approach aims to improve the accuracy, robustness, and stability of attitude estimation in quadrotor drones by fusing data from multiple low-cost MEMS gyroscopes, thereby enabling more reliable flight control without the need for expensive hardware.
The core idea behind my system is to replace the conventional single-gyroscope setup with an array of four gyroscopes strategically positioned on the quadrotor drone’s arms. This configuration forms a multi-node, anti-interference attitude system that provides redundant measurements. By integrating data from these multiple sources, I can mitigate the effects of noise and sensor errors, leading to more precise attitude estimates. The fusion algorithm I developed is based on a BP neural network, but it overcomes a key limitation of traditional BP networks: the requirement for accurately labeled output values during training. Through a neighborhood search technique, I dynamically generate target values for training by analyzing temporal and spatial correlations in the sensor data. This allows the network to adapt to the quadrotor drone’s dynamic environment without prior knowledge of ground truth, making it suitable for real-time applications. In this article, I will detail the design of the gyroscope array system, explain the fusion algorithm, and present experimental results demonstrating its superiority over single-sensor systems and conventional fusion methods like linear weighted averaging. The findings highlight significant improvements in noise resistance and data consistency, with the algorithm achieving a support degree increase of 9.2% and a residual error reduction of 44.2% compared to traditional approaches. Ultimately, this work contributes to enhancing the flight stability of quadrotor drones, paving the way for more reliable operations in diverse scenarios.
The flight control of a quadrotor drone relies heavily on accurate attitude measurements to adjust motor speeds and maintain stability. A typical quadrotor drone features an X-shaped structure with four symmetrically placed rotors, each contributing to controlled movements such as vertical ascent, pitch, roll, and yaw. The dynamics of a quadrotor drone can be modeled using nonlinear equations that describe its position and orientation in space. For instance, the equations of motion for attitude angles—roll ($\phi$), pitch ($\theta$), and yaw ($\psi$)—are derived from Euler’s laws and involve parameters like mass, inertia, and thrust forces. These equations are critical for designing control systems, but they depend on real-time sensor data to function effectively. In traditional setups, a single MEMS gyroscope provides angular velocity measurements, which are then integrated to estimate attitude. However, MEMS sensors are prone to drift and noise, leading to cumulative errors that can destabilize the quadrotor drone. My approach addresses this by deploying multiple gyroscopes in an array, creating a system that not only averages out noise but also provides spatial diversity to capture the quadrotor drone’s complex motion more accurately.
To formalize the quadrotor drone’s dynamics, consider the following equations that govern its attitude and position. The attitude dynamics are given by:
$$ \begin{bmatrix} \ddot{\phi} \\ \ddot{\theta} \\ \ddot{\psi} \end{bmatrix} = \begin{bmatrix} \dot{\theta} \dot{\psi} (I_{yy} – I_{zz})/I_{xx} + J_r \dot{\theta} \Omega / I_{xx} + (F_2 – F_4) l / I_{xx} \\ \dot{\phi} \dot{\psi} (I_{zz} – I_{xx})/I_{yy} + J_r \dot{\phi} \Omega / I_{yy} + (F_1 – F_3) l / I_{yy} \\ \dot{\phi} \dot{\theta} (I_{xx} – I_{yy})/I_{zz} + \sum_{i=1}^{4} (-1)^i M_i / I_{zz} \end{bmatrix} $$
where $\phi$, $\theta$, and $\psi$ are the roll, pitch, and yaw angles, respectively; $I_{xx}$, $I_{yy}$, and $I_{zz}$ are moments of inertia; $J_r$ is the rotor inertia; $\Omega$ is the rotor speed; $F_i$ represents the thrust from motor $i$; $l$ is the distance from the motor to the quadrotor drone’s center of mass; and $M_i$ denotes the torque. The position dynamics are described by:
$$ \begin{bmatrix} \ddot{x} \\ \ddot{y} \\ \ddot{z} \end{bmatrix} = \begin{bmatrix} (\sum_{i=1}^{4} F_i)(\sin\phi \sin\psi + \cos\phi \cos\psi \sin\theta) / m \\ (\sum_{i=1}^{4} F_i)(-\sin\phi \cos\psi + \cos\phi \sin\psi \sin\theta) / m \\ (\sum_{i=1}^{4} F_i)(\cos\phi \cos\theta) / m – g \end{bmatrix} $$
where $x$, $y$, and $z$ are the spatial coordinates, $m$ is the mass, and $g$ is gravitational acceleration. These equations highlight the coupling between attitude and position, underscoring the need for precise sensor data. In my system, the gyroscope array feeds filtered measurements into these models, enabling better control decisions for the quadrotor drone.
The design of the multi-attitude measurement system involves hardware and software components. For hardware, I use four MPU6500 MEMS gyroscopes, which are cost-effective and widely available, mounted at the ends of each arm of the quadrotor drone. This placement ensures that each sensor captures local angular velocities, which may vary due to vibrations or asymmetries in the quadrotor drone’s structure. The sensors are interfaced with an STM32F427 microcontroller based on an ARM Cortex-M4 core, which acts as a co-processor. This microcontroller runs the FreeRTOS operating system to manage multiple tasks concurrently—each task handles data acquisition from one gyroscope via UART communication. The raw sensor data is first preprocessed using an extended Kalman filter (EKF) to reduce noise and predict future states. The EKF is a recursive filter that linearizes nonlinear dynamics around the current estimate, making it suitable for real-time applications on a quadrotor drone. The prediction and update steps of the EKF are summarized below:
$$ \text{Prediction:} \quad \hat{x}_{k|k-1} = f(\hat{x}_{k-1|k-1}, u_k), \quad P_{k|k-1} = F_k P_{k-1|k-1} F_k^T + Q_k $$
$$ \text{Update:} \quad K_k = P_{k|k-1} H_k^T (H_k P_{k|k-1} H_k^T + R_k)^{-1}, \quad \hat{x}_{k|k} = \hat{x}_{k|k-1} + K_k (z_k – h(\hat{x}_{k|k-1})), \quad P_{k|k} = (I – K_k H_k) P_{k|k-1} $$
where $\hat{x}$ is the state estimate, $P$ is the error covariance, $F_k$ and $H_k$ are Jacobian matrices of the nonlinear functions $f$ and $h$, $Q_k$ and $R_k$ are process and measurement noise covariances, $K_k$ is the Kalman gain, and $z_k$ is the sensor measurement. After EKF processing, the data from all four gyroscopes is fused using my proposed BP neural network algorithm, with the fused output transmitted to the quadrotor drone’s main flight controller for attitude determination and control.
The data fusion algorithm is the cornerstone of this research. Traditional fusion methods, such as mean or weighted averaging, often assume linear relationships and may not capture complex interdependencies in sensor data. To overcome this, I employ a BP neural network, which is a multilayer perceptron capable of approximating nonlinear functions. The network has three layers: an input layer with four nodes (one for each gyroscope’s processed data), a hidden layer with four neurons, and an output layer that produces the fused attitude estimate. However, training a BP network typically requires a labeled dataset with known target values, which are unavailable in real-time quadrotor drone operations. My solution integrates a neighborhood search mechanism to generate pseudo-targets dynamically. This approach analyzes temporal sequences of sensor data to find optimal reference values based on local minima in error metrics. Specifically, for a time step $t$, let $X^t_{i,j}$ represent the sensor data matrix, where $i$ indexes the gyroscope (1 to 4) and $j$ denotes the data type (e.g., angular velocity). The neighborhood search computes an error matrix $Y^t_{i,j}$ as:
$$ Y^t_{i,j} = F(X^{t+1}_{i,j+1} – X^t_{i,j}, X^t_{i,j} – X^{t-1}_{i,j-1}) $$
where $F(\cdot)$ is a function that selects the minimum absolute difference, promoting consistency across time. From this, I derive a delta error vector $\Delta E^t_i$ by comparing errors across sensors:
$$ \Delta e^t_{i,j} = [Y^t_{1,j}, Y^t_{2,j} – Y^t_{1,j}, Y^t_{3,j} – Y^t_{1,j}, Y^t_{4,j} – Y^t_{1,j}] $$
$$ \Delta E^t_i = F([\Delta e^t_{i,j}]^T) $$
This yields the minimum error difference among neighboring time steps for the quadrotor drone’s sensors. Using this, I compute a target value $\nu^t_i$ for training the BP network through linear combination:
$$ \nu^t_i = a \cdot X^{t-1}_{i,j-1} + b \cdot X^t_{i,j} + c \cdot X^{t+1}_{i,j+1} $$
where $a$, $b$, and $c$ are weighting coefficients optimized empirically. To enhance robustness, this can be extended to a broader search domain $k$:
$$ \nu^t_i = \sum_{k=-K}^{K} s_{t+k} X^{t+k}_{i,j+k}, \quad k = 1, 2, \dots $$
with $s_{t+k}$ as adaptive weights. The BP network then uses these targets to adjust its weights via backpropagation, minimizing the mean squared error between outputs and pseudo-targets. The weight update rules for the hidden-to-output layer ($\omega_{ij}$) and input-to-hidden layer ($\omega_{mi}$) are:
$$ \Delta \omega_{ij}(n) = \eta e_j(n) \nu^I_i(n), \quad \Delta \omega_{mi}(n) = \eta \delta^I_i(n) x(n) $$
where $\eta$ is the learning rate, $e_j$ is the output error, $\nu^I_i$ is the hidden layer output, $\delta^I_i$ is the local gradient, and $x(n)$ is the input. This process enables the network to learn sensor correlations and produce fused estimates that are more accurate and less noisy than any single sensor’s output for the quadrotor drone.
To validate the effectiveness of my gyroscope array system and fusion algorithm, I conducted a series of experiments using a custom-built quadrotor drone platform. The experimental setup included a high-precision MPU9250 gyroscope as a reference sensor and four MPU6500 gyroscopes for the array, all connected to a data acquisition system running MATLAB 2016b on a computer with an Intel Xeon CPU and 128 GB RAM. The quadrotor drone was subjected to various flight conditions, including hovering, mild vibrations, and aggressive maneuvers, to simulate real-world scenarios. Sensor data was collected via UART ports and processed offline to compare the performance of my algorithm against traditional single-sensor systems and other fusion methods like mean, Gaussian, and weighted fusion. Key metrics for evaluation included support degree and residual error, defined as follows. Support degree quantifies the reliability of fused data relative to a reference (e.g., the high-precision sensor), calculated as:
$$ \text{Support Degree} = \left( \frac{1}{m} \sum_{i=1}^{m} \frac{| \text{Absolute Error} |}{| \text{Single-Sensor Output} |} \right) \times 100\% $$
where the absolute error is the difference between the fused output and the reference value, and $m$ is the number of samples. Residual error measures the deviation of the fused output from the mean of all sensor readings, given by:
$$ \nu_i = \chi_i – E(\chi_i) $$
with $\chi_i$ as the fused value and $E(\chi_i)$ as the mean of all sensor values at time $i$. These metrics help assess how well the fusion algorithm preserves data integrity while reducing noise for the quadrotor drone.
The experimental results demonstrated clear advantages of my approach. In terms of attitude estimation, the gyroscope array system produced smoother and more consistent curves compared to the single-sensor system, which exhibited significant oscillations due to noise. For example, the roll angle estimates from my fused data remained centered within the bounds of the single-sensor fluctuations, indicating effective noise suppression. Under vibration tests, the algorithm maintained stability, whereas traditional methods showed increased deviations. Quantitative analysis revealed that my BP network with neighborhood search achieved a support degree of 84.5%, outperforming linear weighted fusion (75.3%), mean fusion (70.9%), and Gaussian fusion (62.7%). Moreover, the residual error was reduced by 44.2% on average, highlighting better data consistency. The table below summarizes the performance comparison of different fusion algorithms for the quadrotor drone attitude data:
| Algorithm | Variance ($\sigma^2$) | Support Degree (%) |
|---|---|---|
| Mean Fusion | 1.216 | 70.9 |
| Gaussian Fusion | 1.781 | 62.7 |
| Weighted Fusion | 0.980 | 75.3 |
| Proposed Algorithm | 0.547 | 84.5 |
These results underscore the superiority of my method in enhancing the quadrotor drone’s attitude measurement accuracy. The lower variance indicates reduced noise, while the higher support degree reflects greater reliability. Additionally, I performed a real-world flight test using a Pixhawk flight controller integrated with the gyroscope array. The quadrotor drone successfully completed hover and trajectory tasks, with the fused attitude data showing stable trends aligned with the reference sensor, thereby confirming the practical viability of the system for quadrotor drone applications.
The fusion algorithm’s efficiency can be further analyzed through mathematical modeling. Consider the sensor data as a time series $S_i(t)$ for gyroscope $i$. The fused output $F(t)$ from the BP network approximates the true attitude $A(t)$ of the quadrotor drone with an error term $\epsilon(t)$ that incorporates noise and modeling inaccuracies. The goal is to minimize $\epsilon(t)$ by optimizing the network weights. Using the neighborhood search, I define a cost function $C$ based on the pseudo-targets $\nu_i(t)$:
$$ C = \frac{1}{N} \sum_{t=1}^{N} (F(t) – \nu_i(t))^2 + \lambda \sum \omega^2 $$
where $N$ is the number of time steps, $\lambda$ is a regularization parameter to prevent overfitting, and $\omega$ represents the network weights. The gradient descent update during training ensures convergence to a local minimum, improving the quadrotor drone’s attitude estimates over time. To illustrate the data flow, the following equations describe the fusion process step-by-step for a quadrotor drone at time $t$:
- Sensor Acquisition: Each gyroscope $i$ measures angular velocity $\omega_i(t)$.
- EKF Preprocessing: Apply EKF to obtain filtered estimates $\hat{\omega}_i(t)$ and predicted states $\hat{x}_i(t)$.
- Neighborhood Search: Compute error matrix $Y^t_{i,j}$ and target $\nu^t_i$ using equations above.
- BP Network Fusion: Input $\hat{\omega}_i(t)$ into the network to produce fused output $F(t)$.
- Control Integration: Send $F(t)$ to the quadrotor drone’s flight controller for attitude adjustment.
This pipeline ensures real-time operation, critical for dynamic quadrotor drone flights. The use of multiple gyroscopes also provides redundancy; if one sensor fails, the others can compensate, enhancing the quadrotor drone’s fault tolerance. In practice, the system can be extended to include more sensors or different types, such as accelerometers, for a more comprehensive sensor fusion framework.
In conclusion, I have presented a novel gyroscope array-based attitude measurement system for quadrotor drones, along with a data fusion algorithm that combines BP neural networks with neighborhood search. This approach addresses the limitations of single MEMS gyroscopes by leveraging multi-sensor redundancy and intelligent fusion to improve accuracy and robustness. Experimental results confirm that the system significantly reduces noise and increases data reliability compared to traditional methods, with a support degree of 84.5% and a 44.2% reduction in residual error. The algorithm’s ability to generate training targets dynamically makes it suitable for real-time quadrotor drone applications without requiring labeled datasets. Future work could explore adaptive weighting schemes for the neighborhood search, integration with other sensor modalities like vision systems, and implementation on embedded hardware for fully autonomous quadrotor drone operations. By enhancing attitude estimation, this research contributes to safer and more stable flight for quadrotor drones, enabling their use in more demanding environments such as surveillance, delivery, and inspection tasks. The principles developed here may also apply to other robotic systems requiring precise sensor fusion, broadening the impact of this work beyond quadrotor drones.
Throughout this article, I have emphasized the importance of accurate sensor data for quadrotor drone stability. The gyroscope array system exemplifies how low-cost components can be combined with advanced algorithms to achieve high performance, democratizing access to reliable UAV technology. As quadrotor drones continue to evolve, innovations in data fusion will play a pivotal role in unlocking their full potential, from consumer hobbies to critical missions. My hope is that this work inspires further research into multi-sensor systems and machine learning techniques for quadrotor drones, fostering advancements that benefit society at large.