Intelligent Hybrid Control for Conveyor Belt Speed Optimization: Integration of Fuzzy Logic and Neural Networks with PID Control

The integration of artificial intelligence methods with traditional control systems has gained significant momentum in recent years, particularly in conveyor belt control applications.

Mirzoev and Serdarova [10] established a model reference adaptive control (MRAC) framework for belt conveyors using Siemens S7-300, improving speed regulation under variable loads but lacking neural network adaptation.

Aniba et al. [11] developed digital twins for conveyor systems integrating real-time sensor data with predictive models, focusing on monitoring rather than active control.

Zheng et al. [12] demonstrated terminal sliding mode control with RBF networks for acupuncture robots; their neural adaptation methodology provided insights for handling conveyor system uncertainties.

Kiriia and Shyrin [13] implemented fuzzy PID cascade control with a Gradio-based human-machine interface (HMI) for weighing conveyors, addressing sensor integration and safety monitoring.

These works collectively establish foundations for hybrid conveyor control, but each addresses only partial aspects. The current study integrates PID, fuzzy logic, and RBF networks with adaptive weighting and bidirectional synergy, bridging the gap between individual methods and comprehensive hybrid architectures.

4.1 Conveyor belt system dynamics

The mathematical foundation of the conveyor belt system incorporates both electrical and mechanical dynamics. The electrical dynamics of the direct current (DC) motor driving the conveyor are governed by:

${{V}_{s}}\left( t \right)=R\cdot i\left( t \right)+L\frac{di\left( t \right)}{dt}+{{K}_{b}}\cdot \omega \left( t \right)$        (1)

where, ${{V}_{s}}$ represents the supply voltage, R is the armature resistance (0.5 Ω), L is the armature inductance ($2\times {{10}^{-2}}$H), i(t) is the armature current, ${{K}_{b}}$ is the back electromotive force (EMF) constant ($2.83\times {{10}^{-2}}$Vs/rad), and ω(t) is the angular velocity.

The mechanical dynamics follow Newton's law for rotational motion:

${{J}_{tot}}\frac{d\omega \left( t \right)}{dt}={{K}_{m}}\cdot i\left( t \right)-{{K}_{f}}\cdot \omega \left( t \right)-{{T}_{c}}$        (2)

where, ${{J}_{tot}}~$is the total system inertia (2.5 kgm²), ${{K}_{m}}$ is the torque constant ($2.83\times {{10}^{-2}}$ Nm/A), ${{K}_{f}}$ is the viscous damping coefficient (4.83×${{10}^{-2}}$kgm²/s), and TcTc represents the conveyor torque.

This lumped-parameter model captures dominant speed-control dynamics; the electrical time constant (L/R = 0.4 ms) is much smaller than the mechanical constant (J/B = 500 s), justifying a reduced-order model. The adaptive components-RBF network and fuzzy logic-compensate for unmodelled dynamics (belt elasticity, distributed mass, friction), so model simplification does not compromise performance, as validated experimentally in Section 5.

4.2 Energy consumption modelling

Energy consumption is incorporated through resistance-based power models:

$P=\frac{F\cdot v}{1000}\left( kW \right)$           (3)

tu_pian_18.png

Figure 2. Conveyor belt system mathematical model block diagram

where, the total force F encompasses indentation rolling resistance, bulk solid flexure resistance, and secondary resistances, accounting for 89% of total motion resistance. Variable speed optimization enables energy efficiency through dynamic belt speed adjustment:

${{v}_{opt}}=\frac{Q}{\rho \cdot A}$       (4)

Figure 2 illustrates the complete mathematical model of the conveyor belt system, showing the interaction between the electrical and mechanical subsystems. The electrical subsystem includes the input voltage V(s), armature resistance and inductance, back EMF feedback, and armature current. The mechanical subsystem depicts the torque generation, angular velocity dynamics, inertia effects, and load torque interactions that characterize the conveyor belt's rotational behaviour.

4.3 Proportional-integral-derivative controller development

A PID controller modulates the control signal using three control actions. The main function is to keep the feedback signal (process variable) and desired output (set point) consistent. The proportional (P) control multiplies the error by a constant P to output. The Integral (I) control solves the Proportional control's steady-state problems by retaining the error value until it is neutralised. The Derivative (D) control can predict system behaviour by considering the error's rate of change. The following equation describes a common PID:

$a\left( t \right)={{K}_{p}}\left[ e\left( t \right)+\frac{1}{{{T}_{i}}}\mathop{\int }_{0}^{t}e\left( \tau  \right)d\tau +{{T}_{d}}\frac{de\left( t \right)}{dt} \right]$            (5)

where, a(t) is the control signal, e(t) is the error between set point and process variable, K_p is the proportional gain, T_i is the integral time constant, T_d is the derivative time constant.

This formulation highlights the role of each control action in maintaining system stability and performance. The proportional term provides an immediate response to current error, the integral term eliminates steady-state error by accumulating past errors, and the derivative term provides anticipatory control by responding to the rate of error change.

Figure 3 presents the conventional PID control structure for conveyor belt speed regulation.

tu_pian_19.png

Figure 3. Proportional-integral-derivative (PID) controller architecture for conveyor speed control

Table 2. Fuzzy membership function definitions

It shows the desired speed setpoint input, error calculation through comparison with measured speed feedback, and the three parallel control actions: proportional gain (K_p), integral gain (K_i), and derivative gain (K_d). The combined control signal is fed to the motor driver, which actuates the conveyor belt motor and load system to achieve the desired speed response.

4.4 Fuzzy logic controller development

4.4.1 Fuzzy logic control architecture

The fuzzy logic controller (FLC) represents a critical component of the hybrid control system, providing human-like reasoning capabilities to handle the nonlinear characteristics and uncertain operating conditions inherent in conveyor belt systems. The FLC architecture consists of three fundamental components: Fuzzification, inference engine, and defuzzification, each contributing to the overall control strategy through linguistic rule-based decision-making.

The fuzzification process converts crisp input values into fuzzy sets using carefully designed membership functions. For the conveyor belt speed control application, the primary input variables are the speed error (e) and change in speed error (Δe), while the output variable is the control signal (u). The linguistic variables are defined using seven membership functions: "negative large" (NL), "negative medium" (NM), "negative small" (NS), "zero" (Z), "positive small" (PS), "positive medium" (PM), and "positive large" (PL).

4.4.2 Membership function design

The membership functions are designed using triangular and trapezoidal shapes to provide smooth transitions between linguistic states. The universe of discourse for the speed error ranges from -10 to +10 rad/s, while the change in speed error spans -5 to +5 rad/s². The output control signal varies between -100% to +100% of the maximum control effort. The membership function parameters are optimized through genetic algorithm techniques to minimize system overshoot and steady-state error. The complete fuzzy membership function definitions are summarised in Table 2. Comparative assessments of membership function shapes for step and smooth input tracking are reported in the study [14].

The parameters were validated for completeness (ensuring unity coverage across the universe of discourse) and consistency (avoiding contradictory rule activations). Sensitivity analysis showed that ±10% variations in membership function parameters resulted in less than 5% change in overall control performance.

4.4.3 Fuzzy rule base development

The fuzzy rule base consists of 49 IF-THEN rules that capture the expert knowledge for conveyor belt speed control. The rules are formulated based on the principle that large errors require large control actions, while small errors need fine adjustments. The rule structure follows the format: "IF speed error is X AND change in speed error is Y, THEN control output is Z".

4.4.4 Inference engine and defuzzification

The inference engine employs the Mamdani method for fuzzy reasoning, utilizing minimum operation for rule antecedent aggregation and maximum operation for rule consequent combination. This approach provides intuitive interpretation of the control rules and maintains computational efficiency suitable for real-time implementation.

The defuzzification process converts the fuzzy output into a crisp control signal using the centroid method:

${{u}_{crisp}}=\frac{\mathop{\sum }_{i=1}^{n}{{\mu }_{i}}{{u}_{i}}}{\mathop{\sum }_{i=1}^{n}{{\mu }_{i}}}$          (6)

where, ${{\mu }_{i}}$ represents the membership degree of the i-th output fuzzy set and ${{u}_{i}}$ is the corresponding crisp value.

Figure 4 depicts the fuzzy logic controller architecture consisting of three main components: fuzzification (converting crisp input values like speed error and load conditions into fuzzy sets), inference engine with rule base (processing IF-THEN fuzzy rules such as "IF Speed is Fast AND Load is High THEN Motor Power is Reduced"), and defuzzification (converting the fuzzy output back to crisp control signals for motor actuation). This system enables human-like reasoning for handling nonlinear conveyor dynamics.

tu_pian_20.png

Figure 4. Fuzzy logic control system for conveyor belt applications

4.5 Neural network radial basis function controller development

4.5.1 Radial basis function neural network architecture

The radial basis function (RBF) neural network controller represents a sophisticated adaptive control component [11] within the hybrid system, providing nonlinear approximation capabilities and real-time learning for conveyor belt speed optimization. The RBF network architecture consists of three distinct layers: an input layer, a hidden layer with RBF neurons, and a linear output layer. This structure enables the network to approximate complex nonlinear mappings between system inputs and desired control outputs with high accuracy and computational efficiency. Adaptive neural network control of nonlinear systems with unknown dynamics is addressed in the study [15], while the design, analysis, and simulation of RBF network control for mechanical systems is detailed in the study [16].

The input layer receives system state variables including current belt speed ($\omega \left( t \right)$), speed error ($e\left( t \right)$), change in speed error ($\dot{e}\left( t \right)$), and load disturbance estimates (d(t)). The hidden layer contains N-RBF neurons, each characterized by a center vector (${{c}_{i}}$) and width parameter (${{\sigma }_{i}}$), while the output layer produces the neural network control signal (${{u}_{NN}}$) through a weighted linear combination of hidden layer outputs.

4.5.2 Radial basis function activation function and network dynamics

The RBF neurons employ Gaussian activation functions that provide localized response characteristics essential for conveyor belt control applications:

${{\phi }_{i}}\left( x \right)=exp\left( -\frac{\parallel x-{{c}_{i}}{{\parallel }^{2}}}{22_{\sigma }^{i}} \right)$         (7)

where, x represents the input vector, ${{c}_{i}}$ is the center of the i-th RBF neuron, and ${{\sigma }_{i}}$ is the corresponding width parameter. The network output is computed as:

${{u}_{NN}}\left( t \right)=\underset{i=1}{\overset{N}{\mathop \sum }}\,{{w}_{i}}{{\phi }_{i}}\left( x\left( t \right) \right)+{{w}_{0}}$        (8)

where, ${{w}_{i}}$ are the output layer weights and ${{w}_{0}}$ is the bias term. The localized nature of RBF functions ensures that only neurons in the vicinity of the current input contribute significantly to the output, providing excellent generalization capabilities and computational efficiency.

4.5.3 Adaptive learning algorithm

The RBF network training employed a structured approach with clearly defined convergence criteria. The network architecture consisted of 15 hidden neurons, determined through systematic evaluation of network complexity versus approximation accuracy. Training data was collected through extensive simulation runs covering the operational envelope, with 80% used for training and 20% for validation.

The training parameters of the RBF neural network are summarised as follows: an initial learning rate of 0.01 with adaptive decay (0.9 every 100 epochs), a convergence criterion of mean square error (MSE) <1 × 10^-4 or maximum 1000 epochs, an L2 regularisation coefficient of 0.001, and uniformly distributed initial weights within the range of [-0.5, 0.5].

The network typically converged within 300-500 epochs, with training MSE reaching the specified threshold. Cross-validation revealed generalization error within 15% of training error, indicating acceptable generalization capability. The RBF centers were initialized using k-means clustering on representative training data, with width parameters set using the nearest neighbour method with P = 3.

RBF training used a two-phase approach [12]: Phase 1 (unsupervised) employed K-means++ to initialise 25 centres from 1,000 samples (0–25 rad/s, 0–100% load), validated by silhouette analysis (>0.7), with recursive least squares (RLS) updating output weights (λ = 0.995). Phase 2 (supervised) used Levenberg-Marquardt fine-tuning (μ = 0.001), achieving MSE <10⁻⁴ within 300-500 epochs. Five-fold cross-validation confirmed generalisation.

4.5.4 Backstepping Integration with radial basis function network

The integration of RBF neural networks with backstepping control creates a powerful adaptive control framework [17] capable of handling system uncertainties and external disturbances. The backstepping procedure is designed in multiple steps, with the RBF network providing uncertainty compensation at each level. Hybrid schemes combining RBF neural network supervisory control with expert PID are reported in the study [18], and RBF-based adaptive fault-tolerant control of electromechanical servo systems is presented in the study [19].

Step 1: Speed error dynamics

Define the speed tracking error as ${{e}_{1}}=\omega -{{\omega }_{d}}$, where ${{\omega }_{d}}$ is the desired speed. The error dynamics are:

$\overset{}{\mathop{{{e}_{1}}}}\,=\dot{\omega }-\overset{}{\mathop{{{\omega }_{d}}}}\,={{f}_{1}}\left( x \right)+{{g}_{1}}\left( x \right)u+{{d}_{1}}-\overset{}{\mathop{{{\omega }_{d}}}}\,$         (9)

where, ${{f}_{1}}\left( x \right)$ and ${{g}_{1}}\left( x \right)$ represent known system dynamics, u is the control input, and ${{d}_{1}}$ represents uncertainties.

Step 2: Virtual control design

A virtual control law is designed to stabilize the speed error:

${{\alpha }_{1}}=-{{k}_{1}}{{e}_{1}}-{{\hat{f}}_{1}}\left( x \right)+{{\dot{\omega }}_{d}}$         (10)

where, ${{k}_{1}}$>0 is a design parameter and ${{\hat{f}}_{1}}\left( x \right)$ is the RBF network approximation of the uncertain dynamics.

Step 3: RBF uncertainty compensation

The RBF network approximates the unknown function ${{f}_{1}}\left( x \right)$:

${{f}_{1}}\left( x \right)={{W}^{T}}\phi \left( x \right)+\epsilon \left( x \right)$           (11)

where, $W$ is the ideal weight vector and $\epsilon \left( x \right)$ is the approximation error bounded by ∣ϵ(x)∣ ≤ ϵ0∣ϵ(x)∣ ≤ ϵ0.

4.5.5 Stability analysis and convergence

The stability of the RBF-based backstepping controller is analysed using Lyapunov theory. Consider the Lyapunov function:

$V=\frac{1}{2}2_{e}^{1}+\frac{1}{2\gamma }{{\tilde{W}}^{T}}\tilde{W}$          (12)

where, $\tilde{W}=W-\hat{W}$ is the weight estimation error and γ > 0γ > 0 is the adaptation gain. The time derivative of the Lyapunov function yields:

$\dot{V}={{e}_{1}}\overset{}{\mathop{{{e}_{1}}}}\,+\frac{1}{\gamma }{{\tilde{W}}^{T}}\overset{}{\mathop{{\tilde{W}}}}\,$          （13）

By choosing the weight update law as:

Substituting the weight update law Eq. (16) into (13), the derivative of the Lyapunov function simplifies to:

$V=-ke{}^\text{2}+\varepsilon \varphi \left( x \right)$         (14)

where, the first term is negative definite in the tracking error e. By applying Young's inequality, the cross term can be bounded as |ε̃ᵀφ(x)| ≤ (1/2δ)|e|² + (δ/2)|φ(x)|² for any δ > 0. Choosing k₁ sufficiently large such that k₁ > 1/(2δ) ensures:

$V\le -\left( k-1/\left( 2\delta  \right) \right)e{}^\text{2}-\left( \gamma \lambda \_min-\delta /2 \right)\left| \varepsilon  \right|{}^\text{2}$         (15)

This is negative definite when γ > δ/(2λ_min) (where λ_min is the minimum eigenvalue of Φ(x)). Choosing k₁ > 1/(2δ) and γ > δ/(2λ_min) ensures V̇ ≤ 0, guaranteeing convergence of e and ε̃ to a compact set. By LaSalle's principle, trajectories converge to the invariant set where V̇ = 0. The ultimate bound |e| ≤ ε₀/(k₁ − 1/(2δ)) yields 0.04 rad/s for k₁ = 5, δ = 0.5, γ = 0.1, consistent with observed 0.02-0.03 rad/s.

Speed-dependent analysis: at low setpoints (2-5 rad/s), the hybrid controller improved performance by 73-80% due to effective nonlinear compensation; at higher setpoints (10-20 rad/s), improvements were 27-51% as variable frequency drive (VFD) saturation and friction linearization reduced the controller's relative advantage.

$\overset{}{\mathop{{\hat{W}}}}\,=\gamma {{e}_{1}}\phi \left( x \right)-\sigma \hat{W}$        (16)

Figure 5 illustrates the RBF neural network controller structure with three distinct layers. The input layer receives system state variables including current speed, speed error, change in error, and load disturbance. The hidden layer contains multiple RBF neurons, each employing Gaussian activation functions (φ₁, φ₂, etc.) that provide localized response characteristics. The output layer combines the weighted outputs from all RBF neurons through linear summation with bias term to produce the neural network control signal. The weights (w₁, w₂, etc.) are adaptively updated during operation to learn system dynamics and provide uncertainty compensation.

tu_pian_21.png

Figure 5. Radial basis function (RBF) neural network controller architecture for conveyor belt speed control

4.6 Fuzzy logic-neural network radial basis function hybrid controller development

4.6.1 Hybrid architecture integration

The fuzzy logic-neural network RBF (PID-FL-RBF-NN) hybrid controller represents the pinnacle of intelligent control integration, combining the human-like reasoning capabilities of fuzzy logic with the adaptive learning and nonlinear approximation power of RBF neural networks. This synergistic architecture addresses the individual limitations of each control paradigm while amplifying their collective strengths for superior conveyor belt speed control performance.

The hybrid architecture operates through a parallel-cooperative structure where the fuzzy logic component provides rule-based reasoning for different operating regions, while the RBF neural network continuously learns and adapts to system dynamics and uncertainties. The integration mechanism employs a weighted fusion strategy that dynamically adjusts the contribution of each component based on system operating conditions and performance metrics.

The overall control law for the PID-FL-RBF-NN hybrid controller is expressed as:

$\begin{aligned} u_{\text {hybrid }}(t)= & \alpha(t) \cdot u_{F L}(t)+\beta(t) \cdot u_{R B F}(t) +u_{\text {compensation }}(t)\end{aligned}$       (17)

where, $\alpha (t$) and $\beta \left( t \right)$ are adaptive weighting factors satisfying α(t) + β(t) = 1, and ${{u}_{compensation}}\left( t \right)$ provides additional uncertainty compensation.

4.6.2 Adaptive weighting mechanism

The adaptive weighting mechanism dynamically adjusts the contribution of fuzzy logic and RBF neural network components based on real-time performance indicators and system operating conditions. The weighting factors are computed using a performance-based switching function:

$\alpha \left( t \right)=\frac{1}{1+\exp \left( -{{k}_{\alpha }}\left( {{P}_{FL}}\left( t \right)-{{P}_{RBF}}\left( t \right) \right) \right)}$        (18)

$\beta \left( t \right)=1-\alpha \left( t \right)$            (19)

where, ${{k}_{\alpha }}$ is the switching gain, and ${{P}_{FL}}\left( t \right)$ and ${{P}_{RBF}}\left( t \right)$ represent the performance indices of the fuzzy logic and RBF components, respectively. The performance indices are calculated based on tracking error, control effort, and adaptation rate:

$\begin{gathered}P_{F L}(t)=w_1 e^{-\lambda_1|e(t)|} +w_2 e^{-\lambda_2|\dot{e}(t)|}+w_3 e^{-\lambda_3\left|u_{F L}(t)\right|}\end{gathered}$       (20)

$\begin{gathered}P_{R B F}(t)=w_4 e^{-\lambda_4|e(t)|}+w_5 e^{-\lambda_5|\dot{e}(t)|} \quad+w_6 \cdot \text { adaptation rate }(t)\end{gathered}$        (21)

where, ${{w}_{i}}$ are weighting coefficients and ${{\lambda }_{i}}$ are decay constants optimized through a genetic algorithm.

4.6.3 Fuzzy-neural synergy mechanisms

The synergy between fuzzy logic and RBF neural networks is achieved through multiple interaction mechanisms that enhance overall system performance:

Mechanism 1: Fuzzy rule refinement

The RBF network continuously monitors the performance of fuzzy rules and provides refinement signals to adjust rule weights and membership function parameters:

$new_{w}^{rule,i}=old_{w}^{rule,i}+{{\eta }_{rule}}\cdot {{\delta }_{RBF,i}}\cdot e\left( t \right)$         (22)

where, ${{\eta }_{rule}}$ is the rule adaptation rate and ${{\delta }_{RBF,i}}$ is the refinement signal from the RBF network.

Mechanism 2: Neural network initialization

Fuzzy logic provides intelligent initialization for RBF network centers and weights based on expert knowledge:

$initial_{c}^{i}=centroid(fuzzy~regio{{n}_{i}})$        (23)

$initial_{w}^{i}=\frac{rule~strengt{{h}_{i}}}{\mathop{\sum }_{j=1}^{N}rule~strengt{{h}_{j}}}$         (24)

Mechanism 3: Uncertainty partitioning

The hybrid system partitions uncertainty handling between components, with fuzzy logic addressing known nonlinearities and RBF networks handling unknown dynamics:

$\begin{gathered}u_{\text {compensation }}(t)= u_{F L_1 \text { ncertainty }}(t)+u_{R B F_1 \text { ncertainty }}(t)\end{gathered}$        (25)

Figure 6 shows the complete hybrid control architecture that integrates three control paradigms: traditional PID control, fuzzy logic control, and RBF neural network control.

tu_pian_22.png

Figure 6. Hybrid proportional-integral-derivative (PID)-fuzzy logic-radial basis function (RBF) neural network (PID-FL-RBF-NN) control system integration

The system receives reference input and error signals, processes them through parallel control paths with adaptive weighting factors (α, β, γ), and combines their outputs to generate the final control signal. The diagram illustrates the adaptive mechanisms for uncertainty compensation and the feedback loops that enable each controller to contribute its strengths while mitigating individual weaknesses. The integration includes adaptability compensation and uncertainty compensation modules that enhance overall system robustness and performance.

6.1 No-load conditions

Simulations used MATLAB/Simulink R2023a: fixed-step Runge-Kutta solver, 0.01 s step, 50 s duration. PID gains (K_p = 0.6, K_i = 0.5, K_d = 0.125) via Ziegler-Nichols. RBF: 15 neurons (grid-searched 10–30), Gaussian activation, K-means initialization. Fuzzy logic: 49 rules (7 × 7), triangular membership. Adaptive weights: sigmoid switching, k_s = 2.5.

Under no-load conditions, the hybrid controller showed consistent improvements: 20-31% faster rise time, 28-34% shorter settling time, and 27-32% overshoot reduction across all setpoints. At 5 rad/s, overshoot dropped from 54% (PID) to 38%, with steady-state error improving by 32% (Figure 7).

At 10 and 20 rad/s, improvements continued: overshoot decreased from 30% to 22% (Figure 8) and from 12.5% to 8.5% (Figure 9), respectively. Higher setpoints exhibited smaller relative gains due to VFD saturation and friction linearisation effects, though absolute performance remained superior. The corresponding time-domain error metrics are listed in Table 3, and the improvements across all test conditions are summarised in Table 4.

Energy consumption was measured at four setpoints: the hybrid controller achieved 19-23% reduction (e.g., 2 rad/s: 51.8→40.6 kJ, 21.6%; 10 rad/s: 38.2→30.9 kJ, 19.1%) through reduced current draw during transients and smoother acceleration profiles.

tu_pian_23.png

Figure 7. Motor angular velocity at 5 rad/s

tu_pian_24.png

Figure 8. Motor angular velocity at 10 rad/s

tu_pian_25.png

Figure 9. Motor angular velocity at 20 rad/s

Table 3. Time-domain error metrics for controller comparison

Note: Proportional-integral-derivative (PID), radial basis function (RBF), RBF neural network (RBF-NN).

Table 4. Summary of hybrid controller improvements across all test conditions

Note: Percentages represent improvement of the hybrid PID–FL–RBF-NN controller relative to baseline PID. Overshoot reduction is calculated as (OS_PID-OS_hybrid)/OS_PID × 100%.

6.2 Overshoot behaviour analysis

The residual 38% overshoot at 5 rad/s (down from 54% baseline PID) requires contextualization within conveyor system constraints. Three factors limit further overshoot reduction in simulation:

Motor voltage saturation at ±24 V limits aggressive damping during initial transients. Removing saturation in sensitivity analysis reduced overshoot to 22%, confirming actuator limits as the primary bottleneck-a physical reality in industrial implementations.

The 38% overshoot represents near-optimal performance for the given system dynamics (ζ = 0.42 damping ratio from electrical/mechanical time constant interaction) without violating Bode stability margins (phase margin ≥60°, gain margin ≥10 dB required for industrial robustness). Li et al. [20] and Najar et al. [21] reported 35-45% overshoot as typical for optimally tuned conveyor PID controllers, establishing that our 38% result aligns with theoretical expectations.

Overshoot scales inversely with setpoint (8.5% at 20 rad/s vs 38% at 5 rad/s) because controller bandwidth relative to system dynamics improves at higher speeds. This phenomenon matches industrial observations where low-speed positioning exhibits larger relative overshoots than high-speed transport.

The 30% overshoot reduction (54%-38%) achieved by the hybrid controller exceeds the 20-25% improvement Mirzoev and Serdarova [10] reported for neural network conveyor controllers, demonstrating competitive performance within simulation environment constraints.

tu_pian_26.png

Figure 10. Motor angular velocity at 2.5 rad/s (step load disturbance: 50% sudden increase in material loading)

To evaluate whether the adaptive weighting mechanism provides benefits over a simpler fixed-weight design, an additional comparison was conducted with α = β = 0.5 (equal fixed weighting). The fixed-weight hybrid achieved 18% ITAE improvement versus the baseline PID, compared to 23% for the adaptive scheme-a 5 percentage-point advantage. This difference was most pronounced during transient phases and under disturbance conditions, where the adaptive scheme's ability to shift weight toward fuzzy logic (for rapid nonlinear handling) and neural networks (for uncertainty compensation) provided measurable benefits. At steady-state under nominal conditions, the difference between fixed and adaptive weighting was minimal (<2%), suggesting that the adaptive mechanism's primary value lies in handling operating transitions and disturbances rather than steady-state operation. This comparison confirms that the adaptive weighting is not merely added complexity but provides quantifiable performance gains in dynamic scenarios. The complete integral error metrics are summarised in Table 5.

Table 5. Integral error metrics for controller comparison

Note: Proportional-integral-derivative (PID), radial basis function (RBF), RBF neural network (RBF-NN), Integral time absolute error (ITAE).

This paper presented a hybrid controller integrating PID, fuzzy logic, and RBF networks with adaptive weighting for conveyor belt speed control. Component-wise evaluation showed fuzzy logic contributed 8-12%, RBF 12-18%, and their adaptive combination 20- 31%, demonstrating synergy beyond additive effects. Validation across four setpoints (2.5-20 rad/s), variable loads, and three disturbance types confirmed 50-70% transient improvement, 19-23% energy reduction, with 48-52 ms PLC execution.

The component-wise evaluation methodology provides three critical benefits that strengthen both the theoretical foundation and practical applicability of the proposed architecture.

First, the quantified individual contributions, with fuzzy logic delivering 8-12% improvement through region-wise gain scheduling and neural networks adding 5-8% enhancement via adaptive learning, enable designers to make informed trade-offs between system complexity and performance gains. For resource-constrained applications, these findings suggest that deploying only the PID-FL variant may suffice if the additional computational overhead of neural network training cannot be justified.

Second, the demonstration of true synergy is significant: the combined adaptive weighting achieved 23% integral error reduction, which substantially exceeds the arithmetic sum of individual contributions (13-20%). This validates the core hypothesis that performance-based coordination creates complementary rather than redundant control actions, where fuzzy logic handles operating-region transitions while neural networks compensate for residual uncertainties in steady-state.

Third, the composite Lyapunov analysis provides initial stability insights for the proposed architecture, contributing to the limited body of formal stability work in conveyor control literature, though the analysis remains incomplete and would benefit from further refinement. This analysis, while incomplete, offers partial confidence in the architecture's reliability but also provides a systematic framework for tuning the weighting parameters α(t) and β(t) to ensure bounded tracking error under parametric uncertainties.

Parameter sensitivity at 10 rad/s, 50% load, ±20% variations: motor resistance R change caused 8% settling-time degradation (hybrid) vs 25% (PID); inertia J change caused 12% vs 40% overshoot increase; friction change caused 15% vs 35% steady-state error increase. The RBF network's online compensation provides significant robustness over fixed-gain PID.