main-content

## Weitere Artikel dieser Ausgabe durch Wischen aufrufen

27.12.2019 | Methodologies and Application | Ausgabe 15/2020 Open Access

# Fault tolerant control for nonlinear systems using sliding mode and adaptive neural network estimator

Zeitschrift:
Soft Computing > Ausgabe 15/2020
Autoren:
Haiying Qi, Yiran Shi, Shoutao Li, Yantao Tian, Ding-Li Yu, J. B. Gomm
Wichtige Hinweise
Communicated by V. Loia.

## Publisher's Note

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

## 1 Introduction

Fault tolerant control for industrial systems has attracted great attention in the past decades, and different methods have been proposed. A popular method for fault detection of nonlinear dynamic systems is using a nonlinear state observer (Liu et al. 2017; Yang et al. 2015a; Zhang et al. 2016) or a fuzzy observer-based method (Dong et al. 2018; Li et al. 2016). In these methods, observers were used to predict system state. The residual would then be generated as a function of state estimation error. While the fault occurrence can be detected, however, the identification of fault amplitude will normally be difficult. Therefore, these methods do not make a large contribution in passive fault tolerant control design. Another type of fault diagnosis system uses a nonlinear dynamic model to predict system output. The model can be constructed with fuzzy logic or neural networks (Kamal et al. 2014; Yu et al. 2014). In recent years, a nonlinear observer with an on-line estimator method (Zhang et al. 2002; Ferrari et al. 2009; Polycarpou et al. 2004) attracted much attention of researchers. This method uses an on-line estimator in the dynamic equation of the system to estimate a fault or disturbance. While the fault is estimated by the on-line estimator and compensated for in the state dynamics, the observed state under the fault condition converges to the nominal system state. It therefore naturally forms a passive fault tolerant control strategy.
Recently developed methods for fault tolerant control include the use of adaptive neural networks (Chen et al. 2016), back-stepping method (Kwan and Lewis 2000), terminal sliding mode control method (Van et al. 2018), etc. The adaptive observer method for fault tolerant control usually uses an on-line estimator to estimate a fault, where the fault estimator can be implemented using different components and are adapted with different learning algorithms. A radial basis function (RBF) network was used in Trunov and Polycarpou ( 1999) and Polycarpou and Trunov ( 2000) as the on-line estimator, and a projection-based learning algorithm was developed to tune the weights of the network. As the reported work was in an early stage, simulations showed that the tuning of the estimator is very difficult and the convergence of the estimation is slow. Rather than directly estimate disturbance, neural networks have also been used to estimate unknown parameters in a nonlinear uncertain system without combining with a nonlinear state observer. In the air-to-fuel ratio (AFR) control of air path in a spark ignition (SI) engine using a sliding mode method (Wang and Yu 2008), an RBF network was used to estimate two unknown parameters, the partial derivative of air passed the throttle with respect to the air manifold pressure and that w.r.t. crankshaft speed. The adaptive law of the network estimator was derived so that the states out of sliding mode will be guaranteed to converge to the sliding mode in finite time. Moreover, a RBF network was used to estimate the optimal sliding gain in Wang and Yu ( 2007) to achieve an optimal robust performance in AFR control against model uncertainty and measurement noise.
Intelligent methods have been developed for data analysis (Al-Janabi and Alkaim 2019; Al Janabi and Abaid Mahdi 2019; Al Janabi 2018) and applied to networks and communications (Alkaim and Al Janabi 2020; Al Janabi et al. 2020). In fault detection area, fault prediction and fault diagnosis using different analytical methods and data driving method have also investigated (Al-Janabi et al. 2014; Patel et al. 2015; Al-Janabi 2017; Al-Janabi et al. 2015; Ali 2012). The application of these methods greatly enhanced system reliability. Numerical solutions and soft computing have been widely studied Abu Arqub and Abo-Hammour ( 2014), Abu Arqub et al. ( 2016) and applied to solve scientific computing and engineering applications (Abu Arqub et al. 2017; Abu Arqub and Maayanh 2018).

## 2 Related work

Fault tolerant control is defined as a control strategy that guarantees system stability and maintains control performance after a system fault occurs. If an external disturbance is a matched one or the distribution matrix of the system fault is the same as that of the control input, robust control can be achieved easily by using a basic sliding model method. For mismatched disturbance, Chen et al. ( 2000), Chen and Chen ( 2010) and Yang et al. ( 2011) proposed a disturbance observer for a class of nonlinear systems. The developed method can estimate a constant fault but cannot estimate a time-varying fault. A sliding mode method was developed for disturbance estimation in Yang et al. ( 2013), which used the disturbance observer of Chen et al. ( 2000) in the sliding surface. While the disturbance estimation converges, the initial state out of the sliding mode would converge to the sliding mode. The method can guarantee the stability of the whole system, but is still robust to constant disturbance only. So, the aforementioned method will have very limited applications in practice as most faults considered in real industrial systems are time-varying. The disturbance observer was also used in Kayacan et al. ( 2017) to design a robust control for nonlinear systems. In this method, the disturbance estimation was achieved by combining the disturbance observer with a type-2 neural-fuzzy network (T2NFN) in Kayacan et al. ( 2015), and was tuned by combining three adaptive laws: a conventional estimation law, a robust estimation law and the T2NFN law. While the method can estimate time-varying disturbance without bias, the structure of the estimation system is rather complex and the computing load is high.
A class of nonlinear systems discussed in this paper is described by the state space model in ( 1). The model represents many industrial systems, including magnetic levitation suspension systems (Michail 2009), the chaotic Duffing oscillators (Shu 2012), a three-dimension of freedom model helicopter system (Chen et al. 2016), near space vehicle systems (Jiang et al. 2014), robotic manipulators (Yang et al. 2015b), etc. This paper proposes a new fault diagnosis and fault tolerant control method for this class of nonlinear systems. The novelty and contributions of the proposed paper are as follows. The method uses a sliding mode approach and includes an on-line fault estimator in the sliding surface.
The major contribution in this paper is that the proposed method is used to design a feedback tracking system tolerant to time-varying faults compared with the existing methods that can be tolerant to constant fault only, or to time-varying faults but with very high computing load. The fault tolerant control is achieved by compensating the impact of the fault on the system performance. Here, the RBF network is used to on-line estimate the first-order derivative of the fault w.r.t. time and is included in the control law, so that the time-varying fault is tolerated. The Lyapunov method is used to derive the adaptation laws for the RBF estimator, so that the convergence of the estimator and the stability of the entire system are guaranteed. Compared with the three typical existing fault tolerant control methods, the disturbance observer method, the disturbance observer plus neural-fuzzy network and the integral sliding mode method, the advantages of the proposed method are listed in Table  1.
Table 1
Feature comparison between different methods
Methods
Stability
Convergence
Tolerant fault
Tracking control
Disturbance observer (DB)
Stable
Converge
Constant fault
Yes
Low
DB + neural-fuzzy
Not sure
Converge
Time-varying fault
Not sure
High
Integral SMC
Stable
N/A
Constant fault
Yes
Low
Proposed method
Stable
Converge
Time-varying fault
Yes
Low
The proposed method and mentioned three major previous existing methods are all methods for control systems design in nature. Therefore, the system stability is the key feature. Also, a fault tolerant control method is mainly featured by its post-fault stabilization ability. Proving stability is most challenging task in developing these new methods. Because of this, the first feature we compared between the proposed method and the existing methods is chosen stability. Secondly, these methods are usually use algorithm on-line adaptation, or self-learning neural networks. Therefore, the convergence of self-learning network or adaptive algorithms would be the second important feature to be considered. Then, if the fault could be tolerated, and if the time-varying fault rather than constant fault only can be tolerated, is also an important feature. Finally, the two features considered are tracking control and computing load, which is also important due to the requirement for real system implementation.
A numerical simulation is used to evaluate the developed method, and the results prove the effectiveness of the method in the passive fault tolerant control by automatic fault compensation. The paper is organized in the following way. The sliding mode control and fault estimators are described in Sect.  3. Convergence of the adaptive laws for the fault estimators and system stability is proved in Sect.  4. Section  5 presents a simulation example, and Sect.  6 draws some conclusions.

## 3 Fault tolerant control design

In engineering applications, many dynamic systems including robotic systems and aeronautical systems can be modelled with the following class of second-order nonlinear model,
\begin{aligned} & \dot{x}_{1} = x_{2} + f(t), \\ & \dot{x}_{2} = G\left( x \right) + Q\left( x \right)u(t), \\ & y = x_{1} . \\ \end{aligned}
(1)
where $$x_{1}$$, $$x_{2}$$ are system states, $$u$$ is the control variable, f denotes the system component fault that is a smooth nonlinear function, $$y$$ is the output, G(.) and Q(.) are nonlinear functions of state x, and Q is supposed to be invertible. We consider the system component fault which can be presented by the term f(t) in ( 1). Some model-system parameter mismatch or external disturbance can also be presented by this term, and be considered in robust control system design. Note that in the second term of the right-hand side of the second equation in ( 1), the input is separable from the function of state, so that a sliding mode control strategy can be applied to the dynamic system to guarantee the system stability and reference tracking property.
For the purpose of fault tolerant control, we propose to use sliding mode control strategy to form a discontinued state feedback control to stabilize the closed-loop system. The sliding mode control is a type of discontinuous state feedback control, in which a sliding surface is designed such that any state of the surface will be driven onto the surface, and converge to zero along the surface. In this system, a neural network of RBF type will be used to estimate the fault change rate, $$\dot{f}(t)$$. As a class of linearly parameterized neural networks, the RBF network can approximate any smooth nonlinear mapping to any accuracy if provided with enough hidden layer nodes, due to its universal approximation ability. In further, the sliding mode control is such designed that the output is robust to the system fault, to realize the fault tolerant control.
A sliding mode control is developed for the system in ( 1) with the sliding surface designed as follows:
$$s = c_{1} \dot{x}_{1} + \dot{x}_{2} + \widehat{{\dot{f}}} + c_{2} x_{1} ,$$
(2)
where $$c_{1}$$, $$c_{2}$$ are two designing parameters, which will be chosen in the design to give more design freedom and to determine the system response speed, and $$\widehat{{\dot{f}}}$$ is an estimate of the change rate of the fault by a RBF network, $${\text{NN}}(z):R^{q} \to R$$ as follows:
$$\widehat{{\dot{f}}} = {\text{NN}}\left( z \right) = \widehat{W}^{\text{T}} \phi (z),$$
(3)
where $$z = [z_{1} , \ldots ,z_{q} ]^{\text{T}} \in \Re^{q}$$ is the input vector of the RBF network, $$\Phi (z) = [\varphi_{1} (z),\varphi_{2} (z), \ldots ,\varphi_{p} (z)]^{\text{T}} \in \Re^{p}$$ is the output of the nonlinear basis function, $$\hat{W} \in \Re^{p}$$ is the weight vector. The Gaussian function is chosen in this research as the basis function,
$$\varphi_{i} (z) = \exp \left( { - \frac{{\left\| {z - c_{i} } \right\|^{2} }}{{\sigma_{i}^{2} }}} \right),\quad i = 1, \ldots ,p,$$
(4)
where $$c_{i}$$ is a vector of the same dimension with z and is called the centre of the ith hidden layer node and $$\sigma_{i}$$ is the radius of the ith Gaussian function. There are several nonlinear basis functions which can be used in RBF network, e.g. sigmoid function, hyperbolic tangent, etc. We used Gaussian function because it is commonly used by most researchers for nonlinear mapping.
According to the universal approximation of neural networks, the smooth nonlinear function of the change rate of f(t) can be approximated by an optimal network $${\text{NN}}^{*}$$ with a minimal approximation error, i.e.
$$\dot{f}\left( t \right) = {\text{NN}}^{*} \left( z \right) + \varepsilon ,$$
(5)
where $$\varepsilon$$ is the approximation error. The weight of the optimal network $${\text{NN}}^{*}$$ is called optimal weight $$W^{*}$$, which gives the minimum approximation error $$\varepsilon$$ and is defined as follows:
$$W^{*} = \arg \mathop {\hbox{min} }\limits_{{W \in \varOmega_{f} }} \left\{ {\sup \left| {{\text{NN}}\left( {z|W} \right) - \dot{f}} \right|} \right\} .$$
(6)
where $$\varOmega_{f} = \left\{ {\hat{W}:\left\| {\hat{W}} \right\| \le M} \right\}$$ is a valid field of the estimated weight $$\hat{W}$$, M > 0 is a design parameter, and $$S_{z} \subset \Re^{q}$$ is an allowable set of the state vectors. The optimal weight will then generate
$$\dot{f}\left( t \right) = W^{{*{\text{T}}}} \phi \left( z \right) + \varepsilon^{*} ,$$
(7)
with the minimal approximation error bounded by
$$\varepsilon^{*} \le \overline{\varepsilon } ,$$
(8)
where $$\bar{\varepsilon }$$ is a positive number.
Now, with the $$\widehat{{\dot{f}}}(t)$$, the estimate of the first-order derivative of the disturbance w.r.t. time given as
$$\widehat{{\dot{f}}}\left( t \right) = \mathop \sum \limits_{i = 1}^{p} \widehat{w}_{i} \exp \left( { - \frac{{z - c_{i}^{2} }}{{\left( {\sigma_{i} } \right)^{2} }}} \right).$$
(9)
We propose the control law as follows:
$$\left\{ {\begin{array}{*{20}l} {u = U^{ - 1} (x)(u_{1} + u_{2} )} \hfill \\ {u_{1} = - G\left( x \right) - c_{1} x_{2} - \widehat{{\dot{f}}} - c_{2} x_{1} } \hfill \\ {\dot{u}_{2} = - c_{1} \widehat{W}^{\text{T}} \phi \left( z \right) - k*\text{sgn} (s)} \hfill \\ \end{array} } \right.,$$
(10)
where $$\text{sgn} (s)$$ is the sign function of s defined as follows:
$$\text{sgn} (s) = \left\{ {\begin{array}{*{20}l} {1,} \hfill & {s > 0} \hfill \\ {0,} \hfill & {s = 0} \hfill \\ { - 1,} \hfill & {s < 0} \hfill \\ \end{array} } \right..$$
(11)
The estimate of the fault change rate is used to generate fault estimation that is used as fault detection residual. In addition, the estimation of the fault change rate is mainly used in the control system as compensation to form the fault tolerant control. The fault tolerant control configuration including sliding mode control and neural network estimator is demonstrated in the flow chart in Fig.  1.
To outline the algorithm proposed in this paper for fault tolerant control system design, the algorithm is named as the Adaptive Neural Network Estimator based Fault Tolerant Control Scheme (ANNEFTCS). The neural network is used to estimate the fault change rate and is on-line adapted to cope with the post-fault dynamics when the system is subject to fault occurrence. The estimation is then used by the fault compensation mechanism in the fault tolerant control. The stabilization of the post-fault dynamics is operated by the integral sliding mode, which is also used to realize set-point tracking control. In aeronautical engineering and robotic engineering, control systems are often subject to component or actuator faults. The proposed ANNEFTCS will definitely enhance the reliability of these systems.

## 4 Estimation convergence and stability analysis

As the fault estimator used in this research will estimate the fault change rate on-line, the convergence of the estimation is very important. In addition, when a fault occurs within the system, the post-fault dynamics may cause the system unstable. Therefore, stabilize the post-fault system is also important. For the sliding surface designed in ( 2) and control law in ( 10), we now prove system stability and neural estimator convergence. These will be given in the following theorem.
Assumption 1
The system fault f( t) is a smooth time function, i.e. its first-order derivative exists and bounded.
$$\dot{f}(t) \le \overline{{\dot{f}}} ,$$
(12)
where $$\overline{{\dot{f}}}$$ is a constant.
Theorem 1
Consider the nonlinear system in ( 1) with a fault satisfying Assumption 1. If the neural estimator is updated using the adaption law as follows:
$$\widehat{w}_{i} \left( {t + \Delta t} \right) = \widehat{w}_{i} \left( t \right) + \mathop \smallint \limits_{t}^{t + \Delta t} \frac{1}{\gamma }s*\exp \left( { - \frac{{z - c_{i}^{2} }}{{\sigma_{i}^{2} }}} \right){\text{d}}t, \quad i = 1, \ldots ,p,$$
(13)
the system states will be guaranteed to be attracted on the sliding mode ( 2) and along it to converge to 0, the neural estimator will converge to the optimal estimators given in ( 7).
Proof
Proof is given in “ Appendix.”□

### 4.1 Tracking control

We consider the case of zero reference. Deriving $$x_{2} = \dot{x}_{1} - f$$ from ( 1) with respect to t, and substitute it into ( 2), we have
$$s = c_{1} \dot{x}_{1} + \dot{x}_{2} + \widehat{{\dot{f}}} + c_{2} x_{1} = \ddot{x}_{1} + c_{1} \dot{x}_{1} + c_{2} x_{1} - \widetilde{{\dot{f}}},$$
(14)
where
$$\widetilde{{\dot{f}}} = \dot{f} - \widehat{{\dot{f}}}.$$
(15)
when the state converges to the sliding surface, $$s = 0$$, we have
$$\ddot{x}_{1} + c_{1} \dot{x}_{1} + c_{2} x_{1} = \widetilde{{\dot{f}}}.$$
(16)
Lemma 1
(Khalil and Grizzle 1996) If a nonlinear system $$F(x,u)$$ is input-to-state stable, and the input satisfies $$\mathop {\text{Lim}}\nolimits_{t \to \infty } u = 0$$ , then the state satisfies $$\mathop {\text{Lim}}\nolimits_{t \to \infty } x = 0$$. □
By choosing appropriate $$c_{1}$$ and $$c_{2}$$ such that the left-hand side polynomial in ( 16) is Hurwitz, Eq. ( 16) will be input-to-state stable. Also keep in mind that $$\widetilde{{\dot{f}}}$$ converges to 0, we can conclude that according to Lemma 1, $$\mathop {\text{Lim}}\nolimits_{t \to \infty } x_{1} = 0$$. This proves the output converges to the zero reference, $$y = x_{1} \to 0$$.

### 4.2 Limitations and hypothesis

To guarantee the stability of the post-fault dynamics of the entire system and the convergence of the adaptive neural network estimator, a limitation to the fault type has to be applied. That is that the change rate of the time-varying fault must be bounded, i.e. the fault change rate should be equal to or smaller than a pre-specified value given in assumption 1. The developed algorithm extends the type of the fault tolerated from the existing methods to time-varying fault. And the bound of fault change rate makes the stabilization of the system and the adaptive algorithm convergence guaranteed. However, this condition limited the applicability of the developed algorithm in practice, as in aeronautical and robotic engineering some system faults with a big change rate and therefore cannot be tolerable with the developed method. More complexed method may be developed to tackle the faults with too big change rate, but the computing load will correspondingly increased. This will also bring difficulty for practical applications.
Besides, to ensure the designed system output tracks set-point, the system must be input-state stable. This condition is not strict, as most engineering systems possess this feature. If a special system that is not input to state stable, then the stabilization would be first priority in the design.
It is well known the sliding mode control will be subjected to chattering problem that is especially not desirable when the developed method is applied to practical systems. However, we have addressed this problem in the paper by applying an approximating to the sigh function with ( 24). The simulation example proves that it works very well.

## 5 Simulation example

### 5.1 Existing method

To compare the performance of the proposed method with an existing method in Yang et al. ( 2013), the numerical example used in Yang et al. ( 2013) is adopted in this paper, and the integral sliding mode method developed in Yang et al. ( 2013) is also used for the numerical example that is as follows:
\begin{aligned} & \dot{x}_{1} = x_{2} + f\left( t \right), \\ & \dot{x}_{2} = - 2x_{1} - x_{2} + e^{{x_{1} }} + u \\ & y = x_{1} . \\ \end{aligned}
(17)
with the initial states $$x(0) = [1,\; - 1]^{\text{T}}$$. To simulate the control system and compare the performance, a zero reference is used for the output and the fault is simulated as follows:
$${\text{f}}(t) = \left\{ {\begin{array}{*{20}l} {0,} \hfill & {0 \le t < 6(\text{s} )} \hfill \\ {0.5,} \hfill & {6 \le t < 12(\text{s} )} \hfill \\ {\sin [(t - 12)*2\pi /8],} \hfill & {12 \le t < 20(\text{s} )} \hfill \\ \end{array} } \right.$$
(18)
Here, the three piece of time function of the fault are used to present: no fault for the first 6 s, then a constant fault of 0.5 for the second 6 s, and finally a sinusoidal function as time-varying function for the last 8 s.
The integral sliding mode control in Yang et al. ( 2013) used the sliding mode:
$$s = x_{2} + c_{1} x_{1} + c_{2} \int {x_{1} } ,$$
(19)
and the control law is:
$$u = - B^{ - 1} (x)[A(x) + c_{1} x_{2} + c_{2} x_{1} + k\;\text{sgn} (s)].$$
(20)
The design parameters are $$c_{1} = 5,\;c_{2} = 6,\;k = 3$$. Computer software of Math Works, Matlab/Simulink, is used for simulation. A Simulink model is developed to represent the plant, while an M-file is developed to implement the control. The simulation result is shown in Fig.  2.
We can see that the output is insensitive to the constant fault for t = 6–12 s, but deviates away from the zero reference for the period t = 12–20 s.
The method developed in Yang et al. ( 2013) used a disturbance observer to estimate the fault, based on which a siding mode control law is derived. However, the disturbance observer can only estimate a constant disturbance $$(\dot{d} = 0)$$ and not a time-varying fault. This is why the output is not zero for t = 12–20 s. As most faults in real systems are time varying, the method in Yang et al. ( 2013) cannot be used for fault diagnosis and fault tolerant control of most industrial systems.

### 5.2 The proposed method

In the simulation of our developed neural estimator based fault tolerant control, we used a similar nonlinear system modified from system ( 17) used in Yang et al. ( 2013) to make it more complex. The modified system is as follows:
\begin{aligned} & \dot{x}_{1} = x_{2} + f\left( t \right), \\ & \dot{x}_{2} = - x_{1} - 3x_{2} + e^{{0.8x_{1} }} + u \\ & y = x_{1} . \\ \end{aligned}
(21)
To make the simulation results to be illustrated clearer, the fault is also modified as follows. A zero reference is used for the output, and the fault is simulated as follows:
$$f\left( t \right) = \left\{ {\begin{array}{*{20}l} {0,} \hfill & {0 \le t < 10 \;{\text{s}}} \hfill \\ {2,} \hfill & {10 \le t < 20 \;{\text{s}}} \hfill \\ {\sin \left[ {\left( {t - 20} \right)*\frac{2\pi }{10}} \right],} \hfill & {20 \le t < 30 \;{\text{s}}} \hfill \\ \end{array} } \right..$$
(22)
Here, the three piece of time function of the fault are used to present: no fault for the first 10 s, then a constant fault of 2 for the second 10 s, and finally a sinusoidal function as time-varying function for the last 10 s.
The design follows the following design procedure.

#### 5.2.1 Step 1: Set RBF network parameters

The network input vector is chosen as:
$$z\left( k \right) = [x_{1} \left( k \right), x_{2} \left( k \right), \widehat{{\dot{d}}}\left( {k - 1} \right)] .$$
(23)
10 centres are chosen to be evenly distributed in the region between $$z_{d,\hbox{min} } = [ - 1,\; - 1,\; - 3]^{\text{T}}$$ and $$z_{d,\hbox{max} } = [1,\;1,\;3]^{\text{T}}$$. 10 widths of the Gaussian function are $$\sigma = [2, \ldots ,2]^{\text{T}}$$. The input data were scaled before feeding into the network by a linear scale: $$z_{\text{scale}} = \frac{{z - z_{\hbox{min} } }}{{z_{\hbox{max} } - z_{\hbox{min} } }}$$.

#### 5.2.2 Step 2: Initialization

The initial value for states is $$x_{1} \left( 0 \right) = 1, x_{2} \left( 0 \right) = - 1$$. The initial value for network weights is chosen as a random value between 0 and 0.001.

#### 5.2.3 Step 3: Set control parameters

The design parameters are chosen as $$c_{1} = 12, c_{2} = 36, k = 15$$, to set the two poles at $$p_{1,2} = - 6$$. The learning rate for network weight updating is chosen as $$\frac{1}{\gamma } = 0.2 (\gamma = 5)$$.
In addition, to avoid chattering around the sliding surface, an approximation to the sign function is applied as follows:
$$\text{sgn} (s) = \frac{s}{\left| s \right| + \delta }$$
(24)
with $$\delta = 0.05$$.

#### 5.2.4 Step 4: Simulation

The sampling time is chosen as $$T_{s} = 0.01$$ s, and the simulation runs for 30 s. The results are displayed in Fig.  3.
In Fig.  3, the top figure displays the fault that is applied to the system. We can see from the second figure that the output $$y = x_{1}$$ converges to the reference value of zero when the fault is zero ( t = 0–10 s), a nonzero constant ( t = 11–20 s), and is time varying ( t = 21–30 s). This confirms that the proposed method is tolerant from the constant fault and time-varying fault. The third figure displays that the other state $$x_{2}$$ is bounded, which implies the entire system including the neural estimator is bounded and the stability of the post-fault system is guaranteed. The fourth figure displays the control signal u(t), which has no chattering due to the damped sign function. At the bottom, the fifth figure displays the sliding mode s(t), which indicates that the state is attracted on to the sliding mode s = 0 and stick on it for the whole simulation period. With the compensation of the estimated fault change rate, the system output is not affected by the occurrence of the fault. In addition, the sliding mode control guarantees the entire system stability under the appearance of the fault. Thus, the fault tolerant control is achieved.

## 6 Conclusions

The paper proposes a new fault diagnosis and fault tolerant control method for a class of nonlinear system. The main contribution of this paper is the tracking control of nonlinear system tolerant to time-varying fault. This is achieved by using a neural network to on-line estimate the change rate of the fault in the sliding mode control scheme. The estimator is on-line adapted to model post-fault dynamics, and the adaptation law is derived using the Lyapunov method. With the estimated fault compensation, fault tolerant control is achieved in terms of maintaining the entire system stability and closed-loop system performance. A numerical example is simulated to evaluate the proposed method, and the results indicate the effectiveness of the method. As the method is simple and straightforward to implement, it has a great potential to be applied in real fault tolerant control for industrial systems. A limitation to the application of the method is that the fault should be a smooth time function due to the network modelling ability. Otherwise, the modelling accuracy and consequently the fault tolerance will be affected. Further work would be to investigate application to an industrial system with real data experiment.

## Acknowledgements

This research is partially supported by Natural Science Fund of The Science and Technology Bureau of Jilin Province, China, with Ref. 20190201099JC.

## Compliance with ethical standards

### Conflict of interest

The authors declare that they have no conflict of interest.

## Appendix

Proof of Theorem 1.
Proof
A Lyapunov function as follows is designed:
$$V = \frac{1}{2}s^{2} + \frac{1}{2}\gamma c_{1} \widetilde{W}^{\text{T}} \widetilde{W}$$
(A1)
where $$\widetilde{W} = W^{*} - \widehat{W}$$, $$W \in {\mathcal{R}}^{q}$$ is the weight vector of the RBF estimator and $$\widetilde{W}$$ is the weight optimization error, $$\gamma$$ is the learning rate for the network weight.□
Generally, a Lyapunov function should be chosen such that it represents some variables that must converge to zero in the system, such as the sliding surface in ( A1) (for stability) and weight estimation error in ( A1) (for network convergence). In addition, the Lyapunov function must be chosen greater than zero, and its first-order derivative with respect to time can be proved to be less than zero.
From ( 2), we have
\begin{aligned} s & = \dot{x}_{2} + c_{1} \dot{x}_{1} + \widehat{{\dot{f}}} + c_{2} x_{1} \\ & = Z\left( x \right) + U\left( x \right)u\left( t \right) + c_{1} x_{2} + c_{1} f + \widehat{{\dot{f}}} + c_{2} x_{1} \\ \end{aligned}
(A2)
Substituting u(t) in ( 10) into ( A2),
$$s = c_{1} f + u_{2}$$
(A3)
Then, using $$u_{2}$$ in ( 10) and $$\dot{f}$$ in ( 7) we have
\begin{aligned} \dot{s} & = \dot{u}_{2} + c_{1} \dot{f} = - c_{1} \widehat{W}^{\text{T}} \phi \left( z \right) - k*\text{sgn} \left( s \right) + c_{1} \left[ {W^{{*{\text{T}}}} \phi \left( z \right) + \varepsilon^{*} } \right] \\ & = c_{1} \widetilde{W}^{\text{T}} \phi \left( z \right) - k*\text{sgn} \left( s \right) + c_{1} \varepsilon^{*} \\ \end{aligned}
(A4)
Having prepared $$\dot{s}$$, we now have
\begin{aligned} \dot{V} & = s\dot{s} + \gamma c_{1} \widetilde{W}^{\text{T}} \mathop {\widetilde{W}}\limits^{.} \\ & = c_{1} \widetilde{W}^{\text{T}} \left[ {s\phi \left( z \right) - \gamma \mathop {\widetilde{W}}\limits^{.} } \right] - k\left| s \right| + c_{1} s\varepsilon^{*} \\ \end{aligned}
(A5)
Now, we choose the updating rate of the RBF network weight $$\mathop {\widehat{W}}\limits^{.}$$ as,
$$\mathop {\widehat{W}}\limits^{.} = \frac{1}{\gamma }s\phi (z)$$
(A6)
Then, we have
\begin{aligned} \dot{V} & = - k\left| s \right| + c_{1} s\varepsilon^{*} \\ & \le - \left( {k - c_{1} \overline{\varepsilon } } \right)\left| s \right| \\ \end{aligned}
(A7)
It can then be seen that in ( A7) if k is designed such that $$k > c_{1} \overline{\varepsilon }$$, $$\dot{V} < 0$$ will hold true. According to the Lyapunov stability theory, V will converge to zero, implying that system state will converge to the sliding surface ( s = 0). At the same time, the adaptive weights of the RBF estimator will converge to the optimal weight existing for the change rate of the fault. On the other hand, weight updating law in ( A6) directly leads to Eq. ( 10) in the theorem.

## Publisher's Note

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Literatur
Über diesen Artikel

Zur Ausgabe