Online Fault Detection for Four Wheeled Skid Steered UGV Using Neural Network

Abstract

This paper proposes a neural network-based actuator fault detection scheme for four-wheeled skid-steered unmanned ground vehicles (UGV). The neural network approach is first validated on vehicle dynamics simulations. Then, it is tailored for the experimental setup. Experiments involve a motion tracking system, Husarion Rosbot 2.0 UGV with associated network control systems. For experimental work, the disturbance is intentionally induced by augmenting wheels with a bump. Network size optimization is also carried out so that computing resource is saved without degrading detecting accuracy too much. The resulting network exhibit fault detection and isolation accuracy over 97% of the test data. A scenario is experimentally illustrated where a fault occurs, is detected, and tracking control is modified to continue operation in the presence of an actuator fault.

1. Introduction

Unmanned Ground Vehicles (UGV) have been an actively studied topic in the industry and academia [1,2,3]. The most widely used UGVs are skid-steered type [4,5] and mecanum wheel type [6]. Successful applications of UGV include warehouse cleanup, rescue, search, and reconnaissance [7]. However, difficulties arise in actual applications due to mechanical/electrical failures [8,9]. Thus, fault detection and isolation have also been studied [10,11,12,13,14,15,16,17,18,19,20].

This work addresses the problem of detecting actuator faults of skid-steered UGVs using deep learning [21]. First, the deep learning approach is applied to the computer-simulated dynamics of the skid-steered UGV to efficiently determine the type and size of the neural network and also scope out necessary inputs (e.g., position, velocity, control input, etc.). Building a fault-detecting neural network on actual data from experiments is carried out with a moderate number of adjustments on the network and inputs obtained from simulated data.

The actuator fault-detecting neural network is trained offline, but is intended to be used online. Illustrations are given that actuator faults occur during operations, and the network detects faults within a pre-defined time delay.

In addition to the online fault detection, we demonstrate a strategy to react to actuator faults. Skid-steered robots use 2, 4, and 6 wheels. Actuator redundancy exists for four- and six-wheeled skid-steered robots. They can move forward or steer as long as one actuator per each side remains intact. Thus, a strategy to continue the task may exist if this redundancy is exploited. Specifically, we carry out experiments to demonstrate a scenario where a fault occurs, it is online detected by the neural network, and the reference command (velocity reduced) for the motion controller is adjusted so that the motion of the UGV remains close to the desired trajectory.

A brief review of the prior work is given on fault detection for electro-mechanical systems including UGV, unmanned aerial vehicles, wind turbines, and motors. References for dynamic model-based approach include [10,11,12,13,14]. Reference [10] introduced the model-based fault diagnosis for a dynamic system. A disturbance observer (DOB) [11] can detect a fault in a disturbance-free experimental environment. A UIO (Unknown Input Observer) based actuator fault detection method for UGV with four mecanum wheels is presented in paper [12]. The model based actuator fault (tire flatness) detection for four-wheel skid steered robot is proposed in paper [13]. Reference [14] introduced the robot parameter estimation based skid steered mobile robot fault (tire flatness) detection method.

Prior work on data-based approach include [15,16,17,18,19,20]. Reference [15] introduced an artificial neural network-based motor failure detection method. The robust data-driven fault detection approach for the wind turbine is proposed in paper [16]. Real-time distributed ensemble learning for UGV suspension fault is presented in paper [17]. Reference [18] presented the neural network-based quadrotor fault detection method. The neural network-based UAV (Unmanned Aerial Vehicle) fault detection method is proposed in paper [19]. Reference [20] presented the bearing fault detection using neural networks that can be used in noisy environments.

It must be pointed out that applying the model-based approach to skid-steered UGV is challenging due to the nonlinear dynamics of the robot. To the best of the authors’ knowledge, no prior work is found that applies the data-based approach to the actuator fault detection of the four-wheeled skid steered robots.

The rest of this paper is organized as follows: Section 2 develops a fault-detecting neural network for the simulated dynamics of a four-wheeled skid-steered vehicle. This method is extended to the actual robot experiment in Section 3. Section 4 presents a scenario in which an induced fault is detected, and a strategy is deployed to continue the trajectory following the task. Finally, conclusions are given in Section 5.

2. Fault Detecting Neural Network for Simulated Dynamics

2.1. Skid Steered Vehicle Kinematics

Kinematics of skid-steered mobile robots are introduced in paper [4,5]. Kinematics of four-wheeled skid-steered mobile robot are shown in Figure 1.

In this figure, the body of the vehicle with four tires is shown. The position of the vehicle center of mass (COM) is denoted by X and Y in the global frame. The vehicle orientation, an angle between global X frame and local x frame, denoted by $\theta$ is depicted in the figure. The Center of geometry (COG) is the geometric center of the UGV. The instantaneous center of rotation (ICR) in local frame is denoted by $(-x_c,y_c)$. The angular velocity around ICR is denoted by $\omega$. The vehicle speed at COM is denoted by $(v_x,v_y)$. The speed of the vehicle at each wheel in local frame is denoted by ${\dot{x}}_i$ and ${\dot{y}}_i,(i=1,2,3,4)$, respectively. The mobile robot is assumed to be moving only on a horizontal plane. It is also assumed that wheels do not slip in the longitudinal direction.

The vehicle state vector q in the global coordinate is defined by

$$\begin{array}{cc}\hfill q& ={\left[\begin{array}{ccc}X& Y& \theta \end{array}\right]}^{\top }.\hfill \end{array}$$

(1)

Kinematic equation of motion is given by rotation matrix as follows:

$$\dot{q}=\left[\begin{array}{c}\dot{X}\\ \dot{Y}\\ \dot{\theta }\end{array}\right]=\left[\begin{array}{ccc}\cos \theta & -\sin \theta & 0\\ \sin \theta & \cos \theta & 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{v}_x\\ v_y\\ \omega \end{array}\right].$$

(2)

The velocity in the local frame is defined by an inverse rotation matrix as follows:

$$\left[\begin{array}{c}{v}_x\\ v_y\end{array}\right]=\left[\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin \theta & \cos \theta \end{array}\right]\left[\begin{array}{c}\dot{X}\\ \dot{Y}\end{array}\right]$$

(3)

The UGV system has a non-holonomic constraint. The UGV cannot move sideways infinitesimally $v_y=0$ by its construction unless the UGV rotates around ICR, which yields $v_y=x_c\omega$. Combining (3) and $v_y=x_c\omega$ gives

$$-\dot{X}\sin \theta +\dot{Y}\cos \theta -x_c\omega =0.$$

(4)

We define a row vector A by $A=\left[\begin{array}{ccc}-\sin \theta & \cos \theta & -x_c\end{array}\right]$. Then, the above equation implies a constraint on the generalized velocity, it is given by

$$A\dot{q}=0,$$

(5)

Combining (2) and (5), we can get kinematics with constraints.

$$\dot{q}=S\eta$$

(6)

where $S=\left[\begin{array}{cc}\cos \theta & -x_c\sin \theta \\ \sin \theta & x_c\cos \theta \\ 0& 1\end{array}\right]$, $\eta =\left[\begin{array}{c}{v}_x\\ \omega \end{array}\right]$.

Due to the constraint (5), the following equality holds for any non-zero $\eta$.

$$0=A\dot{q}=AS\eta$$

(7)

The above equation gives $AS=0$ or $S^T{A}^T=0$.

2.2. Skid Steered Vehicle Dynamics

Dynamics of skid-steered mobile robots are introduced in paper [4,5]. Figure 2 shows the forces acting on each wheel of the mobile robot.

In this figure, the tractive forces of the vehicle are denoted by $F_{xi},(i=1,2,3,4)$. The friction forces are denoted by $f_{xi}$ and $f_{yi},(i=1,2,3,4)$. Four wheels generate the tractive force $F_{xi}$ against resistance forces $f_{xi}$. We assume that wheel tractive force is equal on each side of the vehicle to prevent longitudinal slip. Therefore, wheel tractive forces satisfy $F_{x1}=F_{x4}$ and $F_{x2}=F_{x3}$. The distance from COM to the front of the vehicle is denoted by a, the back of the vehicle by b, and the side by c.

The input of conventional dynamics in previous papers [4,5] is divided into the left and right sides of torque. In order to detect the fault of all four actuators separately, we propose a dynamic that deals with four independent inputs by modifying the conventional dynamics. Using the variables shown in Figure 2, the dynamics of the mobile robot in the global frame are written as:

$$M\ddot{q}+R=B\tau$$

(8)

where $M=\left[\begin{array}{ccc}m& 0& 0\\ 0& m& 0\\ 0& 0& I\end{array}\right]$, $R=\left[\begin{array}{c}{f}_x\cos \theta -f_y\sin \theta \\ f_x\sin \theta +f_y\cos \theta \\ M_r\end{array}\right]$, $B=\frac{1}{r}\left[\begin{array}{cc}\cos \theta & \cos \theta \\ \sin \theta & \sin \theta \\ -c& c\end{array}\right]$, $\tau =\left[\begin{array}{c}{\tau }_1+{\tau }_4\\ {\tau }_2+{\tau }_3\end{array}\right]$, m is the vehicle mass, I is the moment of inertial, and r is the wheel radius. The variables ${\tau }_1,{\tau }_2,{\tau }_3$ and ${\tau }_4$ are torques on each wheel, and given by ${\tau }_i=2r{F}_{xi},$ $(i=1,2,3,4)$, respectively. The variables $f_x$, $f_y$, and $M_r$ are, respectively, the sum of friction forces in x direction, y direction, and the resistive moment generated during rotation. Each one of the three is explained in the next paragraph.

In order to explain $f_x$, $f_y$, and $M_r$ in (8) the gravitational load distribution of the vehicle must be considered first. The vehicle load is allocated by the geometrical structure. The vehicle gravitational loads acting on the wheel-ground contact points at four wheels are given by

$$\begin{array}{cc}\hfill F_{z1}& =F_{z2}=\frac{b}{a+b}·\frac{mg}{2},\hfill \\ \hfill F_{z3}& =F_{z4}=\frac{a}{a+b}·\frac{mg}{2}.\hfill \end{array}$$

(9)

The longitudinal resistive force of each wheel is $f_{xi}={\mu }_x{F}_{zi}\mathrm{sgn}\left({\dot{x}}_i\right),(i=1,2,3,4)$, where ${\mu }_x$ is the longitudinal friction coefficient. Finally, the longitudinal resistive force $f_x={\sum }_{i=1}^4{f}_{xi}$. Because we assume wheels on the same side have the same speed, we obtain

$$f_x=\sum _{i=1}^4{f}_{xi}=\frac{{\mu }_{x}mg}{2}(\mathrm{sgn}\left({\dot{x}}_1\right)+\mathrm{sgn}\left({\dot{x}}_2\right)).$$

(10)

Similarly, the total lateral force $f_y$ is given by

$$f_y=\sum _{i=1}^4{f}_{yi}=\frac{{\mu }_{y}mg}{a+b}(\mathrm{sgn}\left({\dot{y}}_1\right)+\mathrm{sgn}\left({\dot{y}}_3\right)).$$

(11)

The resistive moment $M_r$ is induced by $f_{xi}$ and $f_{yi}$, and given by

$$\begin{array}{cc}\hfill M_r& =a(f_{y1}+f_{y2})-b(f_{y3}+f_{y4})+c[(f_{x2}+f_{x3})-(f_{x1}+f_{x4})]\hfill \\ \hfill & ={\mu }_y\frac{abmg}{a+b}(\mathrm{sgn}\left({\dot{y}}_1\right)-\mathrm{sgn}\left({\dot{y}}_3\right))+{\mu }_x\frac{cmg}{2}(\mathrm{sgn}\left({\dot{x}}_2\right)-\mathrm{sgn}\left({\dot{x}}_1\right)).\hfill \end{array}$$

(12)

The individual wheel velocities are given by

$$\begin{array}{cc}\hfill {\dot{x}}_1& ={\dot{x}}_4=v_x-c\omega ,{\dot{x}}_2={\dot{x}}_3=v_x+c\omega ,\hfill \\ \hfill {\dot{y}}_1& ={\dot{y}}_2=v_y+a\omega ,{\dot{y}}_3={\dot{y}}_4=v_y-b\omega .\hfill \end{array}$$

(13)

If the constraint (5) is applied to the dynamics, the dynamics including the constraint can be given as:

$$M\ddot{q}+R=B\tau +A^T\lambda$$

(14)

where $\lambda$ is the vector of Lagrange multipliers.

Now, in order to reflect the kinematics in (14), we differentiate (6) to obtain

$$\ddot{q}=\dot{S}\eta +S\dot{\eta }.$$

(15)

Combining (7), (14), and (15) yields

$$\begin{array}{cc}\hfill S^{T}M\dot{S}\eta +S^{T}MS\dot{\eta }+S^{T}R& =S^{T}B\tau .\hfill \end{array}$$

(16)

We rearrange the (16), the torque input dynamics are as follows.

$$\begin{array}{ll}\left[\begin{array}{c}{\dot{v}}_x\\ \dot{\omega }\end{array}\right]& =\left[\begin{array}{c}{x}_c{\omega }^2-\frac{1}{m}{f}_x\\ -\frac{1}{m{x}_c^2+I}(m{x}_c\omega v_x+x_c{f}_y+M_r)\end{array}\right]\\ & +\left[\begin{array}{cc}\frac{1}{mr}& \frac{1}{mr}\\ -\frac{c}{r(m{x}_c^2+I)}& \frac{c}{r(m{x}_c^2+I)}\end{array}\right]\left[\begin{array}{c}{\tau }_1+{\tau }_4\\ {\tau }_2+{\tau }_3\end{array}\right]\end{array}$$

(17)

An actual robot is controlled by a voltage input. However, the dynamics (17) are consisted of torque inputs. In order to unify the input of the actual robot and the simulation, the input is converted to a voltage. The torque-voltage conversion equation is as follows.

$${\tau }_i+\frac{b_{mot}{R}_{mot}+k_{mot}^2}{R_{mot}}{\omega }_i=\frac{k_{mot}}{R_{mot}}{u}_i,$$

(18)

where $u_i$ is the voltage input, $k_{mot}$ is the motor constant, $R_{mot}$ is the motor resistance, $b_{mot}$ is the motor friction constant, and ${\omega }_i=\frac{{\dot{x}}_i}{r}$ is the wheel angular velocity.

The final voltage input UGV dynamics are given by

$$\begin{array}{ll}\left[\begin{array}{c}{\dot{v}}_x\\ \dot{\omega }\end{array}\right]& =\left[\begin{array}{cc}-\frac{4(b_{mot}{R}_{mot}+k_{mot}^2)}{m{r}^2{R}_{mot}}& 0\\ 0& -\frac{4c^2(b_{mot}{R}_{mot}+k_{mot}^2)}{r^2{R}_{mot}(m{x}_c^2+I)}\end{array}\right]\left[\begin{array}{c}{v}_x\\ \omega \end{array}\right]\\ & +\left[\begin{array}{cc}\frac{k_{mot}}{mr{R}_{mot}}& \frac{k_{mot}}{mr{R}_{mot}}\\ -\frac{c{k}_{mot}}{r{R}_{mot}(m{x}_c^2+I)}& \frac{c{k}_{mot}}{r{R}_{mot}(m{x}_c^2+I)}\end{array}\right]\left[\begin{array}{c}{u}_1+u_4\\ u_2+u_3\end{array}\right]\\ & +\left[\begin{array}{c}{x}_c{\omega }^2-\frac{1}{m}{f}_x\\ -\frac{1}{m{x}_c^2+I}(m{x}_c\omega v_x+x_c{f}_y+M_r)\end{array}\right].\end{array}$$

(19)

Combining (6) and (19), the UGV dynamics are written with five state variables: position $(X,Y)$, orientation $\left(\theta \right)$, linear velocity $\left(v_x\right)$, and angular velocity $\left(\omega \right)$. The UGV has 5 degrees of freedom including translation on a plain, roll, pitch, and yaw. Roll and pitch are permitted due to tires. Only three of them (translation, yaw) are controlled. The number of state variables and the degrees of freedom are the same for normal operation and faulty operation.

The input voltage of the actual UGV is limited according to the specification of the actuator. In order to create a realistic dynamical model, we limit the input voltage as follows.

$$-u_{lim}\le u_i\le u_{lim}.$$

(20)

As indicated by (19), actuators on the same side complement each other. As an example, the inequality $-2u_{lim}\le u_1+u_4\le 2u_{lim}$ holds.

Actuator fault for the simulated dynamics is defined by setting $u_i=0$ for the i-th actuator. This is a short-circuit condition for the actuator. According to (18), a faulty actuator yields a braking torque (negative sign). The fault defined in this manner does not require modifications of the matrix involved in (19). We note that. for the actual experiment. a fault is defined as a power outage implemented by relays.

If a fault occurs in the first actuator, $u_1=0$, the left side of system input capacity decreases to $-u_{lim}\le u_1+u_4\le u_{lim}$. If all the two left actuators are faulted, the left actuator input becomes $u_1+u_4=0$.

Trajectory tracking feedback control of the UGV dynamics consists of a high-level position tracking controller and four low-level motor controllers. The high level controller takes the desired trajectory and the current state of the UGV and computes desired values of $v_x$ and $\omega$, respectively. The four individual motor controller controls the angular velocity of each wheel. The output of the four controllers are respectively denoted by ${\widehat{u}}_i$, $i=1,2,3,4$. When a fault occurs on the i-th actuator, $u_i=0$ takes place regardless of the value of ${\widehat{u}}_i$.

The parameters of the simulation used are summarized in

Table 1. Parameter value of simulation.

Parameter	Symbol	Value	Unit
vehicle mass	m	2.84	kg
moment of inertia	I	0.0225	kg·m${}^2$
gravitational acceleration	g	9.81	m/s${}^2$
wheel radius	r	0.085	m
distance from front wheel to COM	a	0.053	m
distance from rear wheel to COM	b	0.053	m
half of vehicle width	c	0.096	m
center of rotation x position	$x_c$	0	m
longitudinal friction coefficient	${\mu }_x$	0.001	-
lateral friction coefficient	${\mu }_y$	0.2	-
motor constant	$k_{mot}$	0.01	N·m/$\sqrt{\mathrm{W}}$
motor resistance	$R_{mot}$	1	$\mathsf{\Omega }$
motor friction constant	$b_{mot}$	0.1	N·m·s

.

2.3. Actuator Fault Detecting Neural Network

First, we consider the input of the network. We propose the data pre-processing method for training the neural network. The input of a neural network consists of system states and control input sampled periodically by the period $T_s$. We stack the sampled states and control input as a vector.

$$h_i={\left[\begin{array}{c}X(Ts\ast i)\\ Y(Ts\ast i)\\ \theta (Ts\ast i)\\ \dot{X}(Ts\ast i)\\ \dot{Y}(Ts\ast i)\\ \dot{\theta }(Ts\ast i)\\ {\widehat{u}}_1(Ts\ast i)\\ {\widehat{u}}_2(Ts\ast i)\\ {\widehat{u}}_3(Ts\ast i)\\ {\widehat{u}}_4(Ts\ast i)\end{array}\right]}^{\top },$$

(21)

where $h_i\in {\mathbb{R}}^{10}$ is a vector of states and control inputs stacked. Note that the network takes input $h_i$ that contains ${\widehat{u}}_i$ instead of $u_i$.

The continuous L data input approach is frequently used as an input to a neural network [18,19]. In order to input the consecutive data, we stack the L depth input vector $H_{i,L}$.

$$H_{i,L}={\left[\begin{array}{cccc}{h}_{i-L+1}& h_{i-L+2}& \dots & h_i\end{array}\right]}^{\top }$$

(22)

We define the initial position of the input vector as

$$h_{i,pos}={\left[\begin{array}{c}X(T_s\ast (i-L+1))\\ Y(T_s\ast (i-L+1))\\ \theta (T_s\ast (i-L+1))\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0\end{array}\right]}^{\top }.$$

(23)

In order not to be affected by the initial position, subtract the first position of each component of $H_{i,L}$. We use the pre-processed data ${\overline{H}}_i$ as an input to the neural network.

$${\overline{H}}_i={\left[\begin{array}{cccc}{h}_{i-L+1}-h_{i,pos}& h_{i-L+2}-h_{i,pos}& \dots & h_i-h_{i,pos}\end{array}\right]}^{\top }$$

(24)

The output of the network is a scalar value denoted by ${\xi }_i$. The output only takes three discrete values, $1,2$ and 3, each of which implies

$$\begin{array}{cc}\hfill {\xi }_i& =1,\mathrm{no}\mathrm{fault},\hfill \\ \hfill {\xi }_i& =2,\mathrm{fault}\mathrm{occurs}\mathrm{at}{u}_1\mathrm{or}{u}_4,\hfill \\ \hfill {\xi }_i& =3,\mathrm{fault}\mathrm{occurs}\mathrm{at}{u}_2\mathrm{or}{u}_3.\hfill \end{array}$$

(25)

It must be pointed out that the dynamics in Section 2.2 used for simulation are constrained by ${\omega }_1={\omega }_4$ and ${\omega }_2={\omega }_3$. This is because no tire slippage is included in the model. For this reason, although four individual controllers exist for motion control, two control outputs on each side are always identical, i.e., ${\widehat{u}}_1={\widehat{u}}_4$ and ${\widehat{u}}_2={\widehat{u}}_3$. Thus, the network cannot isolate the faults from the same side. Therefore, ${\xi }_i$ takes three discrete values instead of five values. Since no such constraint is imposed on the actual experiment, we expand the output to have five discrete values in Section 3.

We point out that the output ${\xi }_i$ defined as (25) does fault detection and isolation at the same time. Note that the value of ${\xi }_i$ is obtained at time later than $t=T_s(i+L)$ as the input $H_i$, L requires $h_i$ to $h_{i-L+1}$.

For the neural network, we use the fully connected layer and ReLU function. Stochastic Gradient Descent is used for training the network. The network consists of four layers and each layer contains 512 nodes. The initial learning rate is 0.01. The learning rate drop factor is 0.9 and the learning rate drop period is 3. We also use momentum as 0.95 to prevent convergence to the local minimum. A dropout of 0.3 is used to prevent the over-fitting of specific features. We train the network by using the pre-processed data.

2.4. Neural Network Training for Simulation

Data for network training are obtained as follows. Six trajectories are considered

$$\begin{array}{cccc}\hfill X\left(t\right)=& 0.5t,\hfill & \hfill Y\left(t\right)& =0.5t,\hfill \end{array}$$

(26)

$$\begin{array}{cccc}\hfill X\left(t\right)=& 0.5t,\hfill & \hfill Y\left(t\right)& =-0.5t,\hfill \end{array}$$

(27)

$$\begin{array}{cccc}\hfill X\left(t\right)=& \sin \left(0.5t\right),\hfill & \hfill Y\left(t\right)& =\cos \left(0.5t\right),\hfill \end{array}$$

(28)

$$\begin{array}{cccc}\hfill X\left(t\right)=& \cos \left(0.5t\right),\hfill & \hfill Y\left(t\right)& =\sin \left(0.5t\right),\hfill \end{array}$$

(29)

$$\begin{array}{cccc}\hfill X\left(t\right)=& \sin \left(0.5t\right){\cos }^2\left(0.5t\right),\hfill & \hfill Y\left(t\right)& ={\sin }^2\left(0.5t\right)\cos \left(0.5t\right),\hfill \end{array}$$

(30)

$$\begin{array}{cccc}\hfill X\left(t\right)=& {\sin }^2\left(0.5t\right)\cos \left(0.5t\right),\hfill & \hfill Y\left(t\right)& =\sin \left(0.5t\right){\cos }^2\left(0.5t\right),\hfill \end{array}$$

(31)

where the first two are referred to as linear, the third and fourth are referred to as circular and the last two as clover. Trajectories (27)–(32) starting at $\left(X\right(0),Y(0\left)\right)=(0,0)$ is shown in Figure 3a–f, trajectory (29) starting at $\left(X\right(0),Y(0\left)\right)=(1,0)$ is shown in Figure 3g, trajectory (30) starting at $\left(X\right(0),Y(0\left)\right)=(0,1)$ is shown in Figure 3h. For each trajectory, data were collected under normal (solid in black), a left actuator fault from $t=0$ (dashed dot in blue), and a right actuator fault from $t=0$ (dash-dot in red) conditions. Figure 3c,d show that the UGV cannot follow the desired trajectory when faults occur. The initial position of the UGV is off the trajectory. In contrast, Figure 3g,h shows that the UGV stays on the desired trajectory when faults occur. This is because the UGV is initially located on the trajectory.

The collected data are pre-processed by using (21), (22), (23), and (24). The parameter L is set to $L=10$. Out of the total pre-processed data, 70% is used for training, and 30% is used for testing. The accuracy of fault detection and isolation turns out to be over 99%.

We also consider noise in the position sensors. The noises are all zero mean, and standard deviation of 0.001 for X, Y, and 0.002 for $\theta$. The fault detection and isolation accuracies are summarized in

Table 2. Neural network training result for simulation.

	Train Accuracy (%)	Test Accuracy (%)
Without noise	99.22	99.88
With noise	95.70	91.72

. Although decreased compared to the case without noise, the accuracy is still over 90%.

2.5. Online Fault Detection Simulation

Detecting faults online using a neural network requires significant computational resources. Indeed, the actuator fault detecting neural network has 4 layers and 512 nodes per layer, which gives 1,103,875 parameters. The number of computing operations is substantial.

In order to reduce the computational load, the size of the neural network is analyzed. The neural network size is reduced as much as possible while maintaining the fault detection accuracy. The results are summarized in

Table 3. Fault detection accuracy according to network size for simulation.

Number of Nodes per Layer	Number of Layers	Number of Parameters	Test Accuracy (%)
512	4	1,103,875	99.88
512	3	841,219	99.27
512	2	578,563	99.34
256	4	289,795	98.21
256	3	224,003	99.13
256	2	158,211	99.13
128	2	46,339	95.24

. In the table, with only 2 layers and 256 nodes per layer, the accuracy is maintained above 99%. If 2 layers and 128 nodes per layer are used, the accuracy drops by almost 4%. Thus, for online fault detection, 2 layers and 256 nodes per layer are selected. The resulting number of parameters is 158,211 which is reduced from 1,103,875 by almost 85%.

To detect faults online, a neural network is trained using collected data from Section 2.4. Online fault detection is performed on the trajectories (27)–(32). The fault scenarios are normal from 0 to 5 s, a left actuator fault from 5 s to 10 s, a right actuator fault from 10 s to 15 s, and finally, from 15 s to 20 s is normal.

If a fault is determined by the output of the neural network at one instance, the accuracy may be poor. We assume that when a fault occurs, it lasts for a period of time. Then, the detection is designed to take place by looking at the last N values of ${\xi }_i$ rather than a single value of ${\xi }_i$. Denote the detection output by ${\overline{\xi }}_i$, then it is written as

$${\overline{\xi }}_i=\mathrm{mode}\{{\xi }_i,{\xi }_{(i-1)},\ddots ,{\xi }_{(i-N+1)}\},i>N-1,$$

(32)

where the function ‘mode’ gives the value of the most frequently appearing in the set. The parameter $N=1000$ is used. The sampling time of the simulation is 0.001 s. Therefore, a delay of 1 s is expected to obtain the first fault detection result. Additionally, the same delay occurs when the fault condition changes because of checking 1000 neural network outputs. Figure 4 shows the online fault detection results. In this figure, the solid black line represents the actual fault class, and the solid red line represents the fault detection result. Faults can be detected and isolated online. Also, we can check the expected delay, when the initial fault detection result is obtained and when the fault condition is changed.

3. Fault Detecting Neural Network for an Actual UGV

3.1. Neural Network Training for Experiment

In this section, we apply the fault detection method in the experiment. The fault detection method is similar to Section 2.3. The difference is that the input and output of the neural network are adjusted according to the experimental resource.

Figure 5 shows the experimental setup. The robot is controlled by receiving commands from the PC. The PC reads UGV position and orientation from the motion tracker every 10 ms. The position of the UGV is measured using a Vicon Tracker. We use Husarion’s Rosbot 2.0 as a UGV to obtain data for fault detection. Figure 6 shows Husarion’s Rosbot 2.0. This robot is a four-wheeled skid-steered robot with 4 actuators controlled independently. Four Xinhe motor XH-25D are used for Rosbot 2.0 actuators. A quadrature encoder is mounted on each actuator. The actuators are controlled by CORE2 which is an STM32F407-based microcontroller. A single board computer on Rosbot 2.0 is an ASUS Tinker board with 2 GB RAM. The robot is equipped with a VL53L0X distance sensor, an Orbbec Astra RGBD camera, an RpLidar A2 lidar sensor, and an MPU-9250 IMU sensor. To obtain data when a fault occurs, the fault generator of each actuator is designed using Arduino. The UGV used in this work is Rosbot 2.0 by Husarion. It operates on three 3500 mAh batteries that last about 5 h, which is shorter than the time it took us to collect motion data. We used two sets of batteries so that experiments were not interrupted.

In addition, we attach a bump, made by using a 3D printer, on each tire to create the effect of disturbance. The bumps are attached to the wheel; it is expected to emulate driving conditions on an uneven surface such as an open field. A bump attached to a wheel is shown in Figure 7.

Data for network training are obtained as follows. Six trajectories are considered: circular, clover, and modified clover trajectories. We do not use the linear trajectory used in the simulation due to the limitation of the experimental space. Clockwise and counterclockwise rotations are considered for each of the six trajectories. For each trajectory, data are collected in the normal and each actuator fault conditions. The fault considered in the experiment is a case in which the actuator voltage input is disconnected due to the fault of the power supply circuit.

$$\begin{array}{cccc}\hfill X\left(t\right)=& 1.5\sin \left(0.26t\right),\hfill & \hfill Y\left(t\right)& =1.5\cos \left(0.26t\right),\hfill \end{array}$$

(33)

$$\begin{array}{cccc}\hfill X\left(t\right)=& 1.5\cos \left(0.26t\right),\hfill & \hfill Y\left(t\right)& =1.5\sin \left(0.26t\right),\hfill \end{array}$$

(34)

$$\begin{array}{cccc}\hfill X\left(t\right)=& 3\sin \left(0.1t\right){\cos }^2\left(0.1t\right),\hfill & \hfill Y\left(t\right)& =3{\sin }^2\left(0.1t\right)\cos \left(0.1t\right),\hfill \end{array}$$

(35)

$$\begin{array}{cccc}\hfill X\left(t\right)=& 3{\sin }^2\left(0.1t\right)\cos \left(0.1t\right),\hfill & \hfill Y\left(t\right)& =3\sin \left(0.1t\right){\cos }^2\left(0.1t\right),\hfill \end{array}$$

(36)

$$\begin{array}{cccc}\hfill X\left(t\right)=& \sin \left(0.1432t\right){\cos }^2\left(0.186t\right),\hfill & \hfill Y\left(t\right)& ={\sin }^2\left(0.139t\right)\cos \left(0.1576t\right),\hfill \end{array}$$

(37)

$$\begin{array}{cccc}\hfill X\left(t\right)=& {\sin }^2\left(0.139t\right)\cos \left(0.1576t\right),\hfill & \hfill Y\left(t\right)& =\sin \left(0.1432t\right){\cos }^2\left(0.186t\right).\hfill \end{array}$$

(38)

Collected data are shown in Figure 8 and Figure 9. Figure 8 shows the experimental data without disturbance (without the bumps) while Figure 9 shows the experimental data with disturbance. For each trajectory, data are collected under normal (solid in black), 1st actuator fault (dashed dot in blue) 2nd actuator fault (dash-dot in red), 3rd actuator fault (dot in magenta), and 4th actuator fault (dot in cyan) conditions.

The input and output of the neural network are adjusted according to the experimental environment. The inputs of the fault detection neural network are the position $(X,Y)$ in the global frame, orientation $\theta$, and the control input $pwm$ of each actuator. The output consists of a normal and a fault of each actuator. Each actuator controls each wheel by receiving angle feedback from each encoder, independently. Therefore, the fault of each actuator can be detected, independently. The output of the network is a scalar value denoted by ${\xi }_i$. The output only takes five discrete values, $1,2,3,4$ and 5, each of which implies

$$\begin{array}{cc}\hfill {\xi }_i& =1,\mathrm{no}\mathrm{fault},\hfill \\ \hfill {\xi }_i& =2,\mathrm{fault}\mathrm{occurs}\mathrm{at}1\mathrm{st}\mathrm{wheel},\hfill \\ \hfill {\xi }_i& =3,\mathrm{fault}\mathrm{occurs}\mathrm{at}2\mathrm{nd}\mathrm{wheel},\hfill \\ \hfill {\xi }_i& =4,\mathrm{fault}\mathrm{occurs}\mathrm{at}3\mathrm{rd}\mathrm{wheel},\hfill \\ \hfill {\xi }_i& =5,\mathrm{fault}\mathrm{occurs}\mathrm{at}4\mathrm{th}\mathrm{wheel}.\hfill \end{array}$$

(39)

The network type and training options of the neural network are configured the same as in Section 2.3. The obtained data are pre-processed according to the depth of the input vector $L=2,3,4,5,10$, and 20. The pre-processed data are divided into 70% for the train and 30% for the test. As a result, it is possible to obtain a fault detection accuracy of over 90%.

Table 4. Neural network training result for experiment.

L	2	3	4	5	10	20
Test accuracy (%)	93.26	94.42	94.78	95.27	96.78	98.14

shows the fault detection result according to the depth of the input vector. As the depth L of the input vector increases the accuracy increases.

3.2. Online Fault Detection Experiment

We consider the size of the neural network to reduce the computational loads. We check the test fault detection accuracy by the size of the neural network when the depth of the input vector L is 20. Indeed, the actuator fault detection neural network has 4 layers and 512 nodes per layer, which gives 1,125,381 parameters. The number of computing operations is substantial.

In order to reduce the computational load, the size of the neural network is analyzed. The neural network size is reduced as much as possible while maintaining the fault detection accuracy. The results are summarized in

Table 5. Fault detection accuracy according to network size for experiment.

Number of Node	Number of Layer	Number of Parameter	Test Accuracy (%)
512	4	1,125,381	98.18
512	3	862,725	98.10
512	2	600,069	98.31
256	3	234,757	97.74
256	2	168,965	97.97
128	2	51,717	97.55
64	2	17,669	96.77

. In the table, with only 2 layers and 128 nodes per layer, the accuracy is maintained above 97%. if 2 layers and 64 nodes per layer are used, the accuracy drops by almost 1%. Thus, for online fault detection, 2 layers and 128 nodes per layer are selected. The resulting number of parameters is 51,717 which is reduced from 1,125,381 by almost 95%.

To detect faults online, a pre-trained neural network from Section 3.1 is used. Online fault detection is performed on the trajectories (33)–(38). The fault scenarios are normal, and each actuator fault conditions from $t=0$.

The fault detection result is decided by 100 of ${\xi }_i$ (32). The sampling time of the simulation is 0.13 s. Therefore, a delay of 13 s is expected to obtain the first fault detection result. We perform online fault detection while driving on a clockwise circular trajectory with the disturbance. Figure 10 shows the online fault detection results in the experiment. In this figure, the solid black line represents the actual fault condition, and the solid red line represents the fault detection result. Faults can be detected and isolated online. Also, we can check the expected delay, when the initial fault detection result is obtained.

4. Scenarios of Fault Detection and Toleration

In this section, we propose the fault toleration method based on the online fault detection result. The fault toleration scenario is that the UGV reduces the velocity of the trajectory when a fault is detected. In order to properly respond to a fault, limited performance is quantified. The limited performance maintenance condition (40) is defined as the Mean Square Error $\left(MSE\right)$.

$$\mathrm{mean}({(X-X_r)}^2-{(Y-Y_r)}^2)\le 0.1,$$

(40)

where $X_r$ and $Y_r$ are reference trajectories in the global frame. We measured the circular trajectory lap time $T_{max}=2\pi /{\omega }_{max}$ it takes to drive one lap while increasing the speed of the trajectory ${\omega }_{max}$ when the limited performance maintenance condition is satisfied. The following

Table 6. Limited performance quantification result.

Class	Lap Time (s) $\mathit{r}=1\mathbf{m}$		Lap Time (s) $\mathit{r}=1.5\mathbf{m}$
	CCW	CW	CCW	CW
1	9.97	12.08	12.32	20.26
2	9.87	20.94	12.32	48.33
3	16.98	12.32	22.43	20.26
4	12.85	11.85	19.63	19.04
5	9.81	16.98	12.32	26.17

shows limited performance quantification results. In this table, if a fault occurs, the one lap time is increased. The fault of the wheel closer to the center of the circle has little effect, and the fault of the wheel farther from the center of the circle is greatly affected.

The experiment scenario is as follows: the UGV is faulted in the 2nd actuator from $t=0$. The fault is detected online while driving on a circular trajectory in the 2nd actuator fault condition. When a fault is detected online, the velocity of the circular trajectory is reduced which can be driven in the 2nd actuator fault condition based on Table 6.

Figure 11 shows the fault detection and toleration result. In Figure 11a,b, the solid black line means the reference trajectory and the red dotted line means the UGV path. In Figure 11c, the solid black line means the fault condition and the red dotted line means the fault detection result. In this Figure, a fault is detected at about 13 s. At that time, the velocity of the trajectory is reduced based on Table 6, then, the trajectory can be followed. This result shows that if the UGV reduces its velocity of trajectory to maintain limited performance, it can continue its mission and return to the base for repair. Therefore, it is possible to prevent the leakage of military secrets and economic loss due to mission failure.

5. Conclusions

In this paper, we developed actuator fault detection/isolation neural networks for four-wheeled skid-steered UGV. Initially, a network is developed for a dynamic mode of a four-wheel skid-steered UGV. The actuator fault for this case is a short circuit of the voltage input to the motor drive for simplicity. Due to the limitation of the dynamic model (wheel speeds on the same side are always identical) the resulting network isolates which sides a fault has occurred but does not distinguish fault at the front or rear motor. Overall detection accuracy is high with a two-layer, 256 nodes/layer, fully connected network. UGV trajectories that data for network training are tested and selected in the simulation study.

Experimental work is also carried out. A Husarion Rosbot 2.0 robot and VICON positioning system are used. A motor fault is implemented by additional circuitry that realizes as a relay switch for power supplied to each and every one of the motors. This fault is different from the one considered in the simulation study but is viewed as more realistic. High accuracy for detection and isolation has been achieved by the neural network. For experimental work, a 2 layer 128 nodes/layer fully connected network is used to reduce computational load since it resides in a UGV mounted onboard unit operating with the UGV batteries. Several scenarios have been illustrated for fault detection and isolation.

Limitations of this work include the followings. Network training is done with only one UGV. Applying the network for a different but same type of UGV and validating accuracy remains future work. Detection of a fault occurring on UGV trajectories that are not used for training has not been performed, which remains future work too.