Simulation and Experimental Evaluation of DC Motor Control Strategies Using MATLAB and Arduino Mega

The increasing adoption of electric transportation systems is driven by the urgent need to reduce CO₂ emissions and improve air quality. Among various types of electric motors, DC motors are essential for applications ranging from transportation to robotics and industrial automation due to their simplicity, efficiency, and precise control. However, achieving optimal performance in these systems requires effective and reliable control strategies to address challenges such as non-linearity, disturbances, and parameter uncertainties. The development and implementation of robust control techniques—such as Proportional-Integral-Derivative (PID) control, Fuzzy Logic Control (FLC), and Sliding Mode Control (SMC)—are crucial to meet the dynamic demands of DC motor control [1].

Accurate speed regulation of DC motors is crucial because it directly affects the efficiency, reliability, and performance of various practical applications. In electric vehicles, precise speed control ensures smooth acceleration, energy efficiency, and an enhanced driving experience. In industrial automation, DC motors are fundamental to systems such as conveyors, robotic arms, and precision production processes, where even minor speed variations can compromise product quality and operational safety. In the healthcare sector, medical technologies like surgical robots and infusion pumps rely on DC motors for their accuracy and responsiveness, which is vital for ensuring patient safety. Furthermore, DC motors play a key role in renewable energy systems, where precise control improves energy collection and conversion efficiency in devices like solar trackers and wind turbines. These diverse applications underscore the need for advanced control techniques that can meet the complex demands of modern systems. However, DC motors often operate in environments characterized by significant non-linearities, external disturbances, and unpredictable parameter fluctuations. Such conditions necessitate control solutions that are both precise and robust, capable of adapting to changing dynamics [2].

PID controllers are commonly used for DC motor control due to their simplicity and effectiveness in linear systems. These controllers maintain stable operation by adjusting proportional, integral, and derivative gains. However, tuning PID controllers can be challenging, especially in non-linear systems, potentially resulting in issues such as overshoot, oscillations, and slow response times [3].

FLC offers an alternative by simulating human reasoning through linguistic rules and fuzzy sets. Unlike PID controllers, FLC does not require precise mathematical models, making it suitable for non-linear and uncertain systems. FLC operates through fuzzification, rule-based inference, and defuzzification, allowing it to adapt to changing operating conditions [4]. While it effectively handles uncertainties, FLC’s performance relies heavily on expert knowledge for rule design and may be sensitive to transient conditions.

SMC is a robust non-linear technique that directs system states along a predefined sliding surface to achieve desired dynamics. It operates in two phases: the reaching phase, where system states converge to the sliding surface, and the sliding phase, which ensures robustness against disturbances [5]. SMC provides exceptional precision and resilience but can suffer from chattering, which limits its practical implementation.

Each approach—PID, FLC, and SMC—has advantages and limitations. PID controllers are popular due to their straightforwardness, yet their performance can decline under non-linear conditions and disturbances. In contrast, FLC and SMC provide viable solutions for non-linear systems, with FLC employing adaptive rule-based reasoning and SMC leveraging robustness and precision on sliding surfaces. However, FLC relies on expert knowledge to construct rules, while SMC requires careful design to mitigate its chattering issue and ensure practical applicability. This research compares the performance of these advanced control strategies—PID, FLC, and SMC—for precise DC motor speed control [6-8].

The study evaluates their adaptability, precision, and robustness using MATLAB Simulink simulations and hardware implementation on an Arduino Mega platform. This work bridges the gap between theoretical models and real-world applications by addressing challenges like tuning complexity and chattering. The findings offer valuable insights for developing cost-effective, high-performance control systems for embedded motor control solutions.

3.1 Modelling of the DC motor

Diagram of a DC motor, as seen in Figure 1, armature resistance (R), armature inductance (L), friction torque, inertia (J), angular speed ($\omega$), motor torque (T), armature current (i), DC power supply, and V_emf$~$ electromotive force voltage.

image003.png

Figure 1. Diagram of the DC motor [16]

The equations derived from the analysis of Kirchhoff's voltage law are as follows:

$Ri+L\frac{di}{dt}=V-{{K}_{e}}W$                            (1)

where, K_e is the constant for electromotive force.

Newton's second law of rotation can be expressed as follows:

$J\dot{\omega }+b\omega ={{K}_{t}}i$                            (2)

where, K_t is the motor's torque constant, and b is the friction constant of the motor.

Upon executing the mathematical computations with Eqs. (1) and (2), we derived:

$L\frac{di}{dt}=-Ri-{{K}_{e}}W+V$                       (3)

$J\dot{\omega }=-bw+{{K}_{t}}i$                                 (4)

Define the control signal variable and the state space variables as shown below:

${{X}_{1}}=W$                   (5)

${{X}_{2}}=i$                    (6)

$u=V$                       (7)

Next, the state space variable is shown below:

${{\dot{X}}_{1}}=\dot{W}=\frac{d\theta }{dt}=-\frac{b}{J}W+\frac{{{K}_{t}}}{J}i$                     (8)

${{\dot{X}}_{2}}=i=\frac{di}{dt}=-\frac{{{K}_{e}}}{L}W-\frac{R}{L}i+\frac{1}{L}u$                           (9)

Next, use the substitution method to find:

${{\dot{X}}_{1}}=-\frac{b}{J}{{X}_{1}}+\frac{{{K}_{t}}}{J}{{X}_{2}}$                      (10)

${{\dot{X}}_{2}}=-\frac{{{K}_{e}}}{L}{{X}_{1}}-\frac{R}{L}{{X}_{2}}+\frac{1}{L}u$                 (11)

The state-space model is as follows:

$\dot{X}=AX+Bu$                      (12)

$y=CX$                                   (13)

where,

X=$\left[ \begin{matrix}  {{X}_{1}}  \\   {{X}_{2}}  \\ \end{matrix} \right]$, A=$\left[ \begin{matrix}   -\frac{b}{J} & \frac{{{K}_{t}}}{J}  \\   -\frac{{{K}_{e}}}{L} & -\frac{R}{L}  \\ \end{matrix} \right],\text{ }\!\!~\!\!\text{ }B=\left[ \begin{matrix}   0  \\   \frac{1}{L}  \\ \end{matrix} \right],\text{ }\!\!~\!\!\text{ }C=\left[ \begin{matrix}   1 & 0  \\ \end{matrix} \right]$

Table 1 presents the DC motor's parameter values used to build the Simulink and design the controller.

Table 1. Value of the DC motor [17]

The state space model, defined in Eqs. (12) and (13), is created by applying the parameters listed in Table 1, as seen below:

$\dot{X}=~\left[ \begin{matrix}   -5.4 & 36  \\    -0.0181 & -0.1515  \\ \end{matrix} \right]$ x + $\left[ \begin{matrix}   0  \\   0.3030  \\ \end{matrix} \right]$ u                         (14)

$y=\left[ \begin{matrix}   1 & 0  \\ \end{matrix} \right]$                             (15)

Then, convert the state model to a transfer function using MATLAB.

$\omega \left( s \right)=\frac{10.91}{{{S}^{2}}+5.552S+1.47}V\left( S \right)$                               (16)

3.2 PID controller model

Due to its simplicity and efficacy, the proportional-integral-derivative (PID) controller is a regularly used feedback control mechanism for managing the speed of DC motors [18]. It operates by continuously calculating the error between the desired speed and the motor's actual speed. The controller then applies a correction based on three components: proportional, integral, and derivative. The output of the controller adjusts the motor's speed accordingly [19, 20].

where, e(t) is the error between the desired and actual speed at the time, ${{K}_{p}}$ is the proportional gain, which determines the response to the current error, ${{K}_{i}}~$is the integral gain, which addresses accumulated past errors, and ${{K}_{d}}~$is the derivative gain, which predicts future errors based on the rate of change of the error.

Popular tuning techniques include manual tuning, Ziegler-Nichols, and Cohen-Coon. During manual tuning, the proportional gain (K_p) is first increased until the system starts oscillation. Subsequently, the integral gain (K_i) is calibrated to eliminate any steady-state inaccuracy, while the derivative gain (K_d) is adjusted to reduce oscillations [21]. The Ziegler-Nichols method provides an empirical technique that uses the system's ultimate gain and oscillation period to recommend starting parameter settings. Upon establishing these values, precise modifications are implemented to equilibrate trade-offs across performance indicators, including rise time, overshoot, and settling time. Figure 2 shows the PID configuration model.

image004.png

Figure 2. The configuring model of a PID controller

3.3 Fuzzy logic controller model

FLC consists of four main components: the fuzzifier, knowledge base, inference mechanism, and defuzzifier (refer to Figure 3).

• Fuzzifier: This component converts classical inputs into fuzzy sets using membership functions, which can be triangular, trapezoidal, or Gaussian, depending on the specific application.

• Knowledge Base: The knowledge base contains IF-THEN rules that define the control logic for the system.

• Inference Mechanism: This mechanism processes the rules from the knowledge base to generate a fuzzy output.

• Defuzzifier: Finally, the defuzzifier converts the fuzzy output into a crisp control signal.

image005.png

Figure 3. Schematic of fuzzy logic controller

The Mamdani method is widely credited for its intuitive design and remains a popular choice in literature and applications. However, other methods, such as Sugeno, offer computational advantages and may be preferred in certain scenarios [22-25].

U(t) = ${{K}_{p}}$ e(t) +$~{{K}_{i}}$ $\mathop{\int }_{0}^{t}e\left( t \right)\text{ }\!\!~\!\!\text{ }$dt + ${{K}_{d}}$ $\frac{de}{dt}$         (17)

This research adopts the Mamdani method to develop an FLC for regulating the speed of a DC motor. The Mamdani method is noted for its intuitive and interpretable approach, leveraging expert knowledge to build a rule-based system. Fuzzy rules are formulated as "if-then" statements, connecting input variables such as Error (E) and Sum of Error ($\Sigma$E) to corresponding control actions [26]. Inputs are fuzzified using Gaussian membership functions, which enable smooth transitions and improve sensitivity to changes. The output employs triangular membership functions to simplify the defuzzification process and enhance the system's responsiveness.

The FLC is designed with four variables: two inputs and two outputs, enhancing precision and stability in controlling the motor's nonlinear dynamics. This configuration minimizes oscillations and ensures responsive, reliable control [27]. A total of 25 fuzzy rules defines the system's operational logic, addressing various errors and dynamic conditions. The inference mechanism utilizes these rules to generate suitable control actions, while the defuzzification process produces precise output signals optimized for real-time applications.

Figure 4 and Table 2 illustrate the membership functions and the interactions of fuzzy rules, respectively, emphasizing the system's capability to adapt effectively to changing operating conditions. This approach demonstrates how the FLC balances simplicity and robustness, making it well-suited for applications demanding high precision and adaptability. Figure 5 demonstrates how fuzzy logic rules influence the output signal, showcasing the impact of different combinations of Error (E) and Cumulative Error ($\Sigma$Error) on the control response. These rules define the relationships between input and output variables, shaping the system's dynamic behavior. Figure 6 provides a more detailed perspective through 3D surface plots, illustrating how changes in both error terms result in smooth, continuous transitions in the control signal. This visual representation emphasizes the adaptability of the fuzzy logic controller in managing system dynamics and ensuring stable performance under varying conditions.

image006.png

Figure 4. Membership function of error

Table 2. FLC rules conditions

Note: E refers to Error, and SE refers to Sum of Errors

image007.png

Figure 5. FLC rules membership function

image008.png

Figure 6. FLC controls the surface

3.3 Slide mode controller model

The controller for the motor must be written in state space; thus, we can write Eq. (16) in the time domain as shown below:

$\overset{\ddot{\ }}{\mathop{\omega }}\,+5.552\dot{\omega }+1.47\omega =10.91V$                         (18)

Define the state space variables as:

${{X}_{1}}=\omega$                     (19)

${{X}_{2}}=\dot{\omega }$                             (20)

$u=V$                           (21)

Next, we can express the system in its controllable canonical form as follows:

${{\dot{X}}_{1}}={{X}_{2}}$                   (22)

${{\dot{X}}_{2}}=-5.552{{X}_{2}}-1.47{{X}_{1}}+10.91V$                     (23)

Next, we will proceed with the design of the sliding mode function as follows:

$S=Ce+\dot{e}$                          (24)

The variable (e) represents the tracking error value, while the value of the variable (C) must adhere to the Hurwitz rule (C > 0) [28]. The values of the error and its derivative are as follows:

$e={{\omega }_{d}}-\omega$                                (25)

$\dot{e}={{\dot{\omega }}_{d}}-\dot{\omega }$                            (26)

$\overset{\ddot{\ }}{\mathop{e}}\,={{\overset{\ddot{\ }}{\mathop{\omega }}\,}_{d}}-\overset{\ddot{\ }}{\mathop{\omega }}\,$                           (27)

The variable ($\omega_d$) represents the reference signal, while ($\omega$) represents the actual angular velocity. Now, let's define the Lyapunov function as follows:

$V=\frac{1}{2}{{S}^{2}}$              (28)

To guarantee stability, the Lyapunov function in Eq. (28) must meet the condition ($\dot{V}$<0) [29].

$S\dot{S}<0$                    (29)

The equation for the sliding mode function is:

$\dot{S}=C\dot{e}+\overset{\ddot{\ }}{\mathop{e}}\,=C\dot{e}+{{\overset{\ddot{\ }}{\mathop{\omega }}\,}_{d}}-\overset{\ddot{\ }}{\mathop{\omega }}\,$                         (30)

Therefore, the derivative of the Lyapunov function $\dot{V}$ is:

$S \dot{S}=S\left(C \dot{e}+\ddot{\omega}_d+5.552 \dot{\omega}+1.47 \omega-10.91 U\right)$                          (31)

To satisfy the condition ($S\dot{S}~$< 0) the sliding mode controller is designed as follows:

$U=\frac{1}{10.91}\left( 1.47\omega +5.552\dot{\omega }+{{\overset{\ddot{\ }}{\mathop{\omega }}\,}_{d}}+C\dot{e}+Ksgn\left( s \right) \right)$                            (32)

where,

$\operatorname{sgn}(s)= \begin{cases}1 . & s>0 \\ 0 . & s=0 \\ -1 . & s<0\end{cases}$

By substituting Eq. (32) to Eq. (28), then we get:

$S\dot{S}=-ksgn\left( s \right)<0$                 (33)