Stable Rules Definition for Fuzzy TS Speed Controller Implemented for BLDC Motor

Abstract

This paper deals with the application of a fuzzy-logic-based controller for a drive with a BLDC motor. Two main aspects of the work are presented in this paper. The first of them is focused on the design process of the fuzzy model. For this purpose, the rules of the applied fuzzy system are defined according to the Lyapunov function. The gain coefficients of the controller are optimized using the Chameleon Swarm Algorithm. Various issues and aspects were analyzed in the simulation tests (robustness against parameter changes, the influence of the controller parameters on the precision of control, stages of optimization, etc.). The presented work confirms the assumptions regarding precision and stable operation (also in the presence of changes in the object parameters—the mechanical time constants of the engine) in connection with the applied fuzzy speed controller. Moreover, the second part of the manuscript presents the low-cost power electronic device developed for laboratory tests. It uses STM32 ARM-based microcontrollers (state variable measurement, control algorithm calculation, control signal generation) and a Raspberry Pi 4B microcomputer (control application—reference value and parameter definition). The experiment performed for the control structure—an electric drive with a BLDC motor—verified the theoretical considerations.

1. Introduction

The application of artificial intelligence (AI) elements has become the most common trend in modern electric drives. This is mainly due to the requirements of Industry 5.0, which often promotes the autonomous, robust, and adaptive operation of machines and robots. This machinery should be able to reproduce the desired dynamics without the intervention of a dedicated operator. The machinery’s operation in various conditions is the most important and inextricable requirement. Different ideas have provided solutions to this issue, each having advantages and disadvantages. Neural network controllers [1,2,3] are commonly described in the literature; however, the most notable disadvantage is the necessity for the parallel computing of the neurons in a single layer. This leads to more powerful hardware and, therefore, cost increases. On the other hand, there are standard PI controllers or state controllers enhanced by tunable parameters. This adaptation can be achieved with different algorithms, leading to varied complexity and efficiency. A common problem of such controllers is the stability issue [4,5,6].

Modern industry is a meaningful concept whose main role is to ensure the sustainable development of the economy and the dynamic growth of the quality of people’s lives. In almost every single factory there are plenty of essential devices that use electric drives. Coal mines, heavy elevators, HVAC control systems, small tools, printers, and CNC machines all use electric drives. A strong desire to generate high-quality products has forced factories to become more productive. The key to ensuring a reasonable production rate is to minimize the risk of breakdowns or outages caused by electric drive systems. One of the biggest weaknesses of conventional brushed DC motors is their maintenance. Because of the friction caused by brushes, classic DC motors require the periodic exchange of certain components [7,8]. Comparing both constructions, it is unquestionable that the brushless DC (BLDC) motor has a simplified internal structure. Furthermore, the lower number of internal elements in the BLDC motor allows manufacturers to design a motor with a smaller chassis than its conventional equivalent with the same power. This has a huge influence on decreasing the electromagnetic noise generated by the motor. From another point of view, the construction of the BLDC motor is a critical feature that ensures much better dynamics and a higher efficiency compared to brushed motors, with improvements of up to 95%. Because of this, it is obvious that BLDC motors provide the user with an opportunity to control their speed and position at a precise level. This makes these machines a perfect choice as the main drive in popular applications (e.g., CNC machines or robots) [9,10]. The biggest and most noticeable disadvantage of brushless motors is the necessity of using a dedicated controller to ensure correct operation.

Nowadays, brushless electric motors can be distinguished as one of the most important parts of electric drives and can be divided into permanent-magnet synchronous motors (PMSMs) and BLDC motors. In spite of their similar mechanical constructions (stator windings and permanent magnets placed on the rotor), a huge difference between them can be noticed while developing a proper control system. Due to the fact that the BLDC motor works with a direct current, the shape of the back electromotive force is trapezoidal. Because of this, a different technique of control is required. The most essential element of a typical drive with a three-phase BLDC motor is a power electronic controller—a three-branch inverter module, with two switches in each branch [11,12]. The internal structure of a typical drive with a BLDC motor is shown in Figure 1.

The goal is to make the BLDC motor rotate properly in both directions. For this purpose, a particular inverter is used. It is a substitute for the mechanical commutator used in brushed DC motors. The electronic commutator works with no physical connection between the stator and rotor (a lack of brushes). In order to make the motor rotate properly, information about the current rotor position needs to be given to the microcontroller unit. In modern BLDC motor controllers, this is usually realized by receiving information from Hall sensors located inside the motor. More advanced devices are based on the fact that in a specific time period the current flows only through two of three phases. Therefore, it is possible to deduce a current rotor position based on calculating the back electromotive force induced on the unused phase [13,14]. Having received the rotor position, it is compared by a microcontroller with the implemented switching tables. These are used to define which of the six transistor switches need to be open or closed (based on the current rotor position) in a specific time window to make the motor rotate in the desired direction. There are many types of BLDC motor controllers available on the market. This allows the user to choose an appropriate controller for the project to be performed. No matter what kind of project is being realized, one can find a proper controller for its requirements, e.g., a Radio-Controlled (RC) model, electric scooter, automotive industry application, or large control cabinet for a high-power BLDC motor [15,16,17,18,19]. Moreover, the constant improvement of microcontrollers ensures that a variety of hardware solutions are available on the market. Depending on the designed application and initial requirements of the project, it is possible to choose between both amateur and professional microprocessors. Even a simple programable device, due to its computational capabilities, can provide enough power to handle the BLDC commutation process [20,21]. Furthermore, modern Advanced RISC Machine (ARM) processors ensure a perfect combination of computational capabilities while fulfilling the assumption of a low-cost solution. These devices are capable of running even complicated algorithms while handling the BLDC commutation process simultaneously [22,23]. Due to the constantly increasing interest in ARM processors, manufacturers offer BLDC motor controllers in the form of dedicated shields [24]. Additionally, demanding applications are often handled by modern digital signal processors, which are a convenient way to run a variety of advanced algorithms [25,26,27]. The most sophisticated implementations (e.g., BLDC neural speed controllers) are often executed with the use of parallel computing ensured by field-programable gate array (FPGA) modules [28,29,30]. However, in terms of testing and developing rapid-prototyping systems, FPGAs are widely used as well [31].

Despite the fact that classic control structures (e.g., PID) are incredibly popular methods in modern industry, it is well known that they are not convenient in the context of nonlinear systems. Moreover, the values of the object parameters can fluctuate over time. Using conventional techniques, the precision of control is difficult to ensure. This is the point at which fuzzy logic becomes a reasonable solution. It is by definition a branch of mathematics that was designed for describing uncertain objects. The main goal while creating fuzzy logic principles is to obtain a tool capable of modeling nonlinear phenomena, which are usually hard to describe with mathematical equations. One of the most important parts of data processing in a fuzzy model is the rule base—defined using the designer’s experience and knowledge. Considering the fact that, nowadays, fuzzy logic may be used in many fields, it is also widely implemented in control systems, in the form of a fuzzy logic controller [32,33,34,35]. The main idea of these controllers is to create a dependency between the input signals and the output of the controller using predefined rules. Thus, it is possible to describe the current state of a plant with linguistic variables (instead of specific state equations). This can be performed after the fuzzification stage in the first layer of the controller. The second layer (inference) calculates conclusions and their significance in the final control signal through several iterations of the algorithm. Then, the received values are taken to the defuzzification layer and changed from the fuzzy variable to a specific value, which allows the fuzzy model to cooperate with the rest of the control system (e.g., the torque control loop of the electric drive) [34,35,36,37,38]. Additionally, the dynamic development of cheap and powerful microprocessor units makes it easier and more reasonable to use fuzzy logic controllers in everyday applications. One of the most representative implementations, based on a fuzzy logic model, may be seen in a typical modern car, i.e., an active cruise control system [39]. Considering the fact that there are a variety of reference speed values that can be achieved by a car, the characteristics of the plant are strongly dependent on the current gear, actual motor speed value, and weight of the vehicle. There are also plenty of factors and circumstances that directly influence the above-mentioned characteristics (e.g., the number of people inside the car). Therefore, it is clear that a conventional controller (PID/PI) may be insufficient. Moreover, a fuzzy logic controller does not require specific plant parameters (during the design stage) to make the system work properly.

Any control structure requires the tuning of its parameters to perform well with different objects. The efficiency and performance of the controlled drive rely on correctly selected coefficients. A variety of optimization approaches can be found in control theory, among which standard (based on a mathematical model of the structure) and numerical methods can be distinguished. One of the most interesting methods, which seems to have become very popular in recent years, is based on metaheuristic algorithms. These describe different calculations that provide general instructions to minimize the value of a given cost function. In comparison to standard optimization algorithms, metaheuristic optimizers work without difficult mathematical calculations (e.g., the gradient can be neglected) [40]. Thus, they can be applied easily to complex problems (including nonlinear objects and parameter modifications). The implementation of the tool is universal for different issues (without additional recalculations). Due to these advantages, a wide range of applications in different areas of science [41], engineering [42,43], economics [44], and medicine [45] can be found. Their high popularity is a result of not only the ease of application but also the high efficiency of metaheuristic algorithms. Because of the iterative process, the initial results may be quickly modified, and then, in the following iterations, their precision may be improved. Metaheuristic algorithms are often based on observations of nature, especially swarm processes [46]. These methods often include elements of artificial intelligence (AI) [47].

This article describes the complete design process and implementation of a fuzzy logic speed controller for a BLDC motor. The theoretical background and mathematical model of the control system are analyzed. Then, the stability issue is considered, and a practical application of the Lyapunov theorem for rule base definition is provided. The next part presents an application of a nature-inspired metaheuristic optimizer for controller efficiency improvement (Chameleon Swarm Algorithm). The subsequent section introduces the results of simulation tests of the established fuzzy logic control structure. Considerations of different operation scenarios are discussed, and the chosen speed transients are presented. A significant part of the paper is related to the design process and construction of the microcontroller system and power electronics for a low-cost test bench. The hardware section deals with the electronics of the device and ancillary mechanical equipment (cabinets, coupling). The developed control software (graphical user interface) is also briefly analyzed. The paper ends with experimental results and concluding remarks.

2. Description of the Speed Control Algorithm

2.1. Fuzzy Controller Applied in the Control Structure

In the presented research, a BLDC drive was used. BLDC motors are very popular in various industrial and electromobility applications. They are characterized by a noticeably higher power and relatively small size in comparison to standard brushed DC motors. In most industrial implementations, the high speed of BLDC motors is reduced through gearboxes. However, in a large number of applications, a high rotational speed is demanded. In devices such as drones, RC models, and electric scooters, the active load is applied directly to the rotor. For instance, the propellers of a drone are mounted on motor shafts, and their speed and the produced thrust are proportional to the motor speed [48,49]. There are also applications in which the rotor is the external part of the motor—such a design is very popular in electric scooters—and the rotor cooperates directly with a wheel [48,50]. For the abovementioned applications and many others, the mechanical part of the drive can be modeled with a simple transfer function defined as follows (1):

$$G_m\left(s\right)=\frac{1}{T_m·s}$$

(1)

where $T_m$ is the mechanical time constant of the motor.

In fact, the speed control structure can be considered as a cascade-connected system. It consists of the mechanical part (described above), the loop related to the electromagnetic torque, and the external speed control path (Figure 2). The main purpose of this work was the hardware construction of the drive, algorithm implementation, and tests of the fuzzy controller. However, for initial feature analysis, numerical tests are also presented. Thus, for the definition of the simplified mathematical model of the speed control structure, some conditions (simplifications) must be predefined:

• The mechanical part does not include nonlinearities (e.g., friction torque and backlash).
• The elasticity of the shaft is omitted.
• The optimal tuning of the internal part is ensured (the dynamic response of the electromagnetic torque after the reference signal from the speed controller).
• The fast processing and measurement of the state variables.
• The relation between the total time constant of the torque control loop $T_e$ and $T_m$, due to the modern switches used in specialized power electronic devices and modern control techniques [51], can be defined as follows:

  $$T_e<<T_m$$

  (2)
• The omission of the influence of disturbances in the power electronic devices.

Considering the assumptions/relations mentioned above, the representation of the torque shaping loop can be described with transmittance:

$$G_e\left(s\right)=\frac{1}{T_e·s+1}$$

(3)

where $T_e$ is the electrical time constant of power electronics (fulfilling Relation (2)).

2.2. Fuzzy Speed Controller

The most essential element of the structure presented in Figure 2 is the fuzzy speed controller. It provides the possibility of computing the control signal using fuzzy-logic-based data processing and expert knowledge according to the dataflow presented in Figure 3.

The inference stage is computed using the fuzzy values obtained in the fuzzification part. The “crisp” input signal suffers interference from the membership function representing linguistic description, called the rationale. As a result of this process, the input signals are characterized by attributed significance levels. This can be modeled by Equation (4):

$$x_i=f_i·a_i$$

(4)

where $a_i$ is the crisp value input; $f_i$ is the membership function; and $x_i$ is the fuzzified input. The following step is responsible for the exact inference based on both the fuzzified input signals and the knowledge base. The knowledge base is the container of membership functions and the relationships between particular variables. The calculations are based on expert knowledge, providing the conclusions according to the input rationale. The shape of the expert base may vary depending on the fuzzy model used. For the Mamdami reasoning approach, the base rule is given by a fully linguistic description, such as:

If input1  is … and  input2  is …, then the  output  is…,

• where the considered variables are not given as crisp values, but rather as fuzzy labels. The next step of the fuzzy controller data processing is defuzzification, the process of translating a fuzzy conclusion into a crisp output value. Different defuzzification methods can be found in the literature [52]. The commonly used singleton method utilizes weights placed at the peak coordinates of the membership functions. In comparison to Mamdami reasoning, the Takagi–Sugeno (T-S) model applies a different structure for the inference block. The fuzzified inputs are compiled with functions, resulting in a crisp output. The T-S fuzzy system is very efficient, and hardware implementation in programable devices seems to be easier. It was applied in tests described later on in this paper. A schematic representing the fuzzy logic controller is presented in Figure 4.

The output value of the Takagi–Sugeno type 1 fuzzy system can be described as in Equation (5):

$$y=\frac{{\sum }_{i=1}^I{x}_i·w_i}{{\sum }_{i=1}^I{x}_i}=\frac{{\sum }_{i=1}^I(e·{\mathbf{f}}_{\mathbf{1}}·\dot{e}·{\mathbf{f}}_{\mathbf{2}})·w_i}{{\sum }_{i=1}^I{x}_i}$$

(5)

where y is the crisp output of the fuzzy system; $x_i$ is the fuzzified input; $f_i$ is the vector of membership functions; I is the number of input signals; and $w_i$ is the defuzzification singleton value.

2.3. Fuzzy Rules Definition

The requirement of good dynamics is the main assumption for designing a speed controller. Nevertheless, it is crucial, at the same time, to ensure the stability of operation. This can be achieved by adapting the transfer function of the controller to the plant when all the elements are properly identified and the parameters are correctly selected. If more complex nonlinear controllers are taken into account, the mathematical model also becomes more problematic. Because of this, such a procedure is unfeasible in real applications and is susceptible to changes in the drive parameters. A common concept in the design process is based on the fact that the stability of the control structure may be verified for the system. Different methods can be used to prove the stability of the control structure, among which the Routh–Hurwitz [53] or Nyquist [54] stability criteria are the most popular in control theory. However, for nonlinear systems, verification according to the Lyapunov stability theorem is the most common approach [55,56,57]. In this application of the fuzzy model, as the speed controller of a drive, it was assumed that the key element for the correct operation of the system was the definition of the rule base.

The stable rules selection began with the definition of the speed error as

$$e={\omega }_m-{\omega }_{ref}$$

(6)

where ${\omega }_m$ is the measured speed, and ${\omega }_{ref}$ is the reference speed.

• For the stability considerations, the two-element positive-definite Lyapunov candidate function was chosen (7):

$$V(q_1,q_2)=\frac{q_1^2+q_2^2}{2}$$

(7)

where $q_1$ and $q_2$ are the controlled process state variables. For the analyzed controller, the following mathematical expressions were assumed:

$$q_1=e$$

(8)

$$q_2=\frac{de}{dt}=\dot{e}$$

(9)

According to the Lyapunov criterion, in order to confirm the system stability, the condition given by Equation (10) has to be fulfilled [58].

$$\dot{V}\le 0$$

(10)

where $\dot{V}$ is the derivative of the Lyapunov candidate function:

$$\dot{V}=q_1·{\dot{q}}_1+q_2·{\dot{q}}_2$$

(11)

Hence, replacing the universal variables with the process-specific ones ((8) and (9)) and combining them with the Formula (10), the stability condition is defined as follows:

$$e·\dot{e}+\dot{e}·\ddot{e}\le 0$$

(12)

Because the error value depends on the object state variable (6), it can be assumed that the second derivative of the error value is proportional to the control signal:

$$\ddot{e}\propto u$$

(13)

where u is the control signal. Thus, the following considerations were included in the expression presented below:

$$e·\dot{e}+\dot{e}·u\le 0$$

(14)

$$\dot{e}·(e+u)\le 0$$

(15)

It can be noted that if $\dot{e}=0$, the condition is fulfilled arbitrarily for any value of the speed error e and control signal u. In order to define a full knowledge base, where all state variables are determined, the scenario presented below was applied:

$$\dot{e}\to 0^{-}=0-\delta$$

(16)

$$\dot{e}\to 0^{+}=0+\delta$$

(17)

where $\delta$ is a very small value. In such a case, the sign of the equation in brackets (15) can always be determined.

Using the above-described assumptions, a definition of the stable control rules can be provided. The considerations of the first rule are presented below.

Let $\dot{e}<0$; then, the condition in (15) is true if $e+u\ge 0$. This is always true for $e\ge 0$ and $u\ge 0$.

• This is a trivial relation but not the only possible combination. Depending on the size of the knowledge base and the resolution of the membership function, more detailed rules could be defined. The following statement can also be considered:

Let $\dot{e}<0$; then, the requirement in (15) is fulfilled if $e\ge -u$, which is true for $e>0$, $u\le 0$, and $\left|u\right|\le e$.

• Based on a similar analysis, more rules can be defined, and the control surface can be achieved (Figure 5). It can be noted that an offset of at least a single linguistic label should be present between the values of $\left|e\right|$ and $\left|u\right|$. For the membership functions presented in Figure 6, the stable control rules are gathered in

  Table 1. Lyapunov-based stable control rule table.

  $\dot{\mathit{e}}$	e	u
  N	PB	PB
  N	P	PB
  N	PB	P
  N	P	P
  N	PB	N
  N	P	0
  N	PB	0
  N	0	PB
  N	0	P
  N	0	0
  N	N	PB
  P	N	N
  P	N	NB
  P	NB	N
  P	NB	NB
  P	0	N
  P	0	NB
  P	NB	0
  P	N	0
  P	NB	P
  P	P	NB

  .

2.4. Bio-Inspired Optimization of the Fuzzy Speed Controller Using the Chameleon Swarm Algorithm

The control structure contains three tunable parameters—these are the two input signal gains $K_e$ and $K_{de}$ and the controller output coefficient $K_u$. In order to keep the above stability considerations valid, it is required that the parameters do not equal 0 and are positive. Considering the rules (Table 1), the relationship between the external parameters of the model could be determined. The output coefficient should have a higher value than the error and error derivative gains. Taking into consideration the above observations, the boundaries of the parameter values were defined for the optimization process according to

Table 2. Limits for the controller parameters.

Parameter	Lower Boundary	Upper Boundary
$K_e$	0.001	10
$K_{de}$	0.001	10
$K_u$	0.001	1000

.

In control theory, different approaches to controller coefficient calculations have been proposed, including popular ones such as magnitude and symmetric optimum criteria [59,60], or the pole placement method [61,62,63]. The application of these methods requires the precise identification of the object and the transmittance of the elements. This makes them very difficult to implement with neural or fuzzy controllers, where the controller dynamics cannot be easily described with a transfer function. However, the present trend in tuning controllers is the application of intelligent algorithms [55,64,65,66]. These can solve the problem by an adaptation of the controller coefficients based on object response. This is especially convenient for insufficiently identified machines or compound structures whose mathematical description is very complex.

Different groups of optimization algorithms may be considered, depending on the operation principles and inspiration. Bio-inspired metaheuristic optimization algorithms are the most popular [67]. A variety of successful applications have already been presented in papers from different scientific disciplines. The most common problems deal with economic sciences [68,69], power distribution [70,71], and mechanics [72]. The tuning process can also be automatized with the application of these algorithms.

In this study, the Chameleon Swarm Algorithm (CSA), developed by Braik in 2021 [73], was applied to tune the controller coefficients. The tool is a nature-inspired metaheuristic optimization algorithm that mimics chameleon hunting behavior. The algorithm was initially evaluated successfully with 67 benchmark functions, and since then a variety of implementations have been proposed. The CSA has been implemented for telecommunication and electronic device design [74,75] and developed as a computer system supervisor [76] and dataset manager [77]. It was successfully proven that the CSA can also be used as an intelligent tool for robot suspension synthesis [78]. The premise of the CSA is that the best solution is synonymous with prey, while the optimization agent is a hunting chameleon. Similarly to other nature-inspired algorithms, the optimization is calculated iteratively for an evolving group of specimens called the population. Every iteration of the algorithm consists of three steps that are inspired by consecutive chameleon hunting behaviors (reflected in the flowchart of the CSA presented in Figure 7):

• Search for prey;
• Eye rotation to locate prey;
• Prey capture.

The two first steps are based on the unique sight of chameleons, which enables a viewing area of 360${}^{\circ }$ and helps to reveal prey position. This provides the possibility to explore the search space and define the direction towards the best solution. The last step determines the new position of the chameleon as it approaches its victim with its tongue.

The algorithm considers multiple chameleons that explore the optimization space. Every specimen represents a single solution. The size of the population (N) can be adjusted by the user:

$${\mathbf{x}}_{\mathbf{i}}^{\mathbf{n}}=[x_i^{n,1},x_i^{n,2},x_i^{n,3},\dots ,x_i^{n,d}]$$

(18)

where $n=1,2,3,\dots ,N$ is the number of specimens in the population; i is the number of iterations; and d is the number of searched values. The initial population $x_0^n$ is compiled in accordance with the following equation:

$$x_0^{n,d}=l_{b_d}+v\times (u_{b_d}-l_{b_d})$$

(19)

where n is the number of specimens; d is the number of dimensions; v is a randomly drawn value from the range $[0,1]$; $l_{b_d}$ is the lower bound of the search range; and $u_{b_d}$ is the upper bound of the search range. In subsequent iterations, the value of every specimen is updated by adding the correction factor. The improved solution is given by the following equation:

$$x_{i+1}^{n,d}={\Delta }_{x_i^{n,d}}+x_i^{n,d}$$

(20)

where $x_{i+1}^{n,d}$ is the new solution; ${\Delta }_{x_i^{n,d}}$ is the improvement factor; and $x_i^{n,d}$ is the current solution.

The improvement factor is calculated in the first step of the algorithm—corresponding to prospection for prey. The formula for this parameter is given by Equation (21). The selection is carried out during every iteration and is performed by randomly drawing a switch value (s).

$${\Delta }_{x_i^{n,d}}=\{\begin{array}{c}\mu ((u_{b_d}-l_{b_d})v_3+u_{b_d})sgn(v_4-0.5)s<P_p\hfill \\ \sigma (g_i^{n,d}-G_i^d)v_1+\tau (G_i^d-x_i^{n,d})v_{2}s⩾P_p\hfill \end{array}$$

(21)

where s is the randomly generated switch value; $u_{b_d}$ and $l_{b_d}$ are the upper and lower boundaries of the search range, respectively; $\tau$ and $\sigma$ are the customizable CSA parameters; sgn() is the sign function; $v_1,v_2,v_3,v_4$ are the random numbers drawn in every iteration from the range [0, 1]; $g_i^{n,d}$ is the best solution obtained so far by the exact $n^{t}h$ specimen; $G_i^d$ is the global best solution so far; and $\mu$ is the consistently decreasing step factor.

Then, the eye rotation stage is computed, and thus the transformation of the improvement vector is obtained in the form of rotation matrices—for the given problem, along the axes of the 2D coordinate system, as in (22) and (23).

$$ro{t}_x=\left[\begin{array}{ccc}1& 0& 0\\ 0& cos\varphi & -\sin \varphi \\ 0& sin\varphi & \cos \varphi \end{array}\right]$$

(22)

$$ro{t}_y=\left[\begin{array}{ccc}cos\Phi & 0& sin\Phi \\ 0& 1& 0\\ -sin\Phi & 0& \cos \varphi \end{array}\right]$$

(23)

In the final step, the hunting process is reproduced—the new solution is approached along the previously calculated vector with the rate corresponding to the chameleon tongue acceleration model given by the equation

$$a=2590\times (1-e^{-log\left(i\right)})$$

(24)

where i is the number of iterations. The final solution for every specimen is given by (25):

$$x_{i+1}^{n,d}=x_i^{n,d}+\frac{{\left(p_i^{n,d}\right)}^2-{\left(p_{i-1}^{n,d}\right)}^2}{2a}$$

(25)

where $p_i^{n,d}$ and $p_{i-1}^{n,d}$ are the speeds of the tongue in the two proceeding iterations. The new solutions are evaluated by the cost function. If an improvement is obtained, the global best solution is updated. The optimization process is finished if the maximum number of iterations ($I_{max}$) is reached or no improvement in five subsequent iterations is obtained.

3. Simulation Results

The main point of this research was the hardware implementation of a controller in a low-cost microcontroller board. In order to reduce the risk of faults in the control algorithm and (potential) hardware damage, the implementation was preceded by simulation tests. The model was established in Matlab/Simulink 2022b on the basis of the mathematical description given in the introductory part of the paper (Section 2). Because further hardware development was the main objective, the reference and measured speeds were subjected to interference from the noise signal in order to align the test conditions with a real microcontroller system environment. The time constants for the transfer functions representing the power electronics $T_e$ and mechanical inertia $T_m$ of the laboratory drive and the simulation sample time $T_s$ are presented in

Table 3. Time constants of the simulation model.

Parameter	Value
$T_e$	0.001 s
$T_m$	0.016 s
$T_s$	0.001 s

.

The first test was conducted with controller gains equal to 1 to appraise the accuracy of the defined rules. Despite the fact that the speed transient dynamics were not at a satisfactory level, the test was passed correctly. The Lyapunov function $\dot{V}$ was within the desired range throughout the whole test, as we can see in Figure 8. For the test purposes, a square reference signal was used, representing the most difficult operation conditions—immediate response to reference speed change.

The controller gains were then optimized using the CSA with all the above considerations taken into account. For the purpose of the research, a simple cost function was defined (26):

$$F_c=\frac{{\sum }_{s=1}^S|w_{m_s}-{w_{ref}}_s|}{S}$$

(26)

where S is the number of considered samples; $w_{m_s}$ is the measured speed; and ${w_{ref}}_s$ is the reference speed.

In Figure 9, the chosen speed transients obtained in the selected iterations (i) of the CSA optimization are depicted. For comparison purposes, the speed of the motor drive measured for the case of the controller with gains equal to 1 is also attached.

An unquestionable improvement in the dynamics can be noticed in Figure 9. The overshoots and oscillations in both the dynamic and static operation of the motor were reduced drastically. This figure also confirms the fact that the correct tuning of the controller gains is essential for correct operation. It should be emphasized that the fuzzy logic controller, even in a very basic configuration, provides the possibility to track the reference signal. However, the dynamics can be improved by correct gains calculations. The presented transients also confirm that the CSA is an efficient tool for tuning fuzzy controllers. After five iterations of the algorithm processing, the offset in the steady state was eliminated. The further iterations eliminated the overshoot level and damped high-frequency oscillations. Thus, the error between the reference signal and the measured speed was minimized—this can be noticed in Figure 10.

The parameters of motors in an industrial environment change during operation because of the variable temperature, different load torques, etc. [79]. The second part of the simulation tests was focused on the verification of the drive operation with an increased mechanical time constant $T_m$. Figure 11 presents the speed transients of the motor with different (disturbed) time constants and an initially tuned controller. The results were obtained for the following optimized controller coefficients: $K_e=0.59$, $K_{de}=3.32$, and $K_u=870.20.$

It can be seen that all the transients tracked the reference signals with high precision. However, the increase in the time constant, as was expected, led to an increased rise time for the speed.

4. Hardware Construction and Tests of the Stable Fuzzy Speed Controller

The main goal of the hardware implementation was to develop (from scratch) a low-cost power electronic device capable of cooperation with the BLDC motor. In addition, popular development boards were chosen (Nucleo and Raspberry Pi boards) for the project. It is known that combining a powerful microcontroller system with a single-board microcomputer ensures substantial computational power; easy access to peripheral properties (e.g., the timer’s duty cycle); and the possibility of integrating the whole system using a self-made human–machine interface. Moreover, despite using popular microprocessing units, the device should be capable of running the advanced speed control loop, based on a fuzzy logic controller.

4.1. The Design of the Control and Power System

From the viewpoint of a microprocessor, controlling a BLDC motor is much more complicated and power-demanding than running a brushed direct-current machine. The lack of a mechanical commutator in a brushless DC motor requires the use of an electronic one. Its role is to read the current rotor position using the input signals from Hall sensors and switch on the proper transistors in a specific time window. The whole process requires the use of many external interrupts from the Hall sensors in the microcontroller unit. What is more, developing an advanced control system requires many operations to be conducted in a defined time period. Because of this, realizing a speed measuring loop in the same unit as the commutation process is uncertain. In order to obtain a correct value for the measured speed, it is strongly recommended to ensure a constant period of time in which the difference between the counted encoder pulses can be calculated correctly. To achieve this, the decision to use two independent Nucleo boards was made. The main control system was developed using one STM32 Nucleo 64 (F446RE) board, one STM32 Nucleo 32 (L432KC) board, and a Raspberry Pi 4B microcomputer. The chosen parameters of these microcontrollers are compared in

Table 4. Parameters of programable devices used in the project.

Device	Raspberry Pi 4B	STM32 Nucleo 64	STM32 Nucleo 32
Power consumption	15 W	<1 W	<1 W
Core	Chipset Broadcom BCM2711 with 64-bit Quad-Core ARM-8 Cortex A-72 CPU	ARM Cortex M4	ARM Cortex M4
Clock rate	1.5 GHz	180 MHz	80 MHz
User memory size	External SD memory	512 kB	256 kB
RAM	2 GB (up to 8 GB, depending on version)	128 kB	64 kB

. The integration of the whole control system was based on a Master–Slave data transfer. The concept of the control system is shown in Figure 12. The Raspberry Pi board handles the control application written in Python (v3.6.9). It gives the user the ability to set a reference speed and change it during the operation of the drive. It also captures information about the actual speed. It is a highly effective device for the whole system. A Nucleo 64 deals with the main control algorithm. It works as a Slave device relative to the Raspberry Pi and as a Master device relative to the second Nucleo board. It is also responsible for ensuring a correct commutation process. It captures the input signals from the Hall sensors module, calculates the output signal from the control algorithm, and generates PWM signals for the power module board. These PWM signals are provided to a proper insulated-gate bipolar transistor (IGBT) switch (based on an implemented switching table). This receives information about the actual speed from the Nucleo 32. Communication between the boards is realized with the UART protocol.

An essential part of a power electronic device is the power system. Its role is to ensure power delivery to all components used in a project. A Raspberry Pi computer requires a 230 V AC power supply, while the other devices work on a direct current. The whole power system was based on a 24 V DC main power supply, which distributed energy to three small-voltage controllers. Each of them was responsible for supplying a voltage to different on-board systems: a module of IGBT drivers, a fan cooling setup dedicated to the power module, and an IGBT board. The two Nucleo microcontrollers were powered by USB cables plugged into the Raspberry Pi microcomputer ports. The structure of the power system is shown in Figure 13.

4.2. Power Module

Except for the control system, the second most essential part of a BLDC motor controller is the power module. In order to minimize the risk of damaging switches during the first tests, the decision to use IGBT transistors with high current persistence was made. To power the three-phase BLDC motor, the main inverter module consisted of three branches with two IGBT switches each (six IGBT transistors in total). A specific gate current and voltage with a specified edge were required to control the switches properly and avoid an undefined state for an IGBT’s gate. To achieve this, an additional board with IR2301 IGBT drivers was created (Figure 14). The IGBT drivers transformed the PWM signal generated by the STM32 microcontroller into a corresponding signal with strictly specified values, which could be correctly interpreted by the gates of the transistors. Moreover, the drivers mentioned above ensured optoisolation between the power module and the control system. The cooling setup consisted of three small Raspberry Pi fans. Its role was to provide air flow between transistors. All of them were powered by 5 V DC.

4.3. Cabinet

A BLDC motor controller is an inherently complicated device. It needs to handle many input–output signals and run a variety of on-board systems (e.g., cooling fans). Additionally, according to the global structure of the device (many voltage sources, 230 V socket for powering a microcomputer), it might have been dangerous to work with. In order to avoid risky situations, the next step in the project was to construct a proper cabinet for all electrical and electronic devices. Its structure was based on a two-level interior covered by an exterior case. The lower level of the interior construction was intended to store the main power supply, a 230 V socket for powering the Raspberry Pi, and the additional board with encoder pull-up resistors (Figure 15). On the upper level, the rest of the devices were placed. The two parts of the cabinet are shown in Figure 16. The completely assembled device is presented in Figure 17.

4.4. Control Panel—The Python Application

To control the state of the constructed BLDC motor controller, it was decided to develop a proper Python application. This was handled by the Raspberry Pi microcomputer. As the number of such devices constantly expands, the variety of potential applications is increasing. That being said, a Raspberry Pi is a great tool for not only object detection algorithms [80], but also other deep learning applications [81]. Thus, it was assumed that Raspberry Pi would be a sufficient tool for handling the designed user interface. This simple application gave the user the ability to start and stop the motor, change the reference speed value while running, and return the value of a measured speed. The front panel of the application is shown in Figure 18.

4.5. Encoder

A speed control loop requires the provision of continuous feedback about the actual speed value. In the constructed BLDC motor controller, this was realized by a simple, low-cost incremental encoder. Its resolution seemed to be high enough to provide proper speed information. It produced 400 pulses per revolution for one phase. Considering the fact that the STM32 was equipped with a dedicated timer with an encoder mode, it was possible to increase the above-mentioned value to 1600 pulses per revolution by using signals from two phases at once and setting the trigger detection at both the rising and falling edge.

4.6. BLDC Motor

The motor used in the project was a three-phase BLDC machine with an integrated Hall sensor module plugged in directly to the shaft at the back. It produced 26 W of power, which made it safe to use in the tests, especially considering the fact that it was powered by 24 V DC, making it suitable for the developed device. Its rated current was much lower than the maximum one allowed in the power module. All parameters can be seen in

Table 5. ACT 42BLF01 BLDC motor parameters.

Parameter	Value
Model	42BLF01
Number of Poles	8
Rated voltage	24 V
Rated speed	4000 rpm
Rated current	1.9 A
Maximum power	26 W
Maximum torque	0.18 Nm
Back-EMF	3.7 V/kRPM
Torque constant	0.035 Nm/A

.

4.7. Experimental Results

First, after assembling the BLDC controller, the overall work itself was investigated. The main goal of this part of the tests was to check for proper operation, ensuring that the motor rotated in two directions. This part of the tests was focused on verifying the switching table’s correctness and the data flow between individual controllers throughout the whole control system (including the Hall sensor interrupt setup for rotor position feedback). In the next step, the analyzed control structure with the fuzzy model was implemented in the main controller board. The final tests were divided into two parts. The first stage of the tests was conducted with a square signal applied as a reference trajectory. The time of reversal for each electric drive was controlled by the user with the Graphical User Interface. Its amplitude was modified for several attempts (in order to examine whether the quality of the implemented control algorithm and the hardware operation was adequate). The second part covered the issue related to changes in the reference speed values. Furthermore, the behavior of the control system after applying additional load torque ($t\simeq 3.1$ s) was analyzed. The simulation tests allowed us to predict the actual speed value and follow its reference trajectory. Due to the applied parameter optimization algorithm, a highly dynamic drive and no overshoots were expected to be observed. Precise reference value tracking was achieved. The tests verified whether the experimental results were similar to those obtained in the simulation. The achieved results are shown in Figure 19.

The dynamics obtained during the experimental tests were very similar to the simulation results presented in Figure 11. Thus, it was proved that the implementation of the control algorithm was successful, and the optimized controller coefficients were calculated with very high precision. It could also be noticed that the developed microcontroller system was able to acquire the state variables accurately. The obtained noise level was negligible and significantly smaller than that assumed during the simulation tests.

After conducting the tests with the optimized controller parameters, the additional behavior of the system was examined. In order to emphasize the importance of metaheuristic algorithms in the tuning process, the initial parameters of the controller were modified. Each attempt investigated slightly different parameters of the controller. Changes in several gains (proportional, derivative, and integrator path) were considered. The achieved results are shown in Figure 20. The presented speed transients show that the measured speed tried to follow its reference value, but the quality of the control process was not optimal. Many overshoots and disturbances were visible in both the static and dynamic states of the object.

5. Conclusions

This paper focused on two main points: the design process of a fuzzy speed controller applied to an electric drive with a BLDC motor, and the hardware construction proposed and used for the experimental tests.

The designed fuzzy rules base was defined according to the Lyapunov stability criterion. The candidate function was fitted to the presented problem and derived in order to generate the stability condition. A successful approach to controller tuning with a metaheuristic optimization algorithm was also presented. For this purpose, the Chameleon Swarm Algorithm was used. The combination of the above-mentioned methods was a novel solution for problematic issues related to the fuzzy controller design process. It led to the efficient application of this algorithm, known from artificial intelligence, to an electric drive.

The whole hardware controller deployment process turned out to be complex in some areas. One of the greatest difficulties faced during hardware controller development was related to software integration issues. The deployment process showed that having all devices send and receive the necessary commands in a particular time window is crucial for making the whole system work properly and may be a huge concern.

The main feature observed in the tests was the robustness of the fuzzy controller against parametric disturbance. A modified mechanical time constant did not significantly affect the speed transients. The achieved results confirmed the precise operation of the drive according to the reference waveform.

The successful accomplishment of the described project constitutes a promising base for future work. One of the possible avenues of future work is rebuilding the whole device using SMD components and independent microcontroller units placed on a single PCB board. In this way, it would be possible to reduce the size of the assembled device. The developed hardware may also be used as an alternative device for testing different control algorithms, as it may be a competitive solution compared to, e.g., the popular dSPACE system, commonly used in the field of electric drives.