Electric Drive with an Adaptive Controller and Wireless Communication System

Abstract

In this paper, the problem of the remote control of electric drives with a complex mechanical structure is discussed. Oscillations of state variables and control precision are the main issues found in such applications. The article proposes a smart, IoT-enabled controller, which allows remote communication with a drive. To solve the problem of speed oscillations and to make the system robust to parameter uncertainty, an adaptive controller with two neural networks is designed. First, numerical tests are conducted in a Matlab/Simulink environment to examine the operation of the proposed control strategy. Afterwards, the obtained results are verified in a laboratory setup equipped with a 0.5 kW electric motor. Remote access is provided by a low-cost, ARM-based ESP32 microcontroller. Usually, virtual instruments used to communicate with remote devices require specific software, which may be expensive and pose compatibility problems. Therefore, the main contribution of the article is the creation of a low-cost, web-based Human-Machine Interface (HMI) with an asynchronous server utility provided by the ESP32 that allows remote control and data acquisition of electric drive state variables.

1. Introduction

1.1. Problem Formulation

The problem of precise speed control is still prevalent in industrial electrical drives with a complex mechanical structure [1]. Usually, analysis of control schemes is performed under the assumption that the connection between the motor and the load is rigid and does not negatively affect the drive. The elasticity of the shaft and gears can become a source of disturbance and oscillations [2,3]. It can lead to poorer product quality, damage to mechanical parts of the drive, or problems with stability. In the literature, two machines coupled with a flexible element are often referred to as a two-mass system and are the subject of numerous publications [4,5,6]. Examples of two-mass systems observed in the industry include rolling mills [7], wind turbines [8,9], and robotic manipulators [10,11,12]. Because of the requirement for high dynamics and the presence of oscillations, such applications must be controlled with more intricate control schemes.

PID cascade control is one of the most frequently used strategies due to its low computational power demand and the simplicity of practical implementation [13,14]. The gains of the controller can be adjusted with the pole distribution method or the modulus and symmetry criteria. However, the structure does not take any information about the load machine. It is not suitable for applications with varying speeds between the motor and the load [15]. In such cases, the problem can be solved by providing additional feedback from other variables [16] or using a state feedback controller [17,18]. In a state controller, all state variables (angular speed of the motor and load, and the torsional torque) are connected back to the speed controller to compensate for the elasticity of the coupling element. Nevertheless, both of these strategies suffer one significant disadvantage—they are susceptible to changes in plant parameters. The gains of these controllers are set to work correctly for a selected operating point. The error margin is narrow; even slight changes in plant parameters or a sudden appearance of disturbances can lead to loss of control precision (reference speed tracking) [19].

To address the issue of parameter uncertainty, adaptive control schemes are often applied. Among the possible approaches, gain scheduling [20] and self-tuning methods [21] can be listed. One of the most efficient solutions is model reference adaptive control (MRAC) [22,23]. In MRAC, the difference between the model of the system and the actual output is fed to the adaptation algorithm, then new values of the controller are established. In this way, the controller remains correctly updated. Additionally, only approximate values of the plant parameters are needed to establish the initial value of the gains. There are two main downsides to this strategy [24]. The adaptation algorithm must be carefully chosen to ensure the stable operation of the drive, which is a difficult task. Furthermore, the use of the reference model can nullify the original non-linearities of the plant. This effect can negatively influence the dynamics of the system if the model is selected inappropriately.

The model-free approach relies on the use of intelligent structures, such as neural networks, which are widely used in different tasks related to electrical drives. They can be implemented to estimate state variables [25] or the state of charge (SoC) of electric vehicle batteries [26]. Deep learning algorithms are used to facilitate fault detection [27]. Neural structures are also applied to the task of controlling the angular speed of electric motors [28]. In this concept, gradient algorithms are used to adjust the weights of the network during drive operation. Adaptive properties are achieved through the use of online training. The design process includes the selection of the network structure and the learning coefficient. The stability of neural controllers can be proven through the use of the Lyapunov stability theorem [29]. The learning coefficient can be optimized using swarm inspired algorithms.

Effective optimization of the initial parameters of a neural network can significantly improve the drive’s performance. This is especially important because no training is performed prior to starting the drive. With a wrong initiation point, the control structure can struggle to quickly adapt to the current state of the control structure. Incorrect setting of the weights and the learning rate can cause an oscillatory response [30]. The selection of more appropriate values can be facilitated by using nature-inspired metaheuristic optimization algorithms [31]. The major advantage of such algorithms lies in the fact that they do not need information about the cost function derivative to find better values. As a trade-off, reaching the global minimum is never guaranteed. One of the most common algorithms from this group is Particle Swarm Optimization (PSO) [32]. Other examples include Cuckoo Search (CS) [33,34], the Grey Wolf Optimizer (GWO) [35,36], Ant Colony Optimization (ACO) [37,38,39], or the Bat algorithm [40]. In this work, the Artificial Bee Colony (ABC) algorithm [41] was implemented to facilitate the proper selection of the parameters responsible for scaling the input of the proposed neural network.

Distributed measurement systems are developed to establish a connection between multiple units via the internet [42,43,44]. Remote access to information from a vastly distant instrument is often required. To obtain the measurements, virtual instruments (VIs) are often implemented. The VIs are usually created with the use of software dedicated to instrument control, such as LabVIEW™, LabWindows™/CVI, and Keysight VEE™. Using these environments forces the user to install the required software and may cause VI compatibility problems. To resolve this issue, a web-based Human-Machine Interface was created to collect and visualize the data acquired during the drive operation.

1.2. Related Work

Different approaches can be observed in the published papers. Most of the research is focused on the control structures and does not provide sufficient discussion on experimental data acquisition and visualization. On the other hand, some papers present complex designs of the front-end applications for data visualization without the examination of plant control. The authors mainly deal with proper data presentation [45,46], interaction with the user by using haptic-feedback features [47,48] and the optimization of required hardware resources [49,50]. Both of the approaches lack the integrity of the process, the control structure, and its state variables. This makes them difficult to compare directly, as different targets are defined for various purposes. Because the idea of Industry 5.0 is becoming very popular, it is essential to focus on interactive smart products and enable human-machine and human-robot collaboration [51,52,53]. This can only be achieved with user-friendly interfaces and smart control structures (using artificial intelligence). Thus, the presented research addresses the smart control structure of the neural speed controller extended with online data presentation.

In this paper, a neural adaptive control structure is applied to control the speed of a two-mass drive. The experimental results obtained with an incremental encoder are sent to the end user via an ESP32 device. The visualization of the data is performed by a web-based HMI. In the first section, the mathematical description of the plant and the control structure is presented. Next, the working principle of the ADALINE neural predictor implemented in the proposed controller is discussed. The ABC algorithm is described later. The following section focuses on the numerical tests of the control structure performed in Matlab™/Simulink. Afterward, the experimental results are presented. They serve as a practical verification of the simulation studies. Then, ESP32-based data transmission and visualization HMI are shown. The article is concluded with a brief analysis of the results obtained and final comments.

2. Mathematical Model of the Control Structure and the Controller

The discussed control structure consists of two neural networks that are applied to a mechanical system with elastic joints. Such a construction is often referred to as a two-mass system. Expressions describing the dynamic properties of the drive can be formulated using a set of the following equations [4,54,55]:

$$T_{1}s{\omega }_1=T_e-T_s-T_{f1}$$

(1)

$$T_{2}s{\omega }_2=T_s-T_L-T_{f2}$$

(2)

$$T_{c}s{T}_s={\omega }_1-{\omega }_2$$

(3)

where $T_1$, $T_2$, and $T_c$ are the mechanical time constants of the motor, load and shaft, respectively, $T_e$, $T_s$ are the electromagnetic torque and shaft torque, ${\omega }_1$ and ${\omega }_2$ are the rotor speeds of the motor and load, respectively, $T_L$ is the load torque, and $T_{f1}$ and $T_{f2}$ are non-linear functions that describe the friction present in a real drive [30]:

$$T_{fi}=\left(c\left|{\omega }_i\right|+d\right)\mathrm{sgn}\left({\omega }_i\right)$$

(4)

where c and d represent the viscous and Coulomb friction coefficients, respectively. It was assumed during the design process of the control structure that the current control loop (inner loop) is simplified to a first-order element and can be represented as a simple transfer function:

$$G_i\left(s\right)=\frac{1}{T_{p}s+1}.$$

(5)

A simplified schematic of the control structure is presented in Figure 1. The first neural network presented (in blue in Figure 1) is a network composed of an input layer, a hidden layer, and an output layer. In addition, a hidden layer has a recurrent connection, which is called a context layer. The second one (represented in orange in Figure 1) represents the neural predictor of the feedback signal. Both networks work to achieve a reliable performance by the plant according to a reference value. The Elman network is described below, as the neural predictor is in Section 3.

The Elman neural network consists of I inputs, N hidden neurons, and an output neuron that generates the reference value of the electromagnetic torque—$T_{eref}$. The input layer is a linear layer with i neurons. Equations for the input can be written as:

$$h_i^1\left(k\right)=x_i\left(k\right)$$

(6)

$$z_i^1\left(k\right)=f\left(h_i^1\left(k\right)\right)=h_i^1\left(k\right)$$

(7)

where h, z are the input and output node, respectively, i is the number of the input, x is the input signal, and k represents samples. The hidden layer, with a hyperbolic activation function, processes signals from the previous layer. In addition, in the Elman network, recurrent signals from context layer are introduced, which act as an additional memory that can learn supplementary features of the plant [56]. The equations for the hidden layer input and output signal can be written as follows:

$$h_j^2\left(k\right)=\sum _{i,j=1}^N\left(w_{ij}^1\left(k\right)z_i^1\left(k\right)+w_j^c\left(k\right)z_j^c\left(k\right)\right)$$

(8)

$$z_j^2\left(k\right)=f\left(h_j^2\left(k\right)\right)=tanh\left(h_j^2\left(k\right)\right)$$

(9)

and for the context layer:

$$h_j^c\left(k\right)=z_j^2(k-1)$$

(10)

$$z_j^c\left(k\right)=f\left(h_j^c\left(k\right)\right)=h_j^c\left(k\right)$$

(11)

where w is a weight corresponding to the given layer and neuron and c stands for the context layer indicator. The output layer is also a linear layer, so its output can be presented similarly to the input layer:

$$h^3\left(k\right)=\sum _{j=1}^N{w}_j^2\left(k\right)z_j^2\left(k\right)$$

(12)

$$z^3\left(k\right)=f\left(h^3\left(k\right)\right)=h^3\left(k\right)=y_{nn}$$

(13)

The Elman neural network, presented in Figure 2 below, operates in on-line mode, which implies that it learns during the operation of the drive.

In this work, the gradient descent technique is used—weights between the first and second layer, second and third, and in the context layer, are subject to update their value during the running process of the drive. To calculate the new weights correctly, the cost function (14) should be defined (it should be differentiable). It tells the network how the weights should change and is the crucial part of the algorithm.

$$E\left(k\right)=\frac{1}{2}{\left({\omega }_{ref}^m\left(k\right)-{\omega }_1\left(k\right)\right)}^2$$

(14)

To ensure the stable work of a control structure, the reference speed signal is connected using the element described with the following formula [57]:

$$H_m\left(s\right)=\frac{{\omega }_r^2}{s^2+2{\omega }_r\xi s+{\omega }_r^2}$$

(15)

where ${\omega }_r$ is the resonant frequency and $\xi$ is the damping coefficient, which changes the overshoot in case of $\xi$ and defines the dynamics of the drive (${\omega }_r$). After calculating the cost function, updates for the weights can be processed. It should be started from the last layer, then the second to last layer is calculated, etc. This process is called backpropagation. The updates for parameters between the hidden and the output layer can be formulated as follows:

$$\Delta w_j^2\left(k\right)=\frac{\partial E\left(k\right)}{\partial w_j^2\left(k\right)}=\underset{e_m\left(k\right)}{\underbrace{\frac{\partial E\left(k\right)}{\partial y_{nn}\left(k\right)}}}\underset{1}{\underbrace{\frac{\partial y_{nn}\left(k\right)}{\partial h^3\left(k\right)}}}\underset{z_j^2\left(k\right)}{\underbrace{\frac{\partial h^3\left(k\right)}{\partial w_j^2\left(k\right)}}}$$

(16)

The context layer weight update takes a similar form:

$$\Delta w_j^c\left(k\right)=\frac{\partial E\left(k\right)}{\partial w_j^c\left(k\right)}=\underset{e_m\left(k\right)}{\underbrace{\frac{\partial E\left(k\right)}{\partial y_{nn}\left(k\right)}}}\underset{1}{\underbrace{\frac{\partial y_{nn}\left(k\right)}{\partial h^3\left(k\right)}}}\underset{w_j^2\left(k\right)}{\underbrace{\frac{\partial h^3\left(k\right)}{\partial z_j^2\left(k\right)}}}\underset{f^{\prime }\left(h_j^2\left(k\right)\right)}{\underbrace{\frac{\partial z_j^2\left(k\right)}{\partial w_j^c\left(k\right)}}}$$

(17)

At last, update values for the weights between the input and the hidden layer should be calculated:

$$\Delta w_{ij}^1\left(k\right)=\frac{\partial E\left(k\right)}{\partial w_{ij}^1\left(k\right)}=\underset{e_m\left(k\right)}{\underbrace{\frac{\partial E\left(k\right)}{\partial y_{nn}\left(k\right)}}}\underset{1}{\underbrace{\frac{\partial y_{nn}\left(k\right)}{\partial h^3\left(k\right)}}}\underset{w_j^2\left(k\right)}{\underbrace{\frac{\partial h^3\left(k\right)}{\partial z_j^2\left(k\right)}}}\underset{f^{\prime }\left(h_j^2\left(k\right)\right)}{\underbrace{\frac{\partial z_j^2\left(k\right)}{\partial w_{ij}^1\left(k\right)}}}$$

(18)

where term $f^{\prime }\left(h_j^2\left(k\right)\right)$ means the calculation of the derivative of the compound function. New weights should be calculated before proceeding to the next step [58]:

$$w_j^2(k+1)=w_j^2\left(k\right)-\eta \Delta w_j^2\left(k\right)$$

(19)

$$w_j^c(k+1)=w_j^c\left(k\right)-\eta \Delta w_j^c\left(k\right)$$

(20)

$$w_{ij}^1(k+1)=w_{ij}^1\left(k\right)-\eta \Delta w_{ij}^1\left(k\right)$$

(21)

3. ADALINE Predictor

In the previous section, it was mentioned that the cost function requires motor speed in its calculations (14). As all signals are based on the current sample of the reference and motor speeds, if the motor speed is known in advance, the neural controller can take that into account and be more precise and robust in its work (due to faster reaction). To predict the value of a motor speed, a simple ADALINE model is proposed. The ADALINE model consists of simple linear function neurons. Data processing is performed similarly to classic neural networks—input values are multiplied by weights, then the sum of these values is taken. The advantage of this approach is the use of a model that can predict (with the proper connections of the signals) data without an actual plant model. The cost function [59] and output signal for an ADALINE model can be defined similarly to (13), (14):

$$E_{pred}\left(k\right)=\frac{1}{2}{\left(y_{pred}\left(k\right)-in\left(k\right)\right)}^2$$

(22)

$$y^{pred}\left(k\right)=\sum _{\gamma =1}^{N_a}{x}_{\gamma }\left(k\right)w_{\gamma }^{pred}\left(k\right)$$

(23)

where x is the processed state variable, $w^{pred}$ is the weight associated with a given input, $y^{p}red$ is the output of the predictor, in is the model input, and $N_a$ is the number of inputs.

The update process principle remains the same as in the previous chapter. However, this time, the calculations are performed to optimize $w^{pred}$ (it should be noted that the value of the learning rate $\beta$ is a small value):

$$w_{\gamma }^{pred}(k+1)=w_{\gamma }^{pred}\left(k\right)+\beta \left[\left(\sum _{\gamma =1}^{N_a}{x}_{\gamma }\left(k\right)w_{\gamma }^{pred}\left(k\right)-in\left(k\right)\right)x_{\gamma }^{pred}\left(k\right)\right]$$

(24)

It can also be written as:

$$w_{\gamma }^{pred}(k+1)=w_{\gamma }^{pred}\left(k\right)+\beta \Delta w_{\gamma }^{pred}\left(k\right)$$

(25)

The update function is based on a gradient of the defined cost function for a predictor:

$$\Delta w_{\gamma }^{pred}=\frac{\partial E_{pred}\left(k\right)}{\partial w_{\gamma }^{pred}\left(k\right)}=\left[\left(\sum _{\gamma =1}^{N_a}{x}_{\gamma }\left(k\right)w_{\gamma }^{pred}\left(k\right)-in\left(k\right)\right)x_{\gamma }^{pred}\left(k\right)\right]$$

(26)

The neural predictor can be organized so that the output of one unit is the input of the second. Such a combination increases the prediction horizon by a number of connected units. If, for example, k units were connected as presented, the output of the entire predictor system would predict k future steps, which is presented in detail in [60]. An example system of connected predictor nodes is presented in Figure 3.

A stable training procedure for a neural network should allow small and smooth gradient changes and minimization of the defined error, $E_{pred}$. This process can be written as follows:

$$E_{pred}\left(w_{\gamma }^{pred}\left(k\right)\right)<E_{pred}\left(w_{\gamma }^{pred}(k-1)\right)$$

(27)

After modification and using Equation (25), it can be expressed as:

$$E_{pred}\left(w_{\gamma }^{pred}\left(k\right)+\Delta w_{\gamma }^{pred}\left(k\right)\right)<E_{pred}\left(w_{\gamma }^{pred}(k-1)\right)$$

(28)

The gradient value is presented with expression (26). The prediction error can also be defined:

$$e\left(k\right)=y_{ref}^{pred}\left(k\right)-y^{pred}\left(k\right)$$

(29)

The first part in (27) is a reference prediction value, which is achieved for the optimal weights value:

$$y_{ref}^{pred}\left(k\right)=\sum _{\gamma =1}^{nan}{x}_{\gamma }\left(k\right)w_{{\gamma }_{opt}}^{pred}\left(k\right)$$

(30)

After inserting Equations (30) and (23) into (29), it yields:

$$e\left(k\right)=w_{\gamma opt}^{pred}{x}_{\gamma }\left(k\right)-w_{\gamma }^{pred}\left(k\right)x_{\gamma }\left(k\right)=\Theta \left(k\right)x_{\gamma }\left(k\right)$$

(31)

where $\Theta$ is a weight adaptation error, and it can be expressed as:

$$\Theta \left(k\right)=w_{\gamma opt}^{pred}-w_{\gamma }^{pred}\left(k\right)$$

(32)

It should be noted that $w_{\gamma opt}^{pred}$ does not depend on time or samples because it is an optimal value. After combining expressions (25) and (32), the weight update error can be written as:

$$\Theta (k+1)=(1-\beta )\left(w_{\gamma opt}^{pred}-w_{\gamma }^{pred}\left(k\right)\right)$$

(33)

A proper analysis of the stability of the neural network should define a Lyapunov function. It can be defined as follows:

$$L\left(k\right)={\Theta }^2\left(k\right)$$

(34)

This value should be minimized during the learning process, so for each iteration, the value of L(k) should be reduced:

$$L\left(k\right)<L(k-1)$$

(35)

Using expression (33), the previous equation can be rewritten as:

$${\left[\left(w_{\gamma opt}^{pred}-w_{\gamma }^{pred}\right)(1-\beta )\right]}^2<\left(w_{\gamma opt}^{pred}-w_{\gamma }^{pred}\right)$$

(36)

From the last inequality, a learning rate to ensure stability can be easily found. It is also known that a small value of a learning rate tends to increase the time needed to adapt the parameters, and a higher value may cause higher jumps, which result in spikes in the output signal. Depending on the application, an adaptive learning rate or a small constant value should be considered.

4. Utilization of Artificial Bee Colony Algorithm

Artificial Bee Colony (Figure 4) is an algorithm inspired by a swarm, which consists of one queen, some male bees called drones, and many female workers. Bees can be divided into three main groups—employed, onlookers, and scouts [61]. The task of each member of the group is different, but all of them are working for a greater good—their queen and the hive. Before any optimization is performed, the initialization process for the algorithm takes place.

A population of N bees is randomly generated using a pseudo-random generator it is schematically presented in the Figure 4 as a bee hive. Any member of a population should be constrained to the limits of the problem that is solved:

$$x_{ij}=x_i^{lb}+\mathrm{rand}(0,1)(x_i^{ub}-x_i^{lb})$$

(37)

where i is the dimension of a problem, j is the number of an individual bee, and $x^{lb}$ and $x^{ub}$ are the lower and upper bounds of the considered task. In the next step, the fitness function for the whole population is evaluated according to the equation:

$$fi{t}_{ij}=\left\{\begin{array}{cc}\frac{1}{1+f_{ij}}& ,f_{ij}\ge 0\\ 1+\left|f_{ij}\right|& ,f_{ij}<0\end{array}\right.$$

(38)

where $f_{ij}$ is a fitness function defined by a user, and $fi{t}_{ij}$ is a benchmark defined in an algorithm itself [62]. Next, the first main part takes place—the employed bees phase (yellow bee), throughout which employed bees are looking for a new solution, using the expression:

$$x_{ij}^{new}\left(iter\right)=x_{ij}\left(iter\right)+{\varphi }_{ij}\left(x_{ij}\left(iter\right)-x_{kj}\left(iter\right)\right)$$

(39)

where $x_{ij}^{new}$ is a new solution found by an employed bee, $x_{kj}$ is a randomly selected solution other than $x_{ij}$, iter is a number of a current iteration of an algorithm, and ${\varphi }_{ij}$ is a random number in a range (−1, 1). The newly found solution $x_{ij}^{new}$ is then compared to the old one $x_{ij}$ according to the fitness value of each solution (38). If a new value is better (lower) than the previous one, it is exchanged so that the better value takes the place of the old one. However, if $x_{ij}^{new}$ has a higher value, it is deleted from the population (the old value of a $x_{ij}$ is kept in the population), and the abandoned solution counter (AC) is incremented. The next phase starts with a probability calculation which tells if a bee should be exploited in this part. It is done according to a simple equation:

$$p^{OB}=\frac{fi{t}_j}{{\sum }_{k=1}^{N}fi{t}_k}$$

(40)

In the onlooker bees phase (red bee), the solutions with the highest probability are further exploited using an equation similar to (39):

$$x_{ij}^{new}\left(iter\right)=x_{ij}^{p_{OB}}\left(iter\right)+{\varphi }_{ij}\left(x_{ij}^{p_{OB}}\left(iter\right)-x_{kj}\left(iter\right)\right)$$

(41)

where $x_{ij}^{p_{OB}}$ is a solution candidate for an onlooker phase with a chosen probability. This takes place until all onlookers find their solution—the food source. AC is also incremented in this phase. In the scout bees phase (green bee), the abandonment counter can be used. If its value exceeds the set limit, the bee becomes a scout bee, and then it is looking for a new source of food for its hive. In such a case, the Equation (37) is used. The end of the optimization process is evaluated by fulfilling at least one of the following criteria: reaching the maximum number of iterations, exceeding the calculation time, or obtaining small changes in the best value. The complexity of the ABC algorithm is proportional to the number of dimensions of the problem and the size of population, as well as the number of iterations of the main loop of the algorithm. The whole process is presented in Figure 5.

In this paper, the ABC was used to optimize the coefficients in the input layer of a neural network controller. Examples of different values of $k_e$ and $k_I$ are shown in Figure 6. Only one variable was changed at a time. The results prove the necessity of correct selection of the gains. The optimization was performed using the following fitness function consisting of three parts:

$$f=F_e+F_{de}+F_T$$

(42)

$$F_e={\int }_{t=0}^{t_{sim}}{t}^2{\left({\omega }_{ref}\left(t\right)-{\omega }_1\left(t\right)\right)}^{2}dt$$

(43)

$$F_{de}={\int }_{t=0}^{t_{sim}}\zeta \frac{d}{dt}\left({\omega }_{ref}\left(t\right)-{\omega }_1\left(t\right)\right)dt$$

(44)

$$F_T={\int }_{t=0}^{t_{sim}}\chi \frac{d}{dt}{T}_{e}dt$$

(45)

where $t_{sim}$ is the duration of the simulation, and $\zeta$ and $\chi$ are empirically selected coefficients to achieve the desired speed response of the drive.

The maximum iteration count for an algorithm was set to 20, with the size of the population equal to $[20\times D]$, where $D=2$ is the dimension of the optimization task. Changes in the fit objective function can be observed in Figure 7 below. The process was started with random values for both variables. The lower bound was set to [0.1 0.1], lower values caused the process to throw an error, and an upper limit was set to [50 100]; this should ensure that the final values were in the proper range.

Exemplary transients gathered during the optimization process are depicted below in Figure 8. During the first iteration, high-frequency oscillations are visible during the simulation. It is much improved in the 5th iteration of the ABC—high overshoot is present in the initial phase of operation, and high noise is visible. The step response is refined during the optimization, which can be seen in the last iteration—high dynamics of the response with no oscillations in both static and dynamic states of the drive.

5. Simulation Tests

After the optimization of the gains of the input layer of the neural controller, tests of the optimized control structure were performed. Firstly, the work of the predictor was verified. The optimized control structure with a predictor applied was compared to the regular MRAC structure (with no predictor). All the tests were conducted for 20 seconds. The load torque was applied in the 9th second of the drive operation, and it was switched off in the 11th. Selected time frames from the simulation were chosen in the comparison. In all parts of Figure 9, the load speed of the drive, after the predictor application, has a lower value of overshoot than the MRAC one. In Figure 9a, the startup process of the drive is presented; at first, the speeds match, and after some adaptation of the neural controller, the settling time is lower. After the adaptation of both networks (the Elman controller and the ADALINE predictor), it can be clearly seen that the latter one works better just before the load is switched on (Figure 9b) and after performing a reversion with a load torque applied (Figure 9c).

The prediction element is applied to the learning algorithm. For the test purposes, it was deactivated to check the difference. The fitness functions of the both structures are presented in

Table 1. Fitness function comparison of analyzed control structures.

Structure	Fitness Function Values
MRAC	0.0525
MRAC with predictor	0.0499

.

Next tests, after the comparison, were performed for a different moment of inertia added to the different parts of the drive. Firstly, the nominal parameters were tested (transients of speeds and torques are presented in Figure 10). There is a small overshoot observed after the start of the drive. Due to the update operation of the internal weights of both neural networks, it is minimized after one reversion. The time constants of the motors in industrial applications (e.g., robotic arms) are changing under the operation. Figure 11 presents the transients gathered in the second test, where the load time constant $T_2$ was increased. No apparent changes are visible in the speeds other than a lower error of speed after applying the load torque, which was presumed. Higher values of torques are observable due to the fact that the controller tries to achieve the same speed as in the nominal parameter case, but higher values of inertia imply higher amplitude of torques.

6. Experimental Verification

6.1. Description of the Laboratory Setup

After all the simulation tests were carried out, experimental verification on the laboratory stand took place. The drive consists of two DC motors coupled together with 600 mm long steel shaft. The stiffness time constant can be changed by exchanging the different shaft with different diameters, and additional flywheels can be added on the motor to increase the time constant of the load motor. It should be noted that the type of motor used in the experimental bench is insignificant since the work is focused around the mechanical part of the drive. Thus, the same tests can be carried out using two coupled induction motors.

LEM sensors are introduced to measure the currents, and incremental encoders are also present on both machines for speed measurements. The drive is powered by an H-bridge, and an additional resistor is added to ensure the proper working of the load motor. The control algorithm was uploaded to a dSpace 1103 card with a DSP by a PC with a Windows operating system. The code was generated with use of a Matlab Embedded Function, which drastically simplifies the process of compiling the uploading the Simulink code to the dSpace card. All the data were observed in the part of the dSpace software called ControlDesk, where the virtual panel was created. The nominal parameters of the setup are presented in

Table 2. Nominal parameters of the drive.

Parameter	Value
Motor nominal power	500 W
Load nominal power	500 W
Shaft length	600 mm
Shaft nominal diameter	5 mm
Encoder impulse	36,000 ppr

, and the laboratory setup is shown in Figure 12.

6.2. Remote Data Visualization

The design of the control system was extended with a remote Human-Machine Interface. The main task for the HMI was the visualization of the system state variables; the user interface additionally provides access to basic control, such as selecting the speed set-point and enabling/disabling the drive with a start&stop switch. In comparison to known HMI systems, which in most cases require special, licensed software and specialized hardware (e.g. additional sensors or measurement cards) for data acquisition and visualization [63,64,65], the proposed system broadcasts the desired data to any network-connected device. The developed system consists of the power electronics and sensors that were required for the drive operation. The state variables were extracted from the control hardware via the serial port and processed with a low-cost, highly adaptable dual-core ESP32 microcontroller. The ESP32 incorporates a wide range of communication modules, both wired (I2C, I2S, SPI, UART) and wireless (Bluetooth Classic, Bluetooth Low Energy (BLE) and Wi-Fi), which makes it a universal tool that can be implemented in a variety of applications [66,67,68]. The embedded Wi-Fi module was used to provide remote access for end users. A simple web page was generated, thus enabling data monitoring through any device, such as mobile phones, tablets, or laptop PCs. The scenario assumes the situation with ESP32 working as an internet-connected web server (Figure 13). It enables cloud-based drive monitoring from any destination around the world—the approach especially valuable for maintenance staff in international companies. Not only industrial solutions can use the IoT-enabled machinery, but also research centers and universities may conduct experiments remotely. This is an essential in the home office and remote learning reality of pandemic. Because of the increasing necessity of ensuring data safety, advanced encryption is required. The access can be granted only for the authenticated users (3rd party services are no required). A parameter comparison between typical industrial HMI solutions and the device utilized in this article is presented in

Table 3. Comparison of different devices providing HMI functionality [69,70,71].

Device	Siemens Simatic Panel Basic	ESP32	Omron NB-Series HMI
Power consumption	3 W	≈1 W	≈5 W
Screen size	up to 15″	end-user device dependent	up to 10″
Connectivity interfaces	Ethernet + Profinet	USB + Wi-Fi + Bluetooth	Ethernet + USB + RS232
User memory size	10 MB	4 MB (up to 16 MB)	128 MB
HMI design language/ required software	TIA PORTAL WINCC	HTML/CSS/C++	NB-Designer
Price	$$$	$	$$$

.

The network framework was developed using an asynchronous web server ESP32 utility. It allows generating a responsive web page design based on HTML syntax. The communication between control system acquisition module and the web server in asynchronous mode was established in a request-based manner. Every reload of the web page or user activity (such as switch toggle) generates a defined request to access microcontroller variables. The asynchronous operation reduces the workload of the processor, as the data exchange was only conducted at the user request. The CSS style file and HTML code are stored in flash memory of the ESP32 with the utilization of SPIFFS (SPI Flash File System). Such an approach allows to generate a more complex graphical interface in comparison to the minimal code constrained by program memory. Moreover, the web page file was replaced in the microcontroller memory without the interference with the network configuration and data acquisition logic.

The designed HMI web page was linked with the system during the experimental tests. The speed transient was plotted from the buffered samples. The length of the single data package was affected with the sampling frequency of the control structure. The captured screen can be found in Figure 14.

The most important element was the speed transient that covered most of the web page area. The Plotly library was used for this purpose. Not only did it allow data plotting, but it also enabled manipulation over the figure—zooming, panning and data cursor attaching. Furthermore, the interface provides the possibility to save the speed transient as an image.

6.3. Experimental Results

Experimental results are presented in Figure 15 and Figure 16—for the nominal parameters of the drive and increased time constant of the load machine ($T_2=2T_{2n}$), respectively. Reference speed transients are assumed to be the same as in the simulation tests to reproduce the results best. Cycling reversions of the speed occur every 5 s, and the amplitude of the reference speed was set to 25% of the nominal value to prevent the limitation of the current. The load torque was also switched during the operation of the drive.

The experimental results are comparable to those obtained in the simulations. Overshoot can be noticed in the initial part of the operation. Reaction to the load is fast, and the drop of the speed is small. The results from Figure 16 show that increasing the load time constant slightly increases the overshoot during the first two reversions. Other than that, the transients are similar and comparable to the simulations for both tests.

7. Conclusions

In this paper, an IoT-enabled, ARM-based monitoring and control system was developed and applied to an electric drive with finite stiffness. An Elman recurrent neural network and a neural predictor were designed to control a drive with an elastic joint. The comparison of a drive operating with and without the predictor applied was also shown to confirm the superiority of two neural networks cooperating in a single speed control structure. The convenient and effective approach to optimization of the parameters (of the neural network) with the Artificial Bee Colony algorithm was provided. The presented results confirm that the use of a metaheuristic algorithm can facilitate the design process, since there is no given prescription for selection of correct values of coefficients. The developed data server enables online observation of the plant state variables and basic control of the electrical machines. The presented idea of coupling the smart controller utilizing elements of artificial intelligence and online data visualization is coherent with the Industry 5.0 concept. The novelty was not only provided by the original idea of synthesizing the controller structure and data presentation, but also by the implementation of a low-cost mainstream microcontroller. The data flow of the proposed system was described in detail. Thus, the framework for developing similar systems was established.

The implementation of a low-cost ESP32 chip proves that modern machinery can be monitored with simple devices without complex and expensive specialized HMI systems. Both cost-effective design and online data acquisition are essential to improve electric drive data availability in the industry. The advantage of the proposed HMI is that it was developed as a web page with a customized layout that can be adapted to requirements and can be opened with any device with access to the internet.