In the field of robotics, aerospace, and industrial automation, the accurate measurement of multi-dimensional forces and moments is critical for ensuring precision and reliability. Six-axis force sensors, capable of measuring three orthogonal forces and three moments, play a pivotal role in these applications. However, coupling effects—where the output in one direction is influenced by inputs in other directions—significantly degrade the accuracy of these sensors. Traditional decoupling methods, such as linear approaches, often fall short when dealing with complex nonlinearities inherent in sensor systems. To address this, we propose a novel decoupling algorithm based on the Osprey Optimization Algorithm (OOA) optimized Radial Basis Function Neural Network (RBFNN), referred to as OOA-RBF. This algorithm leverages the global optimization capabilities of OOA to fine-tune RBFNN parameters, enhancing decoupling performance, robustness, and generalization. In this article, we detail the development, implementation, and validation of the OOA-RBF algorithm for a capacitive six-axis force sensor, demonstrating its superiority over conventional methods through extensive experiments.
The capacitive six-axis force sensor used in this study is designed to measure forces and moments with high sensitivity and precision. Its structure incorporates multiple capacitors arranged both horizontally and vertically to capture multi-directional inputs. During operation, when a load is applied along a specific axis, not only do the capacitors aligned with that axis respond, but others also exhibit changes due to mechanical and electrical couplings. This cross-talk results in inaccurate readings, necessitating effective decoupling techniques. The sensor’s specifications include a force range of ±200 N for the x and y axes, ±400 N for the z axis, and a moment range of ±10 N·m for all rotational axes. To illustrate the sensor’s configuration, consider the following representation of its internal capacitor layout, which highlights the arrangement crucial for capturing multi-dimensional inputs.
Calibration experiments are essential for establishing the relationship between applied loads and sensor outputs. In our setup, we applied incremental loads from negative to positive full scale in 10% increments across all six directions (Fx, Fy, Fz, Mx, My, Mz). Data acquisition was performed using a dedicated software interface, resulting in 252 data points that serve as the dataset for training and testing the decoupling algorithms. During calibration, we observed significant coupling effects; for instance, applying a force along the x-axis caused noticeable changes in capacitors intended for other directions, such as the z-axis. This nonlinear behavior underscores the need for advanced decoupling methods beyond simple linear models. The output characteristics for various directions, such as Fx and Fz, were plotted, revealing deviations that contribute to errors in uncorrected measurements. The overall dataset was normalized to a range of [-1, 1] to facilitate neural network training, ensuring faster convergence and improved accuracy.
The core of our approach lies in the integration of the Osprey Optimization Algorithm with a Radial Basis Function Neural Network. RBFNN is a feedforward neural network known for its excellent nonlinear approximation capabilities, making it suitable for modeling complex sensor behaviors. It consists of an input layer, a hidden layer with radial basis functions, and an output layer. The Gaussian function is commonly used as the activation function in the hidden layer, defined as:
$$\phi(\|x_i – \mu_i\|) = \exp\left(-\frac{\|x_i – \mu_i\|^2}{2\sigma_i^2}\right)$$
where \(x_i\) is the input vector, \(\mu_i\) is the center of the i-th hidden node, and \(\sigma_i\) is the width parameter. The output of the RBFNN is computed as a weighted sum of these radial basis functions:
$$R_i = \sum_{i=1}^{n} \omega_i \phi(\|x_i – \mu_i\|^2)$$
where \(\omega_i\) represents the weights between the hidden and output layers. However, the performance of RBFNN heavily depends on the selection of centers, widths, and weights. Random initialization often leads to suboptimal results, which is why we employ OOA for optimization.
The Osprey Optimization Algorithm mimics the hunting behavior of ospreys, involving global exploration and local exploitation phases. In the global phase, ospreys search for prey by dynamically adjusting their positions based on the best-found solutions, enhancing the algorithm’s ability to avoid local optima. The position update in this phase is given by:
$$y_{pl,i,j} = y_{i,j} + r_{i,j} \cdot (S_{A_{i,j}} – I_{i,j} \cdot y_{i,j})$$
where \(y_{i,j}\) is the current position, \(r_{i,j}\) is a random number, \(S_{A_{i,j}}\) is the selected target position, and \(I_{i,j}\) is a random integer. In the local phase, ospreys refine their positions to simulate carrying prey to a safe spot, calculated as:
$$y_{p2,i,j} = y_{i,j} + \frac{lb_j + r \cdot (ub_j – lb_j)}{t}$$
where \(lb_j\) and \(ub_j\) are the lower and upper bounds, \(r\) is a random value, and \(t\) is the current iteration. The fitness function for OOA is the mean squared error (MSE) between predicted and actual outputs:
$$MSE = \frac{1}{n} \sum_{i=1}^{n} (\alpha_i – \alpha’_i)^2$$
where \(\alpha_i\) is the predicted value, \(\alpha’_i\) is the true value, and \(n\) is the number of samples. By minimizing MSE, OOA optimizes the RBFNN parameters, leading to improved decoupling accuracy. The combined OOA-RBF algorithm involves initializing the osprey population, evaluating fitness, updating positions, and iterating until convergence. The optimized parameters are then used to train the RBFNN, resulting in a robust model for decoupling the six-axis force sensor outputs.
To implement the decoupling experiment, we developed a software application in Visual Studio 2022 using the .NET 8 framework. The code comprises several classes: Program (main entry point), QR (for matrix decomposition), DataNormalization (for preprocessing), and OOA-RBFNetwork (core algorithm). The dataset of 252 samples was randomly split into 80% for training and 20% for testing. Data normalization was applied to scale inputs to the [-1, 1] range, improving training efficiency. The OOA parameters included a population size of 30 and a maximum of 200 iterations. The RBFNN was configured with 6 input nodes (corresponding to capacitor readings) and 6 output nodes (for force and moment components). We compared the OOA-RBF algorithm against three established methods: Least Squares (LS), Backpropagation Neural Network (BPNN), and standard RBFNN. This comparative analysis allowed us to evaluate performance in terms of decoupling errors.
The effectiveness of decoupling algorithms is typically assessed using Type I and Type II errors. Type I error, or nonlinear error, measures the deviation in the primary direction of loading, calculated as:
$$\delta_1 = \frac{F_i – F’_i}{Z_i}$$
where \(F_i\) is the applied load, \(F’_i\) is the measured load, and \(Z_i\) is the full-scale value. Type II error, or coupling error, quantifies the interference from other directions:
$$\delta_2 = \frac{F_{ij}}{Z_i}$$
where \(F_{ij}\) is the spurious output in direction i when loading direction j. Lower values of these errors indicate better decoupling performance. Our experiments revealed that the OOA-RBF algorithm significantly outperforms other methods. For instance, the maximum Type I error for OOA-RBF was 0.0228%, compared to 1.1514% for LS, 1.0176% for BPNN, and 0.1071% for RBFNN. Similarly, the maximum Type II error for OOA-RBF was 0.0279%, whereas LS, BPNN, and RBFNN had errors of 1.6312%, 1.0790%, and 0.2290%, respectively. The following table summarizes the error comparisons across all six directions, highlighting the superior accuracy of OOA-RBF.
| Algorithm | Direction | Fx | Fy | Fz | Mx | My | Mz |
|---|---|---|---|---|---|---|---|
| LS | Fx | 1.0112 | 0.7530 | 0.1153 | 0.3423 | 0.0534 | 1.6312 |
| Fy | 0.6314 | 0.3074 | 0.2674 | 0.2392 | 0.3361 | 0.6370 | |
| Fz | 0.4520 | 0.3091 | 0.6542 | 0.5531 | 0.4362 | 0.2384 | |
| Mx | 0.9731 | 0.5242 | 0.7101 | 1.1514 | 0.4503 | 0.1134 | |
| My | 0.9731 | 0.9802 | 1.4364 | 0.0865 | 0.9412 | 0.5961 | |
| Mz | 0.4513 | 0.8904 | 1.1542 | 0.8582 | 0.0761 | 0.6182 | |
| BPNN | Fx | 0.5028 | 0.0833 | 0.1801 | 0.0351 | 0.0216 | 0.2868 |
| Fy | 0.1458 | 0.1686 | 0.0421 | 0.0399 | 0.0367 | 0.1464 | |
| Fz | 0.0104 | 0.3750 | 1.0176 | 0.4518 | 1.0790 | 0.0368 | |
| Mx | 0.0107 | 0.1499 | 0.0178 | 0.0207 | 0.0609 | 0.0266 | |
| My | 0.2116 | 0.2118 | 0.2922 | 0.1269 | 0.3494 | 0.1959 | |
| Mz | 0.0554 | 0.0238 | 0.0013 | 0.0689 | 0.2966 | 0.0704 | |
| RBFNN | Fx | 0.0535 | 0.0593 | 0.0524 | 0.1178 | 0.0435 | 0.1329 |
| Fy | 0.0108 | 0.0171 | 0.0314 | 0.0221 | 0.0467 | 0.1001 | |
| Fz | 0.0011 | 0.0197 | 0.0662 | 0.0899 | 0.0067 | 0.0058 | |
| Mx | 0.0028 | 0.0190 | 0.0292 | 0.0342 | 0.0422 | 0.0017 | |
| My | 0.0015 | 0.0166 | 0.0890 | 0.2290 | 0.1071 | 0.0799 | |
| Mz | 0.1753 | 0.0306 | 0.0181 | 0.0223 | 0.2478 | 0.0169 | |
| OOA-RBF | Fx | 0.0026 | 0.0027 | 0.0116 | 0.0113 | 0.0105 | 0.0097 |
| Fy | 0.0019 | 0.0228 | 0.0121 | 0.0090 | 0.0012 | 0.0042 | |
| Fz | 0.0063 | 0.0098 | 0.0193 | 0.0190 | 0.0075 | 0.0062 | |
| Mx | 0.0042 | 0.0067 | 0.0033 | 0.0218 | 0.0279 | 0.0025 | |
| My | 0.0009 | 0.0005 | 0.0037 | 0.0064 | 0.0034 | 0.0010 | |
| Mz | 0.0030 | 0.0001 | 0.0018 | 0.0031 | 0.0066 | 0.0020 |
Further analysis using box plots illustrates the distribution of errors across the six directions for each algorithm. The OOA-RBF algorithm shows the tightest error distribution, with median and mean errors below 0.05% for all directions, indicating high consistency and precision. In contrast, LS and BPNN exhibit wider spreads and higher outliers, reflecting their susceptibility to nonlinearities and couplings. The RBFNN performs better but still lags behind OOA-RBF due to suboptimal parameter selection. The optimization process of OOA ensures that the RBFNN parameters are finely tuned, reducing overfitting and enhancing generalization. This is particularly important for real-world applications where the six-axis force sensor may encounter varying operating conditions.
The implementation of the OOA-RBF algorithm in a .NET environment demonstrates its practicality for embedded systems or real-time processing. The software architecture allows for efficient data handling and model execution, making it suitable for integration into sensor systems. During training, the OOA-RBF network achieved rapid convergence, with the MSE dropping significantly within the first 50 iterations. This efficiency is attributed to the global search capabilities of OOA, which avoids local minima common in gradient-based methods. For the six-axis force sensor, this translates to faster calibration and improved reliability in dynamic environments.
In conclusion, the OOA-RBF decoupling algorithm represents a significant advancement in enhancing the accuracy of capacitive six-axis force sensors. By combining the nonlinear modeling strengths of RBFNN with the robust optimization of OOA, we achieve a decoupling performance that surpasses traditional methods. The algorithm reduces both Type I and Type II errors to below 0.03%, ensuring precise measurements in multi-dimensional force sensing applications. Future work could explore adaptive versions of OOA-RBF for online learning or extend its application to other types of multi-axis sensors. Overall, this approach underscores the importance of intelligent algorithms in overcoming the limitations of physical sensor designs, paving the way for more reliable and accurate six-axis force sensor systems in robotics, aerospace, and beyond.
The development and validation of the OOA-RBF algorithm highlight its potential for widespread adoption. As six-axis force sensors become increasingly integral to advanced automation, such decoupling techniques will play a crucial role in ensuring data integrity and system performance. We encourage further research into hybrid optimization methods and real-time implementations to push the boundaries of sensor technology.